/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: 2017-05-21 18:10:28 UTC
  • mto: This revision was merged to the branch mainline in revision 6623.
  • Revision ID: jelmer@jelmer.uk-20170521181028-zn04pdfw0od9hfj3
Rename brzlib => breezy.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_selftest.py
39
39
    )
40
40
import testtools.testresult.doubles
41
41
 
42
 
import brzlib
43
 
from brzlib import (
 
42
import breezy
 
43
from breezy import (
44
44
    branchbuilder,
45
45
    bzrdir,
46
46
    controldir,
58
58
    workingtree_3,
59
59
    workingtree_4,
60
60
    )
61
 
from brzlib.repofmt import (
 
61
from breezy.repofmt import (
62
62
    groupcompress_repo,
63
63
    )
64
 
from brzlib.symbol_versioning import (
 
64
from breezy.symbol_versioning import (
65
65
    deprecated_function,
66
66
    deprecated_in,
67
67
    deprecated_method,
68
68
    )
69
 
from brzlib.tests import (
 
69
from breezy.tests import (
70
70
    features,
71
71
    test_lsprof,
72
72
    test_server,
73
73
    TestUtil,
74
74
    )
75
 
from brzlib.trace import note, mutter
76
 
from brzlib.transport import memory
 
75
from breezy.trace import note, mutter
 
76
from breezy.transport import memory
77
77
 
78
78
 
79
79
def _test_ids(test_suite):
106
106
 
107
107
 
108
108
class TestClassesAvailable(tests.TestCase):
109
 
    """As a convenience we expose Test* classes from brzlib.tests"""
 
109
    """As a convenience we expose Test* classes from breezy.tests"""
110
110
 
111
111
    def test_test_case(self):
112
 
        from brzlib.tests import TestCase
 
112
        from breezy.tests import TestCase
113
113
 
114
114
    def test_test_loader(self):
115
 
        from brzlib.tests import TestLoader
 
115
        from breezy.tests import TestLoader
116
116
 
117
117
    def test_test_suite(self):
118
 
        from brzlib.tests import TestSuite
 
118
        from breezy.tests import TestSuite
119
119
 
120
120
 
121
121
class TestTransportScenarios(tests.TestCase):
135
135
            def get_test_permutations(self):
136
136
                return sample_permutation
137
137
        sample_permutation = [(1,2), (3,4)]
138
 
        from brzlib.tests.per_transport import get_transport_test_permutations
 
138
        from breezy.tests.per_transport import get_transport_test_permutations
139
139
        self.assertEqual(sample_permutation,
140
140
                         get_transport_test_permutations(MockModule()))
141
141
 
144
144
        # as there are in all the registered transport modules - we assume if
145
145
        # this matches its probably doing the right thing especially in
146
146
        # combination with the tests for setting the right classes below.
147
 
        from brzlib.tests.per_transport import transport_test_permutations
148
 
        from brzlib.transport import _get_transport_modules
 
147
        from breezy.tests.per_transport import transport_test_permutations
 
148
        from breezy.transport import _get_transport_modules
149
149
        modules = _get_transport_modules()
150
150
        permutation_count = 0
151
151
        for module in modules:
162
162
        # This test used to know about all the possible transports and the
163
163
        # order they were returned but that seems overly brittle (mbp
164
164
        # 20060307)
165
 
        from brzlib.tests.per_transport import transport_test_permutations
 
165
        from breezy.tests.per_transport import transport_test_permutations
166
166
        scenarios = transport_test_permutations()
167
167
        # there are at least that many builtin transports
168
168
        self.assertTrue(len(scenarios) > 6)
169
169
        one_scenario = scenarios[0]
170
170
        self.assertIsInstance(one_scenario[0], str)
171
171
        self.assertTrue(issubclass(one_scenario[1]["transport_class"],
172
 
                                   brzlib.transport.Transport))
 
172
                                   breezy.transport.Transport))
173
173
        self.assertTrue(issubclass(one_scenario[1]["transport_server"],
174
 
                                   brzlib.transport.Server))
 
174
                                   breezy.transport.Server))
175
175
 
176
176
 
177
177
class TestBranchScenarios(tests.TestCase):
179
179
    def test_scenarios(self):
180
180
        # check that constructor parameters are passed through to the adapted
181
181
        # test.
182
 
        from brzlib.tests.per_branch import make_scenarios
 
182
        from breezy.tests.per_branch import make_scenarios
183
183
        server1 = "a"
184
184
        server2 = "b"
185
185
        formats = [("c", "C"), ("d", "D")]
204
204
    def test_scenarios(self):
205
205
        # check that constructor parameters are passed through to the adapted
206
206
        # test.
207
 
        from brzlib.tests.per_controldir import make_scenarios
 
207
        from breezy.tests.per_controldir import make_scenarios
208
208
        vfs_factory = "v"
209
209
        server1 = "a"
210
210
        server2 = "b"
227
227
class TestRepositoryScenarios(tests.TestCase):
228
228
 
229
229
    def test_formats_to_scenarios(self):
230
 
        from brzlib.tests.per_repository import formats_to_scenarios
 
230
        from breezy.tests.per_repository import formats_to_scenarios
231
231
        formats = [("(c)", remote.RemoteRepositoryFormat()),
232
232
                   ("(d)", repository.format_registry.get(
233
233
                    'Bazaar repository format 2a (needs bzr 1.16 or later)\n'))]
268
268
    """Tests for the test adaption facilities."""
269
269
 
270
270
    def test_apply_scenario(self):
271
 
        from brzlib.tests import apply_scenario
 
271
        from breezy.tests import apply_scenario
272
272
        input_test = TestTestScenarioApplication("test_apply_scenario")
273
273
        # setup two adapted tests
274
274
        adapted_test1 = apply_scenario(input_test,
290
290
        self.assertEqual("readonly-server",
291
291
            adapted_test1.transport_readonly_server)
292
292
        self.assertEqual(
293
 
            "brzlib.tests.test_selftest.TestTestScenarioApplication."
 
293
            "breezy.tests.test_selftest.TestTestScenarioApplication."
294
294
            "test_apply_scenario(new id)",
295
295
            adapted_test1.id())
296
296
        self.assertEqual(None, adapted_test2.bzrdir_format)
297
297
        self.assertEqual(
298
 
            "brzlib.tests.test_selftest.TestTestScenarioApplication."
 
298
            "breezy.tests.test_selftest.TestTestScenarioApplication."
299
299
            "test_apply_scenario(new id 2)",
300
300
            adapted_test2.id())
301
301
 
305
305
    def test_scenarios(self):
306
306
        # check that constructor parameters are passed through to the adapted
307
307
        # test.
308
 
        from brzlib.tests.per_interrepository import make_scenarios
 
308
        from breezy.tests.per_interrepository import make_scenarios
309
309
        server1 = "a"
310
310
        server2 = "b"
311
311
        formats = [("C0", "C1", "C2", "C3"), ("D0", "D1", "D2", "D3")]
331
331
    def test_scenarios(self):
332
332
        # check that constructor parameters are passed through to the adapted
333
333
        # test.
334
 
        from brzlib.tests.per_workingtree import make_scenarios
 
334
        from breezy.tests.per_workingtree import make_scenarios
335
335
        server1 = "a"
336
336
        server2 = "b"
337
337
        formats = [workingtree_4.WorkingTreeFormat4(),
378
378
        # 'return_parameter' and the revision one set to
379
379
        # revision_tree_from_workingtree.
380
380
 
381
 
        from brzlib.tests.per_tree import (
 
381
        from breezy.tests.per_tree import (
382
382
            _dirstate_tree_from_workingtree,
383
383
            make_scenarios,
384
384
            preview_tree_pre,
473
473
        # unlike the TestProviderAdapter we dont want to automatically add a
474
474
        # parameterized one for WorkingTree - the optimisers will tell us what
475
475
        # ones to add.
476
 
        from brzlib.tests.per_tree import (
 
476
        from breezy.tests.per_tree import (
477
477
            return_parameter,
478
478
            )
479
 
        from brzlib.tests.per_intertree import (
 
479
        from breezy.tests.per_intertree import (
480
480
            make_scenarios,
481
481
            )
482
 
        from brzlib.workingtree_3 import WorkingTreeFormat3
483
 
        from brzlib.workingtree_4 import WorkingTreeFormat4
 
482
        from breezy.workingtree_3 import WorkingTreeFormat3
 
483
        from breezy.workingtree_4 import WorkingTreeFormat4
484
484
        input_test = TestInterTreeScenarios(
485
485
            "test_scenarios")
486
486
        server1 = "a"
525
525
        self.assertIsSameRealPath(self.test_home_dir, os.environ['HOME'])
526
526
 
527
527
    def test_assertEqualStat_equal(self):
528
 
        from brzlib.tests.test_dirstate import _FakeStat
 
528
        from breezy.tests.test_dirstate import _FakeStat
529
529
        self.build_tree(["foo"])
530
530
        real = os.lstat("foo")
531
531
        fake = _FakeStat(real.st_size, real.st_mtime, real.st_ctime,
563
563
        """The test_home_dir for TestCaseWithMemoryTransport is missing.
564
564
 
565
565
        This is because TestCaseWithMemoryTransport is for tests that do not
566
 
        need any disk resources: they should be hooked into brzlib in such a
 
566
        need any disk resources: they should be hooked into breezy in such a
567
567
        way that no global settings are being changed by the test (only a
568
568
        few tests should need to do that), and having a missing dir as home is
569
569
        an effective way to ensure that this is the case.
669
669
    """Tests for the convenience functions TestCaseWithTransport introduces."""
670
670
 
671
671
    def test_get_readonly_url_none(self):
672
 
        from brzlib.transport.readonly import ReadonlyTransportDecorator
 
672
        from breezy.transport.readonly import ReadonlyTransportDecorator
673
673
        self.vfs_transport_factory = memory.MemoryServer
674
674
        self.transport_readonly_server = None
675
675
        # calling get_readonly_transport() constructs a decorator on the url
683
683
        self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
684
684
 
685
685
    def test_get_readonly_url_http(self):
686
 
        from brzlib.tests.http_server import HttpServer
687
 
        from brzlib.transport.http import HttpTransportBase
 
686
        from breezy.tests.http_server import HttpServer
 
687
        from breezy.transport.http import HttpTransportBase
688
688
        self.transport_server = test_server.LocalURLServer
689
689
        self.transport_readonly_server = HttpServer
690
690
        # calling get_readonly_transport() gives us a HTTP server instance.
764
764
class TestTestResult(tests.TestCase):
765
765
 
766
766
    def check_timing(self, test_case, expected_re):
767
 
        result = brzlib.tests.TextTestResult(self._log_file,
 
767
        result = breezy.tests.TextTestResult(self._log_file,
768
768
                descriptions=0,
769
769
                verbosity=1,
770
770
                )
788
788
                          r"^ +[0-9]+ms\*$")
789
789
 
790
790
    def test_unittest_reporting_unittest_class(self):
791
 
        # getting the time from a non-brzlib test works ok
 
791
        # getting the time from a non-breezy test works ok
792
792
        class ShortDelayTestCase(unittest.TestCase):
793
793
            def test_short_delay(self):
794
794
                time.sleep(0.003)
807
807
        """Verbose test result prints lsprof statistics from test cases."""
808
808
        self.requireFeature(features.lsprof_feature)
809
809
        result_stream = StringIO()
810
 
        result = brzlib.tests.VerboseTestResult(
 
810
        result = breezy.tests.VerboseTestResult(
811
811
            result_stream,
812
812
            descriptions=0,
813
813
            verbosity=2,
882
882
    def test_verbose_report_known_failure(self):
883
883
        # verbose test output formatting
884
884
        result_stream = StringIO()
885
 
        result = brzlib.tests.VerboseTestResult(
 
885
        result = breezy.tests.VerboseTestResult(
886
886
            result_stream,
887
887
            descriptions=0,
888
888
            verbosity=2,
929
929
    def test_verbose_report_unsupported(self):
930
930
        # verbose test output formatting
931
931
        result_stream = StringIO()
932
 
        result = brzlib.tests.VerboseTestResult(
 
932
        result = breezy.tests.VerboseTestResult(
933
933
            result_stream,
934
934
            descriptions=0,
935
935
            verbosity=2,
968
968
        self.assertEqual(0, result.error_count)
969
969
 
970
970
    def test_strict_with_unsupported_feature(self):
971
 
        result = brzlib.tests.TextTestResult(self._log_file, descriptions=0,
 
971
        result = breezy.tests.TextTestResult(self._log_file, descriptions=0,
972
972
                                             verbosity=1)
973
973
        test = self.get_passing_test()
974
974
        feature = "Unsupported Feature"
977
977
        self.assertEqual(None, result._extractBenchmarkTime(test))
978
978
 
979
979
    def test_strict_with_known_failure(self):
980
 
        result = brzlib.tests.TextTestResult(self._log_file, descriptions=0,
 
980
        result = breezy.tests.TextTestResult(self._log_file, descriptions=0,
981
981
                                             verbosity=1)
982
982
        test = _get_test("test_xfail")
983
983
        test.run(result)
985
985
        self.assertEqual(None, result._extractBenchmarkTime(test))
986
986
 
987
987
    def test_strict_with_success(self):
988
 
        result = brzlib.tests.TextTestResult(self._log_file, descriptions=0,
 
988
        result = breezy.tests.TextTestResult(self._log_file, descriptions=0,
989
989
                                             verbosity=1)
990
990
        test = self.get_passing_test()
991
991
        result.addSuccess(test)
1030
1030
        TestCaseInTempDir.TEST_ROOT
1031
1031
 
1032
1032
        There should be no tests in this file that use
1033
 
        brzlib.tests.TextTestRunner without using this convenience method,
 
1033
        breezy.tests.TextTestRunner without using this convenience method,
1034
1034
        because of our use of global state.
1035
1035
        """
1036
1036
        old_root = tests.TestCaseInTempDir.TEST_ROOT
1288
1288
 
1289
1289
 
1290
1290
class TestTestCase(tests.TestCase):
1291
 
    """Tests that test the core brzlib TestCase."""
 
1291
    """Tests that test the core breezy TestCase."""
1292
1292
 
1293
1293
    def test_assertLength_matches_empty(self):
1294
1294
        a_list = []
1334
1334
        self.assertEqual(1, result.testsRun)
1335
1335
 
1336
1336
    def test_debug_flags_sanitised(self):
1337
 
        """The brzlib debug flags should be sanitised by setUp."""
 
1337
        """The breezy debug flags should be sanitised by setUp."""
1338
1338
        if 'allow_debug' in tests.selftest_debug_flags:
1339
1339
            raise tests.TestNotApplicable(
1340
1340
                '-Eallow_debug option prevents debug flag sanitisation')
1344
1344
        flags = set()
1345
1345
        if self._lock_check_thorough:
1346
1346
            flags.add('strict_locks')
1347
 
        self.assertEqual(flags, brzlib.debug.debug_flags)
 
1347
        self.assertEqual(flags, breezy.debug.debug_flags)
1348
1348
 
1349
1349
    def change_selftest_debug_flags(self, new_flags):
1350
1350
        self.overrideAttr(tests, 'selftest_debug_flags', set(new_flags))
1351
1351
 
1352
1352
    def test_allow_debug_flag(self):
1353
 
        """The -Eallow_debug flag prevents brzlib.debug.debug_flags from being
 
1353
        """The -Eallow_debug flag prevents breezy.debug.debug_flags from being
1354
1354
        sanitised (i.e. cleared) before running a test.
1355
1355
        """
1356
1356
        self.change_selftest_debug_flags(set(['allow_debug']))
1357
 
        brzlib.debug.debug_flags = set(['a-flag'])
 
1357
        breezy.debug.debug_flags = set(['a-flag'])
1358
1358
        class TestThatRecordsFlags(tests.TestCase):
1359
1359
            def test_foo(nested_self):
1360
 
                self.flags = set(brzlib.debug.debug_flags)
 
1360
                self.flags = set(breezy.debug.debug_flags)
1361
1361
        test = TestThatRecordsFlags('test_foo')
1362
1362
        test.run(self.make_test_result())
1363
1363
        flags = set(['a-flag'])
1369
1369
        """The -Edisable_lock_checks flag disables thorough checks."""
1370
1370
        class TestThatRecordsFlags(tests.TestCase):
1371
1371
            def test_foo(nested_self):
1372
 
                self.flags = set(brzlib.debug.debug_flags)
 
1372
                self.flags = set(breezy.debug.debug_flags)
1373
1373
                self.test_lock_check_thorough = nested_self._lock_check_thorough
1374
1374
        self.change_selftest_debug_flags(set())
1375
1375
        test = TestThatRecordsFlags('test_foo')
1388
1388
    def test_this_fails_strict_lock_check(self):
1389
1389
        class TestThatRecordsFlags(tests.TestCase):
1390
1390
            def test_foo(nested_self):
1391
 
                self.flags1 = set(brzlib.debug.debug_flags)
 
1391
                self.flags1 = set(breezy.debug.debug_flags)
1392
1392
                self.thisFailsStrictLockCheck()
1393
 
                self.flags2 = set(brzlib.debug.debug_flags)
 
1393
                self.flags2 = set(breezy.debug.debug_flags)
1394
1394
        # Make sure lock checking is active
1395
1395
        self.change_selftest_debug_flags(set())
1396
1396
        test = TestThatRecordsFlags('test_foo')
1399
1399
        self.assertEqual(set(), self.flags2)
1400
1400
 
1401
1401
    def test_debug_flags_restored(self):
1402
 
        """The brzlib debug flags should be restored to their original state
 
1402
        """The breezy debug flags should be restored to their original state
1403
1403
        after the test was run, even if allow_debug is set.
1404
1404
        """
1405
1405
        self.change_selftest_debug_flags(set(['allow_debug']))
1406
1406
        # Now run a test that modifies debug.debug_flags.
1407
 
        brzlib.debug.debug_flags = set(['original-state'])
 
1407
        breezy.debug.debug_flags = set(['original-state'])
1408
1408
        class TestThatModifiesFlags(tests.TestCase):
1409
1409
            def test_foo(self):
1410
 
                brzlib.debug.debug_flags = set(['modified'])
 
1410
                breezy.debug.debug_flags = set(['modified'])
1411
1411
        test = TestThatModifiesFlags('test_foo')
1412
1412
        test.run(self.make_test_result())
1413
 
        self.assertEqual(set(['original-state']), brzlib.debug.debug_flags)
 
1413
        self.assertEqual(set(['original-state']), breezy.debug.debug_flags)
1414
1414
 
1415
1415
    def make_test_result(self):
1416
1416
        """Get a test result that writes to the test log file."""
1441
1441
        # one child, we should instead see the bad result inside our test with
1442
1442
        # the two children.
1443
1443
        # the outer child test
1444
 
        original_trace = brzlib.trace._trace_file
 
1444
        original_trace = breezy.trace._trace_file
1445
1445
        outer_test = TestTestCase("outer_child")
1446
1446
        result = self.make_test_result()
1447
1447
        outer_test.run(result)
1448
 
        self.assertEqual(original_trace, brzlib.trace._trace_file)
 
1448
        self.assertEqual(original_trace, breezy.trace._trace_file)
1449
1449
 
1450
1450
    def method_that_times_a_bit_twice(self):
1451
1451
        # call self.time twice to ensure it aggregates
1456
1456
        """Test that the TestCase.time() method accumulates a benchmark time."""
1457
1457
        sample_test = TestTestCase("method_that_times_a_bit_twice")
1458
1458
        output_stream = StringIO()
1459
 
        result = brzlib.tests.VerboseTestResult(
 
1459
        result = breezy.tests.VerboseTestResult(
1460
1460
            output_stream,
1461
1461
            descriptions=0,
1462
1462
            verbosity=2)
1466
1466
            r"\d+ms\*\n$")
1467
1467
 
1468
1468
    def test_hooks_sanitised(self):
1469
 
        """The brzlib hooks should be sanitised by setUp."""
 
1469
        """The breezy hooks should be sanitised by setUp."""
1470
1470
        # Note this test won't fail with hooks that the core library doesn't
1471
1471
        # use - but it trigger with a plugin that adds hooks, so its still a
1472
1472
        # useful warning in that case.
1473
 
        self.assertEqual(brzlib.branch.BranchHooks(), brzlib.branch.Branch.hooks)
1474
 
        self.assertEqual(
1475
 
            brzlib.smart.server.SmartServerHooks(),
1476
 
            brzlib.smart.server.SmartTCPServer.hooks)
1477
 
        self.assertEqual(
1478
 
            brzlib.commands.CommandHooks(), brzlib.commands.Command.hooks)
 
1473
        self.assertEqual(breezy.branch.BranchHooks(), breezy.branch.Branch.hooks)
 
1474
        self.assertEqual(
 
1475
            breezy.smart.server.SmartServerHooks(),
 
1476
            breezy.smart.server.SmartTCPServer.hooks)
 
1477
        self.assertEqual(
 
1478
            breezy.commands.CommandHooks(), breezy.commands.Command.hooks)
1479
1479
 
1480
1480
    def test__gather_lsprof_in_benchmarks(self):
1481
1481
        """When _gather_lsprof_in_benchmarks is on, accumulate profile data.
1491
1491
        self.assertEqual(2, len(self._benchcalls))
1492
1492
        self.assertEqual((time.sleep, (0.000,), {}), self._benchcalls[0][0])
1493
1493
        self.assertEqual((time.sleep, (0.003,), {}), self._benchcalls[1][0])
1494
 
        self.assertIsInstance(self._benchcalls[0][1], brzlib.lsprof.Stats)
1495
 
        self.assertIsInstance(self._benchcalls[1][1], brzlib.lsprof.Stats)
 
1494
        self.assertIsInstance(self._benchcalls[0][1], breezy.lsprof.Stats)
 
1495
        self.assertIsInstance(self._benchcalls[1][1], breezy.lsprof.Stats)
1496
1496
        del self._benchcalls[:]
1497
1497
 
1498
1498
    def test_knownFailure(self):
1727
1727
        self.assertRaises(AttributeError, getattr, obj, 'test_attr')
1728
1728
 
1729
1729
    def test_recordCalls(self):
1730
 
        from brzlib.tests import test_selftest
 
1730
        from breezy.tests import test_selftest
1731
1731
        calls = self.recordCalls(
1732
1732
            test_selftest, '_add_numbers')
1733
1733
        self.assertEqual(test_selftest._add_numbers(2, 10),
1906
1906
 
1907
1907
 
1908
1908
class TestExtraAssertions(tests.TestCase):
1909
 
    """Tests for new test assertions in brzlib test suite"""
 
1909
    """Tests for new test assertions in breezy test suite"""
1910
1910
 
1911
1911
    def test_assert_isinstance(self):
1912
1912
        self.assertIsInstance(2, int)
2009
2009
 
2010
2010
    def test_make_branch_and_tree_with_format(self):
2011
2011
        # we should be able to supply a format to make_branch_and_tree
2012
 
        self.make_branch_and_tree('a', format=brzlib.bzrdir.BzrDirMetaFormat1())
2013
 
        self.assertIsInstance(brzlib.controldir.ControlDir.open('a')._format,
2014
 
                              brzlib.bzrdir.BzrDirMetaFormat1)
 
2012
        self.make_branch_and_tree('a', format=breezy.bzrdir.BzrDirMetaFormat1())
 
2013
        self.assertIsInstance(breezy.controldir.ControlDir.open('a')._format,
 
2014
                              breezy.bzrdir.BzrDirMetaFormat1)
2015
2015
 
2016
2016
    def test_make_branch_and_memory_tree(self):
2017
2017
        # we should be able to get a new branch and a mutable tree from
2018
2018
        # TestCaseWithTransport
2019
2019
        tree = self.make_branch_and_memory_tree('a')
2020
 
        self.assertIsInstance(tree, brzlib.memorytree.MemoryTree)
 
2020
        self.assertIsInstance(tree, breezy.memorytree.MemoryTree)
2021
2021
 
2022
2022
    def test_make_tree_for_local_vfs_backed_transport(self):
2023
2023
        # make_branch_and_tree has to use local branch and repositories
2039
2039
    def run_selftest(self, **kwargs):
2040
2040
        """Run selftest returning its output."""
2041
2041
        output = StringIO()
2042
 
        old_transport = brzlib.tests.default_transport
 
2042
        old_transport = breezy.tests.default_transport
2043
2043
        old_root = tests.TestCaseWithMemoryTransport.TEST_ROOT
2044
2044
        tests.TestCaseWithMemoryTransport.TEST_ROOT = None
2045
2045
        try:
2046
2046
            self.assertEqual(True, tests.selftest(stream=output, **kwargs))
2047
2047
        finally:
2048
 
            brzlib.tests.default_transport = old_transport
 
2048
            breezy.tests.default_transport = old_transport
2049
2049
            tests.TestCaseWithMemoryTransport.TEST_ROOT = old_root
2050
2050
        output.seek(0)
2051
2051
        return output
2052
2052
 
2053
2053
 
2054
2054
class TestSelftest(tests.TestCase, SelfTestHelper):
2055
 
    """Tests of brzlib.tests.selftest."""
 
2055
    """Tests of breezy.tests.selftest."""
2056
2056
 
2057
2057
    def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
2058
2058
        factory_called = []
2061
2061
            return TestUtil.TestSuite()
2062
2062
        out = StringIO()
2063
2063
        err = StringIO()
2064
 
        self.apply_redirected(out, err, None, brzlib.tests.selftest,
 
2064
        self.apply_redirected(out, err, None, breezy.tests.selftest,
2065
2065
            test_suite_factory=factory)
2066
2066
        self.assertEqual([True], factory_called)
2067
2067
 
2138
2138
 
2139
2139
    def test_starting_with_single_argument(self):
2140
2140
        output = self.run_selftest(test_suite_factory=self.factory,
2141
 
            starting_with=['brzlib.tests.test_selftest.Test.a'],
 
2141
            starting_with=['breezy.tests.test_selftest.Test.a'],
2142
2142
            list_only=True)
2143
 
        self.assertEqual('brzlib.tests.test_selftest.Test.a\n',
 
2143
        self.assertEqual('breezy.tests.test_selftest.Test.a\n',
2144
2144
            output.getvalue())
2145
2145
 
2146
2146
    def test_starting_with_multiple_argument(self):
2147
2147
        output = self.run_selftest(test_suite_factory=self.factory,
2148
 
            starting_with=['brzlib.tests.test_selftest.Test.a',
2149
 
                'brzlib.tests.test_selftest.Test.b'],
 
2148
            starting_with=['breezy.tests.test_selftest.Test.a',
 
2149
                'breezy.tests.test_selftest.Test.b'],
2150
2150
            list_only=True)
2151
 
        self.assertEqual('brzlib.tests.test_selftest.Test.a\n'
2152
 
            'brzlib.tests.test_selftest.Test.b\n',
 
2151
        self.assertEqual('breezy.tests.test_selftest.Test.a\n'
 
2152
            'breezy.tests.test_selftest.Test.b\n',
2153
2153
            output.getvalue())
2154
2154
 
2155
2155
    def check_transport_set(self, transport_server):
2158
2158
            captured_transport.append(a_transport)
2159
2159
        class Capture(tests.TestCase):
2160
2160
            def a(self):
2161
 
                seen_transport(brzlib.tests.default_transport)
 
2161
                seen_transport(breezy.tests.default_transport)
2162
2162
        def factory():
2163
2163
            return TestUtil.TestSuite([Capture("a")])
2164
2164
        self.run_selftest(transport=transport_server, test_suite_factory=factory)
2166
2166
 
2167
2167
    def test_transport_sftp(self):
2168
2168
        self.requireFeature(features.paramiko)
2169
 
        from brzlib.tests import stub_sftp
 
2169
        from breezy.tests import stub_sftp
2170
2170
        self.check_transport_set(stub_sftp.SFTPAbsoluteServer)
2171
2171
 
2172
2172
    def test_transport_memory(self):
2375
2375
    def apply_redirected(self, stdin=None, stdout=None, stderr=None,
2376
2376
                         a_callable=None, *args, **kwargs):
2377
2377
        self.stdin = stdin
2378
 
        self.factory_stdin = getattr(brzlib.ui.ui_factory, "stdin", None)
2379
 
        self.factory = brzlib.ui.ui_factory
 
2378
        self.factory_stdin = getattr(breezy.ui.ui_factory, "stdin", None)
 
2379
        self.factory = breezy.ui.ui_factory
2380
2380
        self.working_dir = osutils.getcwd()
2381
2381
        stdout.write('foo\n')
2382
2382
        stderr.write('bar\n')
2399
2399
        # own UI factory, which is an instance of TestUIFactory,
2400
2400
        # with stdin, stdout and stderr attached to the stdin,
2401
2401
        # stdout and stderr of the invoked run_bzr
2402
 
        current_factory = brzlib.ui.ui_factory
 
2402
        current_factory = breezy.ui.ui_factory
2403
2403
        self.run_bzr(['foo'])
2404
2404
        self.assertFalse(current_factory is self.factory)
2405
2405
        self.assertNotEqual(sys.stdout, self.factory.stdout)
2642
2642
                          working_dir='foo')
2643
2643
        self.assertEqual(['foo', 'current'], chdirs)
2644
2644
 
2645
 
    def test_get_brz_path_with_cwd_brzlib(self):
 
2645
    def test_get_brz_path_with_cwd_breezy(self):
2646
2646
        self.get_source_path = lambda: ""
2647
2647
        self.overrideAttr(os.path, "isfile", lambda path: True)
2648
2648
        self.assertEqual(self.get_brz_path(), "brz")
2672
2672
        self.suite = TestUtil.TestSuite()
2673
2673
        self.loader = TestUtil.TestLoader()
2674
2674
        self.suite.addTest(self.loader.loadTestsFromModule(
2675
 
            sys.modules['brzlib.tests.test_selftest']))
 
2675
            sys.modules['breezy.tests.test_selftest']))
2676
2676
        self.all_names = _test_ids(self.suite)
2677
2677
 
2678
2678
    def test_condition_id_re(self):
2679
 
        test_name = ('brzlib.tests.test_selftest.TestSelftestFiltering.'
 
2679
        test_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2680
2680
            'test_condition_id_re')
2681
2681
        filtered_suite = tests.filter_suite_by_condition(
2682
2682
            self.suite, tests.condition_id_re('test_condition_id_re'))
2683
2683
        self.assertEqual([test_name], _test_ids(filtered_suite))
2684
2684
 
2685
2685
    def test_condition_id_in_list(self):
2686
 
        test_names = ['brzlib.tests.test_selftest.TestSelftestFiltering.'
 
2686
        test_names = ['breezy.tests.test_selftest.TestSelftestFiltering.'
2687
2687
                      'test_condition_id_in_list']
2688
2688
        id_list = tests.TestIdList(test_names)
2689
2689
        filtered_suite = tests.filter_suite_by_condition(
2693
2693
        self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
2694
2694
 
2695
2695
    def test_condition_id_startswith(self):
2696
 
        klass = 'brzlib.tests.test_selftest.TestSelftestFiltering.'
 
2696
        klass = 'breezy.tests.test_selftest.TestSelftestFiltering.'
2697
2697
        start1 = klass + 'test_condition_id_starts'
2698
2698
        start2 = klass + 'test_condition_id_in'
2699
2699
        test_names = [ klass + 'test_condition_id_in_list',
2706
2706
    def test_condition_isinstance(self):
2707
2707
        filtered_suite = tests.filter_suite_by_condition(
2708
2708
            self.suite, tests.condition_isinstance(self.__class__))
2709
 
        class_pattern = 'brzlib.tests.test_selftest.TestSelftestFiltering.'
 
2709
        class_pattern = 'breezy.tests.test_selftest.TestSelftestFiltering.'
2710
2710
        re_filtered = tests.filter_suite_by_re(self.suite, class_pattern)
2711
2711
        self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
2712
2712
 
2713
2713
    def test_exclude_tests_by_condition(self):
2714
 
        excluded_name = ('brzlib.tests.test_selftest.TestSelftestFiltering.'
 
2714
        excluded_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2715
2715
            'test_exclude_tests_by_condition')
2716
2716
        filtered_suite = tests.exclude_tests_by_condition(self.suite,
2717
2717
            lambda x:x.id() == excluded_name)
2726
2726
        self.all_names = _test_ids(self.suite)
2727
2727
        filtered_suite = tests.exclude_tests_by_re(self.suite,
2728
2728
                                                   'exclude_tests_by_re')
2729
 
        excluded_name = ('brzlib.tests.test_selftest.TestSelftestFiltering.'
 
2729
        excluded_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2730
2730
            'test_exclude_tests_by_re')
2731
2731
        self.assertEqual(len(self.all_names) - 1,
2732
2732
            filtered_suite.countTestCases())
2736
2736
        self.assertEqual(remaining_names, _test_ids(filtered_suite))
2737
2737
 
2738
2738
    def test_filter_suite_by_condition(self):
2739
 
        test_name = ('brzlib.tests.test_selftest.TestSelftestFiltering.'
 
2739
        test_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2740
2740
            'test_filter_suite_by_condition')
2741
2741
        filtered_suite = tests.filter_suite_by_condition(self.suite,
2742
2742
            lambda x:x.id() == test_name)
2746
2746
        filtered_suite = tests.filter_suite_by_re(self.suite,
2747
2747
                                                  'test_filter_suite_by_r')
2748
2748
        filtered_names = _test_ids(filtered_suite)
2749
 
        self.assertEqual(filtered_names, ['brzlib.tests.test_selftest.'
 
2749
        self.assertEqual(filtered_names, ['breezy.tests.test_selftest.'
2750
2750
            'TestSelftestFiltering.test_filter_suite_by_re'])
2751
2751
 
2752
2752
    def test_filter_suite_by_id_list(self):
2753
 
        test_list = ['brzlib.tests.test_selftest.'
 
2753
        test_list = ['breezy.tests.test_selftest.'
2754
2754
                     'TestSelftestFiltering.test_filter_suite_by_id_list']
2755
2755
        filtered_suite = tests.filter_suite_by_id_list(
2756
2756
            self.suite, tests.TestIdList(test_list))
2757
2757
        filtered_names = _test_ids(filtered_suite)
2758
2758
        self.assertEqual(
2759
2759
            filtered_names,
2760
 
            ['brzlib.tests.test_selftest.'
 
2760
            ['breezy.tests.test_selftest.'
2761
2761
             'TestSelftestFiltering.test_filter_suite_by_id_list'])
2762
2762
 
2763
2763
    def test_filter_suite_by_id_startswith(self):
2764
2764
        # By design this test may fail if another test is added whose name also
2765
2765
        # begins with one of the start value used.
2766
 
        klass = 'brzlib.tests.test_selftest.TestSelftestFiltering.'
 
2766
        klass = 'breezy.tests.test_selftest.TestSelftestFiltering.'
2767
2767
        start1 = klass + 'test_filter_suite_by_id_starts'
2768
2768
        start2 = klass + 'test_filter_suite_by_id_li'
2769
2769
        test_list = [klass + 'test_filter_suite_by_id_list',
2800
2800
        self.all_names = _test_ids(self.suite)
2801
2801
        condition = tests.condition_id_re('test_filter_suite_by_r')
2802
2802
        split_suite = tests.split_suite_by_condition(self.suite, condition)
2803
 
        filtered_name = ('brzlib.tests.test_selftest.TestSelftestFiltering.'
 
2803
        filtered_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2804
2804
            'test_filter_suite_by_re')
2805
2805
        self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2806
2806
        self.assertFalse(filtered_name in _test_ids(split_suite[1]))
2812
2812
        self.all_names = _test_ids(self.suite)
2813
2813
        split_suite = tests.split_suite_by_re(self.suite,
2814
2814
                                              'test_filter_suite_by_r')
2815
 
        filtered_name = ('brzlib.tests.test_selftest.TestSelftestFiltering.'
 
2815
        filtered_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2816
2816
            'test_filter_suite_by_re')
2817
2817
        self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2818
2818
        self.assertFalse(filtered_name in _test_ids(split_suite[1]))
2901
2901
 
2902
2902
    def test_load_tests_from_module_name_smoke_test(self):
2903
2903
        loader = TestUtil.TestLoader()
2904
 
        suite = loader.loadTestsFromModuleName('brzlib.tests.test_sampler')
2905
 
        self.assertEqual(['brzlib.tests.test_sampler.DemoTest.test_nothing'],
 
2904
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
 
2905
        self.assertEqual(['breezy.tests.test_sampler.DemoTest.test_nothing'],
2906
2906
                          _test_ids(suite))
2907
2907
 
2908
2908
    def test_load_tests_from_module_name_with_bogus_module_name(self):
2967
2967
 
2968
2968
    def test_test_suite_matches_id_list_with_unknown(self):
2969
2969
        loader = TestUtil.TestLoader()
2970
 
        suite = loader.loadTestsFromModuleName('brzlib.tests.test_sampler')
2971
 
        test_list = ['brzlib.tests.test_sampler.DemoTest.test_nothing',
 
2970
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
 
2971
        test_list = ['breezy.tests.test_sampler.DemoTest.test_nothing',
2972
2972
                     'bogus']
2973
2973
        not_found, duplicates = tests.suite_matches_id_list(suite, test_list)
2974
2974
        self.assertEqual(['bogus'], not_found)
2976
2976
 
2977
2977
    def test_suite_matches_id_list_with_duplicates(self):
2978
2978
        loader = TestUtil.TestLoader()
2979
 
        suite = loader.loadTestsFromModuleName('brzlib.tests.test_sampler')
 
2979
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
2980
2980
        dupes = loader.suiteClass()
2981
2981
        for test in tests.iter_suite_tests(suite):
2982
2982
            dupes.addTest(test)
2983
2983
            dupes.addTest(test) # Add it again
2984
2984
 
2985
 
        test_list = ['brzlib.tests.test_sampler.DemoTest.test_nothing',]
 
2985
        test_list = ['breezy.tests.test_sampler.DemoTest.test_nothing',]
2986
2986
        not_found, duplicates = tests.suite_matches_id_list(
2987
2987
            dupes, test_list)
2988
2988
        self.assertEqual([], not_found)
2989
 
        self.assertEqual(['brzlib.tests.test_sampler.DemoTest.test_nothing'],
 
2989
        self.assertEqual(['breezy.tests.test_sampler.DemoTest.test_nothing'],
2990
2990
                          duplicates)
2991
2991
 
2992
2992
 
2997
2997
        # by _test_suite_testmod_names.
2998
2998
        test_list = tests._test_suite_testmod_names()
2999
2999
        self.assertSubset([
3000
 
            'brzlib.tests.blackbox',
3001
 
            'brzlib.tests.per_transport',
3002
 
            'brzlib.tests.test_selftest',
 
3000
            'breezy.tests.blackbox',
 
3001
            'breezy.tests.per_transport',
 
3002
            'breezy.tests.test_selftest',
3003
3003
            ],
3004
3004
            test_list)
3005
3005
 
3012
3012
            self.assertEqual([], test_list)
3013
3013
            return
3014
3014
        self.assertSubset([
3015
 
            'brzlib.timestamp',
 
3015
            'breezy.timestamp',
3016
3016
            ],
3017
3017
            test_list)
3018
3018
 
3026
3026
        def testmod_names():
3027
3027
            calls.append("testmod_names")
3028
3028
            return [
3029
 
                'brzlib.tests.blackbox.test_branch',
3030
 
                'brzlib.tests.per_transport',
3031
 
                'brzlib.tests.test_selftest',
 
3029
                'breezy.tests.blackbox.test_branch',
 
3030
                'breezy.tests.per_transport',
 
3031
                'breezy.tests.test_selftest',
3032
3032
                ]
3033
3033
        self.overrideAttr(tests, '_test_suite_testmod_names', testmod_names)
3034
3034
        def doctests():
3035
3035
            calls.append("modules_to_doctest")
3036
3036
            if __doc__ is None:
3037
3037
                return []
3038
 
            return ['brzlib.timestamp']
 
3038
            return ['breezy.timestamp']
3039
3039
        self.overrideAttr(tests, '_test_suite_modules_to_doctest', doctests)
3040
3040
        expected_test_list = [
3041
3041
            # testmod_names
3042
 
            'brzlib.tests.blackbox.test_branch.TestBranch.test_branch',
3043
 
            ('brzlib.tests.per_transport.TransportTests'
 
3042
            'breezy.tests.blackbox.test_branch.TestBranch.test_branch',
 
3043
            ('breezy.tests.per_transport.TransportTests'
3044
3044
             '.test_abspath(LocalTransport,LocalURLServer)'),
3045
 
            'brzlib.tests.test_selftest.TestTestSuite.test_test_suite',
 
3045
            'breezy.tests.test_selftest.TestTestSuite.test_test_suite',
3046
3046
            # plugins can't be tested that way since selftest may be run with
3047
3047
            # --no-plugins
3048
3048
            ]
3049
3049
        if __doc__ is not None:
3050
3050
            expected_test_list.extend([
3051
3051
                # modules_to_doctest
3052
 
                'brzlib.timestamp.format_highres_date',
 
3052
                'breezy.timestamp.format_highres_date',
3053
3053
                ])
3054
3054
        suite = tests.test_suite()
3055
3055
        self.assertEqual(set(["testmod_names", "modules_to_doctest"]),
3061
3061
        # to know that starting_with == None works. So a second load is
3062
3062
        # incurred - note that the starting_with parameter causes a partial load
3063
3063
        # rather than a full load so this test should be pretty quick.
3064
 
        test_list = ['brzlib.tests.test_selftest.TestTestSuite.test_test_suite']
 
3064
        test_list = ['breezy.tests.test_selftest.TestTestSuite.test_test_suite']
3065
3065
        suite = tests.test_suite(test_list,
3066
 
                                 ['brzlib.tests.test_selftest.TestTestSuite'])
 
3066
                                 ['breezy.tests.test_selftest.TestTestSuite'])
3067
3067
        # test_test_suite_list_and_start is not included 
3068
3068
        self.assertEqual(test_list, _test_ids(suite))
3069
3069
 
3109
3109
        return loader
3110
3110
 
3111
3111
    def test_load_tests(self):
3112
 
        test_list = ['brzlib.tests.test_sampler.DemoTest.test_nothing']
 
3112
        test_list = ['breezy.tests.test_sampler.DemoTest.test_nothing']
3113
3113
        loader = self._create_loader(test_list)
3114
 
        suite = loader.loadTestsFromModuleName('brzlib.tests.test_sampler')
 
3114
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
3115
3115
        self.assertEqual(test_list, _test_ids(suite))
3116
3116
 
3117
3117
    def test_exclude_tests(self):
3118
3118
        test_list = ['bogus']
3119
3119
        loader = self._create_loader(test_list)
3120
 
        suite = loader.loadTestsFromModuleName('brzlib.tests.test_sampler')
 
3120
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
3121
3121
        self.assertEqual([], _test_ids(suite))
3122
3122
 
3123
3123
 
3130
3130
        return loader
3131
3131
 
3132
3132
    def test_load_tests(self):
3133
 
        test_list = ['brzlib.tests.test_sampler.DemoTest.test_nothing']
3134
 
        loader = self._create_loader('brzlib.tests.test_samp')
 
3133
        test_list = ['breezy.tests.test_sampler.DemoTest.test_nothing']
 
3134
        loader = self._create_loader('breezy.tests.test_samp')
3135
3135
 
3136
 
        suite = loader.loadTestsFromModuleName('brzlib.tests.test_sampler')
 
3136
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
3137
3137
        self.assertEqual(test_list, _test_ids(suite))
3138
3138
 
3139
3139
    def test_load_tests_inside_module(self):
3140
 
        test_list = ['brzlib.tests.test_sampler.DemoTest.test_nothing']
3141
 
        loader = self._create_loader('brzlib.tests.test_sampler.Demo')
 
3140
        test_list = ['breezy.tests.test_sampler.DemoTest.test_nothing']
 
3141
        loader = self._create_loader('breezy.tests.test_sampler.Demo')
3142
3142
 
3143
 
        suite = loader.loadTestsFromModuleName('brzlib.tests.test_sampler')
 
3143
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
3144
3144
        self.assertEqual(test_list, _test_ids(suite))
3145
3145
 
3146
3146
    def test_exclude_tests(self):
3147
3147
        test_list = ['bogus']
3148
3148
        loader = self._create_loader('bogus')
3149
3149
 
3150
 
        suite = loader.loadTestsFromModuleName('brzlib.tests.test_sampler')
 
3150
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
3151
3151
        self.assertEqual([], _test_ids(suite))
3152
3152
 
3153
3153
 
3187
3187
 
3188
3188
    def test_predefined_prefixes(self):
3189
3189
        tpr = tests.test_prefix_alias_registry
3190
 
        self.assertEqual('brzlib', tpr.resolve_alias('brzlib'))
3191
 
        self.assertEqual('brzlib.doc', tpr.resolve_alias('bd'))
3192
 
        self.assertEqual('brzlib.utils', tpr.resolve_alias('bu'))
3193
 
        self.assertEqual('brzlib.tests', tpr.resolve_alias('bt'))
3194
 
        self.assertEqual('brzlib.tests.blackbox', tpr.resolve_alias('bb'))
3195
 
        self.assertEqual('brzlib.plugins', tpr.resolve_alias('bp'))
 
3190
        self.assertEqual('breezy', tpr.resolve_alias('breezy'))
 
3191
        self.assertEqual('breezy.doc', tpr.resolve_alias('bd'))
 
3192
        self.assertEqual('breezy.utils', tpr.resolve_alias('bu'))
 
3193
        self.assertEqual('breezy.tests', tpr.resolve_alias('bt'))
 
3194
        self.assertEqual('breezy.tests.blackbox', tpr.resolve_alias('bb'))
 
3195
        self.assertEqual('breezy.plugins', tpr.resolve_alias('bp'))
3196
3196
 
3197
3197
 
3198
3198
class TestThreadLeakDetection(tests.TestCase):
3321
3321
        self.assertEqual(result.postcode, Test.runTest.func_code)
3322
3322
 
3323
3323
    def test_location_bt_error(self):
3324
 
        """Needs right post mortem traceback with erroring brzlib.tests case"""
 
3324
        """Needs right post mortem traceback with erroring breezy.tests case"""
3325
3325
        class Test(tests.TestCase):
3326
3326
            def test_error(self):
3327
3327
                raise RuntimeError
3330
3330
        self.assertEqual(result.postcode, Test.test_error.func_code)
3331
3331
 
3332
3332
    def test_location_bt_failure(self):
3333
 
        """Needs right post mortem traceback with failing brzlib.tests case"""
 
3333
        """Needs right post mortem traceback with failing breezy.tests case"""
3334
3334
        class Test(tests.TestCase):
3335
3335
            def test_failure(self):
3336
3336
                raise self.failureException