← 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: Canonical.com Patch Queue Manager
  • Date: 2008-06-05 04:05:05 UTC
  • mfrom: (3473.1.1 ianc-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20080605040505-i9kqxg2fps2qjdi0
Add the 'alias' command (Tim Penhey)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_selftest.py
1
 
# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
26
26
 
27
27
import bzrlib
28
28
from bzrlib import (
29
 
    branchbuilder,
30
29
    bzrdir,
31
30
    errors,
32
31
    memorytree,
33
32
    osutils,
34
 
    remote,
35
33
    repository,
36
34
    symbol_versioning,
37
35
    tests,
38
 
    workingtree,
39
36
    )
40
37
from bzrlib.progress import _BaseProgressBar
41
 
from bzrlib.repofmt import (
42
 
    pack_repo,
43
 
    weaverepo,
44
 
    )
 
38
from bzrlib.repofmt import weaverepo
45
39
from bzrlib.symbol_versioning import (
46
40
    one_zero,
47
41
    zero_eleven,
109
103
                              'a test message\n')
110
104
 
111
105
 
112
 
class TestUnicodeFilename(TestCase):
113
 
 
114
 
    def test_probe_passes(self):
115
 
        """UnicodeFilename._probe passes."""
116
 
        # We can't test much more than that because the behaviour depends
117
 
        # on the platform.
118
 
        tests.UnicodeFilename._probe()
119
 
 
120
 
 
121
106
class TestTreeShape(TestCaseInTempDir):
122
107
 
123
108
    def test_unicode_paths(self):
124
 
        self.requireFeature(tests.UnicodeFilename)
125
 
 
126
109
        filename = u'hell\u00d8'
127
 
        self.build_tree_contents([(filename, 'contents of hello')])
 
110
        try:
 
111
            self.build_tree_contents([(filename, 'contents of hello')])
 
112
        except UnicodeEncodeError:
 
113
            raise TestSkipped("can't build unicode working tree in "
 
114
                "filesystem encoding %s" % sys.getfilesystemencoding())
128
115
        self.failUnlessExists(filename)
129
116
 
130
117
 
247
234
            adapter.scenarios)
248
235
 
249
236
 
250
 
class TestRepositoryParameterisation(TestCase):
 
237
class TestRepositoryProviderAdapter(TestCase):
251
238
    """A group of tests that test the repository implementation test adapter."""
252
239
 
 
240
    def test_constructor(self):
 
241
        # check that constructor parameters are passed through to the
 
242
        # scenarios.
 
243
        from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
 
244
        server1 = "a"
 
245
        server2 = "b"
 
246
        formats = [("c", "C"), ("d", "D")]
 
247
        adapter = RepositoryTestProviderAdapter(server1, server2, formats)
 
248
        self.assertEqual([
 
249
            ('str',
 
250
             {'bzrdir_format': 'C',
 
251
              'repository_format': 'c',
 
252
              'transport_readonly_server': 'b',
 
253
              'transport_server': 'a'}),
 
254
            ('str',
 
255
             {'bzrdir_format': 'D',
 
256
              'repository_format': 'd',
 
257
              'transport_readonly_server': 'b',
 
258
              'transport_server': 'a'})],
 
259
            adapter.scenarios)
 
260
 
 
261
    def test_setting_vfs_transport(self):
 
262
        """The vfs_transport_factory can be set optionally."""
 
263
        from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
 
264
        formats = [("a", "b"), ("c", "d")]
 
265
        adapter = RepositoryTestProviderAdapter(None, None, formats,
 
266
            vfs_transport_factory="vfs")
 
267
        self.assertEqual([
 
268
            ('str',
 
269
             {'bzrdir_format': 'b',
 
270
              'repository_format': 'a',
 
271
              'transport_readonly_server': None,
 
272
              'transport_server': None,
 
273
              'vfs_transport_factory': 'vfs'}),
 
274
            ('str',
 
275
             {'bzrdir_format': 'd',
 
276
              'repository_format': 'c',
 
277
              'transport_readonly_server': None,
 
278
              'transport_server': None,
 
279
              'vfs_transport_factory': 'vfs'})],
 
280
            adapter.scenarios)
 
281
 
253
282
    def test_formats_to_scenarios(self):
254
283
        """The adapter can generate all the scenarios needed."""
255
 
        from bzrlib.tests.per_repository import formats_to_scenarios
256
 
        formats = [("(c)", remote.RemoteRepositoryFormat()),
257
 
                   ("(d)", repository.format_registry.get(
258
 
                        'Bazaar pack repository format 1 (needs bzr 0.92)\n'))]
259
 
        no_vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
260
 
            None)
261
 
        vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
262
 
            vfs_transport_factory="vfs")
263
 
        # no_vfs generate scenarios without vfs_transport_factory
 
284
        from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
 
285
        no_vfs_adapter = RepositoryTestProviderAdapter("server", "readonly",
 
286
            [], None)
 
287
        vfs_adapter = RepositoryTestProviderAdapter("server", "readonly",
 
288
            [], vfs_transport_factory="vfs")
 
289
        # no_vfs generate scenarios without vfs_transport_factor
 
290
        formats = [("c", "C"), (1, "D")]
264
291
        self.assertEqual([
265
 
            ('RemoteRepositoryFormat(c)',
266
 
             {'bzrdir_format': remote.RemoteBzrDirFormat(),
267
 
              'repository_format': remote.RemoteRepositoryFormat(),
 
292
            ('str',
 
293
             {'bzrdir_format': 'C',
 
294
              'repository_format': 'c',
268
295
              'transport_readonly_server': 'readonly',
269
296
              'transport_server': 'server'}),
270
 
            ('RepositoryFormatKnitPack1(d)',
271
 
             {'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
272
 
              'repository_format': pack_repo.RepositoryFormatKnitPack1(),
 
297
            ('int',
 
298
             {'bzrdir_format': 'D',
 
299
              'repository_format': 1,
273
300
              'transport_readonly_server': 'readonly',
274
301
              'transport_server': 'server'})],
275
 
            no_vfs_scenarios)
 
302
            no_vfs_adapter.formats_to_scenarios(formats))
276
303
        self.assertEqual([
277
 
            ('RemoteRepositoryFormat(c)',
278
 
             {'bzrdir_format': remote.RemoteBzrDirFormat(),
279
 
              'repository_format': remote.RemoteRepositoryFormat(),
 
304
            ('str',
 
305
             {'bzrdir_format': 'C',
 
306
              'repository_format': 'c',
280
307
              'transport_readonly_server': 'readonly',
281
308
              'transport_server': 'server',
282
309
              'vfs_transport_factory': 'vfs'}),
283
 
            ('RepositoryFormatKnitPack1(d)',
284
 
             {'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
285
 
              'repository_format': pack_repo.RepositoryFormatKnitPack1(),
 
310
            ('int',
 
311
             {'bzrdir_format': 'D',
 
312
              'repository_format': 1,
286
313
              'transport_readonly_server': 'readonly',
287
314
              'transport_server': 'server',
288
315
              'vfs_transport_factory': 'vfs'})],
289
 
            vfs_scenarios)
 
316
            vfs_adapter.formats_to_scenarios(formats))
290
317
 
291
318
 
292
319
class TestTestScenarioApplier(TestCase):
293
320
    """Tests for the test adaption facilities."""
294
321
 
295
322
    def test_adapt_applies_scenarios(self):
296
 
        from bzrlib.tests.per_repository import TestScenarioApplier
 
323
        from bzrlib.tests.repository_implementations import TestScenarioApplier
297
324
        input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
298
325
        adapter = TestScenarioApplier()
299
326
        adapter.scenarios = [("1", "dict"), ("2", "settings")]
307
334
            (input_test, ("2", "settings"))], calls)
308
335
 
309
336
    def test_adapt_test_to_scenario(self):
310
 
        from bzrlib.tests.per_repository import TestScenarioApplier
 
337
        from bzrlib.tests.repository_implementations import TestScenarioApplier
311
338
        input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
312
339
        adapter = TestScenarioApplier()
313
340
        # setup two adapted tests
368
395
            adapter.formats_to_scenarios(formats))
369
396
 
370
397
 
 
398
class TestInterVersionedFileProviderAdapter(TestCase):
 
399
    """A group of tests that test the InterVersionedFile test adapter."""
 
400
 
 
401
    def test_scenarios(self):
 
402
        # check that constructor parameters are passed through to the adapted
 
403
        # test.
 
404
        from bzrlib.tests.interversionedfile_implementations \
 
405
            import InterVersionedFileTestProviderAdapter
 
406
        server1 = "a"
 
407
        server2 = "b"
 
408
        formats = [(str, "C1", "C2"), (int, "D1", "D2")]
 
409
        adapter = InterVersionedFileTestProviderAdapter(server1, server2, formats)
 
410
        self.assertEqual([
 
411
            ('str',
 
412
             {'interversionedfile_class':str,
 
413
              'transport_readonly_server': 'b',
 
414
              'transport_server': 'a',
 
415
              'versionedfile_factory': 'C1',
 
416
              'versionedfile_factory_to': 'C2'}),
 
417
            ('int',
 
418
             {'interversionedfile_class': int,
 
419
              'transport_readonly_server': 'b',
 
420
              'transport_server': 'a',
 
421
              'versionedfile_factory': 'D1',
 
422
              'versionedfile_factory_to': 'D2'})],
 
423
            adapter.scenarios)
 
424
 
 
425
 
 
426
class TestRevisionStoreProviderAdapter(TestCase):
 
427
    """A group of tests that test the RevisionStore test adapter."""
 
428
 
 
429
    def test_scenarios(self):
 
430
        # check that constructor parameters are passed through to the adapted
 
431
        # test.
 
432
        from bzrlib.tests.revisionstore_implementations \
 
433
            import RevisionStoreTestProviderAdapter
 
434
        # revision stores need a store factory - i.e. RevisionKnit
 
435
        #, a readonly and rw transport 
 
436
        # transport servers:
 
437
        server1 = "a"
 
438
        server2 = "b"
 
439
        store_factories = ["c", "d"]
 
440
        adapter = RevisionStoreTestProviderAdapter(server1, server2, store_factories)
 
441
        self.assertEqual([
 
442
            ('c',
 
443
             {'store_factory': 'c',
 
444
              'transport_readonly_server': 'b',
 
445
              'transport_server': 'a'}),
 
446
            ('d',
 
447
             {'store_factory': 'd',
 
448
              'transport_readonly_server': 'b',
 
449
              'transport_server': 'a'})],
 
450
            adapter.scenarios)
 
451
 
 
452
 
371
453
class TestWorkingTreeProviderAdapter(TestCase):
372
454
    """A group of tests that test the workingtree implementation test adapter."""
373
455
 
378
460
            import WorkingTreeTestProviderAdapter
379
461
        server1 = "a"
380
462
        server2 = "b"
381
 
        formats = [workingtree.WorkingTreeFormat2(),
382
 
                   workingtree.WorkingTreeFormat3(),]
 
463
        formats = [("c", "C"), ("d", "D")]
383
464
        adapter = WorkingTreeTestProviderAdapter(server1, server2, formats)
384
465
        self.assertEqual([
385
 
            ('WorkingTreeFormat2',
386
 
             {'bzrdir_format': formats[0]._matchingbzrdir,
387
 
              'transport_readonly_server': 'b',
388
 
              'transport_server': 'a',
389
 
              'workingtree_format': formats[0]}),
390
 
            ('WorkingTreeFormat3',
391
 
             {'bzrdir_format': formats[1]._matchingbzrdir,
392
 
              'transport_readonly_server': 'b',
393
 
              'transport_server': 'a',
394
 
              'workingtree_format': formats[1]})],
 
466
            ('str',
 
467
             {'bzrdir_format': 'C',
 
468
              'transport_readonly_server': 'b',
 
469
              'transport_server': 'a',
 
470
              'workingtree_format': 'c'}),
 
471
            ('str',
 
472
             {'bzrdir_format': 'D',
 
473
              'transport_readonly_server': 'b',
 
474
              'transport_server': 'a',
 
475
              'workingtree_format': 'd'})],
395
476
            adapter.scenarios)
396
477
 
397
478
 
411
492
            return_parameter,
412
493
            revision_tree_from_workingtree
413
494
            )
 
495
        from bzrlib.workingtree import WorkingTreeFormat, WorkingTreeFormat3
414
496
        input_test = TestTreeProviderAdapter(
415
497
            "test_adapted_tests")
416
498
        server1 = "a"
417
499
        server2 = "b"
418
 
        formats = [workingtree.WorkingTreeFormat2(),
419
 
                   workingtree.WorkingTreeFormat3(),]
 
500
        formats = [("c", "C"), ("d", "D")]
420
501
        adapter = TreeTestProviderAdapter(server1, server2, formats)
421
502
        suite = adapter.adapt(input_test)
422
503
        tests = list(iter(suite))
423
504
        # XXX We should not have tests fail as we add more scenarios
424
505
        # abentley 20080412
425
 
        self.assertEqual(6, len(tests))
 
506
        self.assertEqual(5, len(tests))
426
507
        # this must match the default format setp up in
427
508
        # TreeTestProviderAdapter.adapt
428
 
        default_format = workingtree.WorkingTreeFormat3
429
 
        self.assertEqual(tests[0].workingtree_format, formats[0])
430
 
        self.assertEqual(tests[0].bzrdir_format, formats[0]._matchingbzrdir)
 
509
        default_format = WorkingTreeFormat3
 
510
        self.assertEqual(tests[0].workingtree_format, formats[0][0])
 
511
        self.assertEqual(tests[0].bzrdir_format, formats[0][1])
431
512
        self.assertEqual(tests[0].transport_server, server1)
432
513
        self.assertEqual(tests[0].transport_readonly_server, server2)
433
514
        self.assertEqual(tests[0]._workingtree_to_test_tree, return_parameter)
434
 
        self.assertEqual(tests[1].workingtree_format, formats[1])
435
 
        self.assertEqual(tests[1].bzrdir_format, formats[1]._matchingbzrdir)
 
515
        self.assertEqual(tests[1].workingtree_format, formats[1][0])
 
516
        self.assertEqual(tests[1].bzrdir_format, formats[1][1])
436
517
        self.assertEqual(tests[1].transport_server, server1)
437
518
        self.assertEqual(tests[1].transport_readonly_server, server2)
438
519
        self.assertEqual(tests[1]._workingtree_to_test_tree, return_parameter)
472
553
        server2 = "b"
473
554
        format1 = WorkingTreeFormat2()
474
555
        format2 = WorkingTreeFormat3()
475
 
        formats = [("1", str, format1, format2, "converter1"),
476
 
            ("2", int, format2, format1, "converter2")]
 
556
        formats = [(str, format1, format2, "converter1"),
 
557
            (int, format2, format1, "converter2")]
477
558
        adapter = InterTreeTestProviderAdapter(server1, server2, formats)
478
559
        suite = adapter.adapt(input_test)
479
560
        tests = list(iter(suite))
480
561
        self.assertEqual(2, len(tests))
481
 
        self.assertEqual(tests[0].intertree_class, formats[0][1])
482
 
        self.assertEqual(tests[0].workingtree_format, formats[0][2])
483
 
        self.assertEqual(tests[0].workingtree_format_to, formats[0][3])
484
 
        self.assertEqual(tests[0].mutable_trees_to_test_trees, formats[0][4])
 
562
        self.assertEqual(tests[0].intertree_class, formats[0][0])
 
563
        self.assertEqual(tests[0].workingtree_format, formats[0][1])
 
564
        self.assertEqual(tests[0].workingtree_format_to, formats[0][2])
 
565
        self.assertEqual(tests[0].mutable_trees_to_test_trees, formats[0][3])
485
566
        self.assertEqual(tests[0]._workingtree_to_test_tree, return_parameter)
486
567
        self.assertEqual(tests[0].transport_server, server1)
487
568
        self.assertEqual(tests[0].transport_readonly_server, server2)
488
 
        self.assertEqual(tests[1].intertree_class, formats[1][1])
489
 
        self.assertEqual(tests[1].workingtree_format, formats[1][2])
490
 
        self.assertEqual(tests[1].workingtree_format_to, formats[1][3])
491
 
        self.assertEqual(tests[1].mutable_trees_to_test_trees, formats[1][4])
 
569
        self.assertEqual(tests[1].intertree_class, formats[1][0])
 
570
        self.assertEqual(tests[1].workingtree_format, formats[1][1])
 
571
        self.assertEqual(tests[1].workingtree_format_to, formats[1][2])
 
572
        self.assertEqual(tests[1].mutable_trees_to_test_trees, formats[1][3])
492
573
        self.assertEqual(tests[1]._workingtree_to_test_tree, return_parameter)
493
574
        self.assertEqual(tests[1].transport_server, server1)
494
575
        self.assertEqual(tests[1].transport_readonly_server, server2)
502
583
        self.assertIsSameRealPath(self.test_dir, cwd)
503
584
        self.assertIsSameRealPath(self.test_home_dir, os.environ['HOME'])
504
585
 
505
 
    def test_assertEqualStat_equal(self):
506
 
        from bzrlib.tests.test_dirstate import _FakeStat
507
 
        self.build_tree(["foo"])
508
 
        real = os.lstat("foo")
509
 
        fake = _FakeStat(real.st_size, real.st_mtime, real.st_ctime,
510
 
            real.st_dev, real.st_ino, real.st_mode)
511
 
        self.assertEqualStat(real, fake)
512
 
 
513
 
    def test_assertEqualStat_notequal(self):
514
 
        self.build_tree(["foo", "bar"])
515
 
        self.assertRaises(AssertionError, self.assertEqualStat,
516
 
            os.lstat("foo"), os.lstat("bar"))
517
 
 
518
586
 
519
587
class TestTestCaseWithMemoryTransport(TestCaseWithMemoryTransport):
520
588
 
561
629
        self.assertEqual(format.repository_format.__class__,
562
630
            tree.branch.repository._format.__class__)
563
631
 
564
 
    def test_make_branch_builder(self):
565
 
        builder = self.make_branch_builder('dir')
566
 
        self.assertIsInstance(builder, branchbuilder.BranchBuilder)
567
 
        # Guard against regression into MemoryTransport leaking
568
 
        # files to disk instead of keeping them in memory.
569
 
        self.failIf(osutils.lexists('dir'))
570
 
 
571
 
    def test_make_branch_builder_with_format(self):
572
 
        # Use a repo layout that doesn't conform to a 'named' layout, to ensure
573
 
        # that the format objects are used.
574
 
        format = bzrdir.BzrDirMetaFormat1()
575
 
        repo_format = weaverepo.RepositoryFormat7()
576
 
        format.repository_format = repo_format
577
 
        builder = self.make_branch_builder('dir', format=format)
578
 
        the_branch = builder.get_branch()
579
 
        # Guard against regression into MemoryTransport leaking
580
 
        # files to disk instead of keeping them in memory.
581
 
        self.failIf(osutils.lexists('dir'))
582
 
        self.assertEqual(format.repository_format.__class__,
583
 
                         the_branch.repository._format.__class__)
584
 
        self.assertEqual(repo_format.get_format_string(),
585
 
                         self.get_transport().get_bytes(
586
 
                            'dir/.bzr/repository/format'))
587
 
 
588
 
    def test_make_branch_builder_with_format_name(self):
589
 
        builder = self.make_branch_builder('dir', format='knit')
590
 
        the_branch = builder.get_branch()
591
 
        # Guard against regression into MemoryTransport leaking
592
 
        # files to disk instead of keeping them in memory.
593
 
        self.failIf(osutils.lexists('dir'))
594
 
        dir_format = bzrdir.format_registry.make_bzrdir('knit')
595
 
        self.assertEqual(dir_format.repository_format.__class__,
596
 
                         the_branch.repository._format.__class__)
597
 
        self.assertEqual('Bazaar-NG Knit Repository Format 1',
598
 
                         self.get_transport().get_bytes(
599
 
                            'dir/.bzr/repository/format'))
600
 
 
601
632
    def test_safety_net(self):
602
633
        """No test should modify the safety .bzr directory.
603
634
 
656
687
        self.assertRaises(AssertionError, self.assertIsDirectory, 'a_file', t)
657
688
        self.assertRaises(AssertionError, self.assertIsDirectory, 'not_here', t)
658
689
 
659
 
    def test_make_branch_builder(self):
660
 
        builder = self.make_branch_builder('dir')
661
 
        rev_id = builder.build_commit()
662
 
        self.failUnlessExists('dir')
663
 
        a_dir = bzrdir.BzrDir.open('dir')
664
 
        self.assertRaises(errors.NoWorkingTree, a_dir.open_workingtree)
665
 
        a_branch = a_dir.open_branch()
666
 
        builder_branch = builder.get_branch()
667
 
        self.assertEqual(a_branch.base, builder_branch.base)
668
 
        self.assertEqual((1, rev_id), builder_branch.last_revision_info())
669
 
        self.assertEqual((1, rev_id), a_branch.last_revision_info())
670
 
 
671
690
 
672
691
class TestTestCaseTransports(TestCaseWithTransport):
673
692
 
1030
1049
        self.assertEqual(None, result._extractBenchmarkTime(test))
1031
1050
 
1032
1051
 
1033
 
class TestUnicodeFilenameFeature(TestCase):
1034
 
 
1035
 
    def test_probe_passes(self):
1036
 
        """UnicodeFilenameFeature._probe passes."""
1037
 
        # We can't test much more than that because the behaviour depends
1038
 
        # on the platform.
1039
 
        tests.UnicodeFilenameFeature._probe()
1040
 
 
1041
 
 
1042
1052
class TestRunner(TestCase):
1043
1053
 
1044
1054
    def dummy_test(self):
1338
1348
    def _test_pass(self):
1339
1349
        pass
1340
1350
 
1341
 
class _TestException(Exception):
1342
 
    pass
1343
1351
 
1344
1352
class TestTestCase(TestCase):
1345
1353
    """Tests that test the core bzrlib TestCase."""
1346
1354
 
1347
1355
    def test_debug_flags_sanitised(self):
1348
1356
        """The bzrlib debug flags should be sanitised by setUp."""
1349
 
        if 'allow_debug' in tests.selftest_debug_flags:
1350
 
            raise TestNotApplicable(
1351
 
                '-Eallow_debug option prevents debug flag sanitisation')
1352
1357
        # we could set something and run a test that will check
1353
1358
        # it gets santised, but this is probably sufficient for now:
1354
1359
        # if someone runs the test with -Dsomething it will error.
1355
1360
        self.assertEqual(set(), bzrlib.debug.debug_flags)
1356
1361
 
1357
 
    def change_selftest_debug_flags(self, new_flags):
1358
 
        orig_selftest_flags = tests.selftest_debug_flags
1359
 
        self.addCleanup(self._restore_selftest_debug_flags, orig_selftest_flags)
1360
 
        tests.selftest_debug_flags = set(new_flags)
1361
 
        
1362
 
    def _restore_selftest_debug_flags(self, flags):
1363
 
        tests.selftest_debug_flags = flags
1364
 
 
1365
 
    def test_allow_debug_flag(self):
1366
 
        """The -Eallow_debug flag prevents bzrlib.debug.debug_flags from being
1367
 
        sanitised (i.e. cleared) before running a test.
1368
 
        """
1369
 
        self.change_selftest_debug_flags(set(['allow_debug']))
1370
 
        bzrlib.debug.debug_flags = set(['a-flag'])
1371
 
        class TestThatRecordsFlags(TestCase):
1372
 
            def test_foo(nested_self):
1373
 
                self.flags = set(bzrlib.debug.debug_flags)
1374
 
        test = TestThatRecordsFlags('test_foo')
1375
 
        test.run(self.make_test_result())
1376
 
        self.assertEqual(set(['a-flag']), self.flags)
1377
 
 
1378
 
    def test_debug_flags_restored(self):
1379
 
        """The bzrlib debug flags should be restored to their original state
1380
 
        after the test was run, even if allow_debug is set.
1381
 
        """
1382
 
        self.change_selftest_debug_flags(set(['allow_debug']))
1383
 
        # Now run a test that modifies debug.debug_flags.
1384
 
        bzrlib.debug.debug_flags = set(['original-state'])
1385
 
        class TestThatModifiesFlags(TestCase):
1386
 
            def test_foo(self):
1387
 
                bzrlib.debug.debug_flags = set(['modified'])
1388
 
        test = TestThatModifiesFlags('test_foo')
1389
 
        test.run(self.make_test_result())
1390
 
        self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags)
1391
 
 
1392
 
    def make_test_result(self):
1393
 
        return bzrlib.tests.TextTestResult(
1394
 
            self._log_file, descriptions=0, verbosity=1)
1395
 
 
1396
1362
    def inner_test(self):
1397
1363
        # the inner child test
1398
1364
        note("inner_test")
1401
1367
        # the outer child test
1402
1368
        note("outer_start")
1403
1369
        self.inner_test = TestTestCase("inner_child")
1404
 
        result = self.make_test_result()
 
1370
        result = bzrlib.tests.TextTestResult(self._log_file,
 
1371
                                        descriptions=0,
 
1372
                                        verbosity=1)
1405
1373
        self.inner_test.run(result)
1406
1374
        note("outer finish")
1407
1375
 
1419
1387
        # the outer child test
1420
1388
        original_trace = bzrlib.trace._trace_file
1421
1389
        outer_test = TestTestCase("outer_child")
1422
 
        result = self.make_test_result()
 
1390
        result = bzrlib.tests.TextTestResult(self._log_file,
 
1391
                                        descriptions=0,
 
1392
                                        verbosity=1)
1423
1393
        outer_test.run(result)
1424
1394
        self.assertEqual(original_trace, bzrlib.trace._trace_file)
1425
1395
 
1541
1511
            ],
1542
1512
            result.calls)
1543
1513
 
1544
 
    def test_assert_list_raises_on_generator(self):
1545
 
        def generator_which_will_raise():
1546
 
            # This will not raise until after the first yield
1547
 
            yield 1
1548
 
            raise _TestException()
1549
 
 
1550
 
        e = self.assertListRaises(_TestException, generator_which_will_raise)
1551
 
        self.assertIsInstance(e, _TestException)
1552
 
 
1553
 
        e = self.assertListRaises(Exception, generator_which_will_raise)
1554
 
        self.assertIsInstance(e, _TestException)
1555
 
 
1556
 
    def test_assert_list_raises_on_plain(self):
1557
 
        def plain_exception():
1558
 
            raise _TestException()
1559
 
            return []
1560
 
 
1561
 
        e = self.assertListRaises(_TestException, plain_exception)
1562
 
        self.assertIsInstance(e, _TestException)
1563
 
 
1564
 
        e = self.assertListRaises(Exception, plain_exception)
1565
 
        self.assertIsInstance(e, _TestException)
1566
 
 
1567
 
    def test_assert_list_raises_assert_wrong_exception(self):
1568
 
        class _NotTestException(Exception):
1569
 
            pass
1570
 
 
1571
 
        def wrong_exception():
1572
 
            raise _NotTestException()
1573
 
 
1574
 
        def wrong_exception_generator():
1575
 
            yield 1
1576
 
            yield 2
1577
 
            raise _NotTestException()
1578
 
 
1579
 
        # Wrong exceptions are not intercepted
1580
 
        self.assertRaises(_NotTestException,
1581
 
            self.assertListRaises, _TestException, wrong_exception)
1582
 
        self.assertRaises(_NotTestException,
1583
 
            self.assertListRaises, _TestException, wrong_exception_generator)
1584
 
 
1585
 
    def test_assert_list_raises_no_exception(self):
1586
 
        def success():
1587
 
            return []
1588
 
 
1589
 
        def success_generator():
1590
 
            yield 1
1591
 
            yield 2
1592
 
 
1593
 
        self.assertRaises(AssertionError,
1594
 
            self.assertListRaises, _TestException, success)
1595
 
 
1596
 
        self.assertRaises(AssertionError,
1597
 
            self.assertListRaises, _TestException, success_generator)
1598
 
 
1599
1514
 
1600
1515
@symbol_versioning.deprecated_function(zero_eleven)
1601
1516
def sample_deprecated_function():
1835
1750
 
1836
1751
    def test_condition_id_startswith(self):
1837
1752
        klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1838
 
        start1 = klass + 'test_condition_id_starts'
1839
 
        start2 = klass + 'test_condition_id_in'
1840
 
        test_names = [ klass + 'test_condition_id_in_list',
1841
 
                      klass + 'test_condition_id_startswith',
1842
 
                     ]
 
1753
        start = klass + 'test_condition_id_starts'
 
1754
        test_names = [klass + 'test_condition_id_startswith']
1843
1755
        filtered_suite = filter_suite_by_condition(
1844
 
            self.suite, tests.condition_id_startswith([start1, start2]))
1845
 
        self.assertEqual(test_names, _test_ids(filtered_suite))
 
1756
            self.suite, tests.condition_id_startswith(start))
 
1757
        my_pattern = 'TestSelftestFiltering.*test_condition_id_startswith'
 
1758
        re_filtered = filter_suite_by_re(self.suite, my_pattern)
 
1759
        self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1846
1760
 
1847
1761
    def test_condition_isinstance(self):
1848
1762
        filtered_suite = filter_suite_by_condition(self.suite,
1901
1815
 
1902
1816
    def test_filter_suite_by_id_startswith(self):
1903
1817
        # By design this test may fail if another test is added whose name also
1904
 
        # begins with one of the start value used.
 
1818
        # begins with the start value used.
1905
1819
        klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1906
 
        start1 = klass + 'test_filter_suite_by_id_starts'
1907
 
        start2 = klass + 'test_filter_suite_by_id_li'
1908
 
        test_list = [klass + 'test_filter_suite_by_id_list',
1909
 
                     klass + 'test_filter_suite_by_id_startswith',
1910
 
                     ]
1911
 
        filtered_suite = tests.filter_suite_by_id_startswith(
1912
 
            self.suite, [start1, start2])
 
1820
        start = klass + 'test_filter_suite_by_id_starts'
 
1821
        test_list = [klass + 'test_filter_suite_by_id_startswith']
 
1822
        filtered_suite = tests.filter_suite_by_id_startswith(self.suite, start)
 
1823
        filtered_names = _test_ids(filtered_suite)
1913
1824
        self.assertEqual(
1914
 
            test_list,
1915
 
            _test_ids(filtered_suite),
1916
 
            )
 
1825
            filtered_names,
 
1826
            ['bzrlib.tests.test_selftest.'
 
1827
             'TestSelftestFiltering.test_filter_suite_by_id_startswith'])
1917
1828
 
1918
1829
    def test_preserve_input(self):
1919
1830
        # NB: Surely this is something in the stdlib to do this?
2225
2136
 
2226
2137
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2227
2138
        self.assertEquals([], _test_ids(suite))
2228
 
 
2229
 
 
2230
 
class TestTestPrefixRegistry(tests.TestCase):
2231
 
 
2232
 
    def _get_registry(self):
2233
 
        tp_registry = tests.TestPrefixAliasRegistry()
2234
 
        return tp_registry
2235
 
 
2236
 
    def test_register_new_prefix(self):
2237
 
        tpr = self._get_registry()
2238
 
        tpr.register('foo', 'fff.ooo.ooo')
2239
 
        self.assertEquals('fff.ooo.ooo', tpr.get('foo'))
2240
 
 
2241
 
    def test_register_existing_prefix(self):
2242
 
        tpr = self._get_registry()
2243
 
        tpr.register('bar', 'bbb.aaa.rrr')
2244
 
        tpr.register('bar', 'bBB.aAA.rRR')
2245
 
        self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
2246
 
        self.assertContainsRe(self._get_log(keep_log_file=True),
2247
 
                              r'.*bar.*bbb.aaa.rrr.*bBB.aAA.rRR')
2248
 
 
2249
 
    def test_get_unknown_prefix(self):
2250
 
        tpr = self._get_registry()
2251
 
        self.assertRaises(KeyError, tpr.get, 'I am not a prefix')
2252
 
 
2253
 
    def test_resolve_prefix(self):
2254
 
        tpr = self._get_registry()
2255
 
        tpr.register('bar', 'bb.aa.rr')
2256
 
        self.assertEquals('bb.aa.rr', tpr.resolve_alias('bar'))
2257
 
 
2258
 
    def test_resolve_unknown_alias(self):
2259
 
        tpr = self._get_registry()
2260
 
        self.assertRaises(errors.BzrCommandError,
2261
 
                          tpr.resolve_alias, 'I am not a prefix')
2262
 
 
2263
 
    def test_predefined_prefixes(self):
2264
 
        tpr = tests.test_prefix_alias_registry
2265
 
        self.assertEquals('bzrlib', tpr.resolve_alias('bzrlib'))
2266
 
        self.assertEquals('bzrlib.doc', tpr.resolve_alias('bd'))
2267
 
        self.assertEquals('bzrlib.utils', tpr.resolve_alias('bu'))
2268
 
        self.assertEquals('bzrlib.tests', tpr.resolve_alias('bt'))
2269
 
        self.assertEquals('bzrlib.tests.blackbox', tpr.resolve_alias('bb'))
2270
 
        self.assertEquals('bzrlib.plugins', tpr.resolve_alias('bp'))