← 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: John Arbash Meinel
  • Date: 2008-10-30 00:55:00 UTC
  • mto: (3815.2.5 prepare-1.9)
  • mto: This revision was merged to the branch mainline in revision 3811.
  • Revision ID: john@arbash-meinel.com-20081030005500-r5cej1cxflqhs3io
Switch so that we are using a simple timestamp as the first action.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_selftest.py
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008 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,
29
30
    bzrdir,
30
31
    errors,
31
32
    memorytree,
32
33
    osutils,
 
34
    remote,
33
35
    repository,
34
36
    symbol_versioning,
35
37
    tests,
 
38
    workingtree,
36
39
    )
37
40
from bzrlib.progress import _BaseProgressBar
38
 
from bzrlib.repofmt import weaverepo
 
41
from bzrlib.repofmt import (
 
42
    pack_repo,
 
43
    weaverepo,
 
44
    )
39
45
from bzrlib.symbol_versioning import (
40
46
    one_zero,
41
47
    zero_eleven,
103
109
                              'a test message\n')
104
110
 
105
111
 
 
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
 
106
121
class TestTreeShape(TestCaseInTempDir):
107
122
 
108
123
    def test_unicode_paths(self):
 
124
        self.requireFeature(tests.UnicodeFilename)
 
125
 
109
126
        filename = u'hell\u00d8'
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())
 
127
        self.build_tree_contents([(filename, 'contents of hello')])
115
128
        self.failUnlessExists(filename)
116
129
 
117
130
 
234
247
            adapter.scenarios)
235
248
 
236
249
 
237
 
class TestRepositoryProviderAdapter(TestCase):
 
250
class TestRepositoryParameterisation(TestCase):
238
251
    """A group of tests that test the repository implementation test adapter."""
239
252
 
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
 
 
282
253
    def test_formats_to_scenarios(self):
283
254
        """The adapter can generate all the scenarios needed."""
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")]
 
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
291
264
        self.assertEqual([
292
 
            ('str',
293
 
             {'bzrdir_format': 'C',
294
 
              'repository_format': 'c',
 
265
            ('RemoteRepositoryFormat(c)',
 
266
             {'bzrdir_format': remote.RemoteBzrDirFormat(),
 
267
              'repository_format': remote.RemoteRepositoryFormat(),
295
268
              'transport_readonly_server': 'readonly',
296
269
              'transport_server': 'server'}),
297
 
            ('int',
298
 
             {'bzrdir_format': 'D',
299
 
              'repository_format': 1,
 
270
            ('RepositoryFormatKnitPack1(d)',
 
271
             {'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
 
272
              'repository_format': pack_repo.RepositoryFormatKnitPack1(),
300
273
              'transport_readonly_server': 'readonly',
301
274
              'transport_server': 'server'})],
302
 
            no_vfs_adapter.formats_to_scenarios(formats))
 
275
            no_vfs_scenarios)
303
276
        self.assertEqual([
304
 
            ('str',
305
 
             {'bzrdir_format': 'C',
306
 
              'repository_format': 'c',
 
277
            ('RemoteRepositoryFormat(c)',
 
278
             {'bzrdir_format': remote.RemoteBzrDirFormat(),
 
279
              'repository_format': remote.RemoteRepositoryFormat(),
307
280
              'transport_readonly_server': 'readonly',
308
281
              'transport_server': 'server',
309
282
              'vfs_transport_factory': 'vfs'}),
310
 
            ('int',
311
 
             {'bzrdir_format': 'D',
312
 
              'repository_format': 1,
 
283
            ('RepositoryFormatKnitPack1(d)',
 
284
             {'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
 
285
              'repository_format': pack_repo.RepositoryFormatKnitPack1(),
313
286
              'transport_readonly_server': 'readonly',
314
287
              'transport_server': 'server',
315
288
              'vfs_transport_factory': 'vfs'})],
316
 
            vfs_adapter.formats_to_scenarios(formats))
 
289
            vfs_scenarios)
317
290
 
318
291
 
319
292
class TestTestScenarioApplier(TestCase):
320
293
    """Tests for the test adaption facilities."""
321
294
 
322
295
    def test_adapt_applies_scenarios(self):
323
 
        from bzrlib.tests.repository_implementations import TestScenarioApplier
 
296
        from bzrlib.tests.per_repository import TestScenarioApplier
324
297
        input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
325
298
        adapter = TestScenarioApplier()
326
299
        adapter.scenarios = [("1", "dict"), ("2", "settings")]
334
307
            (input_test, ("2", "settings"))], calls)
335
308
 
336
309
    def test_adapt_test_to_scenario(self):
337
 
        from bzrlib.tests.repository_implementations import TestScenarioApplier
 
310
        from bzrlib.tests.per_repository import TestScenarioApplier
338
311
        input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
339
312
        adapter = TestScenarioApplier()
340
313
        # setup two adapted tests
395
368
            adapter.formats_to_scenarios(formats))
396
369
 
397
370
 
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
 
 
453
371
class TestWorkingTreeProviderAdapter(TestCase):
454
372
    """A group of tests that test the workingtree implementation test adapter."""
455
373
 
460
378
            import WorkingTreeTestProviderAdapter
461
379
        server1 = "a"
462
380
        server2 = "b"
463
 
        formats = [("c", "C"), ("d", "D")]
 
381
        formats = [workingtree.WorkingTreeFormat2(),
 
382
                   workingtree.WorkingTreeFormat3(),]
464
383
        adapter = WorkingTreeTestProviderAdapter(server1, server2, formats)
465
384
        self.assertEqual([
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'})],
 
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]})],
476
395
            adapter.scenarios)
477
396
 
478
397
 
492
411
            return_parameter,
493
412
            revision_tree_from_workingtree
494
413
            )
495
 
        from bzrlib.workingtree import WorkingTreeFormat, WorkingTreeFormat3
496
414
        input_test = TestTreeProviderAdapter(
497
415
            "test_adapted_tests")
498
416
        server1 = "a"
499
417
        server2 = "b"
500
 
        formats = [("c", "C"), ("d", "D")]
 
418
        formats = [workingtree.WorkingTreeFormat2(),
 
419
                   workingtree.WorkingTreeFormat3(),]
501
420
        adapter = TreeTestProviderAdapter(server1, server2, formats)
502
421
        suite = adapter.adapt(input_test)
503
422
        tests = list(iter(suite))
504
423
        # XXX We should not have tests fail as we add more scenarios
505
424
        # abentley 20080412
506
 
        self.assertEqual(5, len(tests))
 
425
        self.assertEqual(6, len(tests))
507
426
        # this must match the default format setp up in
508
427
        # TreeTestProviderAdapter.adapt
509
 
        default_format = WorkingTreeFormat3
510
 
        self.assertEqual(tests[0].workingtree_format, formats[0][0])
511
 
        self.assertEqual(tests[0].bzrdir_format, formats[0][1])
 
428
        default_format = workingtree.WorkingTreeFormat3
 
429
        self.assertEqual(tests[0].workingtree_format, formats[0])
 
430
        self.assertEqual(tests[0].bzrdir_format, formats[0]._matchingbzrdir)
512
431
        self.assertEqual(tests[0].transport_server, server1)
513
432
        self.assertEqual(tests[0].transport_readonly_server, server2)
514
433
        self.assertEqual(tests[0]._workingtree_to_test_tree, return_parameter)
515
 
        self.assertEqual(tests[1].workingtree_format, formats[1][0])
516
 
        self.assertEqual(tests[1].bzrdir_format, formats[1][1])
 
434
        self.assertEqual(tests[1].workingtree_format, formats[1])
 
435
        self.assertEqual(tests[1].bzrdir_format, formats[1]._matchingbzrdir)
517
436
        self.assertEqual(tests[1].transport_server, server1)
518
437
        self.assertEqual(tests[1].transport_readonly_server, server2)
519
438
        self.assertEqual(tests[1]._workingtree_to_test_tree, return_parameter)
553
472
        server2 = "b"
554
473
        format1 = WorkingTreeFormat2()
555
474
        format2 = WorkingTreeFormat3()
556
 
        formats = [(str, format1, format2, "converter1"),
557
 
            (int, format2, format1, "converter2")]
 
475
        formats = [("1", str, format1, format2, "converter1"),
 
476
            ("2", int, format2, format1, "converter2")]
558
477
        adapter = InterTreeTestProviderAdapter(server1, server2, formats)
559
478
        suite = adapter.adapt(input_test)
560
479
        tests = list(iter(suite))
561
480
        self.assertEqual(2, len(tests))
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])
 
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])
566
485
        self.assertEqual(tests[0]._workingtree_to_test_tree, return_parameter)
567
486
        self.assertEqual(tests[0].transport_server, server1)
568
487
        self.assertEqual(tests[0].transport_readonly_server, server2)
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])
 
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])
573
492
        self.assertEqual(tests[1]._workingtree_to_test_tree, return_parameter)
574
493
        self.assertEqual(tests[1].transport_server, server1)
575
494
        self.assertEqual(tests[1].transport_readonly_server, server2)
583
502
        self.assertIsSameRealPath(self.test_dir, cwd)
584
503
        self.assertIsSameRealPath(self.test_home_dir, os.environ['HOME'])
585
504
 
 
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
 
586
518
 
587
519
class TestTestCaseWithMemoryTransport(TestCaseWithMemoryTransport):
588
520
 
629
561
        self.assertEqual(format.repository_format.__class__,
630
562
            tree.branch.repository._format.__class__)
631
563
 
 
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
 
632
601
    def test_safety_net(self):
633
602
        """No test should modify the safety .bzr directory.
634
603
 
687
656
        self.assertRaises(AssertionError, self.assertIsDirectory, 'a_file', t)
688
657
        self.assertRaises(AssertionError, self.assertIsDirectory, 'not_here', t)
689
658
 
 
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
 
690
671
 
691
672
class TestTestCaseTransports(TestCaseWithTransport):
692
673
 
1049
1030
        self.assertEqual(None, result._extractBenchmarkTime(test))
1050
1031
 
1051
1032
 
 
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
 
1052
1042
class TestRunner(TestCase):
1053
1043
 
1054
1044
    def dummy_test(self):
1348
1338
    def _test_pass(self):
1349
1339
        pass
1350
1340
 
 
1341
class _TestException(Exception):
 
1342
    pass
1351
1343
 
1352
1344
class TestTestCase(TestCase):
1353
1345
    """Tests that test the core bzrlib TestCase."""
1354
1346
 
1355
1347
    def test_debug_flags_sanitised(self):
1356
1348
        """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')
1357
1352
        # we could set something and run a test that will check
1358
1353
        # it gets santised, but this is probably sufficient for now:
1359
1354
        # if someone runs the test with -Dsomething it will error.
1360
1355
        self.assertEqual(set(), bzrlib.debug.debug_flags)
1361
1356
 
 
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
 
1362
1396
    def inner_test(self):
1363
1397
        # the inner child test
1364
1398
        note("inner_test")
1367
1401
        # the outer child test
1368
1402
        note("outer_start")
1369
1403
        self.inner_test = TestTestCase("inner_child")
1370
 
        result = bzrlib.tests.TextTestResult(self._log_file,
1371
 
                                        descriptions=0,
1372
 
                                        verbosity=1)
 
1404
        result = self.make_test_result()
1373
1405
        self.inner_test.run(result)
1374
1406
        note("outer finish")
1375
1407
 
1387
1419
        # the outer child test
1388
1420
        original_trace = bzrlib.trace._trace_file
1389
1421
        outer_test = TestTestCase("outer_child")
1390
 
        result = bzrlib.tests.TextTestResult(self._log_file,
1391
 
                                        descriptions=0,
1392
 
                                        verbosity=1)
 
1422
        result = self.make_test_result()
1393
1423
        outer_test.run(result)
1394
1424
        self.assertEqual(original_trace, bzrlib.trace._trace_file)
1395
1425
 
1511
1541
            ],
1512
1542
            result.calls)
1513
1543
 
 
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
 
1514
1599
 
1515
1600
@symbol_versioning.deprecated_function(zero_eleven)
1516
1601
def sample_deprecated_function():
1750
1835
 
1751
1836
    def test_condition_id_startswith(self):
1752
1837
        klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1753
 
        start = klass + 'test_condition_id_starts'
1754
 
        test_names = [klass + 'test_condition_id_startswith']
 
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
                     ]
1755
1843
        filtered_suite = filter_suite_by_condition(
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))
 
1844
            self.suite, tests.condition_id_startswith([start1, start2]))
 
1845
        self.assertEqual(test_names, _test_ids(filtered_suite))
1760
1846
 
1761
1847
    def test_condition_isinstance(self):
1762
1848
        filtered_suite = filter_suite_by_condition(self.suite,
1815
1901
 
1816
1902
    def test_filter_suite_by_id_startswith(self):
1817
1903
        # By design this test may fail if another test is added whose name also
1818
 
        # begins with the start value used.
 
1904
        # begins with one of the start value used.
1819
1905
        klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
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)
 
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])
1824
1913
        self.assertEqual(
1825
 
            filtered_names,
1826
 
            ['bzrlib.tests.test_selftest.'
1827
 
             'TestSelftestFiltering.test_filter_suite_by_id_startswith'])
 
1914
            test_list,
 
1915
            _test_ids(filtered_suite),
 
1916
            )
1828
1917
 
1829
1918
    def test_preserve_input(self):
1830
1919
        # NB: Surely this is something in the stdlib to do this?
2136
2225
 
2137
2226
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2138
2227
        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'))