/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

  • Committer: Vincent Ladeuil
  • Date: 2009-09-18 08:55:12 UTC
  • mfrom: (4665.5.21 shell-like-tests)
  • mto: This revision was merged to the branch mainline in revision 4703.
  • Revision ID: v.ladeuil+lp@free.fr-20090918085512-grvno4u7gez43cnj
Introduce shell-like tests feature

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_selftest.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
17
17
"""Tests for the test framework."""
18
18
 
19
19
from cStringIO import StringIO
20
 
from doctest import ELLIPSIS
21
20
import os
22
21
import signal
23
22
import sys
25
24
import unittest
26
25
import warnings
27
26
 
28
 
from testtools import MultiTestResult
29
 
from testtools.content_type import ContentType
30
 
from testtools.matchers import (
31
 
    DocTestMatches,
32
 
    Equals,
33
 
    )
34
 
import testtools.tests.helpers
35
 
 
36
27
import bzrlib
37
28
from bzrlib import (
38
29
    branchbuilder,
39
30
    bzrdir,
 
31
    config,
40
32
    debug,
41
33
    errors,
42
34
    lockdir,
61
53
    deprecated_method,
62
54
    )
63
55
from bzrlib.tests import (
64
 
    features,
 
56
    SubUnitFeature,
65
57
    test_lsprof,
66
 
    test_server,
67
58
    test_sftp_transport,
68
59
    TestUtil,
69
60
    )
70
61
from bzrlib.trace import note
71
 
from bzrlib.transport import memory
 
62
from bzrlib.transport.memory import MemoryServer, MemoryTransport
72
63
from bzrlib.version import _get_bzr_source_tree
73
64
 
74
65
 
88
79
                          TestUtil._load_module_by_name,
89
80
                          'bzrlib.no-name-yet')
90
81
 
91
 
 
92
82
class MetaTestLog(tests.TestCase):
93
83
 
94
84
    def test_logging(self):
95
85
        """Test logs are captured when a test fails."""
96
86
        self.log('a test message')
97
 
        details = self.getDetails()
98
 
        log = details['log']
99
 
        self.assertThat(log.content_type, Equals(ContentType(
100
 
            "text", "plain", {"charset": "utf8"})))
101
 
        self.assertThat(u"".join(log.iter_text()), Equals(self.get_log()))
102
 
        self.assertThat(self.get_log(),
103
 
            DocTestMatches(u"...a test message\n", ELLIPSIS))
 
87
        self._log_file.flush()
 
88
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
89
                              'a test message\n')
104
90
 
105
91
 
106
92
class TestUnicodeFilename(tests.TestCase):
505
491
        self.assertEqualStat(real, fake)
506
492
 
507
493
    def test_assertEqualStat_notequal(self):
508
 
        self.build_tree(["foo", "longname"])
 
494
        self.build_tree(["foo", "bar"])
509
495
        self.assertRaises(AssertionError, self.assertEqualStat,
510
 
            os.lstat("foo"), os.lstat("longname"))
 
496
            os.lstat("foo"), os.lstat("bar"))
511
497
 
512
498
 
513
499
class TestTestCaseWithMemoryTransport(tests.TestCaseWithMemoryTransport):
531
517
        cwd = osutils.getcwd()
532
518
        self.assertIsSameRealPath(self.test_dir, cwd)
533
519
 
534
 
    def test_BZR_HOME_and_HOME_are_bytestrings(self):
535
 
        """The $BZR_HOME and $HOME environment variables should not be unicode.
536
 
 
537
 
        See https://bugs.launchpad.net/bzr/+bug/464174
538
 
        """
539
 
        self.assertIsInstance(os.environ['BZR_HOME'], str)
540
 
        self.assertIsInstance(os.environ['HOME'], str)
541
 
 
542
520
    def test_make_branch_and_memory_tree(self):
543
521
        """In TestCaseWithMemoryTransport we should not make the branch on disk.
544
522
 
622
600
 
623
601
    def test_get_readonly_url_none(self):
624
602
        from bzrlib.transport import get_transport
 
603
        from bzrlib.transport.memory import MemoryServer
625
604
        from bzrlib.transport.readonly import ReadonlyTransportDecorator
626
 
        self.vfs_transport_factory = memory.MemoryServer
 
605
        self.vfs_transport_factory = MemoryServer
627
606
        self.transport_readonly_server = None
628
607
        # calling get_readonly_transport() constructs a decorator on the url
629
608
        # for the server
638
617
    def test_get_readonly_url_http(self):
639
618
        from bzrlib.tests.http_server import HttpServer
640
619
        from bzrlib.transport import get_transport
 
620
        from bzrlib.transport.local import LocalURLServer
641
621
        from bzrlib.transport.http import HttpTransportBase
642
 
        self.transport_server = test_server.LocalURLServer
 
622
        self.transport_server = LocalURLServer
643
623
        self.transport_readonly_server = HttpServer
644
624
        # calling get_readonly_transport() gives us a HTTP server instance.
645
625
        url = self.get_readonly_url()
676
656
 
677
657
    def setUp(self):
678
658
        super(TestTestCaseTransports, self).setUp()
679
 
        self.vfs_transport_factory = memory.MemoryServer
 
659
        self.vfs_transport_factory = MemoryServer
680
660
 
681
661
    def test_make_bzrdir_preserves_transport(self):
682
662
        t = self.get_transport()
683
663
        result_bzrdir = self.make_bzrdir('subdir')
684
664
        self.assertIsInstance(result_bzrdir.transport,
685
 
                              memory.MemoryTransport)
 
665
                              MemoryTransport)
686
666
        # should not be on disk, should only be in memory
687
667
        self.failIfExists('subdir')
688
668
 
700
680
 
701
681
    def test_profiles_tests(self):
702
682
        self.requireFeature(test_lsprof.LSProfFeature)
703
 
        terminal = testtools.tests.helpers.ExtendedTestResult()
 
683
        terminal = unittest.TestResult()
704
684
        result = tests.ProfileResult(terminal)
705
685
        class Sample(tests.TestCase):
706
686
            def a(self):
708
688
            def sample_function(self):
709
689
                pass
710
690
        test = Sample("a")
 
691
        test.attrs_to_keep = test.attrs_to_keep + ('_benchcalls',)
711
692
        test.run(result)
712
 
        case = terminal._events[0][1]
713
 
        self.assertLength(1, case._benchcalls)
 
693
        self.assertLength(1, test._benchcalls)
714
694
        # We must be able to unpack it as the test reporting code wants
715
 
        (_, _, _), stats = case._benchcalls[0]
 
695
        (_, _, _), stats = test._benchcalls[0]
716
696
        self.assertTrue(callable(stats.pprint))
717
697
 
718
698
 
723
703
                descriptions=0,
724
704
                verbosity=1,
725
705
                )
726
 
        capture = testtools.tests.helpers.ExtendedTestResult()
727
 
        test_case.run(MultiTestResult(result, capture))
728
 
        run_case = capture._events[0][1]
729
 
        timed_string = result._testTimeString(run_case)
 
706
        test_case.run(result)
 
707
        timed_string = result._testTimeString(test_case)
730
708
        self.assertContainsRe(timed_string, expected_re)
731
709
 
732
710
    def test_test_reporting(self):
753
731
    def _patch_get_bzr_source_tree(self):
754
732
        # Reading from the actual source tree breaks isolation, but we don't
755
733
        # want to assume that thats *all* that would happen.
756
 
        self.overrideAttr(bzrlib.version, '_get_bzr_source_tree', lambda: None)
 
734
        def _get_bzr_source_tree():
 
735
            return None
 
736
        orig_get_bzr_source_tree = bzrlib.version._get_bzr_source_tree
 
737
        bzrlib.version._get_bzr_source_tree = _get_bzr_source_tree
 
738
        def restore():
 
739
            bzrlib.version._get_bzr_source_tree = orig_get_bzr_source_tree
 
740
        self.addCleanup(restore)
757
741
 
758
742
    def test_assigned_benchmark_file_stores_date(self):
759
743
        self._patch_get_bzr_source_tree()
841
825
            def stopTestRun(self): pass
842
826
            def startTests(self): pass
843
827
            def report_test_start(self, test): pass
844
 
            def report_known_failure(self, test, err=None, details=None):
845
 
                self._call = test, 'known failure'
 
828
            def report_known_failure(self, test, err):
 
829
                self._call = test, err
846
830
        result = InstrumentedTestResult(None, None, None, None)
847
 
        class Test(tests.TestCase):
848
 
            def test_function(self):
849
 
                raise tests.KnownFailure('failed!')
850
 
        test = Test("test_function")
 
831
        def test_function():
 
832
            raise tests.KnownFailure('failed!')
 
833
        test = unittest.FunctionTestCase(test_function)
851
834
        test.run(result)
852
835
        # it should invoke 'report_known_failure'.
853
836
        self.assertEqual(2, len(result._call))
854
 
        self.assertEqual(test.id(), result._call[0].id())
855
 
        self.assertEqual('known failure', result._call[1])
 
837
        self.assertEqual(test, result._call[0])
 
838
        self.assertEqual(tests.KnownFailure, result._call[1][0])
 
839
        self.assertIsInstance(result._call[1][1], tests.KnownFailure)
856
840
        # we dont introspec the traceback, if the rest is ok, it would be
857
841
        # exceptional for it not to be.
858
842
        # it should update the known_failure_count on the object.
930
914
        result.report_unsupported(test, feature)
931
915
        output = result_stream.getvalue()[prefix:]
932
916
        lines = output.splitlines()
933
 
        # We don't check for the final '0ms' since it may fail on slow hosts
934
 
        self.assertStartsWith(lines[0], 'NODEP')
935
 
        self.assertEqual(lines[1],
936
 
                         "    The feature 'Feature' is not available.")
 
917
        self.assertEqual(lines, ['NODEP        0ms',
 
918
                                 "    The feature 'Feature' is not available."])
937
919
 
938
920
    def test_unavailable_exception(self):
939
921
        """An UnavailableFeature being raised should invoke addNotSupported."""
945
927
                self._call = test, feature
946
928
        result = InstrumentedTestResult(None, None, None, None)
947
929
        feature = tests.Feature()
948
 
        class Test(tests.TestCase):
949
 
            def test_function(self):
950
 
                raise tests.UnavailableFeature(feature)
951
 
        test = Test("test_function")
 
930
        def test_function():
 
931
            raise tests.UnavailableFeature(feature)
 
932
        test = unittest.FunctionTestCase(test_function)
952
933
        test.run(result)
953
934
        # it should invoke 'addNotSupported'.
954
935
        self.assertEqual(2, len(result._call))
955
 
        self.assertEqual(test.id(), result._call[0].id())
 
936
        self.assertEqual(test, result._call[0])
956
937
        self.assertEqual(feature, result._call[1])
957
938
        # and not count as an error
958
939
        self.assertEqual(0, result.error_count)
971
952
                                             verbosity=1)
972
953
        test = self.get_passing_test()
973
954
        err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
974
 
        result.addExpectedFailure(test, err)
 
955
        result._addKnownFailure(test, err)
975
956
        self.assertFalse(result.wasStrictlySuccessful())
976
957
        self.assertEqual(None, result._extractBenchmarkTime(test))
977
958
 
1034
1015
    def test_known_failure_failed_run(self):
1035
1016
        # run a test that generates a known failure which should be printed in
1036
1017
        # the final output when real failures occur.
1037
 
        class Test(tests.TestCase):
1038
 
            def known_failure_test(self):
1039
 
                self.expectFailure('failed', self.assertTrue, False)
 
1018
        def known_failure_test():
 
1019
            raise tests.KnownFailure('failed')
1040
1020
        test = unittest.TestSuite()
1041
 
        test.addTest(Test("known_failure_test"))
 
1021
        test.addTest(unittest.FunctionTestCase(known_failure_test))
1042
1022
        def failing_test():
1043
 
            self.fail('foo')
 
1023
            raise AssertionError('foo')
1044
1024
        test.addTest(unittest.FunctionTestCase(failing_test))
1045
1025
        stream = StringIO()
1046
1026
        runner = tests.TextTestRunner(stream=stream)
1047
1027
        result = self.run_test_runner(runner, test)
1048
1028
        lines = stream.getvalue().splitlines()
1049
1029
        self.assertContainsRe(stream.getvalue(),
1050
 
            '(?sm)^bzr selftest.*$'
 
1030
            '(?sm)^testing.*$'
1051
1031
            '.*'
1052
1032
            '^======================================================================\n'
1053
 
            '^FAIL: failing_test\n'
 
1033
            '^FAIL: unittest.FunctionTestCase \\(failing_test\\)\n'
1054
1034
            '^----------------------------------------------------------------------\n'
1055
1035
            'Traceback \\(most recent call last\\):\n'
1056
1036
            '  .*' # File .*, line .*, in failing_test' - but maybe not from .pyc
1057
 
            '    self.fail\\(\'foo\'\\)\n'
 
1037
            '    raise AssertionError\\(\'foo\'\\)\n'
1058
1038
            '.*'
1059
1039
            '^----------------------------------------------------------------------\n'
1060
1040
            '.*'
1062
1042
            )
1063
1043
 
1064
1044
    def test_known_failure_ok_run(self):
1065
 
        # run a test that generates a known failure which should be printed in
1066
 
        # the final output.
1067
 
        class Test(tests.TestCase):
1068
 
            def known_failure_test(self):
1069
 
                self.expectFailure('failed', self.assertTrue, False)
1070
 
        test = Test("known_failure_test")
 
1045
        # run a test that generates a known failure which should be printed in the final output.
 
1046
        def known_failure_test():
 
1047
            raise tests.KnownFailure('failed')
 
1048
        test = unittest.FunctionTestCase(known_failure_test)
1071
1049
        stream = StringIO()
1072
1050
        runner = tests.TextTestRunner(stream=stream)
1073
1051
        result = self.run_test_runner(runner, test)
1150
1128
 
1151
1129
    def test_not_applicable(self):
1152
1130
        # run a test that is skipped because it's not applicable
1153
 
        class Test(tests.TestCase):
1154
 
            def not_applicable_test(self):
1155
 
                raise tests.TestNotApplicable('this test never runs')
 
1131
        def not_applicable_test():
 
1132
            raise tests.TestNotApplicable('this test never runs')
1156
1133
        out = StringIO()
1157
1134
        runner = tests.TextTestRunner(stream=out, verbosity=2)
1158
 
        test = Test("not_applicable_test")
 
1135
        test = unittest.FunctionTestCase(not_applicable_test)
1159
1136
        result = self.run_test_runner(runner, test)
1160
1137
        self._log_file.write(out.getvalue())
1161
1138
        self.assertTrue(result.wasSuccessful())
1194
1171
        # Reading from the actual source tree breaks isolation, but we don't
1195
1172
        # want to assume that thats *all* that would happen.
1196
1173
        self._get_source_tree_calls = []
1197
 
        def new_get():
 
1174
        def _get_bzr_source_tree():
1198
1175
            self._get_source_tree_calls.append("called")
1199
1176
            return None
1200
 
        self.overrideAttr(bzrlib.version, '_get_bzr_source_tree',  new_get)
 
1177
        orig_get_bzr_source_tree = bzrlib.version._get_bzr_source_tree
 
1178
        bzrlib.version._get_bzr_source_tree = _get_bzr_source_tree
 
1179
        def restore():
 
1180
            bzrlib.version._get_bzr_source_tree = orig_get_bzr_source_tree
 
1181
        self.addCleanup(restore)
1201
1182
 
1202
1183
    def test_bench_history(self):
1203
1184
        # tests that the running the benchmark passes bench_history into
1213
1194
        self.assertContainsRe(output_string, "--date [0-9.]+")
1214
1195
        self.assertLength(1, self._get_source_tree_calls)
1215
1196
 
 
1197
    def assertLogDeleted(self, test):
 
1198
        log = test._get_log()
 
1199
        self.assertEqual("DELETED log file to reduce memory footprint", log)
 
1200
        self.assertEqual('', test._log_contents)
 
1201
        self.assertIs(None, test._log_file_name)
 
1202
 
 
1203
    def test_success_log_deleted(self):
 
1204
        """Successful tests have their log deleted"""
 
1205
 
 
1206
        class LogTester(tests.TestCase):
 
1207
 
 
1208
            def test_success(self):
 
1209
                self.log('this will be removed\n')
 
1210
 
 
1211
        sio = StringIO()
 
1212
        runner = tests.TextTestRunner(stream=sio)
 
1213
        test = LogTester('test_success')
 
1214
        result = self.run_test_runner(runner, test)
 
1215
 
 
1216
        self.assertLogDeleted(test)
 
1217
 
 
1218
    def test_skipped_log_deleted(self):
 
1219
        """Skipped tests have their log deleted"""
 
1220
 
 
1221
        class LogTester(tests.TestCase):
 
1222
 
 
1223
            def test_skipped(self):
 
1224
                self.log('this will be removed\n')
 
1225
                raise tests.TestSkipped()
 
1226
 
 
1227
        sio = StringIO()
 
1228
        runner = tests.TextTestRunner(stream=sio)
 
1229
        test = LogTester('test_skipped')
 
1230
        result = self.run_test_runner(runner, test)
 
1231
 
 
1232
        self.assertLogDeleted(test)
 
1233
 
 
1234
    def test_not_aplicable_log_deleted(self):
 
1235
        """Not applicable tests have their log deleted"""
 
1236
 
 
1237
        class LogTester(tests.TestCase):
 
1238
 
 
1239
            def test_not_applicable(self):
 
1240
                self.log('this will be removed\n')
 
1241
                raise tests.TestNotApplicable()
 
1242
 
 
1243
        sio = StringIO()
 
1244
        runner = tests.TextTestRunner(stream=sio)
 
1245
        test = LogTester('test_not_applicable')
 
1246
        result = self.run_test_runner(runner, test)
 
1247
 
 
1248
        self.assertLogDeleted(test)
 
1249
 
 
1250
    def test_known_failure_log_deleted(self):
 
1251
        """Know failure tests have their log deleted"""
 
1252
 
 
1253
        class LogTester(tests.TestCase):
 
1254
 
 
1255
            def test_known_failure(self):
 
1256
                self.log('this will be removed\n')
 
1257
                raise tests.KnownFailure()
 
1258
 
 
1259
        sio = StringIO()
 
1260
        runner = tests.TextTestRunner(stream=sio)
 
1261
        test = LogTester('test_known_failure')
 
1262
        result = self.run_test_runner(runner, test)
 
1263
 
 
1264
        self.assertLogDeleted(test)
 
1265
 
 
1266
    def test_fail_log_kept(self):
 
1267
        """Failed tests have their log kept"""
 
1268
 
 
1269
        class LogTester(tests.TestCase):
 
1270
 
 
1271
            def test_fail(self):
 
1272
                self.log('this will be kept\n')
 
1273
                self.fail('this test fails')
 
1274
 
 
1275
        sio = StringIO()
 
1276
        runner = tests.TextTestRunner(stream=sio)
 
1277
        test = LogTester('test_fail')
 
1278
        result = self.run_test_runner(runner, test)
 
1279
 
 
1280
        text = sio.getvalue()
 
1281
        self.assertContainsRe(text, 'this will be kept')
 
1282
        self.assertContainsRe(text, 'this test fails')
 
1283
 
 
1284
        log = test._get_log()
 
1285
        self.assertContainsRe(log, 'this will be kept')
 
1286
        self.assertEqual(log, test._log_contents)
 
1287
 
 
1288
    def test_error_log_kept(self):
 
1289
        """Tests with errors have their log kept"""
 
1290
 
 
1291
        class LogTester(tests.TestCase):
 
1292
 
 
1293
            def test_error(self):
 
1294
                self.log('this will be kept\n')
 
1295
                raise ValueError('random exception raised')
 
1296
 
 
1297
        sio = StringIO()
 
1298
        runner = tests.TextTestRunner(stream=sio)
 
1299
        test = LogTester('test_error')
 
1300
        result = self.run_test_runner(runner, test)
 
1301
 
 
1302
        text = sio.getvalue()
 
1303
        self.assertContainsRe(text, 'this will be kept')
 
1304
        self.assertContainsRe(text, 'random exception raised')
 
1305
 
 
1306
        log = test._get_log()
 
1307
        self.assertContainsRe(log, 'this will be kept')
 
1308
        self.assertEqual(log, test._log_contents)
 
1309
 
1216
1310
    def test_startTestRun(self):
1217
1311
        """run should call result.startTestRun()"""
1218
1312
        calls = []
1311
1405
        self.assertEqual(flags, bzrlib.debug.debug_flags)
1312
1406
 
1313
1407
    def change_selftest_debug_flags(self, new_flags):
1314
 
        self.overrideAttr(tests, 'selftest_debug_flags', set(new_flags))
 
1408
        orig_selftest_flags = tests.selftest_debug_flags
 
1409
        self.addCleanup(self._restore_selftest_debug_flags, orig_selftest_flags)
 
1410
        tests.selftest_debug_flags = set(new_flags)
 
1411
 
 
1412
    def _restore_selftest_debug_flags(self, flags):
 
1413
        tests.selftest_debug_flags = flags
1315
1414
 
1316
1415
    def test_allow_debug_flag(self):
1317
1416
        """The -Eallow_debug flag prevents bzrlib.debug.debug_flags from being
1377
1476
        self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags)
1378
1477
 
1379
1478
    def make_test_result(self):
1380
 
        """Get a test result that writes to the test log file."""
1381
1479
        return tests.TextTestResult(self._log_file, descriptions=0, verbosity=1)
1382
1480
 
1383
1481
    def inner_test(self):
1391
1489
        result = self.make_test_result()
1392
1490
        self.inner_test.run(result)
1393
1491
        note("outer finish")
1394
 
        self.addCleanup(osutils.delete_any, self._log_file_name)
1395
1492
 
1396
1493
    def test_trace_nesting(self):
1397
1494
        # this tests that each test case nests its trace facility correctly.
1409
1506
        outer_test = TestTestCase("outer_child")
1410
1507
        result = self.make_test_result()
1411
1508
        outer_test.run(result)
 
1509
        self.addCleanup(osutils.delete_any, outer_test._log_file_name)
1412
1510
        self.assertEqual(original_trace, bzrlib.trace._trace_file)
1413
1511
 
1414
1512
    def method_that_times_a_bit_twice(self):
1468
1566
        # permitted.
1469
1567
        # Manually set one up (TestCase doesn't and shouldn't provide magic
1470
1568
        # machinery)
1471
 
        transport_server = memory.MemoryServer()
1472
 
        transport_server.start_server()
1473
 
        self.addCleanup(transport_server.stop_server)
 
1569
        transport_server = MemoryServer()
 
1570
        transport_server.setUp()
 
1571
        self.addCleanup(transport_server.tearDown)
1474
1572
        t = transport.get_transport(transport_server.get_url())
1475
1573
        bzrdir.BzrDir.create(t.base)
1476
1574
        self.assertRaises(errors.BzrError,
1529
1627
        """Test disabled tests behaviour with support aware results."""
1530
1628
        test = SampleTestCase('_test_pass')
1531
1629
        class DisabledFeature(object):
1532
 
            def __eq__(self, other):
1533
 
                return isinstance(other, DisabledFeature)
1534
1630
            def available(self):
1535
1631
                return False
1536
1632
        the_feature = DisabledFeature()
1547
1643
                self.calls.append(('addNotSupported', test, feature))
1548
1644
        result = InstrumentedTestResult()
1549
1645
        test.run(result)
1550
 
        case = result.calls[0][1]
1551
1646
        self.assertEqual([
1552
 
            ('startTest', case),
1553
 
            ('addNotSupported', case, the_feature),
1554
 
            ('stopTest', case),
 
1647
            ('startTest', test),
 
1648
            ('addNotSupported', test, the_feature),
 
1649
            ('stopTest', test),
1555
1650
            ],
1556
1651
            result.calls)
1557
1652
 
1558
1653
    def test_start_server_registers_url(self):
1559
 
        transport_server = memory.MemoryServer()
 
1654
        transport_server = MemoryServer()
1560
1655
        # A little strict, but unlikely to be changed soon.
1561
1656
        self.assertEqual([], self._bzr_selftest_roots)
1562
1657
        self.start_server(transport_server)
1618
1713
        self.assertRaises(AssertionError,
1619
1714
            self.assertListRaises, _TestException, success_generator)
1620
1715
 
1621
 
    def test_overrideAttr_without_value(self):
1622
 
        self.test_attr = 'original' # Define a test attribute
1623
 
        obj = self # Make 'obj' visible to the embedded test
1624
 
        class Test(tests.TestCase):
1625
 
 
1626
 
            def setUp(self):
1627
 
                tests.TestCase.setUp(self)
1628
 
                self.orig = self.overrideAttr(obj, 'test_attr')
1629
 
 
1630
 
            def test_value(self):
1631
 
                self.assertEqual('original', self.orig)
1632
 
                self.assertEqual('original', obj.test_attr)
1633
 
                obj.test_attr = 'modified'
1634
 
                self.assertEqual('modified', obj.test_attr)
1635
 
 
1636
 
        test = Test('test_value')
1637
 
        test.run(unittest.TestResult())
1638
 
        self.assertEqual('original', obj.test_attr)
1639
 
 
1640
 
    def test_overrideAttr_with_value(self):
1641
 
        self.test_attr = 'original' # Define a test attribute
1642
 
        obj = self # Make 'obj' visible to the embedded test
1643
 
        class Test(tests.TestCase):
1644
 
 
1645
 
            def setUp(self):
1646
 
                tests.TestCase.setUp(self)
1647
 
                self.orig = self.overrideAttr(obj, 'test_attr', new='modified')
1648
 
 
1649
 
            def test_value(self):
1650
 
                self.assertEqual('original', self.orig)
1651
 
                self.assertEqual('modified', obj.test_attr)
1652
 
 
1653
 
        test = Test('test_value')
1654
 
        test.run(unittest.TestResult())
1655
 
        self.assertEqual('original', obj.test_attr)
1656
 
 
1657
1716
 
1658
1717
# NB: Don't delete this; it's not actually from 0.11!
1659
1718
@deprecated_function(deprecated_in((0, 11, 0)))
1803
1862
        # make_branch_and_tree has to use local branch and repositories
1804
1863
        # when the vfs transport and local disk are colocated, even if
1805
1864
        # a different transport is in use for url generation.
1806
 
        self.transport_server = test_server.FakeVFATServer
 
1865
        from bzrlib.transport.fakevfat import FakeVFATServer
 
1866
        self.transport_server = FakeVFATServer
1807
1867
        self.assertFalse(self.get_url('t1').startswith('file://'))
1808
1868
        tree = self.make_branch_and_tree('t1')
1809
1869
        base = tree.bzrdir.root_transport.base
1907
1967
        self.assertEqual(expected.getvalue(), repeated.getvalue())
1908
1968
 
1909
1969
    def test_runner_class(self):
1910
 
        self.requireFeature(features.subunit)
 
1970
        self.requireFeature(SubUnitFeature)
1911
1971
        from subunit import ProtocolTestCase
1912
1972
        stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
1913
1973
            test_suite_factory=self.factory)
1945
2005
        self.assertEqual(transport_server, captured_transport[0])
1946
2006
 
1947
2007
    def test_transport_sftp(self):
1948
 
        self.requireFeature(features.paramiko)
1949
 
        from bzrlib.tests import stub_sftp
1950
 
        self.check_transport_set(stub_sftp.SFTPAbsoluteServer)
 
2008
        try:
 
2009
            import bzrlib.transport.sftp
 
2010
        except errors.ParamikoNotPresent:
 
2011
            raise tests.TestSkipped("Paramiko not present")
 
2012
        self.check_transport_set(bzrlib.transport.sftp.SFTPAbsoluteServer)
1951
2013
 
1952
2014
    def test_transport_memory(self):
1953
 
        self.check_transport_set(memory.MemoryServer)
 
2015
        self.check_transport_set(bzrlib.transport.memory.MemoryServer)
1954
2016
 
1955
2017
 
1956
2018
class TestSelftestWithIdList(tests.TestCaseInTempDir, SelfTestHelper):
2357
2419
        self.assertEqual('bzr: interrupted\n', result[1])
2358
2420
 
2359
2421
 
 
2422
class TestKnownFailure(tests.TestCase):
 
2423
 
 
2424
    def test_known_failure(self):
 
2425
        """Check that KnownFailure is defined appropriately."""
 
2426
        # a KnownFailure is an assertion error for compatability with unaware
 
2427
        # runners.
 
2428
        self.assertIsInstance(tests.KnownFailure(""), AssertionError)
 
2429
 
 
2430
    def test_expect_failure(self):
 
2431
        try:
 
2432
            self.expectFailure("Doomed to failure", self.assertTrue, False)
 
2433
        except tests.KnownFailure, e:
 
2434
            self.assertEqual('Doomed to failure', e.args[0])
 
2435
        try:
 
2436
            self.expectFailure("Doomed to failure", self.assertTrue, True)
 
2437
        except AssertionError, e:
 
2438
            self.assertEqual('Unexpected success.  Should have failed:'
 
2439
                             ' Doomed to failure', e.args[0])
 
2440
        else:
 
2441
            self.fail('Assertion not raised')
 
2442
 
 
2443
 
2360
2444
class TestFeature(tests.TestCase):
2361
2445
 
2362
2446
    def test_caching(self):
2398
2482
        self.assertIs(feature, exception.args[0])
2399
2483
 
2400
2484
 
2401
 
simple_thunk_feature = tests._CompatabilityThunkFeature(
2402
 
    deprecated_in((2, 1, 0)),
2403
 
    'bzrlib.tests.test_selftest',
2404
 
    'simple_thunk_feature','UnicodeFilename',
2405
 
    replacement_module='bzrlib.tests'
2406
 
    )
2407
 
 
2408
 
class Test_CompatibilityFeature(tests.TestCase):
2409
 
 
2410
 
    def test_does_thunk(self):
2411
 
        res = self.callDeprecated(
2412
 
            ['bzrlib.tests.test_selftest.simple_thunk_feature was deprecated'
2413
 
             ' in version 2.1.0. Use bzrlib.tests.UnicodeFilename instead.'],
2414
 
            simple_thunk_feature.available)
2415
 
        self.assertEqual(tests.UnicodeFilename.available(), res)
2416
 
 
2417
 
 
2418
 
class TestModuleAvailableFeature(tests.TestCase):
2419
 
 
2420
 
    def test_available_module(self):
2421
 
        feature = tests.ModuleAvailableFeature('bzrlib.tests')
2422
 
        self.assertEqual('bzrlib.tests', feature.module_name)
2423
 
        self.assertEqual('bzrlib.tests', str(feature))
2424
 
        self.assertTrue(feature.available())
2425
 
        self.assertIs(tests, feature.module)
2426
 
 
2427
 
    def test_unavailable_module(self):
2428
 
        feature = tests.ModuleAvailableFeature('bzrlib.no_such_module_exists')
2429
 
        self.assertEqual('bzrlib.no_such_module_exists', str(feature))
2430
 
        self.assertFalse(feature.available())
2431
 
        self.assertIs(None, feature.module)
2432
 
 
2433
 
 
2434
2485
class TestSelftestFiltering(tests.TestCase):
2435
2486
 
2436
2487
    def setUp(self):
2615
2666
        # the test framework
2616
2667
        self.assertEquals('always fails', str(e))
2617
2668
        # check that there's no traceback in the test log
2618
 
        self.assertNotContainsRe(self.get_log(), r'Traceback')
 
2669
        self.assertNotContainsRe(self._get_log(keep_log_file=True),
 
2670
            r'Traceback')
2619
2671
 
2620
2672
    def test_run_bzr_user_error_caught(self):
2621
2673
        # Running bzr in blackbox mode, normal/expected/user errors should be
2622
2674
        # caught in the regular way and turned into an error message plus exit
2623
2675
        # code.
2624
 
        transport_server = memory.MemoryServer()
2625
 
        transport_server.start_server()
2626
 
        self.addCleanup(transport_server.stop_server)
 
2676
        transport_server = MemoryServer()
 
2677
        transport_server.setUp()
 
2678
        self.addCleanup(transport_server.tearDown)
2627
2679
        url = transport_server.get_url()
2628
2680
        self.permit_url(url)
2629
2681
        out, err = self.run_bzr(["log", "%s/nonexistantpath" % url], retcode=3)
2773
2825
        # Test that a plausible list of modules to doctest is returned
2774
2826
        # by _test_suite_modules_to_doctest.
2775
2827
        test_list = tests._test_suite_modules_to_doctest()
2776
 
        if __doc__ is None:
2777
 
            # When docstrings are stripped, there are no modules to doctest
2778
 
            self.assertEqual([], test_list)
2779
 
            return
2780
2828
        self.assertSubset([
2781
2829
            'bzrlib.timestamp',
2782
2830
            ],
2789
2837
        # test doubles that supply a few sample tests to load, and check they
2790
2838
        # are loaded.
2791
2839
        calls = []
2792
 
        def testmod_names():
 
2840
        def _test_suite_testmod_names():
2793
2841
            calls.append("testmod_names")
2794
2842
            return [
2795
2843
                'bzrlib.tests.blackbox.test_branch',
2796
2844
                'bzrlib.tests.per_transport',
2797
2845
                'bzrlib.tests.test_selftest',
2798
2846
                ]
2799
 
        self.overrideAttr(tests, '_test_suite_testmod_names', testmod_names)
2800
 
        def doctests():
 
2847
        original_testmod_names = tests._test_suite_testmod_names
 
2848
        def _test_suite_modules_to_doctest():
2801
2849
            calls.append("modules_to_doctest")
2802
 
            if __doc__ is None:
2803
 
                return []
2804
2850
            return ['bzrlib.timestamp']
2805
 
        self.overrideAttr(tests, '_test_suite_modules_to_doctest', doctests)
 
2851
        orig_modules_to_doctest = tests._test_suite_modules_to_doctest
 
2852
        def restore_names():
 
2853
            tests._test_suite_testmod_names = original_testmod_names
 
2854
            tests._test_suite_modules_to_doctest = orig_modules_to_doctest
 
2855
        self.addCleanup(restore_names)
 
2856
        tests._test_suite_testmod_names = _test_suite_testmod_names
 
2857
        tests._test_suite_modules_to_doctest = _test_suite_modules_to_doctest
2806
2858
        expected_test_list = [
2807
2859
            # testmod_names
2808
2860
            'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2809
2861
            ('bzrlib.tests.per_transport.TransportTests'
2810
 
             '.test_abspath(LocalTransport,LocalURLServer)'),
 
2862
             '.test_abspath(LocalURLServer)'),
2811
2863
            'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',
 
2864
            # modules_to_doctest
 
2865
            'bzrlib.timestamp.format_highres_date',
2812
2866
            # plugins can't be tested that way since selftest may be run with
2813
2867
            # --no-plugins
2814
2868
            ]
2815
 
        if __doc__ is not None:
2816
 
            expected_test_list.extend([
2817
 
                # modules_to_doctest
2818
 
                'bzrlib.timestamp.format_highres_date',
2819
 
                ])
2820
2869
        suite = tests.test_suite()
2821
2870
        self.assertEqual(set(["testmod_names", "modules_to_doctest"]),
2822
2871
            set(calls))
2877
2926
    def test_load_tests(self):
2878
2927
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2879
2928
        loader = self._create_loader(test_list)
 
2929
 
2880
2930
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2881
2931
        self.assertEquals(test_list, _test_ids(suite))
2882
2932
 
2883
2933
    def test_exclude_tests(self):
2884
2934
        test_list = ['bogus']
2885
2935
        loader = self._create_loader(test_list)
 
2936
 
2886
2937
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2887
2938
        self.assertEquals([], _test_ids(suite))
2888
2939
 
2933
2984
        tpr.register('bar', 'bbb.aaa.rrr')
2934
2985
        tpr.register('bar', 'bBB.aAA.rRR')
2935
2986
        self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
2936
 
        self.assertThat(self.get_log(),
2937
 
            DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR", ELLIPSIS))
 
2987
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
2988
                              r'.*bar.*bbb.aaa.rrr.*bBB.aAA.rRR')
2938
2989
 
2939
2990
    def test_get_unknown_prefix(self):
2940
2991
        tpr = self._get_registry()