/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 breezy/tests/test_selftest.py

  • Committer: Jelmer Vernooij
  • Date: 2018-11-16 19:47:19 UTC
  • mfrom: (7178 work)
  • mto: This revision was merged to the branch mainline in revision 7179.
  • Revision ID: jelmer@jelmer.uk-20181116194719-m5ut2wfuze5x9s1p
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_selftest.py
103
103
            "text", "plain", {"charset": "utf8"})))
104
104
        self.assertThat(u"".join(log.iter_text()), Equals(self.get_log()))
105
105
        self.assertThat(self.get_log(),
106
 
            DocTestMatches(u"...a test message\n", doctest.ELLIPSIS))
 
106
                        DocTestMatches(u"...a test message\n", doctest.ELLIPSIS))
107
107
 
108
108
 
109
109
class TestTreeShape(tests.TestCaseInTempDir):
162
162
        for module in modules:
163
163
            try:
164
164
                permutation_count += len(reduce(getattr,
165
 
                    (module + ".get_test_permutations").split('.')[1:],
166
 
                     __import__(module))())
 
165
                                                (module
 
166
                                                 + ".get_test_permutations").split('.')[1:],
 
167
                                                __import__(module))())
167
168
            except errors.DependencyNotPresent:
168
169
                pass
169
170
        scenarios = transport_test_permutations()
243
244
                   ("(d)", repository.format_registry.get(
244
245
                    b'Bazaar repository format 2a (needs bzr 1.16 or later)\n'))]
245
246
        no_vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
246
 
            None)
 
247
                                                None)
247
248
        vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
248
 
            vfs_transport_factory="vfs")
 
249
                                             vfs_transport_factory="vfs")
249
250
        # no_vfs generate scenarios without vfs_transport_factory
250
251
        expected = [
251
252
            ('RemoteRepositoryFormat(c)',
283
284
        input_test = TestTestScenarioApplication("test_apply_scenario")
284
285
        # setup two adapted tests
285
286
        adapted_test1 = apply_scenario(input_test,
286
 
            ("new id",
287
 
            {"bzrdir_format":"bzr_format",
288
 
             "repository_format":"repo_fmt",
289
 
             "transport_server":"transport_server",
290
 
             "transport_readonly_server":"readonly-server"}))
 
287
                                       ("new id",
 
288
                                        {"bzrdir_format": "bzr_format",
 
289
                                         "repository_format": "repo_fmt",
 
290
                                         "transport_server": "transport_server",
 
291
                                         "transport_readonly_server": "readonly-server"}))
291
292
        adapted_test2 = apply_scenario(input_test,
292
 
            ("new id 2", {"bzrdir_format":None}))
 
293
                                       ("new id 2", {"bzrdir_format": None}))
293
294
        # input_test should have been altered.
294
295
        self.assertRaises(AttributeError, getattr, input_test, "bzrdir_format")
295
296
        # the new tests are mutually incompatible, ensuring it has
299
300
        self.assertEqual("repo_fmt", adapted_test1.repository_format)
300
301
        self.assertEqual("transport_server", adapted_test1.transport_server)
301
302
        self.assertEqual("readonly-server",
302
 
            adapted_test1.transport_readonly_server)
 
303
                         adapted_test1.transport_readonly_server)
303
304
        self.assertEqual(
304
305
            "breezy.tests.test_selftest.TestTestScenarioApplication."
305
306
            "test_apply_scenario(new id)",
349
350
                   workingtree_3.WorkingTreeFormat3(),
350
351
                   workingtree_4.WorkingTreeFormat6()]
351
352
        scenarios = make_scenarios(server1, server2, formats,
352
 
            remote_server='c', remote_readonly_server='d',
353
 
            remote_backing_server='e')
 
353
                                   remote_server='c', remote_readonly_server='d',
 
354
                                   remote_backing_server='e')
354
355
        self.assertEqual([
355
356
            ('WorkingTreeFormat4',
356
357
             {'bzrdir_format': formats[0]._matchingcontroldir,
403
404
        smart_readonly_server = test_server.ReadonlySmartTCPServer_for_testing
404
405
        mem_server = memory.MemoryServer
405
406
        formats = [workingtree_4.WorkingTreeFormat4(),
406
 
                   workingtree_3.WorkingTreeFormat3(),]
 
407
                   workingtree_3.WorkingTreeFormat3(), ]
407
408
        scenarios = make_scenarios(server1, server2, formats)
408
409
        self.assertEqual(9, len(scenarios))
409
410
        default_wt_format = workingtree.format_registry.get_default()
425
426
              'transport_server': 'a',
426
427
              'workingtree_format': formats[1],
427
428
              '_workingtree_to_test_tree': return_parameter,
428
 
             }),
 
429
              }),
429
430
            ('WorkingTreeFormat6,remote',
430
431
             {'bzrdir_format': wt6_format._matchingcontroldir,
431
432
              'repo_is_remote': True,
434
435
              'vfs_transport_factory': mem_server,
435
436
              'workingtree_format': wt6_format,
436
437
              '_workingtree_to_test_tree': return_parameter,
437
 
             }),
 
438
              }),
438
439
            ('RevisionTree',
439
440
             {'_workingtree_to_test_tree': revision_tree_from_workingtree,
440
441
              'bzrdir_format': default_wt_format._matchingcontroldir,
441
442
              'transport_readonly_server': 'b',
442
443
              'transport_server': 'a',
443
444
              'workingtree_format': default_wt_format,
444
 
             }),
445
 
             ('GitRevisionTree',
446
 
              {'_workingtree_to_test_tree': revision_tree_from_workingtree,
447
 
               'bzrdir_format': git_wt_format._matchingcontroldir,
448
 
               'transport_readonly_server': 'b',
449
 
               'transport_server': 'a',
450
 
               'workingtree_format': git_wt_format,
451
 
             }
452
 
            ),
 
445
              }),
 
446
            ('GitRevisionTree',
 
447
             {'_workingtree_to_test_tree': revision_tree_from_workingtree,
 
448
              'bzrdir_format': git_wt_format._matchingcontroldir,
 
449
              'transport_readonly_server': 'b',
 
450
              'transport_server': 'a',
 
451
              'workingtree_format': git_wt_format,
 
452
              }
 
453
             ),
453
454
            ('DirStateRevisionTree,WT4',
454
455
             {'_workingtree_to_test_tree': _dirstate_tree_from_workingtree,
455
456
              'bzrdir_format': wt4_format._matchingcontroldir,
456
457
              'transport_readonly_server': 'b',
457
458
              'transport_server': 'a',
458
459
              'workingtree_format': wt4_format,
459
 
             }),
 
460
              }),
460
461
            ('DirStateRevisionTree,WT5',
461
462
             {'_workingtree_to_test_tree': _dirstate_tree_from_workingtree,
462
463
              'bzrdir_format': wt5_format._matchingcontroldir,
463
464
              'transport_readonly_server': 'b',
464
465
              'transport_server': 'a',
465
466
              'workingtree_format': wt5_format,
466
 
             }),
 
467
              }),
467
468
            ('PreviewTree',
468
469
             {'_workingtree_to_test_tree': preview_tree_pre,
469
470
              'bzrdir_format': default_wt_format._matchingcontroldir,
476
477
              'transport_readonly_server': 'b',
477
478
              'transport_server': 'a',
478
479
              'workingtree_format': default_wt_format}),
479
 
             ]
 
480
            ]
480
481
        self.assertEqual(expected_scenarios, scenarios)
481
482
 
482
483
 
508
509
        format1 = WorkingTreeFormat4()
509
510
        format2 = WorkingTreeFormat3()
510
511
        formats = [("1", str, format1, format2, "converter1"),
511
 
            ("2", int, format2, format1, "converter2")]
 
512
                   ("2", int, format2, format1, "converter2")]
512
513
        scenarios = make_scenarios(server1, server2, formats)
513
514
        self.assertEqual(2, len(scenarios))
514
515
        expected_scenarios = [
549
550
        self.build_tree(["foo"])
550
551
        real = os.lstat("foo")
551
552
        fake = _FakeStat(real.st_size, real.st_mtime, real.st_ctime,
552
 
            real.st_dev, real.st_ino, real.st_mode)
 
553
                         real.st_dev, real.st_ino, real.st_mode)
553
554
        self.assertEqualStat(real, fake)
554
555
 
555
556
    def test_assertEqualStat_notequal(self):
556
557
        self.build_tree(["foo", "longname"])
557
558
        self.assertRaises(AssertionError, self.assertEqualStat,
558
 
            os.lstat("foo"), os.lstat("longname"))
 
559
                          os.lstat("foo"), os.lstat("longname"))
559
560
 
560
561
    def test_assertPathExists(self):
561
562
        self.assertPathExists('.')
615
616
        self.assertFalse(osutils.lexists('dir'))
616
617
        self.assertIsInstance(tree, memorytree.MemoryTree)
617
618
        self.assertEqual(format.repository_format.__class__,
618
 
            tree.branch.repository._format.__class__)
 
619
                         tree.branch.repository._format.__class__)
619
620
 
620
621
    def test_make_branch_builder(self):
621
622
        builder = self.make_branch_builder('dir')
639
640
                         the_branch.repository._format.__class__)
640
641
        self.assertEqual(repo_format.get_format_string(),
641
642
                         self.get_transport().get_bytes(
642
 
                            'dir/.bzr/repository/format'))
 
643
            'dir/.bzr/repository/format'))
643
644
 
644
645
    def test_make_branch_builder_with_format_name(self):
645
646
        builder = self.make_branch_builder('dir', format='knit')
652
653
                         the_branch.repository._format.__class__)
653
654
        self.assertEqual(b'Bazaar-NG Knit Repository Format 1',
654
655
                         self.get_transport().get_bytes(
655
 
                            'dir/.bzr/repository/format'))
 
656
                             'dir/.bzr/repository/format'))
656
657
 
657
658
    def test_dangling_locks_cause_failures(self):
658
659
        class TestDanglingLock(tests.TestCaseWithMemoryTransport):
710
711
        self.build_tree(['a_dir/', 'a_file'], transport=t)
711
712
        self.assertIsDirectory('a_dir', t)
712
713
        self.assertRaises(AssertionError, self.assertIsDirectory, 'a_file', t)
713
 
        self.assertRaises(AssertionError, self.assertIsDirectory, 'not_here', t)
 
714
        self.assertRaises(
 
715
            AssertionError, self.assertIsDirectory, 'not_here', t)
714
716
 
715
717
    def test_make_branch_builder(self):
716
718
        builder = self.make_branch_builder('dir')
754
756
        self.requireFeature(features.lsprof_feature)
755
757
        terminal = testtools.testresult.doubles.ExtendedTestResult()
756
758
        result = tests.ProfileResult(terminal)
 
759
 
757
760
        class Sample(tests.TestCase):
758
761
            def a(self):
759
762
                self.sample_function()
 
763
 
760
764
            def sample_function(self):
761
765
                pass
762
766
        test = Sample("a")
782
786
        class ShortDelayTestCase(tests.TestCase):
783
787
            def test_short_delay(self):
784
788
                time.sleep(0.003)
 
789
 
785
790
            def test_short_benchmark(self):
786
791
                self.time(time.sleep, 0.003)
787
792
        self.check_timing(ShortDelayTestCase('test_short_delay'),
837
842
        output = result_stream.getvalue()
838
843
        if PY3:
839
844
            self.assertContainsRe(output,
840
 
                r"LSProf output for <class 'str'>\(\(b'hello',\), {'errors': 'replace'}\)")
 
845
                                  r"LSProf output for <class 'str'>\(\(b'hello',\), {'errors': 'replace'}\)")
841
846
            self.assertContainsRe(output,
842
 
                r"LSProf output for <class 'str'>\(\(b'world',\), {'errors': 'replace'}\)")
 
847
                                  r"LSProf output for <class 'str'>\(\(b'world',\), {'errors': 'replace'}\)")
843
848
        else:
844
849
            self.assertContainsRe(output,
845
 
                r"LSProf output for <type 'unicode'>\(\('hello',\), {'errors': 'replace'}\)")
 
850
                                  r"LSProf output for <type 'unicode'>\(\('hello',\), {'errors': 'replace'}\)")
846
851
            self.assertContainsRe(output,
847
 
                r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n")
848
 
        self.assertContainsRe(output,
849
 
            r" *CallCount *Recursive *Total\(ms\) *Inline\(ms\) *module:lineno\(function\)\n")
850
 
        self.assertContainsRe(output,
851
 
            r"( +1 +0 +0\.\d+ +0\.\d+ +<method 'disable' of '_lsprof\.Profiler' objects>\n)?")
 
852
                                  r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n")
 
853
        self.assertContainsRe(output,
 
854
                              r" *CallCount *Recursive *Total\(ms\) *Inline\(ms\) *module:lineno\(function\)\n")
 
855
        self.assertContainsRe(output,
 
856
                              r"( +1 +0 +0\.\d+ +0\.\d+ +<method 'disable' of '_lsprof\.Profiler' objects>\n)?")
852
857
 
853
858
    def test_uses_time_from_testtools(self):
854
859
        """Test case timings in verbose results should use testtools times"""
855
860
        import datetime
 
861
 
856
862
        class TimeAddedVerboseTestResult(tests.VerboseTestResult):
857
863
            def startTest(self, test):
858
864
                self.time(datetime.datetime.utcfromtimestamp(1.145))
859
865
                super(TimeAddedVerboseTestResult, self).startTest(test)
 
866
 
860
867
            def addSuccess(self, test):
861
868
                self.time(datetime.datetime.utcfromtimestamp(51.147))
862
869
                super(TimeAddedVerboseTestResult, self).addSuccess(test)
 
870
 
863
871
            def report_tests_starting(self): pass
864
872
        sio = StringIO()
865
873
        self.get_passing_test().run(TimeAddedVerboseTestResult(sio, 0, 2))
869
877
        """Using knownFailure should trigger several result actions."""
870
878
        class InstrumentedTestResult(tests.ExtendedTestResult):
871
879
            def stopTestRun(self): pass
 
880
 
872
881
            def report_tests_starting(self): pass
 
882
 
873
883
            def report_known_failure(self, test, err=None, details=None):
874
884
                self._call = test, 'known failure'
875
885
        result = InstrumentedTestResult(None, None, None, None)
 
886
 
876
887
        class Test(tests.TestCase):
877
888
            def test_function(self):
878
889
                self.knownFailure('failed!')
899
910
            )
900
911
        _get_test("test_xfail").run(result)
901
912
        self.assertContainsRe(result_stream.getvalue(),
902
 
            "\n\\S+\\.test_xfail\\s+XFAIL\\s+\\d+ms\n"
903
 
            "\\s*(?:Text attachment: )?reason"
904
 
            "(?:\n-+\n|: {{{)"
905
 
            "this_fails"
906
 
            "(?:\n-+\n|}}}\n)")
 
913
                              "\n\\S+\\.test_xfail\\s+XFAIL\\s+\\d+ms\n"
 
914
                              "\\s*(?:Text attachment: )?reason"
 
915
                              "(?:\n-+\n|: {{{)"
 
916
                              "this_fails"
 
917
                              "(?:\n-+\n|}}}\n)")
907
918
 
908
919
    def get_passing_test(self):
909
920
        """Return a test object that can't be run usefully."""
915
926
        """Test the behaviour of invoking addNotSupported."""
916
927
        class InstrumentedTestResult(tests.ExtendedTestResult):
917
928
            def stopTestRun(self): pass
 
929
 
918
930
            def report_tests_starting(self): pass
 
931
 
919
932
            def report_unsupported(self, test, feature):
920
933
                self._call = test, feature
921
934
        result = InstrumentedTestResult(None, None, None, None)
959
972
    def test_unavailable_exception(self):
960
973
        """An UnavailableFeature being raised should invoke addNotSupported."""
961
974
        class InstrumentedTestResult(tests.ExtendedTestResult):
962
 
            def stopTestRun(self): pass
963
 
            def report_tests_starting(self): pass
 
975
            def stopTestRun(self):
 
976
                pass
 
977
 
 
978
            def report_tests_starting(self):
 
979
                pass
 
980
 
964
981
            def addNotSupported(self, test, feature):
965
982
                self._call = test, feature
966
983
        result = InstrumentedTestResult(None, None, None, None)
967
984
        feature = features.Feature()
 
985
 
968
986
        class Test(tests.TestCase):
969
987
            def test_function(self):
970
988
                raise tests.UnavailableFeature(feature)
1003
1021
        """Starting the first test should trigger startTests."""
1004
1022
        class InstrumentedTestResult(tests.ExtendedTestResult):
1005
1023
            calls = 0
1006
 
            def startTests(self): self.calls += 1
 
1024
 
 
1025
            def startTests(self):
 
1026
                self.calls += 1
1007
1027
        result = InstrumentedTestResult(None, None, None, None)
 
1028
 
1008
1029
        def test_function():
1009
1030
            pass
1010
1031
        test = unittest.FunctionTestCase(test_function)
1015
1036
        """With multiple tests startTests should still only be called once"""
1016
1037
        class InstrumentedTestResult(tests.ExtendedTestResult):
1017
1038
            calls = 0
1018
 
            def startTests(self): self.calls += 1
 
1039
 
 
1040
            def startTests(self):
 
1041
                self.calls += 1
1019
1042
        result = InstrumentedTestResult(None, None, None, None)
1020
1043
        suite = unittest.TestSuite([
1021
1044
            unittest.FunctionTestCase(lambda: None),
1055
1078
                self.expectFailure('failed', self.assertTrue, False)
1056
1079
        test = unittest.TestSuite()
1057
1080
        test.addTest(Test("known_failure_test"))
 
1081
 
1058
1082
        def failing_test():
1059
1083
            raise AssertionError('foo')
1060
1084
        test.addTest(unittest.FunctionTestCase(failing_test))
1061
1085
        stream = StringIO()
1062
1086
        runner = tests.TextTestRunner(stream=stream)
1063
 
        result = self.run_test_runner(runner, test)
1064
 
        lines = stream.getvalue().splitlines()
1065
 
        self.assertContainsRe(stream.getvalue(),
 
1087
        self.run_test_runner(runner, test)
 
1088
        self.assertContainsRe(
 
1089
            stream.getvalue(),
1066
1090
            '(?sm)^brz selftest.*$'
1067
1091
            '.*'
1068
1092
            '^======================================================================\n'
1069
1093
            '^FAIL: failing_test\n'
1070
1094
            '^----------------------------------------------------------------------\n'
1071
1095
            'Traceback \\(most recent call last\\):\n'
1072
 
            '  .*' # File .*, line .*, in failing_test' - but maybe not from .pyc
 
1096
            '  .*'  # File .*, line .*, in failing_test' - but maybe not from .pyc
1073
1097
            '    raise AssertionError\\(\'foo\'\\)\n'
1074
1098
            '.*'
1075
1099
            '^----------------------------------------------------------------------\n'
1086
1110
        test = Test("known_failure_test")
1087
1111
        stream = StringIO()
1088
1112
        runner = tests.TextTestRunner(stream=stream)
1089
 
        result = self.run_test_runner(runner, test)
 
1113
        self.run_test_runner(runner, test)
1090
1114
        self.assertContainsRe(stream.getvalue(),
1091
 
            '\n'
1092
 
            '-*\n'
1093
 
            'Ran 1 test in .*\n'
1094
 
            '\n'
1095
 
            'OK \\(known_failures=1\\)\n')
 
1115
                              '\n'
 
1116
                              '-*\n'
 
1117
                              'Ran 1 test in .*\n'
 
1118
                              '\n'
 
1119
                              'OK \\(known_failures=1\\)\n')
1096
1120
 
1097
1121
    def test_unexpected_success_bad(self):
1098
1122
        class Test(tests.TestCase):
1099
1123
            def test_truth(self):
1100
1124
                self.expectFailure("No absolute truth", self.assertTrue, True)
1101
1125
        runner = tests.TextTestRunner(stream=StringIO())
1102
 
        result = self.run_test_runner(runner, Test("test_truth"))
 
1126
        self.run_test_runner(runner, Test("test_truth"))
1103
1127
        self.assertContainsRe(runner.stream.getvalue(),
1104
 
            "=+\n"
1105
 
            "FAIL: \\S+\\.test_truth\n"
1106
 
            "-+\n"
1107
 
            "(?:.*\n)*"
1108
 
            "\\s*(?:Text attachment: )?reason"
1109
 
            "(?:\n-+\n|: {{{)"
1110
 
            "No absolute truth"
1111
 
            "(?:\n-+\n|}}}\n)"
1112
 
            "(?:.*\n)*"
1113
 
            "-+\n"
1114
 
            "Ran 1 test in .*\n"
1115
 
            "\n"
1116
 
            "FAILED \\(failures=1\\)\n\\Z")
 
1128
                              "=+\n"
 
1129
                              "FAIL: \\S+\\.test_truth\n"
 
1130
                              "-+\n"
 
1131
                              "(?:.*\n)*"
 
1132
                              "\\s*(?:Text attachment: )?reason"
 
1133
                              "(?:\n-+\n|: {{{)"
 
1134
                              "No absolute truth"
 
1135
                              "(?:\n-+\n|}}}\n)"
 
1136
                              "(?:.*\n)*"
 
1137
                              "-+\n"
 
1138
                              "Ran 1 test in .*\n"
 
1139
                              "\n"
 
1140
                              "FAILED \\(failures=1\\)\n\\Z")
1117
1141
 
1118
1142
    def test_result_decorator(self):
1119
1143
        # decorate results
1120
1144
        calls = []
 
1145
 
1121
1146
        class LoggingDecorator(ExtendedToOriginalDecorator):
1122
1147
            def startTest(self, test):
1123
1148
                ExtendedToOriginalDecorator.startTest(self, test)
1124
1149
                calls.append('start')
1125
 
        test = unittest.FunctionTestCase(lambda:None)
 
1150
        test = unittest.FunctionTestCase(lambda: None)
1126
1151
        stream = StringIO()
1127
1152
        runner = tests.TextTestRunner(stream=stream,
1128
 
            result_decorators=[LoggingDecorator])
1129
 
        result = self.run_test_runner(runner, test)
 
1153
                                      result_decorators=[LoggingDecorator])
 
1154
        self.run_test_runner(runner, test)
1130
1155
        self.assertLength(1, calls)
1131
1156
 
1132
1157
    def test_skipped_test(self):
1143
1168
 
1144
1169
    def test_skipped_from_setup(self):
1145
1170
        calls = []
 
1171
 
1146
1172
        class SkippedSetupTest(tests.TestCase):
1147
1173
 
1148
1174
            def setUp(self):
1165
1191
 
1166
1192
    def test_skipped_from_test(self):
1167
1193
        calls = []
 
1194
 
1168
1195
        class SkippedTest(tests.TestCase):
1169
1196
 
1170
1197
            def setUp(self):
1198
1225
        self.assertTrue(result.wasSuccessful())
1199
1226
        self.assertTrue(result.wasStrictlySuccessful())
1200
1227
        self.assertContainsRe(out.getvalue(),
1201
 
                r'(?m)not_applicable_test  * N/A')
 
1228
                              r'(?m)not_applicable_test  * N/A')
1202
1229
        self.assertContainsRe(out.getvalue(),
1203
 
                r'(?m)^    this test never runs')
 
1230
                              r'(?m)^    this test never runs')
1204
1231
 
1205
1232
    def test_unsupported_features_listed(self):
1206
1233
        """When unsupported features are encountered they are detailed."""
1207
1234
        class Feature1(features.Feature):
1208
 
            def _probe(self): return False
 
1235
            def _probe(self):
 
1236
                return False
 
1237
 
1209
1238
        class Feature2(features.Feature):
1210
 
            def _probe(self): return False
 
1239
            def _probe(self):
 
1240
                return False
1211
1241
        # create sample tests
1212
1242
        test1 = SampleTestCase('_test_pass')
1213
1243
        test1._test_needs_features = [Feature1()]
1218
1248
        test.addTest(test2)
1219
1249
        stream = StringIO()
1220
1250
        runner = tests.TextTestRunner(stream=stream)
1221
 
        result = self.run_test_runner(runner, test)
 
1251
        self.run_test_runner(runner, test)
1222
1252
        lines = stream.getvalue().splitlines()
1223
1253
        self.assertEqual([
1224
1254
            'OK',
1236
1266
        stream = StringIO()
1237
1267
        runner = tests.TextTestRunner(stream=stream, verbosity=2)
1238
1268
        # Need to use the CountingDecorator as that's what sets num_tests
1239
 
        result = self.run_test_runner(runner, tests.CountingDecorator(suite))
 
1269
        self.run_test_runner(runner, tests.CountingDecorator(suite))
1240
1270
        self.assertStartsWith(stream.getvalue(), "running 2 tests")
1241
1271
 
1242
1272
    def test_startTestRun(self):
1243
1273
        """run should call result.startTestRun()"""
1244
1274
        calls = []
 
1275
 
1245
1276
        class LoggingDecorator(ExtendedToOriginalDecorator):
1246
1277
            def startTestRun(self):
1247
1278
                ExtendedToOriginalDecorator.startTestRun(self)
1248
1279
                calls.append('startTestRun')
1249
 
        test = unittest.FunctionTestCase(lambda:None)
 
1280
        test = unittest.FunctionTestCase(lambda: None)
1250
1281
        stream = StringIO()
1251
1282
        runner = tests.TextTestRunner(stream=stream,
1252
 
            result_decorators=[LoggingDecorator])
1253
 
        result = self.run_test_runner(runner, test)
 
1283
                                      result_decorators=[LoggingDecorator])
 
1284
        self.run_test_runner(runner, test)
1254
1285
        self.assertLength(1, calls)
1255
1286
 
1256
1287
    def test_stopTestRun(self):
1257
1288
        """run should call result.stopTestRun()"""
1258
1289
        calls = []
 
1290
 
1259
1291
        class LoggingDecorator(ExtendedToOriginalDecorator):
1260
1292
            def stopTestRun(self):
1261
1293
                ExtendedToOriginalDecorator.stopTestRun(self)
1262
1294
                calls.append('stopTestRun')
1263
 
        test = unittest.FunctionTestCase(lambda:None)
 
1295
        test = unittest.FunctionTestCase(lambda: None)
1264
1296
        stream = StringIO()
1265
1297
        runner = tests.TextTestRunner(stream=stream,
1266
 
            result_decorators=[LoggingDecorator])
1267
 
        result = self.run_test_runner(runner, test)
 
1298
                                      result_decorators=[LoggingDecorator])
 
1299
        self.run_test_runner(runner, test)
1268
1300
        self.assertLength(1, calls)
1269
1301
 
1270
1302
    def test_unicode_test_output_on_ascii_stream(self):
1279
1311
        else:
1280
1312
            bio = out = StringIO()
1281
1313
        self.overrideAttr(osutils, "get_terminal_encoding",
1282
 
            lambda trace=False: "ascii")
1283
 
        result = self.run_test_runner(tests.TextTestRunner(stream=out),
 
1314
                          lambda trace=False: "ascii")
 
1315
        self.run_test_runner(
 
1316
            tests.TextTestRunner(stream=out),
1284
1317
            FailureWithUnicode("test_log_unicode"))
1285
1318
        out.flush()
1286
1319
        self.assertContainsRe(bio.getvalue(),
1287
 
            b"(?:Text attachment: )?log"
1288
 
            b"(?:\n-+\n|: {{{)"
1289
 
            b"\\d+\\.\\d+  \\\\u2606"
1290
 
            b"(?:\n-+\n|}}}\n)")
 
1320
                              b"(?:Text attachment: )?log"
 
1321
                              b"(?:\n-+\n|: {{{)"
 
1322
                              b"\\d+\\.\\d+  \\\\u2606"
 
1323
                              b"(?:\n-+\n|}}}\n)")
1291
1324
 
1292
1325
 
1293
1326
class SampleTestCase(tests.TestCase):
1295
1328
    def _test_pass(self):
1296
1329
        pass
1297
1330
 
 
1331
 
1298
1332
class _TestException(Exception):
1299
1333
    pass
1300
1334
 
1317
1351
    def test_assertLength_shows_sequence_in_failure(self):
1318
1352
        a_list = [1, 2, 3]
1319
1353
        exception = self.assertRaises(AssertionError, self.assertLength, 2,
1320
 
            a_list)
 
1354
                                      a_list)
1321
1355
        self.assertEqual('Incorrect length: wanted 2, got 3 for [1, 2, 3]',
1322
 
            exception.args[0])
 
1356
                         exception.args[0])
1323
1357
 
1324
1358
    def test_base_setUp_not_called_causes_failure(self):
1325
1359
        class TestCaseWithBrokenSetUp(tests.TestCase):
1326
1360
            def setUp(self):
1327
 
                pass # does not call TestCase.setUp
 
1361
                pass  # does not call TestCase.setUp
 
1362
 
1328
1363
            def test_foo(self):
1329
1364
                pass
1330
1365
        test = TestCaseWithBrokenSetUp('test_foo')
1336
1371
    def test_base_tearDown_not_called_causes_failure(self):
1337
1372
        class TestCaseWithBrokenTearDown(tests.TestCase):
1338
1373
            def tearDown(self):
1339
 
                pass # does not call TestCase.tearDown
 
1374
                pass  # does not call TestCase.tearDown
 
1375
 
1340
1376
            def test_foo(self):
1341
1377
                pass
1342
1378
        test = TestCaseWithBrokenTearDown('test_foo')
1367
1403
        """
1368
1404
        self.change_selftest_debug_flags({'allow_debug'})
1369
1405
        breezy.debug.debug_flags = {'a-flag'}
 
1406
 
1370
1407
        class TestThatRecordsFlags(tests.TestCase):
1371
1408
            def test_foo(nested_self):
1372
1409
                self.flags = set(breezy.debug.debug_flags)
1417
1454
        self.change_selftest_debug_flags({'allow_debug'})
1418
1455
        # Now run a test that modifies debug.debug_flags.
1419
1456
        breezy.debug.debug_flags = {'original-state'}
 
1457
 
1420
1458
        class TestThatModifiesFlags(tests.TestCase):
1421
1459
            def test_foo(self):
1422
1460
                breezy.debug.debug_flags = {'modified'}
1465
1503
        self.time(time.sleep, 0.007)
1466
1504
 
1467
1505
    def test_time_creates_benchmark_in_result(self):
1468
 
        """Test that the TestCase.time() method accumulates a benchmark time."""
 
1506
        """The TestCase.time() method accumulates a benchmark time."""
1469
1507
        sample_test = TestTestCase("method_that_times_a_bit_twice")
1470
1508
        output_stream = StringIO()
1471
1509
        result = breezy.tests.VerboseTestResult(
1482
1520
        # Note this test won't fail with hooks that the core library doesn't
1483
1521
        # use - but it trigger with a plugin that adds hooks, so its still a
1484
1522
        # useful warning in that case.
1485
 
        self.assertEqual(breezy.branch.BranchHooks(), breezy.branch.Branch.hooks)
 
1523
        self.assertEqual(breezy.branch.BranchHooks(),
 
1524
                         breezy.branch.Branch.hooks)
1486
1525
        self.assertEqual(
1487
1526
            breezy.bzr.smart.server.SmartServerHooks(),
1488
1527
            breezy.bzr.smart.server.SmartTCPServer.hooks)
1512
1551
        self.assertRaises(tests.KnownFailure, self.knownFailure, "A Failure")
1513
1552
 
1514
1553
    def test_open_bzrdir_safe_roots(self):
1515
 
        # even a memory transport should fail to open when its url isn't 
 
1554
        # even a memory transport should fail to open when its url isn't
1516
1555
        # permitted.
1517
1556
        # Manually set one up (TestCase doesn't and shouldn't provide magic
1518
1557
        # machinery)
1522
1561
        t = transport.get_transport_from_url(transport_server.get_url())
1523
1562
        controldir.ControlDir.create(t.base)
1524
1563
        self.assertRaises(errors.BzrError,
1525
 
            controldir.ControlDir.open_from_transport, t)
 
1564
                          controldir.ControlDir.open_from_transport, t)
1526
1565
        # But if we declare this as safe, we can open the bzrdir.
1527
1566
        self.permit_url(t.base)
1528
1567
        self._bzr_selftest_roots.append(t.base)
1531
1570
    def test_requireFeature_available(self):
1532
1571
        """self.requireFeature(available) is a no-op."""
1533
1572
        class Available(features.Feature):
1534
 
            def _probe(self):return True
 
1573
            def _probe(self):
 
1574
                return True
1535
1575
        feature = Available()
1536
1576
        self.requireFeature(feature)
1537
1577
 
1538
1578
    def test_requireFeature_unavailable(self):
1539
1579
        """self.requireFeature(unavailable) raises UnavailableFeature."""
1540
1580
        class Unavailable(features.Feature):
1541
 
            def _probe(self):return False
 
1581
            def _probe(self):
 
1582
                return False
1542
1583
        feature = Unavailable()
1543
1584
        self.assertRaises(tests.UnavailableFeature,
1544
1585
                          self.requireFeature, feature)
1550
1591
    def test_run_enabled_unittest_result(self):
1551
1592
        """Test we revert to regular behaviour when the test is enabled."""
1552
1593
        test = SampleTestCase('_test_pass')
 
1594
 
1553
1595
        class EnabledFeature(object):
1554
1596
            def available(self):
1555
1597
                return True
1563
1605
    def test_run_disabled_unittest_result(self):
1564
1606
        """Test our compatability for disabled tests with unittest results."""
1565
1607
        test = SampleTestCase('_test_pass')
 
1608
 
1566
1609
        class DisabledFeature(object):
1567
1610
            def available(self):
1568
1611
                return False
1576
1619
    def test_run_disabled_supporting_result(self):
1577
1620
        """Test disabled tests behaviour with support aware results."""
1578
1621
        test = SampleTestCase('_test_pass')
 
1622
 
1579
1623
        class DisabledFeature(object):
1580
1624
            def __eq__(self, other):
1581
1625
                return isinstance(other, DisabledFeature)
 
1626
 
1582
1627
            def available(self):
1583
1628
                return False
1584
1629
        the_feature = DisabledFeature()
1585
1630
        test._test_needs_features = [the_feature]
 
1631
 
1586
1632
        class InstrumentedTestResult(unittest.TestResult):
1587
1633
            def __init__(self):
1588
1634
                unittest.TestResult.__init__(self)
1589
1635
                self.calls = []
 
1636
 
1590
1637
            def startTest(self, test):
1591
1638
                self.calls.append(('startTest', test))
 
1639
 
1592
1640
            def stopTest(self, test):
1593
1641
                self.calls.append(('stopTest', test))
 
1642
 
1594
1643
            def addNotSupported(self, test, feature):
1595
1644
                self.calls.append(('addNotSupported', test, feature))
1596
1645
        result = InstrumentedTestResult()
1609
1658
        self.assertEqual([], self._bzr_selftest_roots)
1610
1659
        self.start_server(transport_server)
1611
1660
        self.assertSubset([transport_server.get_url()],
1612
 
            self._bzr_selftest_roots)
 
1661
                          self._bzr_selftest_roots)
1613
1662
 
1614
1663
    def test_assert_list_raises_on_generator(self):
1615
1664
        def generator_which_will_raise():
1647
1696
            raise _NotTestException()
1648
1697
 
1649
1698
        # Wrong exceptions are not intercepted
1650
 
        self.assertRaises(_NotTestException,
 
1699
        self.assertRaises(
 
1700
            _NotTestException,
1651
1701
            self.assertListRaises, _TestException, wrong_exception)
1652
 
        self.assertRaises(_NotTestException,
 
1702
        self.assertRaises(
 
1703
            _NotTestException,
1653
1704
            self.assertListRaises, _TestException, wrong_exception_generator)
1654
1705
 
1655
1706
    def test_assert_list_raises_no_exception(self):
1661
1712
            yield 2
1662
1713
 
1663
1714
        self.assertRaises(AssertionError,
1664
 
            self.assertListRaises, _TestException, success)
 
1715
                          self.assertListRaises, _TestException, success)
1665
1716
 
1666
 
        self.assertRaises(AssertionError,
 
1717
        self.assertRaises(
 
1718
            AssertionError,
1667
1719
            self.assertListRaises, _TestException, success_generator)
1668
1720
 
1669
1721
    def _run_successful_test(self, test):
1673
1725
        return result
1674
1726
 
1675
1727
    def test_overrideAttr_without_value(self):
1676
 
        self.test_attr = 'original' # Define a test attribute
1677
 
        obj = self # Make 'obj' visible to the embedded test
 
1728
        self.test_attr = 'original'  # Define a test attribute
 
1729
        obj = self  # Make 'obj' visible to the embedded test
 
1730
 
1678
1731
        class Test(tests.TestCase):
1679
1732
 
1680
1733
            def setUp(self):
1691
1744
        self.assertEqual('original', obj.test_attr)
1692
1745
 
1693
1746
    def test_overrideAttr_with_value(self):
1694
 
        self.test_attr = 'original' # Define a test attribute
1695
 
        obj = self # Make 'obj' visible to the embedded test
 
1747
        self.test_attr = 'original'  # Define a test attribute
 
1748
        obj = self  # Make 'obj' visible to the embedded test
 
1749
 
1696
1750
        class Test(tests.TestCase):
1697
1751
 
1698
1752
            def setUp(self):
1708
1762
 
1709
1763
    def test_overrideAttr_with_no_existing_value_and_value(self):
1710
1764
        # Do not define the test_attribute
1711
 
        obj = self # Make 'obj' visible to the embedded test
 
1765
        obj = self  # Make 'obj' visible to the embedded test
 
1766
 
1712
1767
        class Test(tests.TestCase):
1713
1768
 
1714
1769
            def setUp(self):
1724
1779
 
1725
1780
    def test_overrideAttr_with_no_existing_value_and_no_value(self):
1726
1781
        # Do not define the test_attribute
1727
 
        obj = self # Make 'obj' visible to the embedded test
 
1782
        obj = self  # Make 'obj' visible to the embedded test
 
1783
 
1728
1784
        class Test(tests.TestCase):
1729
1785
 
1730
1786
            def setUp(self):
1743
1799
        calls = self.recordCalls(
1744
1800
            test_selftest, '_add_numbers')
1745
1801
        self.assertEqual(test_selftest._add_numbers(2, 10),
1746
 
            12)
 
1802
                         12)
1747
1803
        self.assertEqual(calls, [((2, 10), {})])
1748
1804
 
1749
1805
 
1754
1810
class _MissingFeature(features.Feature):
1755
1811
    def _probe(self):
1756
1812
        return False
 
1813
 
 
1814
 
1757
1815
missing_feature = _MissingFeature()
1758
1816
 
1759
1817
 
1809
1867
        self.assertEqual(1, len(result.failures))
1810
1868
        result_content = result.failures[0][1]
1811
1869
        self.assertContainsRe(result_content,
1812
 
            '(?m)^(?:Text attachment: )?log(?:$|: )')
 
1870
                              '(?m)^(?:Text attachment: )?log(?:$|: )')
1813
1871
        self.assertContainsRe(result_content, 'this was a failing test')
1814
1872
 
1815
1873
    def test_error_has_log(self):
1817
1875
        self.assertEqual(1, len(result.errors))
1818
1876
        result_content = result.errors[0][1]
1819
1877
        self.assertContainsRe(result_content,
1820
 
            '(?m)^(?:Text attachment: )?log(?:$|: )')
 
1878
                              '(?m)^(?:Text attachment: )?log(?:$|: )')
1821
1879
        self.assertContainsRe(result_content, 'this test errored')
1822
1880
 
1823
1881
    def test_skip_has_no_log(self):
1845
1903
        self.assertEqual(1, len(result.expectedFailures))
1846
1904
        result_content = result.expectedFailures[0][1]
1847
1905
        self.assertNotContainsRe(result_content,
1848
 
            '(?m)^(?:Text attachment: )?log(?:$|: )')
 
1906
                                 '(?m)^(?:Text attachment: )?log(?:$|: )')
1849
1907
        self.assertNotContainsRe(result_content, 'test with expected failure')
1850
1908
 
1851
1909
    def test_unexpected_success_has_log(self):
1926
1984
        self.assertIsInstance(2, int)
1927
1985
        self.assertIsInstance(u'', (str, text_type))
1928
1986
        e = self.assertRaises(AssertionError, self.assertIsInstance, None, int)
1929
 
        self.assertIn(str(e),
1930
 
            ["None is an instance of <type 'NoneType'> rather than <type 'int'>",
1931
 
             "None is an instance of <class 'NoneType'> rather than <class 'int'>"])
 
1987
        self.assertIn(
 
1988
            str(e),
 
1989
            ["None is an instance of <type 'NoneType'> rather than "
 
1990
             "<type 'int'>",
 
1991
             "None is an instance of <class 'NoneType'> rather than "
 
1992
             "<class 'int'>"])
1932
1993
        self.assertRaises(AssertionError, self.assertIsInstance, 23.3, int)
1933
1994
        e = self.assertRaises(AssertionError,
1934
 
            self.assertIsInstance, None, int, "it's just not")
 
1995
                              self.assertIsInstance, None, int,
 
1996
                              "it's just not")
1935
1997
        if PY3:
1936
 
            self.assertEqual(str(e),
1937
 
                "None is an instance of <class 'NoneType'> rather than <class 'int'>: it's "
1938
 
                "just not")
 
1998
            self.assertEqual(
 
1999
                str(e),
 
2000
                "None is an instance of <class 'NoneType'> rather "
 
2001
                "than <class 'int'>: it's just not")
1939
2002
        else:
1940
 
            self.assertEqual(str(e),
1941
 
                "None is an instance of <type 'NoneType'> rather than <type 'int'>"
1942
 
                ": it's just not")
 
2003
            self.assertEqual(
 
2004
                str(e),
 
2005
                "None is an instance of <type 'NoneType'> "
 
2006
                "rather than <type 'int'>: it's just not")
1943
2007
 
1944
2008
    def test_assertEndsWith(self):
1945
2009
        self.assertEndsWith('foo', 'oo')
1949
2013
        e = self.assertRaises(AssertionError,
1950
2014
                              self.assertEqualDiff, '', '\n')
1951
2015
        self.assertEqual(str(e),
1952
 
                          # Don't blink ! The '+' applies to the second string
1953
 
                          'first string is missing a final newline.\n+ \n')
 
2016
                         # Don't blink ! The '+' applies to the second string
 
2017
                         'first string is missing a final newline.\n+ \n')
1954
2018
        e = self.assertRaises(AssertionError,
1955
2019
                              self.assertEqualDiff, '\n', '')
1956
2020
        self.assertEqual(str(e),
1957
 
                          # Don't blink ! The '-' applies to the second string
1958
 
                          'second string is missing a final newline.\n- \n')
 
2021
                         # Don't blink ! The '-' applies to the second string
 
2022
                         'second string is missing a final newline.\n- \n')
1959
2023
 
1960
2024
 
1961
2025
class TestDeprecations(tests.TestCase):
1964
2028
        sample_object = ApplyDeprecatedHelper()
1965
2029
        # calling an undeprecated callable raises an assertion
1966
2030
        self.assertRaises(AssertionError, self.applyDeprecated,
1967
 
            deprecated_in((0, 11, 0)),
1968
 
            sample_object.sample_normal_method)
 
2031
                          deprecated_in((0, 11, 0)),
 
2032
                          sample_object.sample_normal_method)
1969
2033
        self.assertRaises(AssertionError, self.applyDeprecated,
1970
 
            deprecated_in((0, 11, 0)),
1971
 
            sample_undeprecated_function, "a param value")
 
2034
                          deprecated_in((0, 11, 0)),
 
2035
                          sample_undeprecated_function, "a param value")
1972
2036
        # calling a deprecated callable (function or method) with the wrong
1973
2037
        # expected deprecation fails.
1974
2038
        self.assertRaises(AssertionError, self.applyDeprecated,
1975
 
            deprecated_in((0, 10, 0)),
1976
 
            sample_object.sample_deprecated_method, "a param value")
 
2039
                          deprecated_in((0, 10, 0)),
 
2040
                          sample_object.sample_deprecated_method,
 
2041
                          "a param value")
1977
2042
        self.assertRaises(AssertionError, self.applyDeprecated,
1978
 
            deprecated_in((0, 10, 0)),
1979
 
            sample_deprecated_function)
 
2043
                          deprecated_in((0, 10, 0)),
 
2044
                          sample_deprecated_function)
1980
2045
        # calling a deprecated callable (function or method) with the right
1981
2046
        # expected deprecation returns the functions result.
1982
 
        self.assertEqual("a param value",
1983
 
            self.applyDeprecated(deprecated_in((0, 11, 0)),
1984
 
            sample_object.sample_deprecated_method, "a param value"))
 
2047
        self.assertEqual(
 
2048
            "a param value",
 
2049
            self.applyDeprecated(
 
2050
                deprecated_in((0, 11, 0)),
 
2051
                sample_object.sample_deprecated_method, "a param value"))
1985
2052
        self.assertEqual(2, self.applyDeprecated(deprecated_in((0, 11, 0)),
1986
 
            sample_deprecated_function))
 
2053
                                                 sample_deprecated_function))
1987
2054
        # calling a nested deprecation with the wrong deprecation version
1988
2055
        # fails even if a deeper nested function was deprecated with the
1989
2056
        # supplied version.
1990
 
        self.assertRaises(AssertionError, self.applyDeprecated,
 
2057
        self.assertRaises(
 
2058
            AssertionError, self.applyDeprecated,
1991
2059
            deprecated_in((0, 11, 0)), sample_object.sample_nested_deprecation)
1992
2060
        # calling a nested deprecation with the right deprecation value
1993
2061
        # returns the calls result.
1994
 
        self.assertEqual(2, self.applyDeprecated(deprecated_in((0, 10, 0)),
1995
 
            sample_object.sample_nested_deprecation))
 
2062
        self.assertEqual(
 
2063
            2, self.applyDeprecated(
 
2064
                deprecated_in((0, 10, 0)),
 
2065
                sample_object.sample_nested_deprecation))
1996
2066
 
1997
2067
    def test_callDeprecated(self):
1998
2068
        def testfunc(be_deprecated, result=None):
2029
2099
 
2030
2100
    def test_make_branch_and_tree_with_format(self):
2031
2101
        # we should be able to supply a format to make_branch_and_tree
2032
 
        self.make_branch_and_tree('a', format=breezy.bzr.bzrdir.BzrDirMetaFormat1())
 
2102
        self.make_branch_and_tree(
 
2103
            'a', format=breezy.bzr.bzrdir.BzrDirMetaFormat1())
2033
2104
        self.assertIsInstance(breezy.controldir.ControlDir.open('a')._format,
2034
2105
                              breezy.bzr.bzrdir.BzrDirMetaFormat1)
2035
2106
 
2049
2120
        base = tree.controldir.root_transport.base
2050
2121
        self.assertStartsWith(base, 'file://')
2051
2122
        self.assertEqual(tree.controldir.root_transport,
2052
 
                tree.branch.controldir.root_transport)
 
2123
                         tree.branch.controldir.root_transport)
2053
2124
        self.assertEqual(tree.controldir.root_transport,
2054
 
                tree.branch.repository.controldir.root_transport)
 
2125
                         tree.branch.repository.controldir.root_transport)
2055
2126
 
2056
2127
 
2057
2128
class SelfTestHelper(object):
2081
2152
class TestSelftest(tests.TestCase, SelfTestHelper):
2082
2153
    """Tests of breezy.tests.selftest."""
2083
2154
 
2084
 
    def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
 
2155
    def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(
 
2156
            self):
2085
2157
        factory_called = []
 
2158
 
2086
2159
        def factory():
2087
2160
            factory_called.append(True)
2088
2161
            return TestUtil.TestSuite()
2089
2162
        out = StringIO()
2090
2163
        err = StringIO()
2091
2164
        self.apply_redirected(out, err, None, breezy.tests.selftest,
2092
 
            test_suite_factory=factory)
 
2165
                              test_suite_factory=factory)
2093
2166
        self.assertEqual([True], factory_called)
2094
2167
 
2095
2168
    def factory(self):
2097
2170
        class Test(tests.TestCase):
2098
2171
            def id(self):
2099
2172
                return __name__ + ".Test." + self._testMethodName
 
2173
 
2100
2174
            def a(self):
2101
2175
                pass
 
2176
 
2102
2177
            def b(self):
2103
2178
                pass
 
2179
 
2104
2180
            def c(telf):
2105
2181
                pass
2106
2182
        return TestUtil.TestSuite([Test("a"), Test("b"), Test("c")])
2107
2183
 
2108
2184
    def test_list_only(self):
2109
2185
        output = self.run_selftest(test_suite_factory=self.factory,
2110
 
            list_only=True)
 
2186
                                   list_only=True)
2111
2187
        self.assertEqual(3, len(output.readlines()))
2112
2188
 
2113
2189
    def test_list_only_filtered(self):
2114
2190
        output = self.run_selftest(test_suite_factory=self.factory,
2115
 
            list_only=True, pattern="Test.b")
 
2191
                                   list_only=True, pattern="Test.b")
2116
2192
        self.assertEndsWith(output.getvalue(), b"Test.b\n")
2117
2193
        self.assertLength(1, output.readlines())
2118
2194
 
2119
2195
    def test_list_only_excludes(self):
2120
2196
        output = self.run_selftest(test_suite_factory=self.factory,
2121
 
            list_only=True, exclude_pattern="Test.b")
 
2197
                                   list_only=True, exclude_pattern="Test.b")
2122
2198
        self.assertNotContainsRe(b"Test.b", output.getvalue())
2123
2199
        self.assertLength(2, output.readlines())
2124
2200
 
2125
2201
    def test_lsprof_tests(self):
2126
2202
        self.requireFeature(features.lsprof_feature)
2127
2203
        results = []
 
2204
 
2128
2205
        class Test(object):
2129
2206
            def __call__(test, result):
2130
2207
                test.run(result)
 
2208
 
2131
2209
            def run(test, result):
2132
2210
                results.append(result)
 
2211
 
2133
2212
            def countTestCases(self):
2134
2213
                return 1
2135
2214
        self.run_selftest(test_suite_factory=Test, lsprof_tests=True)
2139
2218
    def test_random(self):
2140
2219
        # test randomising by listing a number of tests.
2141
2220
        output_123 = self.run_selftest(test_suite_factory=self.factory,
2142
 
            list_only=True, random_seed="123")
 
2221
                                       list_only=True, random_seed="123")
2143
2222
        output_234 = self.run_selftest(test_suite_factory=self.factory,
2144
 
            list_only=True, random_seed="234")
 
2223
                                       list_only=True, random_seed="234")
2145
2224
        self.assertNotEqual(output_123, output_234)
2146
2225
        # "Randominzing test order..\n\n
2147
2226
        self.assertLength(5, output_123.readlines())
2150
2229
    def test_random_reuse_is_same_order(self):
2151
2230
        # test randomising by listing a number of tests.
2152
2231
        expected = self.run_selftest(test_suite_factory=self.factory,
2153
 
            list_only=True, random_seed="123")
 
2232
                                     list_only=True, random_seed="123")
2154
2233
        repeated = self.run_selftest(test_suite_factory=self.factory,
2155
 
            list_only=True, random_seed="123")
 
2234
                                     list_only=True, random_seed="123")
2156
2235
        self.assertEqual(expected.getvalue(), repeated.getvalue())
2157
2236
 
2158
2237
    def test_runner_class(self):
2168
2247
 
2169
2248
    def test_starting_with_single_argument(self):
2170
2249
        output = self.run_selftest(test_suite_factory=self.factory,
2171
 
            starting_with=['breezy.tests.test_selftest.Test.a'],
2172
 
            list_only=True)
 
2250
                                   starting_with=[
 
2251
                                       'breezy.tests.test_selftest.Test.a'],
 
2252
                                   list_only=True)
2173
2253
        self.assertEqual(b'breezy.tests.test_selftest.Test.a\n',
2174
 
            output.getvalue())
 
2254
                         output.getvalue())
2175
2255
 
2176
2256
    def test_starting_with_multiple_argument(self):
2177
 
        output = self.run_selftest(test_suite_factory=self.factory,
 
2257
        output = self.run_selftest(
 
2258
            test_suite_factory=self.factory,
2178
2259
            starting_with=['breezy.tests.test_selftest.Test.a',
2179
 
                'breezy.tests.test_selftest.Test.b'],
 
2260
                           'breezy.tests.test_selftest.Test.b'],
2180
2261
            list_only=True)
2181
2262
        self.assertEqual(b'breezy.tests.test_selftest.Test.a\n'
2182
 
            b'breezy.tests.test_selftest.Test.b\n',
2183
 
            output.getvalue())
 
2263
                         b'breezy.tests.test_selftest.Test.b\n',
 
2264
                         output.getvalue())
2184
2265
 
2185
2266
    def check_transport_set(self, transport_server):
2186
2267
        captured_transport = []
 
2268
 
2187
2269
        def seen_transport(a_transport):
2188
2270
            captured_transport.append(a_transport)
 
2271
 
2189
2272
        class Capture(tests.TestCase):
2190
2273
            def a(self):
2191
2274
                seen_transport(breezy.tests.default_transport)
 
2275
 
2192
2276
        def factory():
2193
2277
            return TestUtil.TestSuite([Capture("a")])
2194
 
        self.run_selftest(transport=transport_server, test_suite_factory=factory)
 
2278
        self.run_selftest(transport=transport_server,
 
2279
                          test_suite_factory=factory)
2195
2280
        self.assertEqual(transport_server, captured_transport[0])
2196
2281
 
2197
2282
    def test_transport_sftp(self):
2217
2302
    def test_load_unknown(self):
2218
2303
        # Provide a list with one test - this test.
2219
2304
        # And generate a list of the tests in  the suite.
2220
 
        err = self.assertRaises(errors.NoSuchFile, self.run_selftest,
2221
 
            load_list='missing file name', list_only=True)
 
2305
        self.assertRaises(errors.NoSuchFile, self.run_selftest,
 
2306
                          load_list='missing file name', list_only=True)
2222
2307
 
2223
2308
 
2224
2309
class TestSubunitLogDetails(tests.TestCase, SelfTestHelper):
2227
2312
 
2228
2313
    def run_subunit_stream(self, test_name):
2229
2314
        from subunit import ProtocolTestCase
 
2315
 
2230
2316
        def factory():
2231
2317
            return TestUtil.TestSuite([_get_test(test_name)])
2232
2318
        stream = self.run_selftest(
2257
2343
        self.assertEqual({'reason'}, set(reasons))
2258
2344
        skips = reasons['reason']
2259
2345
        self.assertEqual(1, len(skips))
2260
 
        test = skips[0]
 
2346
        # test = skips[0]
2261
2347
        # RemotedTestCase doesn't preserve the "details"
2262
 
        ## self.assertFalse('log' in test.getDetails())
 
2348
        # self.assertFalse('log' in test.getDetails())
2263
2349
 
2264
2350
    def test_missing_feature_has_no_log(self):
2265
2351
        content, result = self.run_subunit_stream('test_missing_feature')
2269
2355
        self.assertEqual({'_MissingFeature\n'}, set(reasons))
2270
2356
        skips = reasons['_MissingFeature\n']
2271
2357
        self.assertEqual(1, len(skips))
2272
 
        test = skips[0]
 
2358
        # test = skips[0]
2273
2359
        # RemotedTestCase doesn't preserve the "details"
2274
 
        ## self.assertFalse('log' in test.getDetails())
 
2360
        # self.assertFalse('log' in test.getDetails())
2275
2361
 
2276
2362
    def test_xfail_has_no_log(self):
2277
2363
        content, result = self.run_subunit_stream('test_xfail')
2280
2366
        self.assertEqual(1, len(result.expectedFailures))
2281
2367
        result_content = result.expectedFailures[0][1]
2282
2368
        self.assertNotContainsRe(result_content,
2283
 
            '(?m)^(?:Text attachment: )?log(?:$|: )')
 
2369
                                 '(?m)^(?:Text attachment: )?log(?:$|: )')
2284
2370
        self.assertNotContainsRe(result_content, 'test with expected failure')
2285
2371
 
2286
2372
    def test_unexpected_success_has_log(self):
2288
2374
        self.assertContainsRe(content, b'(?m)^log$')
2289
2375
        self.assertContainsRe(content, b'test with unexpected success')
2290
2376
        self.assertEqual(1, len(result.unexpectedSuccesses))
2291
 
        test = result.unexpectedSuccesses[0]
 
2377
        # test = result.unexpectedSuccesses[0]
2292
2378
        # RemotedTestCase doesn't preserve the "details"
2293
 
        ## self.assertTrue('log' in test.getDetails())
 
2379
        # self.assertTrue('log' in test.getDetails())
2294
2380
 
2295
2381
    def test_success_has_no_log(self):
2296
2382
        content, result = self.run_subunit_stream('test_success')
2444
2530
 
2445
2531
class StubProcess(object):
2446
2532
    """A stub process for testing run_bzr_subprocess."""
2447
 
    
 
2533
 
2448
2534
    def __init__(self, out="", err="", retcode=0):
2449
2535
        self.out = out
2450
2536
        self.err = err
2466
2552
                             working_dir=None,
2467
2553
                             allow_plugins=False):
2468
2554
        """capture what run_bzr_subprocess tries to do."""
2469
 
        self.subprocess_calls.append({'process_args':process_args,
2470
 
            'env_changes':env_changes,
2471
 
            'skip_if_plan_to_signal':skip_if_plan_to_signal,
2472
 
            'working_dir':working_dir, 'allow_plugins':allow_plugins})
 
2555
        self.subprocess_calls.append(
 
2556
            {'process_args': process_args,
 
2557
             'env_changes': env_changes,
 
2558
             'skip_if_plan_to_signal': skip_if_plan_to_signal,
 
2559
             'working_dir': working_dir, 'allow_plugins': allow_plugins})
2473
2560
        return self.next_subprocess
2474
2561
 
2475
2562
 
2485
2572
        self.next_subprocess = process
2486
2573
        try:
2487
2574
            result = self.run_bzr_subprocess(*args, **kwargs)
2488
 
        except:
 
2575
        except BaseException:
2489
2576
            self.next_subprocess = None
2490
2577
            for key, expected in expected_args.items():
2491
2578
                self.assertEqual(expected, self.subprocess_calls[-1][key])
2498
2585
 
2499
2586
    def test_run_bzr_subprocess(self):
2500
2587
        """The run_bzr_helper_external command behaves nicely."""
2501
 
        self.assertRunBzrSubprocess({'process_args':['--version']},
2502
 
            StubProcess(), '--version')
2503
 
        self.assertRunBzrSubprocess({'process_args':['--version']},
2504
 
            StubProcess(), ['--version'])
 
2588
        self.assertRunBzrSubprocess({'process_args': ['--version']},
 
2589
                                    StubProcess(), '--version')
 
2590
        self.assertRunBzrSubprocess({'process_args': ['--version']},
 
2591
                                    StubProcess(), ['--version'])
2505
2592
        # retcode=None disables retcode checking
2506
 
        result = self.assertRunBzrSubprocess({},
2507
 
            StubProcess(retcode=3), '--version', retcode=None)
2508
 
        result = self.assertRunBzrSubprocess({},
2509
 
            StubProcess(out="is free software"), '--version')
 
2593
        result = self.assertRunBzrSubprocess(
 
2594
            {}, StubProcess(retcode=3), '--version', retcode=None)
 
2595
        result = self.assertRunBzrSubprocess(
 
2596
            {}, StubProcess(out="is free software"), '--version')
2510
2597
        self.assertContainsRe(result[0], 'is free software')
2511
2598
        # Running a subcommand that is missing errors
2512
2599
        self.assertRaises(AssertionError, self.assertRunBzrSubprocess,
2513
 
            {'process_args':['--versionn']}, StubProcess(retcode=3),
2514
 
            '--versionn')
 
2600
                          {'process_args': ['--versionn']
 
2601
                           }, StubProcess(retcode=3),
 
2602
                          '--versionn')
2515
2603
        # Unless it is told to expect the error from the subprocess
2516
 
        result = self.assertRunBzrSubprocess({},
2517
 
            StubProcess(retcode=3), '--versionn', retcode=3)
 
2604
        result = self.assertRunBzrSubprocess(
 
2605
            {}, StubProcess(retcode=3), '--versionn', retcode=3)
2518
2606
        # Or to ignore retcode checking
2519
 
        result = self.assertRunBzrSubprocess({},
2520
 
            StubProcess(err="unknown command", retcode=3), '--versionn',
2521
 
            retcode=None)
 
2607
        result = self.assertRunBzrSubprocess(
 
2608
            {}, StubProcess(err="unknown command", retcode=3),
 
2609
            '--versionn', retcode=None)
2522
2610
        self.assertContainsRe(result[1], 'unknown command')
2523
2611
 
2524
2612
    def test_env_change_passes_through(self):
2525
2613
        self.assertRunBzrSubprocess(
2526
 
            {'env_changes':{'new':'value', 'changed':'newvalue', 'deleted':None}},
 
2614
            {'env_changes': {'new': 'value', 'changed': 'newvalue', 'deleted': None}},
2527
2615
            StubProcess(), '',
2528
 
            env_changes={'new':'value', 'changed':'newvalue', 'deleted':None})
 
2616
            env_changes={'new': 'value', 'changed': 'newvalue', 'deleted': None})
2529
2617
 
2530
2618
    def test_no_working_dir_passed_as_None(self):
2531
2619
        self.assertRunBzrSubprocess({'working_dir': None}, StubProcess(), '')
2532
2620
 
2533
2621
    def test_no_working_dir_passed_through(self):
2534
2622
        self.assertRunBzrSubprocess({'working_dir': 'dir'}, StubProcess(), '',
2535
 
            working_dir='dir')
 
2623
                                    working_dir='dir')
2536
2624
 
2537
2625
    def test_run_bzr_subprocess_no_plugins(self):
2538
2626
        self.assertRunBzrSubprocess({'allow_plugins': False},
2539
 
            StubProcess(), '')
 
2627
                                    StubProcess(), '')
2540
2628
 
2541
2629
    def test_allow_plugins(self):
2542
2630
        self.assertRunBzrSubprocess({'allow_plugins': True},
2543
 
            StubProcess(), '', allow_plugins=True)
 
2631
                                    StubProcess(), '', allow_plugins=True)
2544
2632
 
2545
2633
 
2546
2634
class TestFinishBzrSubprocess(TestWithFakedStartBzrSubprocess):
2608
2696
    def test_set_env(self):
2609
2697
        self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2610
2698
        # set in the child
 
2699
 
2611
2700
        def check_environment():
2612
2701
            self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
2613
2702
        self.check_popen_state = check_environment
2614
2703
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2615
 
                          env_changes={'EXISTANT_ENV_VAR':'set variable'})
 
2704
                          env_changes={'EXISTANT_ENV_VAR': 'set variable'})
2616
2705
        # not set in theparent
2617
2706
        self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2618
2707
 
2619
2708
    def test_run_bzr_subprocess_env_del(self):
2620
2709
        """run_bzr_subprocess can remove environment variables too."""
2621
2710
        self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
 
2711
 
2622
2712
        def check_environment():
2623
2713
            self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2624
2714
        os.environ['EXISTANT_ENV_VAR'] = 'set variable'
2625
2715
        self.check_popen_state = check_environment
2626
2716
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2627
 
                          env_changes={'EXISTANT_ENV_VAR':None})
 
2717
                          env_changes={'EXISTANT_ENV_VAR': None})
2628
2718
        # Still set in parent
2629
2719
        self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
2630
2720
        del os.environ['EXISTANT_ENV_VAR']
2631
2721
 
2632
2722
    def test_env_del_missing(self):
2633
2723
        self.assertFalse('NON_EXISTANT_ENV_VAR' in os.environ)
 
2724
 
2634
2725
        def check_environment():
2635
2726
            self.assertFalse('NON_EXISTANT_ENV_VAR' in os.environ)
2636
2727
        self.check_popen_state = check_environment
2637
2728
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2638
 
                          env_changes={'NON_EXISTANT_ENV_VAR':None})
 
2729
                          env_changes={'NON_EXISTANT_ENV_VAR': None})
2639
2730
 
2640
2731
    def test_working_dir(self):
2641
2732
        """Test that we can specify the working dir for the child"""
2642
 
        orig_getcwd = osutils.getcwd
2643
 
        orig_chdir = os.chdir
2644
2733
        chdirs = []
 
2734
 
2645
2735
        def chdir(path):
2646
2736
            chdirs.append(path)
2647
2737
        self.overrideAttr(os, 'chdir', chdir)
 
2738
 
2648
2739
        def getcwd():
2649
2740
            return 'current'
2650
2741
        self.overrideAttr(osutils, 'getcwd', getcwd)
2687
2778
 
2688
2779
    def test_condition_id_re(self):
2689
2780
        test_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2690
 
            'test_condition_id_re')
 
2781
                     'test_condition_id_re')
2691
2782
        filtered_suite = tests.filter_suite_by_condition(
2692
2783
            self.suite, tests.condition_id_re('test_condition_id_re'))
2693
2784
        self.assertEqual([test_name], _test_ids(filtered_suite))
2706
2797
        klass = 'breezy.tests.test_selftest.TestSelftestFiltering.'
2707
2798
        start1 = klass + 'test_condition_id_starts'
2708
2799
        start2 = klass + 'test_condition_id_in'
2709
 
        test_names = [ klass + 'test_condition_id_in_list',
 
2800
        test_names = [klass + 'test_condition_id_in_list',
2710
2801
                      klass + 'test_condition_id_startswith',
2711
 
                     ]
 
2802
                      ]
2712
2803
        filtered_suite = tests.filter_suite_by_condition(
2713
2804
            self.suite, tests.condition_id_startswith([start1, start2]))
2714
2805
        self.assertEqual(test_names, _test_ids(filtered_suite))
2722
2813
 
2723
2814
    def test_exclude_tests_by_condition(self):
2724
2815
        excluded_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2725
 
            'test_exclude_tests_by_condition')
2726
 
        filtered_suite = tests.exclude_tests_by_condition(self.suite,
2727
 
            lambda x:x.id() == excluded_name)
 
2816
                         'test_exclude_tests_by_condition')
 
2817
        filtered_suite = tests.exclude_tests_by_condition(
 
2818
            self.suite, lambda x: x.id() == excluded_name)
2728
2819
        self.assertEqual(len(self.all_names) - 1,
2729
 
            filtered_suite.countTestCases())
 
2820
                         filtered_suite.countTestCases())
2730
2821
        self.assertFalse(excluded_name in _test_ids(filtered_suite))
2731
2822
        remaining_names = list(self.all_names)
2732
2823
        remaining_names.remove(excluded_name)
2737
2828
        filtered_suite = tests.exclude_tests_by_re(self.suite,
2738
2829
                                                   'exclude_tests_by_re')
2739
2830
        excluded_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2740
 
            'test_exclude_tests_by_re')
 
2831
                         'test_exclude_tests_by_re')
2741
2832
        self.assertEqual(len(self.all_names) - 1,
2742
 
            filtered_suite.countTestCases())
 
2833
                         filtered_suite.countTestCases())
2743
2834
        self.assertFalse(excluded_name in _test_ids(filtered_suite))
2744
2835
        remaining_names = list(self.all_names)
2745
2836
        remaining_names.remove(excluded_name)
2747
2838
 
2748
2839
    def test_filter_suite_by_condition(self):
2749
2840
        test_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2750
 
            'test_filter_suite_by_condition')
2751
 
        filtered_suite = tests.filter_suite_by_condition(self.suite,
2752
 
            lambda x:x.id() == test_name)
 
2841
                     'test_filter_suite_by_condition')
 
2842
        filtered_suite = tests.filter_suite_by_condition(
 
2843
            self.suite, lambda x: x.id() == test_name)
2753
2844
        self.assertEqual([test_name], _test_ids(filtered_suite))
2754
2845
 
2755
2846
    def test_filter_suite_by_re(self):
2756
2847
        filtered_suite = tests.filter_suite_by_re(self.suite,
2757
2848
                                                  'test_filter_suite_by_r')
2758
2849
        filtered_names = _test_ids(filtered_suite)
2759
 
        self.assertEqual(filtered_names, ['breezy.tests.test_selftest.'
2760
 
            'TestSelftestFiltering.test_filter_suite_by_re'])
 
2850
        self.assertEqual(
 
2851
            filtered_names, ['breezy.tests.test_selftest.'
 
2852
                             'TestSelftestFiltering.test_filter_suite_by_re'])
2761
2853
 
2762
2854
    def test_filter_suite_by_id_list(self):
2763
2855
        test_list = ['breezy.tests.test_selftest.'
2811
2903
        condition = tests.condition_id_re('test_filter_suite_by_r')
2812
2904
        split_suite = tests.split_suite_by_condition(self.suite, condition)
2813
2905
        filtered_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2814
 
            'test_filter_suite_by_re')
 
2906
                         'test_filter_suite_by_re')
2815
2907
        self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2816
2908
        self.assertFalse(filtered_name in _test_ids(split_suite[1]))
2817
2909
        remaining_names = list(self.all_names)
2823
2915
        split_suite = tests.split_suite_by_re(self.suite,
2824
2916
                                              'test_filter_suite_by_r')
2825
2917
        filtered_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2826
 
            'test_filter_suite_by_re')
 
2918
                         'test_filter_suite_by_re')
2827
2919
        self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2828
2920
        self.assertFalse(filtered_name in _test_ids(split_suite[1]))
2829
2921
        remaining_names = list(self.all_names)
2872
2964
        self.permit_url(url)
2873
2965
        out, err = self.run_bzr(["log", "%s/nonexistantpath" % url], retcode=3)
2874
2966
        self.assertEqual(out, '')
2875
 
        self.assertContainsRe(err,
2876
 
            'brz: ERROR: Not a branch: ".*nonexistantpath/".\n')
 
2967
        self.assertContainsRe(
 
2968
            err, 'brz: ERROR: Not a branch: ".*nonexistantpath/".\n')
2877
2969
 
2878
2970
 
2879
2971
class TestTestLoader(tests.TestCase):
2883
2975
        """Gets a TestLoader and a module with one test in it."""
2884
2976
        loader = TestUtil.TestLoader()
2885
2977
        module = {}
 
2978
 
2886
2979
        class Stub(tests.TestCase):
2887
2980
            def test_foo(self):
2888
2981
                pass
 
2982
 
2889
2983
        class MyModule(object):
2890
2984
            pass
2891
2985
        MyModule.a_class = Stub
2895
2989
 
2896
2990
    def test_module_no_load_tests_attribute_loads_classes(self):
2897
2991
        loader, module = self._get_loader_and_module()
2898
 
        self.assertEqual(1, loader.loadTestsFromModule(module).countTestCases())
 
2992
        self.assertEqual(1, loader.loadTestsFromModule(
 
2993
            module).countTestCases())
2899
2994
 
2900
2995
    def test_module_load_tests_attribute_gets_called(self):
2901
2996
        loader, module = self._get_loader_and_module()
 
2997
 
2902
2998
        def load_tests(loader, standard_tests, pattern):
2903
2999
            result = loader.suiteClass()
2904
3000
            for test in tests.iter_suite_tests(standard_tests):
2914
3010
        loader = TestUtil.TestLoader()
2915
3011
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
2916
3012
        self.assertEqual(['breezy.tests.test_sampler.DemoTest.test_nothing'],
2917
 
                          _test_ids(suite))
 
3013
                         _test_ids(suite))
2918
3014
 
2919
3015
    def test_load_tests_from_module_name_with_bogus_module_name(self):
2920
3016
        loader = TestUtil.TestLoader()
2937
3033
 
2938
3034
        suite = TestUtil.TestSuite()
2939
3035
        for id in test_id_list:
2940
 
            t  = Stub('test_foo')
 
3036
            t = Stub('test_foo')
2941
3037
            t.id = _create_test_id(id)
2942
3038
            suite.addTest(t)
2943
3039
        return suite
2991
3087
        dupes = loader.suiteClass()
2992
3088
        for test in tests.iter_suite_tests(suite):
2993
3089
            dupes.addTest(test)
2994
 
            dupes.addTest(test) # Add it again
 
3090
            dupes.addTest(test)  # Add it again
2995
3091
 
2996
 
        test_list = ['breezy.tests.test_sampler.DemoTest.test_nothing',]
 
3092
        test_list = ['breezy.tests.test_sampler.DemoTest.test_nothing', ]
2997
3093
        not_found, duplicates = tests.suite_matches_id_list(
2998
3094
            dupes, test_list)
2999
3095
        self.assertEqual([], not_found)
3000
3096
        self.assertEqual(['breezy.tests.test_sampler.DemoTest.test_nothing'],
3001
 
                          duplicates)
 
3097
                         duplicates)
3002
3098
 
3003
3099
 
3004
3100
class TestTestSuite(tests.TestCase):
3030
3126
    def test_test_suite(self):
3031
3127
        # test_suite() loads the entire test suite to operate. To avoid this
3032
3128
        # overhead, and yet still be confident that things are happening,
3033
 
        # we temporarily replace two functions used by test_suite with 
 
3129
        # we temporarily replace two functions used by test_suite with
3034
3130
        # test doubles that supply a few sample tests to load, and check they
3035
3131
        # are loaded.
3036
3132
        calls = []
 
3133
 
3037
3134
        def testmod_names():
3038
3135
            calls.append("testmod_names")
3039
3136
            return [
3042
3139
                'breezy.tests.test_selftest',
3043
3140
                ]
3044
3141
        self.overrideAttr(tests, '_test_suite_testmod_names', testmod_names)
 
3142
 
3045
3143
        def doctests():
3046
3144
            calls.append("modules_to_doctest")
3047
3145
            if __doc__ is None:
3067
3165
            self.assertEqual({"testmod_names"}, set(calls))
3068
3166
        else:
3069
3167
            self.assertEqual({"testmod_names", "modules_to_doctest"},
3070
 
                set(calls))
 
3168
                             set(calls))
3071
3169
        self.assertSubset(expected_test_list, _test_ids(suite))
3072
3170
 
3073
3171
    def test_test_suite_list_and_start(self):
3074
 
        # We cannot test this at the same time as the main load, because we want
3075
 
        # to know that starting_with == None works. So a second load is
3076
 
        # incurred - note that the starting_with parameter causes a partial load
3077
 
        # rather than a full load so this test should be pretty quick.
3078
 
        test_list = ['breezy.tests.test_selftest.TestTestSuite.test_test_suite']
 
3172
        # We cannot test this at the same time as the main load, because we
 
3173
        # want to know that starting_with == None works. So a second load is
 
3174
        # incurred - note that the starting_with parameter causes a partial
 
3175
        # load rather than a full load so this test should be pretty quick.
 
3176
        test_list = [
 
3177
            'breezy.tests.test_selftest.TestTestSuite.test_test_suite']
3079
3178
        suite = tests.test_suite(test_list,
3080
3179
                                 ['breezy.tests.test_selftest.TestTestSuite'])
3081
 
        # test_test_suite_list_and_start is not included 
 
3180
        # test_test_suite_list_and_start is not included
3082
3181
        self.assertEqual(test_list, _test_ids(suite))
3083
3182
 
3084
3183
 
3158
3257
        self.assertEqual(test_list, _test_ids(suite))
3159
3258
 
3160
3259
    def test_exclude_tests(self):
3161
 
        test_list = ['bogus']
3162
3260
        loader = self._create_loader('bogus')
3163
3261
 
3164
3262
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
3182
3280
        tpr.register('bar', 'bBB.aAA.rRR')
3183
3281
        self.assertEqual('bbb.aaa.rrr', tpr.get('bar'))
3184
3282
        self.assertThat(self.get_log(),
3185
 
            DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR",
3186
 
                           doctest.ELLIPSIS))
 
3283
                        DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR",
 
3284
                                       doctest.ELLIPSIS))
3187
3285
 
3188
3286
    def test_get_unknown_prefix(self):
3189
3287
        tpr = self._get_registry()
3216
3314
        def __init__(self):
3217
3315
            tests.ExtendedTestResult.__init__(self, StringIO(), 0, 1)
3218
3316
            self.leaks = []
 
3317
 
3219
3318
        def _report_thread_leak(self, test, leaks, alive):
3220
3319
            self.leaks.append((test, leaks))
3221
3320
 
3231
3330
        result.stopTestRun()
3232
3331
        self.assertEqual(result._tests_leaking_threads_count, 0)
3233
3332
        self.assertEqual(result.leaks, [])
3234
 
        
 
3333
 
3235
3334
    def test_thread_leak(self):
3236
3335
        """Ensure a thread that outlives the running of a test is reported
3237
3336
 
3242
3341
        """
3243
3342
        event = threading.Event()
3244
3343
        thread = threading.Thread(name="Leaker", target=event.wait)
 
3344
 
3245
3345
        class Test(tests.TestCase):
3246
3346
            def test_leak(self):
3247
3347
                thread.start()
3267
3367
        thread_a = threading.Thread(name="LeakerA", target=event.wait)
3268
3368
        thread_b = threading.Thread(name="LeakerB", target=event.wait)
3269
3369
        thread_c = threading.Thread(name="LeakerC", target=event.wait)
 
3370
 
3270
3371
        class Test(tests.TestCase):
3271
3372
            def test_first_leak(self):
3272
3373
                thread_b.start()
 
3374
 
3273
3375
            def test_second_no_leak(self):
3274
3376
                pass
 
3377
 
3275
3378
            def test_third_leak(self):
3276
3379
                thread_c.start()
3277
3380
                thread_a.start()
3302
3405
        def __init__(self):
3303
3406
            tests.ExtendedTestResult.__init__(self, StringIO(), 0, 1)
3304
3407
            self.postcode = None
 
3408
 
3305
3409
        def _post_mortem(self, tb=None):
3306
3410
            """Record the code object at the end of the current traceback"""
3307
3411
            tb = tb or sys.exc_info()[2]
3311
3415
                    tb = next
3312
3416
                    next = next.tb_next
3313
3417
                self.postcode = tb.tb_frame.f_code
 
3418
 
3314
3419
        def report_error(self, test, err):
3315
3420
            pass
 
3421
 
3316
3422
        def report_failure(self, test, err):
3317
3423
            pass
3318
3424
 
3374
3480
                pass
3375
3481
        suite = Stub("test_foo")
3376
3482
        calls = []
 
3483
 
3377
3484
        class MyRunner(tests.TextTestRunner):
3378
3485
            def run(self, test):
3379
3486
                calls.append(test)
3414
3521
        """
3415
3522
        from subunit import ProtocolTestCase
3416
3523
        _original_init = ProtocolTestCase.__init__
 
3524
 
3417
3525
        def _init_with_passthrough(self, *args, **kwargs):
3418
3526
            _original_init(self, *args, **kwargs)
3419
3527
            self._passthrough = stream
3444
3552
        # together due to the way subunit parses and forwards the streams,
3445
3553
        # so permit extra lines between each part of the error output.
3446
3554
        self.assertContainsRe(out,
3447
 
            b"Traceback.*:\n"
3448
 
            b"(?:.*\n)*"
3449
 
            b".+ in fork_for_tests\n"
3450
 
            b"(?:.*\n)*"
3451
 
            b"\\s*workaround_zealous_crypto_random\\(\\)\n"
3452
 
            b"(?:.*\n)*"
3453
 
            b"TypeError:")
 
3555
                              b"Traceback.*:\n"
 
3556
                              b"(?:.*\n)*"
 
3557
                              b".+ in fork_for_tests\n"
 
3558
                              b"(?:.*\n)*"
 
3559
                              b"\\s*workaround_zealous_crypto_random\\(\\)\n"
 
3560
                              b"(?:.*\n)*"
 
3561
                              b"TypeError:")
3454
3562
 
3455
3563
 
3456
3564
class TestUncollectedWarnings(_Selftest, tests.TestCase):
3459
3567
    class Test(tests.TestCase):
3460
3568
        def test_pass(self):
3461
3569
            pass
 
3570
 
3462
3571
        def test_self_ref(self):
3463
3572
            self.also_self = self.test_self_ref
 
3573
 
3464
3574
        def test_skip(self):
3465
3575
            self.skipTest("Don't need")
3466
3576
 
3479
3589
            gc.disable()
3480
3590
        try:
3481
3591
            output = self._run_selftest(test_suite_factory=self._get_suite,
3482
 
                **kwargs)
 
3592
                                        **kwargs)
3483
3593
        finally:
3484
3594
            if gc_on:
3485
3595
                gc.enable()
3504
3614
 
3505
3615
    def test_matching_tests_first(self):
3506
3616
        self._run_selftest_with_suite(matching_tests_first=True,
3507
 
            pattern="test_self_ref$")
 
3617
                                      pattern="test_self_ref$")
3508
3618
 
3509
3619
    def test_starting_with_and_exclude(self):
3510
3620
        out = self._run_selftest_with_suite(starting_with=["bt."],
3511
 
            exclude_pattern="test_skip$")
 
3621
                                            exclude_pattern="test_skip$")
3512
3622
        self.assertNotContainsRe(out, b"test_skip")
3513
3623
 
3514
3624
    def test_additonal_decorator(self):
3515
 
        out = self._run_selftest_with_suite(
3516
 
            suite_decorators=[tests.TestDecorator])
 
3625
        self._run_selftest_with_suite(suite_decorators=[tests.TestDecorator])
3517
3626
 
3518
3627
 
3519
3628
class TestUncollectedWarningsSubunit(TestUncollectedWarnings):
3536
3645
        self.assertFalse('MYVAR' in os.environ)
3537
3646
        self.overrideEnv('MYVAR', '42')
3538
3647
        # We use an embedded test to make sure we fix the _captureVar bug
 
3648
 
3539
3649
        class Test(tests.TestCase):
3540
3650
            def test_me(self):
3541
3651
                # The first call save the 42 value
3683
3793
            def id(self):
3684
3794
                # We don't need the full class path
3685
3795
                return self._testMethodName
 
3796
 
3686
3797
            def a(self):
3687
3798
                pass
 
3799
 
3688
3800
            def b(self):
3689
3801
                pass
 
3802
 
3690
3803
            def c(self):
3691
3804
                pass
3692
3805
        return TestUtil.TestSuite([Test("a"), Test("b"), Test("c")])
3714
3827
 
3715
3828
    def setUp(self):
3716
3829
        super(TestCounterHooks, self).setUp()
 
3830
 
3717
3831
        class Test(tests.TestCase):
3718
3832
 
3719
3833
            def setUp(self):