← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

  • Committer: Vincent Ladeuil
  • Date: 2010-02-09 20:33:43 UTC
  • mto: (5029.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5030.
  • Revision ID: v.ladeuil+lp@free.fr-20100209203343-ktxx7t0xvptvjnt1
Move TestingPathFilteringServer to bzrlib.tests.test_server

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_selftest.py
17
17
"""Tests for the test framework."""
18
18
 
19
19
from cStringIO import StringIO
 
20
from doctest import ELLIPSIS
20
21
import os
 
22
import signal
21
23
import sys
22
24
import time
23
25
import unittest
24
26
import warnings
25
27
 
 
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
 
26
36
import bzrlib
27
37
from bzrlib import (
28
38
    branchbuilder,
37
47
    repository,
38
48
    symbol_versioning,
39
49
    tests,
 
50
    transport,
40
51
    workingtree,
41
52
    )
42
53
from bzrlib.repofmt import (
 
54
    groupcompress_repo,
43
55
    pack_repo,
44
56
    weaverepo,
45
57
    )
49
61
    deprecated_method,
50
62
    )
51
63
from bzrlib.tests import (
 
64
    features,
 
65
    stub_sftp,
52
66
    test_lsprof,
53
67
    test_sftp_transport,
54
68
    TestUtil,
74
88
                          TestUtil._load_module_by_name,
75
89
                          'bzrlib.no-name-yet')
76
90
 
 
91
 
77
92
class MetaTestLog(tests.TestCase):
78
93
 
79
94
    def test_logging(self):
80
95
        """Test logs are captured when a test fails."""
81
96
        self.log('a test message')
82
 
        self._log_file.flush()
83
 
        self.assertContainsRe(self._get_log(keep_log_file=True),
84
 
                              'a test message\n')
 
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))
85
104
 
86
105
 
87
106
class TestUnicodeFilename(tests.TestCase):
124
143
        self.assertEqual(sample_permutation,
125
144
                         get_transport_test_permutations(MockModule()))
126
145
 
127
 
    def test_scenarios_invlude_all_modules(self):
 
146
    def test_scenarios_include_all_modules(self):
128
147
        # this checks that the scenario generator returns as many permutations
129
148
        # as there are in all the registered transport modules - we assume if
130
149
        # this matches its probably doing the right thing especially in
215
234
        from bzrlib.tests.per_repository import formats_to_scenarios
216
235
        formats = [("(c)", remote.RemoteRepositoryFormat()),
217
236
                   ("(d)", repository.format_registry.get(
218
 
                        'Bazaar pack repository format 1 (needs bzr 0.92)\n'))]
 
237
                    'Bazaar repository format 2a (needs bzr 1.16 or later)\n'))]
219
238
        no_vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
220
239
            None)
221
240
        vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
222
241
            vfs_transport_factory="vfs")
223
242
        # no_vfs generate scenarios without vfs_transport_factory
224
 
        self.assertEqual([
 
243
        expected = [
225
244
            ('RemoteRepositoryFormat(c)',
226
245
             {'bzrdir_format': remote.RemoteBzrDirFormat(),
227
246
              'repository_format': remote.RemoteRepositoryFormat(),
228
247
              'transport_readonly_server': 'readonly',
229
248
              'transport_server': 'server'}),
230
 
            ('RepositoryFormatKnitPack1(d)',
 
249
            ('RepositoryFormat2a(d)',
231
250
             {'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
232
 
              'repository_format': pack_repo.RepositoryFormatKnitPack1(),
 
251
              'repository_format': groupcompress_repo.RepositoryFormat2a(),
233
252
              'transport_readonly_server': 'readonly',
234
 
              'transport_server': 'server'})],
235
 
            no_vfs_scenarios)
 
253
              'transport_server': 'server'})]
 
254
        self.assertEqual(expected, no_vfs_scenarios)
236
255
        self.assertEqual([
237
256
            ('RemoteRepositoryFormat(c)',
238
257
             {'bzrdir_format': remote.RemoteBzrDirFormat(),
240
259
              'transport_readonly_server': 'readonly',
241
260
              'transport_server': 'server',
242
261
              'vfs_transport_factory': 'vfs'}),
243
 
            ('RepositoryFormatKnitPack1(d)',
 
262
            ('RepositoryFormat2a(d)',
244
263
             {'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
245
 
              'repository_format': pack_repo.RepositoryFormatKnitPack1(),
 
264
              'repository_format': groupcompress_repo.RepositoryFormat2a(),
246
265
              'transport_readonly_server': 'readonly',
247
266
              'transport_server': 'server',
248
267
              'vfs_transport_factory': 'vfs'})],
293
312
        from bzrlib.tests.per_interrepository import make_scenarios
294
313
        server1 = "a"
295
314
        server2 = "b"
296
 
        formats = [(str, "C1", "C2"), (int, "D1", "D2")]
 
315
        formats = [("C0", "C1", "C2"), ("D0", "D1", "D2")]
297
316
        scenarios = make_scenarios(server1, server2, formats)
298
317
        self.assertEqual([
299
 
            ('str,str,str',
300
 
             {'interrepo_class': str,
301
 
              'repository_format': 'C1',
 
318
            ('C0,str,str',
 
319
             {'repository_format': 'C1',
302
320
              'repository_format_to': 'C2',
303
321
              'transport_readonly_server': 'b',
304
322
              'transport_server': 'a'}),
305
 
            ('int,str,str',
306
 
             {'interrepo_class': int,
307
 
              'repository_format': 'D1',
 
323
            ('D0,str,str',
 
324
             {'repository_format': 'D1',
308
325
              'repository_format_to': 'D2',
309
326
              'transport_readonly_server': 'b',
310
327
              'transport_server': 'a'})],
488
505
        self.assertEqualStat(real, fake)
489
506
 
490
507
    def test_assertEqualStat_notequal(self):
491
 
        self.build_tree(["foo", "bar"])
 
508
        self.build_tree(["foo", "longname"])
492
509
        self.assertRaises(AssertionError, self.assertEqualStat,
493
 
            os.lstat("foo"), os.lstat("bar"))
 
510
            os.lstat("foo"), os.lstat("longname"))
494
511
 
495
512
 
496
513
class TestTestCaseWithMemoryTransport(tests.TestCaseWithMemoryTransport):
514
531
        cwd = osutils.getcwd()
515
532
        self.assertIsSameRealPath(self.test_dir, cwd)
516
533
 
 
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
 
517
542
    def test_make_branch_and_memory_tree(self):
518
543
        """In TestCaseWithMemoryTransport we should not make the branch on disk.
519
544
 
575
600
                         self.get_transport().get_bytes(
576
601
                            'dir/.bzr/repository/format'))
577
602
 
578
 
    def test_safety_net(self):
579
 
        """No test should modify the safety .bzr directory.
580
 
 
581
 
        We just test that the _check_safety_net private method raises
582
 
        AssertionError, it's easier than building a test suite with the same
583
 
        test.
584
 
        """
585
 
        # Oops, a commit in the current directory (i.e. without local .bzr
586
 
        # directory) will crawl up the hierarchy to find a .bzr directory.
587
 
        self.run_bzr(['commit', '-mfoo', '--unchanged'])
588
 
        # But we have a safety net in place.
589
 
        self.assertRaises(AssertionError, self._check_safety_net)
590
 
 
591
603
    def test_dangling_locks_cause_failures(self):
592
604
        class TestDanglingLock(tests.TestCaseWithMemoryTransport):
593
605
            def test_function(self):
597
609
                l.attempt_lock()
598
610
        test = TestDanglingLock('test_function')
599
611
        result = test.run()
600
 
        self.assertEqual(1, len(result.errors))
 
612
        if self._lock_check_thorough:
 
613
            self.assertEqual(1, len(result.errors))
 
614
        else:
 
615
            # When _lock_check_thorough is disabled, then we don't trigger a
 
616
            # failure
 
617
            self.assertEqual(0, len(result.errors))
601
618
 
602
619
 
603
620
class TestTestCaseWithTransport(tests.TestCaseWithTransport):
681
698
        self.assertEqual(url, t.clone('..').base)
682
699
 
683
700
 
 
701
class TestProfileResult(tests.TestCase):
 
702
 
 
703
    def test_profiles_tests(self):
 
704
        self.requireFeature(test_lsprof.LSProfFeature)
 
705
        terminal = testtools.tests.helpers.ExtendedTestResult()
 
706
        result = tests.ProfileResult(terminal)
 
707
        class Sample(tests.TestCase):
 
708
            def a(self):
 
709
                self.sample_function()
 
710
            def sample_function(self):
 
711
                pass
 
712
        test = Sample("a")
 
713
        test.run(result)
 
714
        case = terminal._events[0][1]
 
715
        self.assertLength(1, case._benchcalls)
 
716
        # We must be able to unpack it as the test reporting code wants
 
717
        (_, _, _), stats = case._benchcalls[0]
 
718
        self.assertTrue(callable(stats.pprint))
 
719
 
 
720
 
684
721
class TestTestResult(tests.TestCase):
685
722
 
686
723
    def check_timing(self, test_case, expected_re):
688
725
                descriptions=0,
689
726
                verbosity=1,
690
727
                )
691
 
        test_case.run(result)
692
 
        timed_string = result._testTimeString(test_case)
 
728
        capture = testtools.tests.helpers.ExtendedTestResult()
 
729
        test_case.run(MultiTestResult(result, capture))
 
730
        run_case = capture._events[0][1]
 
731
        timed_string = result._testTimeString(run_case)
693
732
        self.assertContainsRe(timed_string, expected_re)
694
733
 
695
734
    def test_test_reporting(self):
713
752
        self.check_timing(ShortDelayTestCase('test_short_delay'),
714
753
                          r"^ +[0-9]+ms$")
715
754
 
 
755
    def _patch_get_bzr_source_tree(self):
 
756
        # Reading from the actual source tree breaks isolation, but we don't
 
757
        # want to assume that thats *all* that would happen.
 
758
        self.overrideAttr(bzrlib.version, '_get_bzr_source_tree', lambda: None)
 
759
 
716
760
    def test_assigned_benchmark_file_stores_date(self):
 
761
        self._patch_get_bzr_source_tree()
717
762
        output = StringIO()
718
763
        result = bzrlib.tests.TextTestResult(self._log_file,
719
764
                                        descriptions=0,
727
772
        self.assertContainsRe(output_string, "--date [0-9.]+")
728
773
 
729
774
    def test_benchhistory_records_test_times(self):
 
775
        self._patch_get_bzr_source_tree()
730
776
        result_stream = StringIO()
731
777
        result = bzrlib.tests.TextTestResult(
732
778
            self._log_file,
794
840
    def test_known_failure(self):
795
841
        """A KnownFailure being raised should trigger several result actions."""
796
842
        class InstrumentedTestResult(tests.ExtendedTestResult):
797
 
            def done(self): pass
 
843
            def stopTestRun(self): pass
798
844
            def startTests(self): pass
799
845
            def report_test_start(self, test): pass
800
 
            def report_known_failure(self, test, err):
801
 
                self._call = test, err
 
846
            def report_known_failure(self, test, err=None, details=None):
 
847
                self._call = test, 'known failure'
802
848
        result = InstrumentedTestResult(None, None, None, None)
803
 
        def test_function():
804
 
            raise tests.KnownFailure('failed!')
805
 
        test = unittest.FunctionTestCase(test_function)
 
849
        class Test(tests.TestCase):
 
850
            def test_function(self):
 
851
                raise tests.KnownFailure('failed!')
 
852
        test = Test("test_function")
806
853
        test.run(result)
807
854
        # it should invoke 'report_known_failure'.
808
855
        self.assertEqual(2, len(result._call))
809
 
        self.assertEqual(test, result._call[0])
810
 
        self.assertEqual(tests.KnownFailure, result._call[1][0])
811
 
        self.assertIsInstance(result._call[1][1], tests.KnownFailure)
 
856
        self.assertEqual(test.id(), result._call[0].id())
 
857
        self.assertEqual('known failure', result._call[1])
812
858
        # we dont introspec the traceback, if the rest is ok, it would be
813
859
        # exceptional for it not to be.
814
860
        # it should update the known_failure_count on the object.
848
894
    def test_add_not_supported(self):
849
895
        """Test the behaviour of invoking addNotSupported."""
850
896
        class InstrumentedTestResult(tests.ExtendedTestResult):
851
 
            def done(self): pass
 
897
            def stopTestRun(self): pass
852
898
            def startTests(self): pass
853
899
            def report_test_start(self, test): pass
854
900
            def report_unsupported(self, test, feature):
886
932
        result.report_unsupported(test, feature)
887
933
        output = result_stream.getvalue()[prefix:]
888
934
        lines = output.splitlines()
889
 
        self.assertEqual(lines, ['NODEP        0ms',
890
 
                                 "    The feature 'Feature' is not available."])
 
935
        # We don't check for the final '0ms' since it may fail on slow hosts
 
936
        self.assertStartsWith(lines[0], 'NODEP')
 
937
        self.assertEqual(lines[1],
 
938
                         "    The feature 'Feature' is not available.")
891
939
 
892
940
    def test_unavailable_exception(self):
893
941
        """An UnavailableFeature being raised should invoke addNotSupported."""
894
942
        class InstrumentedTestResult(tests.ExtendedTestResult):
895
 
            def done(self): pass
 
943
            def stopTestRun(self): pass
896
944
            def startTests(self): pass
897
945
            def report_test_start(self, test): pass
898
946
            def addNotSupported(self, test, feature):
899
947
                self._call = test, feature
900
948
        result = InstrumentedTestResult(None, None, None, None)
901
949
        feature = tests.Feature()
902
 
        def test_function():
903
 
            raise tests.UnavailableFeature(feature)
904
 
        test = unittest.FunctionTestCase(test_function)
 
950
        class Test(tests.TestCase):
 
951
            def test_function(self):
 
952
                raise tests.UnavailableFeature(feature)
 
953
        test = Test("test_function")
905
954
        test.run(result)
906
955
        # it should invoke 'addNotSupported'.
907
956
        self.assertEqual(2, len(result._call))
908
 
        self.assertEqual(test, result._call[0])
 
957
        self.assertEqual(test.id(), result._call[0].id())
909
958
        self.assertEqual(feature, result._call[1])
910
959
        # and not count as an error
911
960
        self.assertEqual(0, result.error_count)
924
973
                                             verbosity=1)
925
974
        test = self.get_passing_test()
926
975
        err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
927
 
        result._addKnownFailure(test, err)
 
976
        result.addExpectedFailure(test, err)
928
977
        self.assertFalse(result.wasStrictlySuccessful())
929
978
        self.assertEqual(None, result._extractBenchmarkTime(test))
930
979
 
975
1024
        because of our use of global state.
976
1025
        """
977
1026
        old_root = tests.TestCaseInTempDir.TEST_ROOT
 
1027
        old_leak = tests.TestCase._first_thread_leaker_id
978
1028
        try:
979
1029
            tests.TestCaseInTempDir.TEST_ROOT = None
 
1030
            tests.TestCase._first_thread_leaker_id = None
980
1031
            return testrunner.run(test)
981
1032
        finally:
982
1033
            tests.TestCaseInTempDir.TEST_ROOT = old_root
 
1034
            tests.TestCase._first_thread_leaker_id = old_leak
983
1035
 
984
1036
    def test_known_failure_failed_run(self):
985
1037
        # run a test that generates a known failure which should be printed in
986
1038
        # the final output when real failures occur.
987
 
        def known_failure_test():
988
 
            raise tests.KnownFailure('failed')
 
1039
        class Test(tests.TestCase):
 
1040
            def known_failure_test(self):
 
1041
                self.expectFailure('failed', self.assertTrue, False)
989
1042
        test = unittest.TestSuite()
990
 
        test.addTest(unittest.FunctionTestCase(known_failure_test))
 
1043
        test.addTest(Test("known_failure_test"))
991
1044
        def failing_test():
992
 
            raise AssertionError('foo')
 
1045
            self.fail('foo')
993
1046
        test.addTest(unittest.FunctionTestCase(failing_test))
994
1047
        stream = StringIO()
995
1048
        runner = tests.TextTestRunner(stream=stream)
996
1049
        result = self.run_test_runner(runner, test)
997
1050
        lines = stream.getvalue().splitlines()
998
 
        self.assertEqual([
999
 
            '',
1000
 
            '======================================================================',
1001
 
            'FAIL: unittest.FunctionTestCase (failing_test)',
1002
 
            '----------------------------------------------------------------------',
1003
 
            'Traceback (most recent call last):',
1004
 
            '    raise AssertionError(\'foo\')',
1005
 
            'AssertionError: foo',
1006
 
            '',
1007
 
            '----------------------------------------------------------------------',
1008
 
            '',
1009
 
            'FAILED (failures=1, known_failure_count=1)'],
1010
 
            lines[3:8] + lines[9:13] + lines[14:])
 
1051
        self.assertContainsRe(stream.getvalue(),
 
1052
            '(?sm)^bzr selftest.*$'
 
1053
            '.*'
 
1054
            '^======================================================================\n'
 
1055
            '^FAIL: failing_test\n'
 
1056
            '^----------------------------------------------------------------------\n'
 
1057
            'Traceback \\(most recent call last\\):\n'
 
1058
            '  .*' # File .*, line .*, in failing_test' - but maybe not from .pyc
 
1059
            '    self.fail\\(\'foo\'\\)\n'
 
1060
            '.*'
 
1061
            '^----------------------------------------------------------------------\n'
 
1062
            '.*'
 
1063
            'FAILED \\(failures=1, known_failure_count=1\\)'
 
1064
            )
1011
1065
 
1012
1066
    def test_known_failure_ok_run(self):
1013
 
        # run a test that generates a known failure which should be printed in the final output.
1014
 
        def known_failure_test():
1015
 
            raise tests.KnownFailure('failed')
1016
 
        test = unittest.FunctionTestCase(known_failure_test)
 
1067
        # run a test that generates a known failure which should be printed in
 
1068
        # the final output.
 
1069
        class Test(tests.TestCase):
 
1070
            def known_failure_test(self):
 
1071
                self.expectFailure('failed', self.assertTrue, False)
 
1072
        test = Test("known_failure_test")
1017
1073
        stream = StringIO()
1018
1074
        runner = tests.TextTestRunner(stream=stream)
1019
1075
        result = self.run_test_runner(runner, test)
1024
1080
            '\n'
1025
1081
            'OK \\(known_failures=1\\)\n')
1026
1082
 
 
1083
    def test_result_decorator(self):
 
1084
        # decorate results
 
1085
        calls = []
 
1086
        class LoggingDecorator(tests.ForwardingResult):
 
1087
            def startTest(self, test):
 
1088
                tests.ForwardingResult.startTest(self, test)
 
1089
                calls.append('start')
 
1090
        test = unittest.FunctionTestCase(lambda:None)
 
1091
        stream = StringIO()
 
1092
        runner = tests.TextTestRunner(stream=stream,
 
1093
            result_decorators=[LoggingDecorator])
 
1094
        result = self.run_test_runner(runner, test)
 
1095
        self.assertLength(1, calls)
 
1096
 
1027
1097
    def test_skipped_test(self):
1028
1098
        # run a test that is skipped, and check the suite as a whole still
1029
1099
        # succeeds.
1082
1152
 
1083
1153
    def test_not_applicable(self):
1084
1154
        # run a test that is skipped because it's not applicable
1085
 
        def not_applicable_test():
1086
 
            raise tests.TestNotApplicable('this test never runs')
 
1155
        class Test(tests.TestCase):
 
1156
            def not_applicable_test(self):
 
1157
                raise tests.TestNotApplicable('this test never runs')
1087
1158
        out = StringIO()
1088
1159
        runner = tests.TextTestRunner(stream=out, verbosity=2)
1089
 
        test = unittest.FunctionTestCase(not_applicable_test)
 
1160
        test = Test("not_applicable_test")
1090
1161
        result = self.run_test_runner(runner, test)
1091
1162
        self._log_file.write(out.getvalue())
1092
1163
        self.assertTrue(result.wasSuccessful())
1096
1167
        self.assertContainsRe(out.getvalue(),
1097
1168
                r'(?m)^    this test never runs')
1098
1169
 
1099
 
    def test_not_applicable_demo(self):
1100
 
        # just so you can see it in the test output
1101
 
        raise tests.TestNotApplicable('this test is just a demonstation')
1102
 
 
1103
1170
    def test_unsupported_features_listed(self):
1104
1171
        """When unsupported features are encountered they are detailed."""
1105
1172
        class Feature1(tests.Feature):
1125
1192
            ],
1126
1193
            lines[-3:])
1127
1194
 
 
1195
    def _patch_get_bzr_source_tree(self):
 
1196
        # Reading from the actual source tree breaks isolation, but we don't
 
1197
        # want to assume that thats *all* that would happen.
 
1198
        self._get_source_tree_calls = []
 
1199
        def new_get():
 
1200
            self._get_source_tree_calls.append("called")
 
1201
            return None
 
1202
        self.overrideAttr(bzrlib.version, '_get_bzr_source_tree',  new_get)
 
1203
 
1128
1204
    def test_bench_history(self):
1129
 
        # tests that the running the benchmark produces a history file
1130
 
        # containing a timestamp and the revision id of the bzrlib source which
1131
 
        # was tested.
1132
 
        workingtree = _get_bzr_source_tree()
 
1205
        # tests that the running the benchmark passes bench_history into
 
1206
        # the test result object. We can tell that happens if
 
1207
        # _get_bzr_source_tree is called.
 
1208
        self._patch_get_bzr_source_tree()
1133
1209
        test = TestRunner('dummy_test')
1134
1210
        output = StringIO()
1135
1211
        runner = tests.TextTestRunner(stream=self._log_file,
1137
1213
        result = self.run_test_runner(runner, test)
1138
1214
        output_string = output.getvalue()
1139
1215
        self.assertContainsRe(output_string, "--date [0-9.]+")
1140
 
        if workingtree is not None:
1141
 
            revision_id = workingtree.get_parent_ids()[0]
1142
 
            self.assertEndsWith(output_string.rstrip(), revision_id)
1143
 
 
1144
 
    def assertLogDeleted(self, test):
1145
 
        log = test._get_log()
1146
 
        self.assertEqual("DELETED log file to reduce memory footprint", log)
1147
 
        self.assertEqual('', test._log_contents)
1148
 
        self.assertIs(None, test._log_file_name)
1149
 
 
1150
 
    def test_success_log_deleted(self):
1151
 
        """Successful tests have their log deleted"""
1152
 
 
1153
 
        class LogTester(tests.TestCase):
1154
 
 
1155
 
            def test_success(self):
1156
 
                self.log('this will be removed\n')
1157
 
 
1158
 
        sio = StringIO()
1159
 
        runner = tests.TextTestRunner(stream=sio)
1160
 
        test = LogTester('test_success')
1161
 
        result = self.run_test_runner(runner, test)
1162
 
 
1163
 
        self.assertLogDeleted(test)
1164
 
 
1165
 
    def test_skipped_log_deleted(self):
1166
 
        """Skipped tests have their log deleted"""
1167
 
 
1168
 
        class LogTester(tests.TestCase):
1169
 
 
1170
 
            def test_skipped(self):
1171
 
                self.log('this will be removed\n')
1172
 
                raise tests.TestSkipped()
1173
 
 
1174
 
        sio = StringIO()
1175
 
        runner = tests.TextTestRunner(stream=sio)
1176
 
        test = LogTester('test_skipped')
1177
 
        result = self.run_test_runner(runner, test)
1178
 
 
1179
 
        self.assertLogDeleted(test)
1180
 
 
1181
 
    def test_not_aplicable_log_deleted(self):
1182
 
        """Not applicable tests have their log deleted"""
1183
 
 
1184
 
        class LogTester(tests.TestCase):
1185
 
 
1186
 
            def test_not_applicable(self):
1187
 
                self.log('this will be removed\n')
1188
 
                raise tests.TestNotApplicable()
1189
 
 
1190
 
        sio = StringIO()
1191
 
        runner = tests.TextTestRunner(stream=sio)
1192
 
        test = LogTester('test_not_applicable')
1193
 
        result = self.run_test_runner(runner, test)
1194
 
 
1195
 
        self.assertLogDeleted(test)
1196
 
 
1197
 
    def test_known_failure_log_deleted(self):
1198
 
        """Know failure tests have their log deleted"""
1199
 
 
1200
 
        class LogTester(tests.TestCase):
1201
 
 
1202
 
            def test_known_failure(self):
1203
 
                self.log('this will be removed\n')
1204
 
                raise tests.KnownFailure()
1205
 
 
1206
 
        sio = StringIO()
1207
 
        runner = tests.TextTestRunner(stream=sio)
1208
 
        test = LogTester('test_known_failure')
1209
 
        result = self.run_test_runner(runner, test)
1210
 
 
1211
 
        self.assertLogDeleted(test)
1212
 
 
1213
 
    def test_fail_log_kept(self):
1214
 
        """Failed tests have their log kept"""
1215
 
 
1216
 
        class LogTester(tests.TestCase):
1217
 
 
1218
 
            def test_fail(self):
1219
 
                self.log('this will be kept\n')
1220
 
                self.fail('this test fails')
1221
 
 
1222
 
        sio = StringIO()
1223
 
        runner = tests.TextTestRunner(stream=sio)
1224
 
        test = LogTester('test_fail')
1225
 
        result = self.run_test_runner(runner, test)
1226
 
 
1227
 
        text = sio.getvalue()
1228
 
        self.assertContainsRe(text, 'this will be kept')
1229
 
        self.assertContainsRe(text, 'this test fails')
1230
 
 
1231
 
        log = test._get_log()
1232
 
        self.assertContainsRe(log, 'this will be kept')
1233
 
        self.assertEqual(log, test._log_contents)
1234
 
 
1235
 
    def test_error_log_kept(self):
1236
 
        """Tests with errors have their log kept"""
1237
 
 
1238
 
        class LogTester(tests.TestCase):
1239
 
 
1240
 
            def test_error(self):
1241
 
                self.log('this will be kept\n')
1242
 
                raise ValueError('random exception raised')
1243
 
 
1244
 
        sio = StringIO()
1245
 
        runner = tests.TextTestRunner(stream=sio)
1246
 
        test = LogTester('test_error')
1247
 
        result = self.run_test_runner(runner, test)
1248
 
 
1249
 
        text = sio.getvalue()
1250
 
        self.assertContainsRe(text, 'this will be kept')
1251
 
        self.assertContainsRe(text, 'random exception raised')
1252
 
 
1253
 
        log = test._get_log()
1254
 
        self.assertContainsRe(log, 'this will be kept')
1255
 
        self.assertEqual(log, test._log_contents)
 
1216
        self.assertLength(1, self._get_source_tree_calls)
 
1217
 
 
1218
    def test_startTestRun(self):
 
1219
        """run should call result.startTestRun()"""
 
1220
        calls = []
 
1221
        class LoggingDecorator(tests.ForwardingResult):
 
1222
            def startTestRun(self):
 
1223
                tests.ForwardingResult.startTestRun(self)
 
1224
                calls.append('startTestRun')
 
1225
        test = unittest.FunctionTestCase(lambda:None)
 
1226
        stream = StringIO()
 
1227
        runner = tests.TextTestRunner(stream=stream,
 
1228
            result_decorators=[LoggingDecorator])
 
1229
        result = self.run_test_runner(runner, test)
 
1230
        self.assertLength(1, calls)
 
1231
 
 
1232
    def test_stopTestRun(self):
 
1233
        """run should call result.stopTestRun()"""
 
1234
        calls = []
 
1235
        class LoggingDecorator(tests.ForwardingResult):
 
1236
            def stopTestRun(self):
 
1237
                tests.ForwardingResult.stopTestRun(self)
 
1238
                calls.append('stopTestRun')
 
1239
        test = unittest.FunctionTestCase(lambda:None)
 
1240
        stream = StringIO()
 
1241
        runner = tests.TextTestRunner(stream=stream,
 
1242
            result_decorators=[LoggingDecorator])
 
1243
        result = self.run_test_runner(runner, test)
 
1244
        self.assertLength(1, calls)
1256
1245
 
1257
1246
 
1258
1247
class SampleTestCase(tests.TestCase):
1263
1252
class _TestException(Exception):
1264
1253
    pass
1265
1254
 
 
1255
 
1266
1256
class TestTestCase(tests.TestCase):
1267
1257
    """Tests that test the core bzrlib TestCase."""
1268
1258
 
1317
1307
        # we could set something and run a test that will check
1318
1308
        # it gets santised, but this is probably sufficient for now:
1319
1309
        # if someone runs the test with -Dsomething it will error.
1320
 
        self.assertEqual(set(), bzrlib.debug.debug_flags)
 
1310
        flags = set()
 
1311
        if self._lock_check_thorough:
 
1312
            flags.add('strict_locks')
 
1313
        self.assertEqual(flags, bzrlib.debug.debug_flags)
1321
1314
 
1322
1315
    def change_selftest_debug_flags(self, new_flags):
1323
 
        orig_selftest_flags = tests.selftest_debug_flags
1324
 
        self.addCleanup(self._restore_selftest_debug_flags, orig_selftest_flags)
1325
 
        tests.selftest_debug_flags = set(new_flags)
1326
 
 
1327
 
    def _restore_selftest_debug_flags(self, flags):
1328
 
        tests.selftest_debug_flags = flags
 
1316
        self.overrideAttr(tests, 'selftest_debug_flags', set(new_flags))
1329
1317
 
1330
1318
    def test_allow_debug_flag(self):
1331
1319
        """The -Eallow_debug flag prevents bzrlib.debug.debug_flags from being
1338
1326
                self.flags = set(bzrlib.debug.debug_flags)
1339
1327
        test = TestThatRecordsFlags('test_foo')
1340
1328
        test.run(self.make_test_result())
1341
 
        self.assertEqual(set(['a-flag']), self.flags)
 
1329
        flags = set(['a-flag'])
 
1330
        if 'disable_lock_checks' not in tests.selftest_debug_flags:
 
1331
            flags.add('strict_locks')
 
1332
        self.assertEqual(flags, self.flags)
 
1333
 
 
1334
    def test_disable_lock_checks(self):
 
1335
        """The -Edisable_lock_checks flag disables thorough checks."""
 
1336
        class TestThatRecordsFlags(tests.TestCase):
 
1337
            def test_foo(nested_self):
 
1338
                self.flags = set(bzrlib.debug.debug_flags)
 
1339
                self.test_lock_check_thorough = nested_self._lock_check_thorough
 
1340
        self.change_selftest_debug_flags(set())
 
1341
        test = TestThatRecordsFlags('test_foo')
 
1342
        test.run(self.make_test_result())
 
1343
        # By default we do strict lock checking and thorough lock/unlock
 
1344
        # tracking.
 
1345
        self.assertTrue(self.test_lock_check_thorough)
 
1346
        self.assertEqual(set(['strict_locks']), self.flags)
 
1347
        # Now set the disable_lock_checks flag, and show that this changed.
 
1348
        self.change_selftest_debug_flags(set(['disable_lock_checks']))
 
1349
        test = TestThatRecordsFlags('test_foo')
 
1350
        test.run(self.make_test_result())
 
1351
        self.assertFalse(self.test_lock_check_thorough)
 
1352
        self.assertEqual(set(), self.flags)
 
1353
 
 
1354
    def test_this_fails_strict_lock_check(self):
 
1355
        class TestThatRecordsFlags(tests.TestCase):
 
1356
            def test_foo(nested_self):
 
1357
                self.flags1 = set(bzrlib.debug.debug_flags)
 
1358
                self.thisFailsStrictLockCheck()
 
1359
                self.flags2 = set(bzrlib.debug.debug_flags)
 
1360
        # Make sure lock checking is active
 
1361
        self.change_selftest_debug_flags(set())
 
1362
        test = TestThatRecordsFlags('test_foo')
 
1363
        test.run(self.make_test_result())
 
1364
        self.assertEqual(set(['strict_locks']), self.flags1)
 
1365
        self.assertEqual(set(), self.flags2)
1342
1366
 
1343
1367
    def test_debug_flags_restored(self):
1344
1368
        """The bzrlib debug flags should be restored to their original state
1355
1379
        self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags)
1356
1380
 
1357
1381
    def make_test_result(self):
 
1382
        """Get a test result that writes to the test log file."""
1358
1383
        return tests.TextTestResult(self._log_file, descriptions=0, verbosity=1)
1359
1384
 
1360
1385
    def inner_test(self):
1368
1393
        result = self.make_test_result()
1369
1394
        self.inner_test.run(result)
1370
1395
        note("outer finish")
 
1396
        self.addCleanup(osutils.delete_any, self._log_file_name)
1371
1397
 
1372
1398
    def test_trace_nesting(self):
1373
1399
        # this tests that each test case nests its trace facility correctly.
1433
1459
        self.assertEqual((time.sleep, (0.003,), {}), self._benchcalls[1][0])
1434
1460
        self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
1435
1461
        self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
 
1462
        del self._benchcalls[:]
1436
1463
 
1437
1464
    def test_knownFailure(self):
1438
1465
        """Self.knownFailure() should raise a KnownFailure exception."""
1439
1466
        self.assertRaises(tests.KnownFailure, self.knownFailure, "A Failure")
1440
1467
 
 
1468
    def test_open_bzrdir_safe_roots(self):
 
1469
        # even a memory transport should fail to open when its url isn't 
 
1470
        # permitted.
 
1471
        # Manually set one up (TestCase doesn't and shouldn't provide magic
 
1472
        # machinery)
 
1473
        transport_server = MemoryServer()
 
1474
        transport_server.start_server()
 
1475
        self.addCleanup(transport_server.stop_server)
 
1476
        t = transport.get_transport(transport_server.get_url())
 
1477
        bzrdir.BzrDir.create(t.base)
 
1478
        self.assertRaises(errors.BzrError,
 
1479
            bzrdir.BzrDir.open_from_transport, t)
 
1480
        # But if we declare this as safe, we can open the bzrdir.
 
1481
        self.permit_url(t.base)
 
1482
        self._bzr_selftest_roots.append(t.base)
 
1483
        bzrdir.BzrDir.open_from_transport(t)
 
1484
 
1441
1485
    def test_requireFeature_available(self):
1442
1486
        """self.requireFeature(available) is a no-op."""
1443
1487
        class Available(tests.Feature):
1487
1531
        """Test disabled tests behaviour with support aware results."""
1488
1532
        test = SampleTestCase('_test_pass')
1489
1533
        class DisabledFeature(object):
 
1534
            def __eq__(self, other):
 
1535
                return isinstance(other, DisabledFeature)
1490
1536
            def available(self):
1491
1537
                return False
1492
1538
        the_feature = DisabledFeature()
1503
1549
                self.calls.append(('addNotSupported', test, feature))
1504
1550
        result = InstrumentedTestResult()
1505
1551
        test.run(result)
 
1552
        case = result.calls[0][1]
1506
1553
        self.assertEqual([
1507
 
            ('startTest', test),
1508
 
            ('addNotSupported', test, the_feature),
1509
 
            ('stopTest', test),
 
1554
            ('startTest', case),
 
1555
            ('addNotSupported', case, the_feature),
 
1556
            ('stopTest', case),
1510
1557
            ],
1511
1558
            result.calls)
1512
1559
 
 
1560
    def test_start_server_registers_url(self):
 
1561
        transport_server = MemoryServer()
 
1562
        # A little strict, but unlikely to be changed soon.
 
1563
        self.assertEqual([], self._bzr_selftest_roots)
 
1564
        self.start_server(transport_server)
 
1565
        self.assertSubset([transport_server.get_url()],
 
1566
            self._bzr_selftest_roots)
 
1567
 
1513
1568
    def test_assert_list_raises_on_generator(self):
1514
1569
        def generator_which_will_raise():
1515
1570
            # This will not raise until after the first yield
1565
1620
        self.assertRaises(AssertionError,
1566
1621
            self.assertListRaises, _TestException, success_generator)
1567
1622
 
 
1623
    def test_overrideAttr_without_value(self):
 
1624
        self.test_attr = 'original' # Define a test attribute
 
1625
        obj = self # Make 'obj' visible to the embedded test
 
1626
        class Test(tests.TestCase):
 
1627
 
 
1628
            def setUp(self):
 
1629
                tests.TestCase.setUp(self)
 
1630
                self.orig = self.overrideAttr(obj, 'test_attr')
 
1631
 
 
1632
            def test_value(self):
 
1633
                self.assertEqual('original', self.orig)
 
1634
                self.assertEqual('original', obj.test_attr)
 
1635
                obj.test_attr = 'modified'
 
1636
                self.assertEqual('modified', obj.test_attr)
 
1637
 
 
1638
        test = Test('test_value')
 
1639
        test.run(unittest.TestResult())
 
1640
        self.assertEqual('original', obj.test_attr)
 
1641
 
 
1642
    def test_overrideAttr_with_value(self):
 
1643
        self.test_attr = 'original' # Define a test attribute
 
1644
        obj = self # Make 'obj' visible to the embedded test
 
1645
        class Test(tests.TestCase):
 
1646
 
 
1647
            def setUp(self):
 
1648
                tests.TestCase.setUp(self)
 
1649
                self.orig = self.overrideAttr(obj, 'test_attr', new='modified')
 
1650
 
 
1651
            def test_value(self):
 
1652
                self.assertEqual('original', self.orig)
 
1653
                self.assertEqual('modified', obj.test_attr)
 
1654
 
 
1655
        test = Test('test_value')
 
1656
        test.run(unittest.TestResult())
 
1657
        self.assertEqual('original', obj.test_attr)
 
1658
 
1568
1659
 
1569
1660
# NB: Don't delete this; it's not actually from 0.11!
1570
1661
@deprecated_function(deprecated_in((0, 11, 0)))
1613
1704
        self.assertEndsWith('foo', 'oo')
1614
1705
        self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
1615
1706
 
 
1707
    def test_assertEqualDiff(self):
 
1708
        e = self.assertRaises(AssertionError,
 
1709
                              self.assertEqualDiff, '', '\n')
 
1710
        self.assertEquals(str(e),
 
1711
                          # Don't blink ! The '+' applies to the second string
 
1712
                          'first string is missing a final newline.\n+ \n')
 
1713
        e = self.assertRaises(AssertionError,
 
1714
                              self.assertEqualDiff, '\n', '')
 
1715
        self.assertEquals(str(e),
 
1716
                          # Don't blink ! The '-' applies to the second string
 
1717
                          'second string is missing a final newline.\n- \n')
 
1718
 
 
1719
 
 
1720
class TestDeprecations(tests.TestCase):
 
1721
 
1616
1722
    def test_applyDeprecated_not_deprecated(self):
1617
1723
        sample_object = ApplyDeprecatedHelper()
1618
1724
        # calling an undeprecated callable raises an assertion
1695
1801
        tree = self.make_branch_and_memory_tree('a')
1696
1802
        self.assertIsInstance(tree, bzrlib.memorytree.MemoryTree)
1697
1803
 
1698
 
 
1699
 
class TestSFTPMakeBranchAndTree(test_sftp_transport.TestCaseWithSFTPServer):
1700
 
 
1701
 
    def test_make_tree_for_sftp_branch(self):
1702
 
        """Transports backed by local directories create local trees."""
1703
 
 
 
1804
    def test_make_tree_for_local_vfs_backed_transport(self):
 
1805
        # make_branch_and_tree has to use local branch and repositories
 
1806
        # when the vfs transport and local disk are colocated, even if
 
1807
        # a different transport is in use for url generation.
 
1808
        from bzrlib.transport.fakevfat import FakeVFATServer
 
1809
        self.transport_server = FakeVFATServer
 
1810
        self.assertFalse(self.get_url('t1').startswith('file://'))
1704
1811
        tree = self.make_branch_and_tree('t1')
1705
1812
        base = tree.bzrdir.root_transport.base
1706
 
        self.failIf(base.startswith('sftp'),
1707
 
                'base %r is on sftp but should be local' % base)
 
1813
        self.assertStartsWith(base, 'file://')
1708
1814
        self.assertEquals(tree.bzrdir.root_transport,
1709
1815
                tree.branch.bzrdir.root_transport)
1710
1816
        self.assertEquals(tree.bzrdir.root_transport,
1711
1817
                tree.branch.repository.bzrdir.root_transport)
1712
1818
 
1713
1819
 
1714
 
class TestSelftest(tests.TestCase):
 
1820
class SelfTestHelper:
 
1821
 
 
1822
    def run_selftest(self, **kwargs):
 
1823
        """Run selftest returning its output."""
 
1824
        output = StringIO()
 
1825
        old_transport = bzrlib.tests.default_transport
 
1826
        old_root = tests.TestCaseWithMemoryTransport.TEST_ROOT
 
1827
        tests.TestCaseWithMemoryTransport.TEST_ROOT = None
 
1828
        try:
 
1829
            self.assertEqual(True, tests.selftest(stream=output, **kwargs))
 
1830
        finally:
 
1831
            bzrlib.tests.default_transport = old_transport
 
1832
            tests.TestCaseWithMemoryTransport.TEST_ROOT = old_root
 
1833
        output.seek(0)
 
1834
        return output
 
1835
 
 
1836
 
 
1837
class TestSelftest(tests.TestCase, SelfTestHelper):
1715
1838
    """Tests of bzrlib.tests.selftest."""
1716
1839
 
1717
1840
    def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
1725
1848
            test_suite_factory=factory)
1726
1849
        self.assertEqual([True], factory_called)
1727
1850
 
1728
 
 
1729
 
class TestKnownFailure(tests.TestCase):
1730
 
 
1731
 
    def test_known_failure(self):
1732
 
        """Check that KnownFailure is defined appropriately."""
1733
 
        # a KnownFailure is an assertion error for compatability with unaware
1734
 
        # runners.
1735
 
        self.assertIsInstance(tests.KnownFailure(""), AssertionError)
1736
 
 
1737
 
    def test_expect_failure(self):
1738
 
        try:
1739
 
            self.expectFailure("Doomed to failure", self.assertTrue, False)
1740
 
        except tests.KnownFailure, e:
1741
 
            self.assertEqual('Doomed to failure', e.args[0])
1742
 
        try:
1743
 
            self.expectFailure("Doomed to failure", self.assertTrue, True)
1744
 
        except AssertionError, e:
1745
 
            self.assertEqual('Unexpected success.  Should have failed:'
1746
 
                             ' Doomed to failure', e.args[0])
 
1851
    def factory(self):
 
1852
        """A test suite factory."""
 
1853
        class Test(tests.TestCase):
 
1854
            def a(self):
 
1855
                pass
 
1856
            def b(self):
 
1857
                pass
 
1858
            def c(self):
 
1859
                pass
 
1860
        return TestUtil.TestSuite([Test("a"), Test("b"), Test("c")])
 
1861
 
 
1862
    def test_list_only(self):
 
1863
        output = self.run_selftest(test_suite_factory=self.factory,
 
1864
            list_only=True)
 
1865
        self.assertEqual(3, len(output.readlines()))
 
1866
 
 
1867
    def test_list_only_filtered(self):
 
1868
        output = self.run_selftest(test_suite_factory=self.factory,
 
1869
            list_only=True, pattern="Test.b")
 
1870
        self.assertEndsWith(output.getvalue(), "Test.b\n")
 
1871
        self.assertLength(1, output.readlines())
 
1872
 
 
1873
    def test_list_only_excludes(self):
 
1874
        output = self.run_selftest(test_suite_factory=self.factory,
 
1875
            list_only=True, exclude_pattern="Test.b")
 
1876
        self.assertNotContainsRe("Test.b", output.getvalue())
 
1877
        self.assertLength(2, output.readlines())
 
1878
 
 
1879
    def test_lsprof_tests(self):
 
1880
        self.requireFeature(test_lsprof.LSProfFeature)
 
1881
        calls = []
 
1882
        class Test(object):
 
1883
            def __call__(test, result):
 
1884
                test.run(result)
 
1885
            def run(test, result):
 
1886
                self.assertIsInstance(result, tests.ForwardingResult)
 
1887
                calls.append("called")
 
1888
            def countTestCases(self):
 
1889
                return 1
 
1890
        self.run_selftest(test_suite_factory=Test, lsprof_tests=True)
 
1891
        self.assertLength(1, calls)
 
1892
 
 
1893
    def test_random(self):
 
1894
        # test randomising by listing a number of tests.
 
1895
        output_123 = self.run_selftest(test_suite_factory=self.factory,
 
1896
            list_only=True, random_seed="123")
 
1897
        output_234 = self.run_selftest(test_suite_factory=self.factory,
 
1898
            list_only=True, random_seed="234")
 
1899
        self.assertNotEqual(output_123, output_234)
 
1900
        # "Randominzing test order..\n\n
 
1901
        self.assertLength(5, output_123.readlines())
 
1902
        self.assertLength(5, output_234.readlines())
 
1903
 
 
1904
    def test_random_reuse_is_same_order(self):
 
1905
        # test randomising by listing a number of tests.
 
1906
        expected = self.run_selftest(test_suite_factory=self.factory,
 
1907
            list_only=True, random_seed="123")
 
1908
        repeated = self.run_selftest(test_suite_factory=self.factory,
 
1909
            list_only=True, random_seed="123")
 
1910
        self.assertEqual(expected.getvalue(), repeated.getvalue())
 
1911
 
 
1912
    def test_runner_class(self):
 
1913
        self.requireFeature(features.subunit)
 
1914
        from subunit import ProtocolTestCase
 
1915
        stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
 
1916
            test_suite_factory=self.factory)
 
1917
        test = ProtocolTestCase(stream)
 
1918
        result = unittest.TestResult()
 
1919
        test.run(result)
 
1920
        self.assertEqual(3, result.testsRun)
 
1921
 
 
1922
    def test_starting_with_single_argument(self):
 
1923
        output = self.run_selftest(test_suite_factory=self.factory,
 
1924
            starting_with=['bzrlib.tests.test_selftest.Test.a'],
 
1925
            list_only=True)
 
1926
        self.assertEqual('bzrlib.tests.test_selftest.Test.a\n',
 
1927
            output.getvalue())
 
1928
 
 
1929
    def test_starting_with_multiple_argument(self):
 
1930
        output = self.run_selftest(test_suite_factory=self.factory,
 
1931
            starting_with=['bzrlib.tests.test_selftest.Test.a',
 
1932
                'bzrlib.tests.test_selftest.Test.b'],
 
1933
            list_only=True)
 
1934
        self.assertEqual('bzrlib.tests.test_selftest.Test.a\n'
 
1935
            'bzrlib.tests.test_selftest.Test.b\n',
 
1936
            output.getvalue())
 
1937
 
 
1938
    def check_transport_set(self, transport_server):
 
1939
        captured_transport = []
 
1940
        def seen_transport(a_transport):
 
1941
            captured_transport.append(a_transport)
 
1942
        class Capture(tests.TestCase):
 
1943
            def a(self):
 
1944
                seen_transport(bzrlib.tests.default_transport)
 
1945
        def factory():
 
1946
            return TestUtil.TestSuite([Capture("a")])
 
1947
        self.run_selftest(transport=transport_server, test_suite_factory=factory)
 
1948
        self.assertEqual(transport_server, captured_transport[0])
 
1949
 
 
1950
    def test_transport_sftp(self):
 
1951
        self.requireFeature(features.paramiko)
 
1952
        self.check_transport_set(stub_sftp.SFTPAbsoluteServer)
 
1953
 
 
1954
    def test_transport_memory(self):
 
1955
        self.check_transport_set(bzrlib.transport.memory.MemoryServer)
 
1956
 
 
1957
 
 
1958
class TestSelftestWithIdList(tests.TestCaseInTempDir, SelfTestHelper):
 
1959
    # Does IO: reads test.list
 
1960
 
 
1961
    def test_load_list(self):
 
1962
        # Provide a list with one test - this test.
 
1963
        test_id_line = '%s\n' % self.id()
 
1964
        self.build_tree_contents([('test.list', test_id_line)])
 
1965
        # And generate a list of the tests in  the suite.
 
1966
        stream = self.run_selftest(load_list='test.list', list_only=True)
 
1967
        self.assertEqual(test_id_line, stream.getvalue())
 
1968
 
 
1969
    def test_load_unknown(self):
 
1970
        # Provide a list with one test - this test.
 
1971
        # And generate a list of the tests in  the suite.
 
1972
        err = self.assertRaises(errors.NoSuchFile, self.run_selftest,
 
1973
            load_list='missing file name', list_only=True)
 
1974
 
 
1975
 
 
1976
class TestRunBzr(tests.TestCase):
 
1977
 
 
1978
    out = ''
 
1979
    err = ''
 
1980
 
 
1981
    def _run_bzr_core(self, argv, retcode=0, encoding=None, stdin=None,
 
1982
                         working_dir=None):
 
1983
        """Override _run_bzr_core to test how it is invoked by run_bzr.
 
1984
 
 
1985
        Attempts to run bzr from inside this class don't actually run it.
 
1986
 
 
1987
        We test how run_bzr actually invokes bzr in another location.  Here we
 
1988
        only need to test that it passes the right parameters to run_bzr.
 
1989
        """
 
1990
        self.argv = list(argv)
 
1991
        self.retcode = retcode
 
1992
        self.encoding = encoding
 
1993
        self.stdin = stdin
 
1994
        self.working_dir = working_dir
 
1995
        return self.retcode, self.out, self.err
 
1996
 
 
1997
    def test_run_bzr_error(self):
 
1998
        self.out = "It sure does!\n"
 
1999
        out, err = self.run_bzr_error(['^$'], ['rocks'], retcode=34)
 
2000
        self.assertEqual(['rocks'], self.argv)
 
2001
        self.assertEqual(34, self.retcode)
 
2002
        self.assertEqual('It sure does!\n', out)
 
2003
        self.assertEquals(out, self.out)
 
2004
        self.assertEqual('', err)
 
2005
        self.assertEquals(err, self.err)
 
2006
 
 
2007
    def test_run_bzr_error_regexes(self):
 
2008
        self.out = ''
 
2009
        self.err = "bzr: ERROR: foobarbaz is not versioned"
 
2010
        out, err = self.run_bzr_error(
 
2011
            ["bzr: ERROR: foobarbaz is not versioned"],
 
2012
            ['file-id', 'foobarbaz'])
 
2013
 
 
2014
    def test_encoding(self):
 
2015
        """Test that run_bzr passes encoding to _run_bzr_core"""
 
2016
        self.run_bzr('foo bar')
 
2017
        self.assertEqual(None, self.encoding)
 
2018
        self.assertEqual(['foo', 'bar'], self.argv)
 
2019
 
 
2020
        self.run_bzr('foo bar', encoding='baz')
 
2021
        self.assertEqual('baz', self.encoding)
 
2022
        self.assertEqual(['foo', 'bar'], self.argv)
 
2023
 
 
2024
    def test_retcode(self):
 
2025
        """Test that run_bzr passes retcode to _run_bzr_core"""
 
2026
        # Default is retcode == 0
 
2027
        self.run_bzr('foo bar')
 
2028
        self.assertEqual(0, self.retcode)
 
2029
        self.assertEqual(['foo', 'bar'], self.argv)
 
2030
 
 
2031
        self.run_bzr('foo bar', retcode=1)
 
2032
        self.assertEqual(1, self.retcode)
 
2033
        self.assertEqual(['foo', 'bar'], self.argv)
 
2034
 
 
2035
        self.run_bzr('foo bar', retcode=None)
 
2036
        self.assertEqual(None, self.retcode)
 
2037
        self.assertEqual(['foo', 'bar'], self.argv)
 
2038
 
 
2039
        self.run_bzr(['foo', 'bar'], retcode=3)
 
2040
        self.assertEqual(3, self.retcode)
 
2041
        self.assertEqual(['foo', 'bar'], self.argv)
 
2042
 
 
2043
    def test_stdin(self):
 
2044
        # test that the stdin keyword to run_bzr is passed through to
 
2045
        # _run_bzr_core as-is. We do this by overriding
 
2046
        # _run_bzr_core in this class, and then calling run_bzr,
 
2047
        # which is a convenience function for _run_bzr_core, so
 
2048
        # should invoke it.
 
2049
        self.run_bzr('foo bar', stdin='gam')
 
2050
        self.assertEqual('gam', self.stdin)
 
2051
        self.assertEqual(['foo', 'bar'], self.argv)
 
2052
 
 
2053
        self.run_bzr('foo bar', stdin='zippy')
 
2054
        self.assertEqual('zippy', self.stdin)
 
2055
        self.assertEqual(['foo', 'bar'], self.argv)
 
2056
 
 
2057
    def test_working_dir(self):
 
2058
        """Test that run_bzr passes working_dir to _run_bzr_core"""
 
2059
        self.run_bzr('foo bar')
 
2060
        self.assertEqual(None, self.working_dir)
 
2061
        self.assertEqual(['foo', 'bar'], self.argv)
 
2062
 
 
2063
        self.run_bzr('foo bar', working_dir='baz')
 
2064
        self.assertEqual('baz', self.working_dir)
 
2065
        self.assertEqual(['foo', 'bar'], self.argv)
 
2066
 
 
2067
    def test_reject_extra_keyword_arguments(self):
 
2068
        self.assertRaises(TypeError, self.run_bzr, "foo bar",
 
2069
                          error_regex=['error message'])
 
2070
 
 
2071
 
 
2072
class TestRunBzrCaptured(tests.TestCaseWithTransport):
 
2073
    # Does IO when testing the working_dir parameter.
 
2074
 
 
2075
    def apply_redirected(self, stdin=None, stdout=None, stderr=None,
 
2076
                         a_callable=None, *args, **kwargs):
 
2077
        self.stdin = stdin
 
2078
        self.factory_stdin = getattr(bzrlib.ui.ui_factory, "stdin", None)
 
2079
        self.factory = bzrlib.ui.ui_factory
 
2080
        self.working_dir = osutils.getcwd()
 
2081
        stdout.write('foo\n')
 
2082
        stderr.write('bar\n')
 
2083
        return 0
 
2084
 
 
2085
    def test_stdin(self):
 
2086
        # test that the stdin keyword to _run_bzr_core is passed through to
 
2087
        # apply_redirected as a StringIO. We do this by overriding
 
2088
        # apply_redirected in this class, and then calling _run_bzr_core,
 
2089
        # which calls apply_redirected.
 
2090
        self.run_bzr(['foo', 'bar'], stdin='gam')
 
2091
        self.assertEqual('gam', self.stdin.read())
 
2092
        self.assertTrue(self.stdin is self.factory_stdin)
 
2093
        self.run_bzr(['foo', 'bar'], stdin='zippy')
 
2094
        self.assertEqual('zippy', self.stdin.read())
 
2095
        self.assertTrue(self.stdin is self.factory_stdin)
 
2096
 
 
2097
    def test_ui_factory(self):
 
2098
        # each invocation of self.run_bzr should get its
 
2099
        # own UI factory, which is an instance of TestUIFactory,
 
2100
        # with stdin, stdout and stderr attached to the stdin,
 
2101
        # stdout and stderr of the invoked run_bzr
 
2102
        current_factory = bzrlib.ui.ui_factory
 
2103
        self.run_bzr(['foo'])
 
2104
        self.failIf(current_factory is self.factory)
 
2105
        self.assertNotEqual(sys.stdout, self.factory.stdout)
 
2106
        self.assertNotEqual(sys.stderr, self.factory.stderr)
 
2107
        self.assertEqual('foo\n', self.factory.stdout.getvalue())
 
2108
        self.assertEqual('bar\n', self.factory.stderr.getvalue())
 
2109
        self.assertIsInstance(self.factory, tests.TestUIFactory)
 
2110
 
 
2111
    def test_working_dir(self):
 
2112
        self.build_tree(['one/', 'two/'])
 
2113
        cwd = osutils.getcwd()
 
2114
 
 
2115
        # Default is to work in the current directory
 
2116
        self.run_bzr(['foo', 'bar'])
 
2117
        self.assertEqual(cwd, self.working_dir)
 
2118
 
 
2119
        self.run_bzr(['foo', 'bar'], working_dir=None)
 
2120
        self.assertEqual(cwd, self.working_dir)
 
2121
 
 
2122
        # The function should be run in the alternative directory
 
2123
        # but afterwards the current working dir shouldn't be changed
 
2124
        self.run_bzr(['foo', 'bar'], working_dir='one')
 
2125
        self.assertNotEqual(cwd, self.working_dir)
 
2126
        self.assertEndsWith(self.working_dir, 'one')
 
2127
        self.assertEqual(cwd, osutils.getcwd())
 
2128
 
 
2129
        self.run_bzr(['foo', 'bar'], working_dir='two')
 
2130
        self.assertNotEqual(cwd, self.working_dir)
 
2131
        self.assertEndsWith(self.working_dir, 'two')
 
2132
        self.assertEqual(cwd, osutils.getcwd())
 
2133
 
 
2134
 
 
2135
class StubProcess(object):
 
2136
    """A stub process for testing run_bzr_subprocess."""
 
2137
    
 
2138
    def __init__(self, out="", err="", retcode=0):
 
2139
        self.out = out
 
2140
        self.err = err
 
2141
        self.returncode = retcode
 
2142
 
 
2143
    def communicate(self):
 
2144
        return self.out, self.err
 
2145
 
 
2146
 
 
2147
class TestWithFakedStartBzrSubprocess(tests.TestCaseWithTransport):
 
2148
    """Base class for tests testing how we might run bzr."""
 
2149
 
 
2150
    def setUp(self):
 
2151
        tests.TestCaseWithTransport.setUp(self)
 
2152
        self.subprocess_calls = []
 
2153
 
 
2154
    def start_bzr_subprocess(self, process_args, env_changes=None,
 
2155
                             skip_if_plan_to_signal=False,
 
2156
                             working_dir=None,
 
2157
                             allow_plugins=False):
 
2158
        """capture what run_bzr_subprocess tries to do."""
 
2159
        self.subprocess_calls.append({'process_args':process_args,
 
2160
            'env_changes':env_changes,
 
2161
            'skip_if_plan_to_signal':skip_if_plan_to_signal,
 
2162
            'working_dir':working_dir, 'allow_plugins':allow_plugins})
 
2163
        return self.next_subprocess
 
2164
 
 
2165
 
 
2166
class TestRunBzrSubprocess(TestWithFakedStartBzrSubprocess):
 
2167
 
 
2168
    def assertRunBzrSubprocess(self, expected_args, process, *args, **kwargs):
 
2169
        """Run run_bzr_subprocess with args and kwargs using a stubbed process.
 
2170
 
 
2171
        Inside TestRunBzrSubprocessCommands we use a stub start_bzr_subprocess
 
2172
        that will return static results. This assertion method populates those
 
2173
        results and also checks the arguments run_bzr_subprocess generates.
 
2174
        """
 
2175
        self.next_subprocess = process
 
2176
        try:
 
2177
            result = self.run_bzr_subprocess(*args, **kwargs)
 
2178
        except:
 
2179
            self.next_subprocess = None
 
2180
            for key, expected in expected_args.iteritems():
 
2181
                self.assertEqual(expected, self.subprocess_calls[-1][key])
 
2182
            raise
1747
2183
        else:
1748
 
            self.fail('Assertion not raised')
 
2184
            self.next_subprocess = None
 
2185
            for key, expected in expected_args.iteritems():
 
2186
                self.assertEqual(expected, self.subprocess_calls[-1][key])
 
2187
            return result
 
2188
 
 
2189
    def test_run_bzr_subprocess(self):
 
2190
        """The run_bzr_helper_external command behaves nicely."""
 
2191
        self.assertRunBzrSubprocess({'process_args':['--version']},
 
2192
            StubProcess(), '--version')
 
2193
        self.assertRunBzrSubprocess({'process_args':['--version']},
 
2194
            StubProcess(), ['--version'])
 
2195
        # retcode=None disables retcode checking
 
2196
        result = self.assertRunBzrSubprocess({},
 
2197
            StubProcess(retcode=3), '--version', retcode=None)
 
2198
        result = self.assertRunBzrSubprocess({},
 
2199
            StubProcess(out="is free software"), '--version')
 
2200
        self.assertContainsRe(result[0], 'is free software')
 
2201
        # Running a subcommand that is missing errors
 
2202
        self.assertRaises(AssertionError, self.assertRunBzrSubprocess,
 
2203
            {'process_args':['--versionn']}, StubProcess(retcode=3),
 
2204
            '--versionn')
 
2205
        # Unless it is told to expect the error from the subprocess
 
2206
        result = self.assertRunBzrSubprocess({},
 
2207
            StubProcess(retcode=3), '--versionn', retcode=3)
 
2208
        # Or to ignore retcode checking
 
2209
        result = self.assertRunBzrSubprocess({},
 
2210
            StubProcess(err="unknown command", retcode=3), '--versionn',
 
2211
            retcode=None)
 
2212
        self.assertContainsRe(result[1], 'unknown command')
 
2213
 
 
2214
    def test_env_change_passes_through(self):
 
2215
        self.assertRunBzrSubprocess(
 
2216
            {'env_changes':{'new':'value', 'changed':'newvalue', 'deleted':None}},
 
2217
            StubProcess(), '',
 
2218
            env_changes={'new':'value', 'changed':'newvalue', 'deleted':None})
 
2219
 
 
2220
    def test_no_working_dir_passed_as_None(self):
 
2221
        self.assertRunBzrSubprocess({'working_dir': None}, StubProcess(), '')
 
2222
 
 
2223
    def test_no_working_dir_passed_through(self):
 
2224
        self.assertRunBzrSubprocess({'working_dir': 'dir'}, StubProcess(), '',
 
2225
            working_dir='dir')
 
2226
 
 
2227
    def test_run_bzr_subprocess_no_plugins(self):
 
2228
        self.assertRunBzrSubprocess({'allow_plugins': False},
 
2229
            StubProcess(), '')
 
2230
 
 
2231
    def test_allow_plugins(self):
 
2232
        self.assertRunBzrSubprocess({'allow_plugins': True},
 
2233
            StubProcess(), '', allow_plugins=True)
 
2234
 
 
2235
 
 
2236
class TestFinishBzrSubprocess(TestWithFakedStartBzrSubprocess):
 
2237
 
 
2238
    def test_finish_bzr_subprocess_with_error(self):
 
2239
        """finish_bzr_subprocess allows specification of the desired exit code.
 
2240
        """
 
2241
        process = StubProcess(err="unknown command", retcode=3)
 
2242
        result = self.finish_bzr_subprocess(process, retcode=3)
 
2243
        self.assertEqual('', result[0])
 
2244
        self.assertContainsRe(result[1], 'unknown command')
 
2245
 
 
2246
    def test_finish_bzr_subprocess_ignoring_retcode(self):
 
2247
        """finish_bzr_subprocess allows the exit code to be ignored."""
 
2248
        process = StubProcess(err="unknown command", retcode=3)
 
2249
        result = self.finish_bzr_subprocess(process, retcode=None)
 
2250
        self.assertEqual('', result[0])
 
2251
        self.assertContainsRe(result[1], 'unknown command')
 
2252
 
 
2253
    def test_finish_subprocess_with_unexpected_retcode(self):
 
2254
        """finish_bzr_subprocess raises self.failureException if the retcode is
 
2255
        not the expected one.
 
2256
        """
 
2257
        process = StubProcess(err="unknown command", retcode=3)
 
2258
        self.assertRaises(self.failureException, self.finish_bzr_subprocess,
 
2259
                          process)
 
2260
 
 
2261
 
 
2262
class _DontSpawnProcess(Exception):
 
2263
    """A simple exception which just allows us to skip unnecessary steps"""
 
2264
 
 
2265
 
 
2266
class TestStartBzrSubProcess(tests.TestCase):
 
2267
 
 
2268
    def check_popen_state(self):
 
2269
        """Replace to make assertions when popen is called."""
 
2270
 
 
2271
    def _popen(self, *args, **kwargs):
 
2272
        """Record the command that is run, so that we can ensure it is correct"""
 
2273
        self.check_popen_state()
 
2274
        self._popen_args = args
 
2275
        self._popen_kwargs = kwargs
 
2276
        raise _DontSpawnProcess()
 
2277
 
 
2278
    def test_run_bzr_subprocess_no_plugins(self):
 
2279
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [])
 
2280
        command = self._popen_args[0]
 
2281
        self.assertEqual(sys.executable, command[0])
 
2282
        self.assertEqual(self.get_bzr_path(), command[1])
 
2283
        self.assertEqual(['--no-plugins'], command[2:])
 
2284
 
 
2285
    def test_allow_plugins(self):
 
2286
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
 
2287
            allow_plugins=True)
 
2288
        command = self._popen_args[0]
 
2289
        self.assertEqual([], command[2:])
 
2290
 
 
2291
    def test_set_env(self):
 
2292
        self.failIf('EXISTANT_ENV_VAR' in os.environ)
 
2293
        # set in the child
 
2294
        def check_environment():
 
2295
            self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
 
2296
        self.check_popen_state = check_environment
 
2297
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
 
2298
            env_changes={'EXISTANT_ENV_VAR':'set variable'})
 
2299
        # not set in theparent
 
2300
        self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
 
2301
 
 
2302
    def test_run_bzr_subprocess_env_del(self):
 
2303
        """run_bzr_subprocess can remove environment variables too."""
 
2304
        self.failIf('EXISTANT_ENV_VAR' in os.environ)
 
2305
        def check_environment():
 
2306
            self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
 
2307
        os.environ['EXISTANT_ENV_VAR'] = 'set variable'
 
2308
        self.check_popen_state = check_environment
 
2309
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
 
2310
            env_changes={'EXISTANT_ENV_VAR':None})
 
2311
        # Still set in parent
 
2312
        self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
 
2313
        del os.environ['EXISTANT_ENV_VAR']
 
2314
 
 
2315
    def test_env_del_missing(self):
 
2316
        self.failIf('NON_EXISTANT_ENV_VAR' in os.environ)
 
2317
        def check_environment():
 
2318
            self.assertFalse('NON_EXISTANT_ENV_VAR' in os.environ)
 
2319
        self.check_popen_state = check_environment
 
2320
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
 
2321
            env_changes={'NON_EXISTANT_ENV_VAR':None})
 
2322
 
 
2323
    def test_working_dir(self):
 
2324
        """Test that we can specify the working dir for the child"""
 
2325
        orig_getcwd = osutils.getcwd
 
2326
        orig_chdir = os.chdir
 
2327
        chdirs = []
 
2328
        def chdir(path):
 
2329
            chdirs.append(path)
 
2330
        os.chdir = chdir
 
2331
        try:
 
2332
            def getcwd():
 
2333
                return 'current'
 
2334
            osutils.getcwd = getcwd
 
2335
            try:
 
2336
                self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
 
2337
                    working_dir='foo')
 
2338
            finally:
 
2339
                osutils.getcwd = orig_getcwd
 
2340
        finally:
 
2341
            os.chdir = orig_chdir
 
2342
        self.assertEqual(['foo', 'current'], chdirs)
 
2343
 
 
2344
 
 
2345
class TestActuallyStartBzrSubprocess(tests.TestCaseWithTransport):
 
2346
    """Tests that really need to do things with an external bzr."""
 
2347
 
 
2348
    def test_start_and_stop_bzr_subprocess_send_signal(self):
 
2349
        """finish_bzr_subprocess raises self.failureException if the retcode is
 
2350
        not the expected one.
 
2351
        """
 
2352
        self.disable_missing_extensions_warning()
 
2353
        process = self.start_bzr_subprocess(['wait-until-signalled'],
 
2354
                                            skip_if_plan_to_signal=True)
 
2355
        self.assertEqual('running\n', process.stdout.readline())
 
2356
        result = self.finish_bzr_subprocess(process, send_signal=signal.SIGINT,
 
2357
                                            retcode=3)
 
2358
        self.assertEqual('', result[0])
 
2359
        self.assertEqual('bzr: interrupted\n', result[1])
1749
2360
 
1750
2361
 
1751
2362
class TestFeature(tests.TestCase):
1789
2400
        self.assertIs(feature, exception.args[0])
1790
2401
 
1791
2402
 
 
2403
simple_thunk_feature = tests._CompatabilityThunkFeature(
 
2404
    deprecated_in((2, 1, 0)),
 
2405
    'bzrlib.tests.test_selftest',
 
2406
    'simple_thunk_feature','UnicodeFilename',
 
2407
    replacement_module='bzrlib.tests'
 
2408
    )
 
2409
 
 
2410
class Test_CompatibilityFeature(tests.TestCase):
 
2411
 
 
2412
    def test_does_thunk(self):
 
2413
        res = self.callDeprecated(
 
2414
            ['bzrlib.tests.test_selftest.simple_thunk_feature was deprecated'
 
2415
             ' in version 2.1.0. Use bzrlib.tests.UnicodeFilename instead.'],
 
2416
            simple_thunk_feature.available)
 
2417
        self.assertEqual(tests.UnicodeFilename.available(), res)
 
2418
 
 
2419
 
 
2420
class TestModuleAvailableFeature(tests.TestCase):
 
2421
 
 
2422
    def test_available_module(self):
 
2423
        feature = tests.ModuleAvailableFeature('bzrlib.tests')
 
2424
        self.assertEqual('bzrlib.tests', feature.module_name)
 
2425
        self.assertEqual('bzrlib.tests', str(feature))
 
2426
        self.assertTrue(feature.available())
 
2427
        self.assertIs(tests, feature.module)
 
2428
 
 
2429
    def test_unavailable_module(self):
 
2430
        feature = tests.ModuleAvailableFeature('bzrlib.no_such_module_exists')
 
2431
        self.assertEqual('bzrlib.no_such_module_exists', str(feature))
 
2432
        self.assertFalse(feature.available())
 
2433
        self.assertIs(None, feature.module)
 
2434
 
 
2435
 
1792
2436
class TestSelftestFiltering(tests.TestCase):
1793
2437
 
1794
2438
    def setUp(self):
1795
2439
        tests.TestCase.setUp(self)
1796
2440
        self.suite = TestUtil.TestSuite()
1797
2441
        self.loader = TestUtil.TestLoader()
1798
 
        self.suite.addTest(self.loader.loadTestsFromModuleNames([
1799
 
            'bzrlib.tests.test_selftest']))
 
2442
        self.suite.addTest(self.loader.loadTestsFromModule(
 
2443
            sys.modules['bzrlib.tests.test_selftest']))
1800
2444
        self.all_names = _test_ids(self.suite)
1801
2445
 
1802
2446
    def test_condition_id_re(self):
1973
2617
        # the test framework
1974
2618
        self.assertEquals('always fails', str(e))
1975
2619
        # check that there's no traceback in the test log
1976
 
        self.assertNotContainsRe(self._get_log(keep_log_file=True),
1977
 
            r'Traceback')
 
2620
        self.assertNotContainsRe(self.get_log(), r'Traceback')
1978
2621
 
1979
2622
    def test_run_bzr_user_error_caught(self):
1980
2623
        # Running bzr in blackbox mode, normal/expected/user errors should be
1981
2624
        # caught in the regular way and turned into an error message plus exit
1982
2625
        # code.
1983
 
        out, err = self.run_bzr(["log", "/nonexistantpath"], retcode=3)
 
2626
        transport_server = MemoryServer()
 
2627
        transport_server.start_server()
 
2628
        self.addCleanup(transport_server.stop_server)
 
2629
        url = transport_server.get_url()
 
2630
        self.permit_url(url)
 
2631
        out, err = self.run_bzr(["log", "%s/nonexistantpath" % url], retcode=3)
1984
2632
        self.assertEqual(out, '')
1985
2633
        self.assertContainsRe(err,
1986
2634
            'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
2112
2760
 
2113
2761
class TestTestSuite(tests.TestCase):
2114
2762
 
 
2763
    def test__test_suite_testmod_names(self):
 
2764
        # Test that a plausible list of test module names are returned
 
2765
        # by _test_suite_testmod_names.
 
2766
        test_list = tests._test_suite_testmod_names()
 
2767
        self.assertSubset([
 
2768
            'bzrlib.tests.blackbox',
 
2769
            'bzrlib.tests.per_transport',
 
2770
            'bzrlib.tests.test_selftest',
 
2771
            ],
 
2772
            test_list)
 
2773
 
 
2774
    def test__test_suite_modules_to_doctest(self):
 
2775
        # Test that a plausible list of modules to doctest is returned
 
2776
        # by _test_suite_modules_to_doctest.
 
2777
        test_list = tests._test_suite_modules_to_doctest()
 
2778
        self.assertSubset([
 
2779
            'bzrlib.timestamp',
 
2780
            ],
 
2781
            test_list)
 
2782
 
2115
2783
    def test_test_suite(self):
2116
 
        # This test is slow, so we do a single test with one test in each
2117
 
        # category
2118
 
        test_list = [
 
2784
        # test_suite() loads the entire test suite to operate. To avoid this
 
2785
        # overhead, and yet still be confident that things are happening,
 
2786
        # we temporarily replace two functions used by test_suite with 
 
2787
        # test doubles that supply a few sample tests to load, and check they
 
2788
        # are loaded.
 
2789
        calls = []
 
2790
        def testmod_names():
 
2791
            calls.append("testmod_names")
 
2792
            return [
 
2793
                'bzrlib.tests.blackbox.test_branch',
 
2794
                'bzrlib.tests.per_transport',
 
2795
                'bzrlib.tests.test_selftest',
 
2796
                ]
 
2797
        self.overrideAttr(tests, '_test_suite_testmod_names', testmod_names)
 
2798
        def doctests():
 
2799
            calls.append("modules_to_doctest")
 
2800
            return ['bzrlib.timestamp']
 
2801
        self.overrideAttr(tests, '_test_suite_modules_to_doctest', doctests)
 
2802
        expected_test_list = [
2119
2803
            # testmod_names
2120
2804
            'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2121
2805
            ('bzrlib.tests.per_transport.TransportTests'
2122
 
             '.test_abspath(LocalURLServer)'),
 
2806
             '.test_abspath(LocalTransport,LocalURLServer)'),
2123
2807
            'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',
2124
2808
            # modules_to_doctest
2125
2809
            'bzrlib.timestamp.format_highres_date',
2126
2810
            # plugins can't be tested that way since selftest may be run with
2127
2811
            # --no-plugins
2128
2812
            ]
2129
 
        suite = tests.test_suite(test_list)
2130
 
        self.assertEquals(test_list, _test_ids(suite))
 
2813
        suite = tests.test_suite()
 
2814
        self.assertEqual(set(["testmod_names", "modules_to_doctest"]),
 
2815
            set(calls))
 
2816
        self.assertSubset(expected_test_list, _test_ids(suite))
2131
2817
 
2132
2818
    def test_test_suite_list_and_start(self):
 
2819
        # We cannot test this at the same time as the main load, because we want
 
2820
        # to know that starting_with == None works. So a second load is
 
2821
        # incurred - note that the starting_with parameter causes a partial load
 
2822
        # rather than a full load so this test should be pretty quick.
2133
2823
        test_list = ['bzrlib.tests.test_selftest.TestTestSuite.test_test_suite']
2134
2824
        suite = tests.test_suite(test_list,
2135
2825
                                 ['bzrlib.tests.test_selftest.TestTestSuite'])
2180
2870
    def test_load_tests(self):
2181
2871
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2182
2872
        loader = self._create_loader(test_list)
2183
 
 
2184
2873
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2185
2874
        self.assertEquals(test_list, _test_ids(suite))
2186
2875
 
2187
2876
    def test_exclude_tests(self):
2188
2877
        test_list = ['bogus']
2189
2878
        loader = self._create_loader(test_list)
2190
 
 
2191
2879
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2192
2880
        self.assertEquals([], _test_ids(suite))
2193
2881
 
2238
2926
        tpr.register('bar', 'bbb.aaa.rrr')
2239
2927
        tpr.register('bar', 'bBB.aAA.rRR')
2240
2928
        self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
2241
 
        self.assertContainsRe(self._get_log(keep_log_file=True),
2242
 
                              r'.*bar.*bbb.aaa.rrr.*bBB.aAA.rRR')
 
2929
        self.assertThat(self.get_log(),
 
2930
            DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR", ELLIPSIS))
2243
2931
 
2244
2932
    def test_get_unknown_prefix(self):
2245
2933
        tpr = self._get_registry()
2281
2969
                                                self.verbosity)
2282
2970
        tests.run_suite(suite, runner_class=MyRunner, stream=StringIO())
2283
2971
        self.assertLength(1, calls)
2284
 
 
2285
 
    def test_done(self):
2286
 
        """run_suite should call result.done()"""
2287
 
        self.calls = 0
2288
 
        def one_more_call(): self.calls += 1
2289
 
        def test_function():
2290
 
            pass
2291
 
        test = unittest.FunctionTestCase(test_function)
2292
 
        class InstrumentedTestResult(tests.ExtendedTestResult):
2293
 
            def done(self): one_more_call()
2294
 
        class MyRunner(tests.TextTestRunner):
2295
 
            def run(self, test):
2296
 
                return InstrumentedTestResult(self.stream, self.descriptions,
2297
 
                                              self.verbosity)
2298
 
        tests.run_suite(test, runner_class=MyRunner, stream=StringIO())
2299
 
        self.assertEquals(1, self.calls)