← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

Merge direct pack access branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_selftest.py
52
52
    tests,
53
53
    transport,
54
54
    workingtree,
55
 
    workingtree_3,
56
 
    workingtree_4,
57
55
    )
58
56
from bzrlib.repofmt import (
59
57
    groupcompress_repo,
108
106
 
109
107
        filename = u'hell\u00d8'
110
108
        self.build_tree_contents([(filename, 'contents of hello')])
111
 
        self.assertPathExists(filename)
 
109
        self.failUnlessExists(filename)
112
110
 
113
111
 
114
112
class TestClassesAvailable(tests.TestCase):
340
338
        from bzrlib.tests.per_workingtree import make_scenarios
341
339
        server1 = "a"
342
340
        server2 = "b"
343
 
        formats = [workingtree_4.WorkingTreeFormat4(),
344
 
                   workingtree_3.WorkingTreeFormat3(),]
 
341
        formats = [workingtree.WorkingTreeFormat4(),
 
342
                   workingtree.WorkingTreeFormat3(),]
345
343
        scenarios = make_scenarios(server1, server2, formats)
346
344
        self.assertEqual([
347
345
            ('WorkingTreeFormat4',
377
375
            )
378
376
        server1 = "a"
379
377
        server2 = "b"
380
 
        formats = [workingtree_4.WorkingTreeFormat4(),
381
 
                   workingtree_3.WorkingTreeFormat3(),]
 
378
        formats = [workingtree.WorkingTreeFormat4(),
 
379
                   workingtree.WorkingTreeFormat3(),]
382
380
        scenarios = make_scenarios(server1, server2, formats)
383
381
        self.assertEqual(7, len(scenarios))
384
382
        default_wt_format = workingtree.format_registry.get_default()
385
 
        wt4_format = workingtree_4.WorkingTreeFormat4()
386
 
        wt5_format = workingtree_4.WorkingTreeFormat5()
 
383
        wt4_format = workingtree.WorkingTreeFormat4()
 
384
        wt5_format = workingtree.WorkingTreeFormat5()
387
385
        expected_scenarios = [
388
386
            ('WorkingTreeFormat4',
389
387
             {'bzrdir_format': formats[0]._matchingbzrdir,
455
453
        from bzrlib.tests.per_intertree import (
456
454
            make_scenarios,
457
455
            )
458
 
        from bzrlib.workingtree_3 import WorkingTreeFormat3
459
 
        from bzrlib.workingtree_4 import WorkingTreeFormat4
 
456
        from bzrlib.workingtree import WorkingTreeFormat3, WorkingTreeFormat4
460
457
        input_test = TestInterTreeScenarios(
461
458
            "test_scenarios")
462
459
        server1 = "a"
513
510
        self.assertRaises(AssertionError, self.assertEqualStat,
514
511
            os.lstat("foo"), os.lstat("longname"))
515
512
 
516
 
    def test_failUnlessExists(self):
517
 
        """Deprecated failUnlessExists and failIfExists"""
518
 
        self.applyDeprecated(
519
 
            deprecated_in((2, 4)),
520
 
            self.failUnlessExists, '.')
521
 
        self.build_tree(['foo/', 'foo/bar'])
522
 
        self.applyDeprecated(
523
 
            deprecated_in((2, 4)),
524
 
            self.failUnlessExists, 'foo/bar')
525
 
        self.applyDeprecated(
526
 
            deprecated_in((2, 4)),
527
 
            self.failIfExists, 'foo/foo')
528
 
 
529
 
    def test_assertPathExists(self):
530
 
        self.assertPathExists('.')
531
 
        self.build_tree(['foo/', 'foo/bar'])
532
 
        self.assertPathExists('foo/bar')
533
 
        self.assertPathDoesNotExist('foo/foo')
534
 
 
535
513
 
536
514
class TestTestCaseWithMemoryTransport(tests.TestCaseWithMemoryTransport):
537
515
 
571
549
        tree = self.make_branch_and_memory_tree('dir')
572
550
        # Guard against regression into MemoryTransport leaking
573
551
        # files to disk instead of keeping them in memory.
574
 
        self.assertFalse(osutils.lexists('dir'))
 
552
        self.failIf(osutils.lexists('dir'))
575
553
        self.assertIsInstance(tree, memorytree.MemoryTree)
576
554
 
577
555
    def test_make_branch_and_memory_tree_with_format(self):
581
559
        tree = self.make_branch_and_memory_tree('dir', format=format)
582
560
        # Guard against regression into MemoryTransport leaking
583
561
        # files to disk instead of keeping them in memory.
584
 
        self.assertFalse(osutils.lexists('dir'))
 
562
        self.failIf(osutils.lexists('dir'))
585
563
        self.assertIsInstance(tree, memorytree.MemoryTree)
586
564
        self.assertEqual(format.repository_format.__class__,
587
565
            tree.branch.repository._format.__class__)
591
569
        self.assertIsInstance(builder, branchbuilder.BranchBuilder)
592
570
        # Guard against regression into MemoryTransport leaking
593
571
        # files to disk instead of keeping them in memory.
594
 
        self.assertFalse(osutils.lexists('dir'))
 
572
        self.failIf(osutils.lexists('dir'))
595
573
 
596
574
    def test_make_branch_builder_with_format(self):
597
575
        # Use a repo layout that doesn't conform to a 'named' layout, to ensure
603
581
        the_branch = builder.get_branch()
604
582
        # Guard against regression into MemoryTransport leaking
605
583
        # files to disk instead of keeping them in memory.
606
 
        self.assertFalse(osutils.lexists('dir'))
 
584
        self.failIf(osutils.lexists('dir'))
607
585
        self.assertEqual(format.repository_format.__class__,
608
586
                         the_branch.repository._format.__class__)
609
587
        self.assertEqual(repo_format.get_format_string(),
615
593
        the_branch = builder.get_branch()
616
594
        # Guard against regression into MemoryTransport leaking
617
595
        # files to disk instead of keeping them in memory.
618
 
        self.assertFalse(osutils.lexists('dir'))
 
596
        self.failIf(osutils.lexists('dir'))
619
597
        dir_format = bzrdir.format_registry.make_bzrdir('knit')
620
598
        self.assertEqual(dir_format.repository_format.__class__,
621
599
                         the_branch.repository._format.__class__)
654
632
        url2 = self.get_readonly_url('foo/bar')
655
633
        t = transport.get_transport(url)
656
634
        t2 = transport.get_transport(url2)
657
 
        self.assertIsInstance(t, ReadonlyTransportDecorator)
658
 
        self.assertIsInstance(t2, ReadonlyTransportDecorator)
 
635
        self.failUnless(isinstance(t, ReadonlyTransportDecorator))
 
636
        self.failUnless(isinstance(t2, ReadonlyTransportDecorator))
659
637
        self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
660
638
 
661
639
    def test_get_readonly_url_http(self):
669
647
        # the transport returned may be any HttpTransportBase subclass
670
648
        t = transport.get_transport(url)
671
649
        t2 = transport.get_transport(url2)
672
 
        self.assertIsInstance(t, HttpTransportBase)
673
 
        self.assertIsInstance(t2, HttpTransportBase)
 
650
        self.failUnless(isinstance(t, HttpTransportBase))
 
651
        self.failUnless(isinstance(t2, HttpTransportBase))
674
652
        self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
675
653
 
676
654
    def test_is_directory(self):
684
662
    def test_make_branch_builder(self):
685
663
        builder = self.make_branch_builder('dir')
686
664
        rev_id = builder.build_commit()
687
 
        self.assertPathExists('dir')
 
665
        self.failUnlessExists('dir')
688
666
        a_dir = bzrdir.BzrDir.open('dir')
689
667
        self.assertRaises(errors.NoWorkingTree, a_dir.open_workingtree)
690
668
        a_branch = a_dir.open_branch()
706
684
        self.assertIsInstance(result_bzrdir.transport,
707
685
                              memory.MemoryTransport)
708
686
        # should not be on disk, should only be in memory
709
 
        self.assertPathDoesNotExist('subdir')
 
687
        self.failIfExists('subdir')
710
688
 
711
689
 
712
690
class TestChrootedTest(tests.ChrootedTestCase):
2320
2298
        # stdout and stderr of the invoked run_bzr
2321
2299
        current_factory = bzrlib.ui.ui_factory
2322
2300
        self.run_bzr(['foo'])
2323
 
        self.assertFalse(current_factory is self.factory)
 
2301
        self.failIf(current_factory is self.factory)
2324
2302
        self.assertNotEqual(sys.stdout, self.factory.stdout)
2325
2303
        self.assertNotEqual(sys.stderr, self.factory.stderr)
2326
2304
        self.assertEqual('foo\n', self.factory.stdout.getvalue())
2508
2486
        self.assertEqual([], command[2:])
2509
2487
 
2510
2488
    def test_set_env(self):
2511
 
        self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
 
2489
        self.failIf('EXISTANT_ENV_VAR' in os.environ)
2512
2490
        # set in the child
2513
2491
        def check_environment():
2514
2492
            self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
2520
2498
 
2521
2499
    def test_run_bzr_subprocess_env_del(self):
2522
2500
        """run_bzr_subprocess can remove environment variables too."""
2523
 
        self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
 
2501
        self.failIf('EXISTANT_ENV_VAR' in os.environ)
2524
2502
        def check_environment():
2525
2503
            self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2526
2504
        os.environ['EXISTANT_ENV_VAR'] = 'set variable'
2532
2510
        del os.environ['EXISTANT_ENV_VAR']
2533
2511
 
2534
2512
    def test_env_del_missing(self):
2535
 
        self.assertFalse('NON_EXISTANT_ENV_VAR' in os.environ)
 
2513
        self.failIf('NON_EXISTANT_ENV_VAR' in os.environ)
2536
2514
        def check_environment():
2537
2515
            self.assertFalse('NON_EXISTANT_ENV_VAR' in os.environ)
2538
2516
        self.check_popen_state = check_environment
2813
2791
        self.assertEqual(remaining_names, _test_ids(split_suite[1]))
2814
2792
 
2815
2793
 
2816
 
class TestCheckTreeShape(tests.TestCaseWithTransport):
 
2794
class TestCheckInventoryShape(tests.TestCaseWithTransport):
2817
2795
 
2818
 
    def test_check_tree_shape(self):
 
2796
    def test_check_inventory_shape(self):
2819
2797
        files = ['a', 'b/', 'b/c']
2820
2798
        tree = self.make_branch_and_tree('.')
2821
2799
        self.build_tree(files)
2822
2800
        tree.add(files)
2823
2801
        tree.lock_read()
2824
2802
        try:
2825
 
            self.check_tree_shape(tree, files)
 
2803
            self.check_inventory_shape(tree.inventory, files)
2826
2804
        finally:
2827
2805
            tree.unlock()
2828
2806
 
3364
3342
class TestEnvironHandling(tests.TestCase):
3365
3343
 
3366
3344
    def test_overrideEnv_None_called_twice_doesnt_leak(self):
3367
 
        self.assertFalse('MYVAR' in os.environ)
 
3345
        self.failIf('MYVAR' in os.environ)
3368
3346
        self.overrideEnv('MYVAR', '42')
3369
3347
        # We use an embedded test to make sure we fix the _captureVar bug
3370
3348
        class Test(tests.TestCase):