← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/bzrdir_implementations/test_bzrdir.py

  • Committer: John Arbash Meinel
  • Date: 2009-02-23 15:29:35 UTC
  • mfrom: (3943.7.7 bzr.code_style_cleanup)
  • mto: This revision was merged to the branch mainline in revision 4033.
  • Revision ID: john@arbash-meinel.com-20090223152935-oel9m92mwcc6nb4h
Merge the removal of all trailing whitespace, and resolve conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/bzrdir_implementations/test_bzrdir.py
75
75
        """Assert that the content of source and target are identical.
76
76
 
77
77
        paths in ignore list will be completely ignored.
78
 
        
 
78
 
79
79
        We ignore paths that represent data which is allowed to change during
80
80
        a clone or sprout: for instance, inventory.knit contains gzip fragements
81
 
        which have timestamps in them, and as we have read the inventory from 
 
81
        which have timestamps in them, and as we have read the inventory from
82
82
        the source knit, the already-read data is recompressed rather than
83
83
        reading it again, which leads to changed timestamps. This is ok though,
84
84
        because the inventory.kndx file is not ignored, and the integrity of
169
169
 
170
170
    def skipIfNoWorkingTree(self, a_bzrdir):
171
171
        """Raises TestSkipped if a_bzrdir doesn't have a working tree.
172
 
        
 
172
 
173
173
        If the bzrdir does have a workingtree, this is a no-op.
174
174
        """
175
175
        try:
180
180
 
181
181
    def createWorkingTreeOrSkip(self, a_bzrdir):
182
182
        """Create a working tree on a_bzrdir, or raise TestSkipped.
183
 
        
 
183
 
184
184
        A simple wrapper for create_workingtree that translates NotLocalUrl into
185
185
        TestSkipped.  Returns the newly created working tree.
186
186
        """
194
194
                     force_new_repo=False, accelerator_tree=None,
195
195
                     create_tree_if_local=True):
196
196
        """Sprout from_bzrdir into to_url, or raise TestSkipped.
197
 
        
 
197
 
198
198
        A simple wrapper for from_bzrdir.sprout that translates NotLocalUrl into
199
199
        TestSkipped.  Returns the newly sprouted bzrdir.
200
200
        """
286
286
        self.assertNotEqual(dir.transport.base, target.transport.base)
287
287
        self.assertDirectoriesEqual(dir.root_transport, target.root_transport,
288
288
                                    ['./.bzr/merge-hashes'])
289
 
    
 
289
 
290
290
    def test_clone_bzrdir_empty_force_new_ignored(self):
291
291
        # the force_new_repo parameter should have no effect on an empty
292
292
        # bzrdir's clone logic
295
295
        self.assertNotEqual(dir.transport.base, target.transport.base)
296
296
        self.assertDirectoriesEqual(dir.root_transport, target.root_transport,
297
297
                                    ['./.bzr/merge-hashes'])
298
 
    
 
298
 
299
299
    def test_clone_bzrdir_repository(self):
300
300
        tree = self.make_branch_and_tree('commit_tree')
301
301
        self.build_tree(['foo'], transport=tree.bzrdir.transport.clone('..'))
389
389
        self.assertTrue(branch.repository.has_revision('1'))
390
390
        self.assertFalse(branch.repository.make_working_trees())
391
391
        self.assertTrue(branch.repository.is_shared())
392
 
        
 
392
 
393
393
    def test_clone_bzrdir_repository_under_shared_force_new_repo(self):
394
394
        tree = self.make_branch_and_tree('commit_tree')
395
395
        self.build_tree(['commit_tree/foo'])
414
414
        # test for revision limiting, [smoke test, not corner case checks].
415
415
        # make a repository with some revisions,
416
416
        # and clone it with a revision limit.
417
 
        # 
 
417
        #
418
418
        tree = self.make_branch_and_tree('commit_tree')
419
419
        self.build_tree(['commit_tree/foo'])
420
420
        tree.add('foo')
510
510
        # test for revision limiting, [smoke test, not corner case checks].
511
511
        # make a branch with some revisions,
512
512
        # and clone it with a revision limit.
513
 
        # 
 
513
        #
514
514
        tree = self.make_branch_and_tree('commit_tree')
515
515
        self.build_tree(['commit_tree/foo'])
516
516
        tree.add('foo')
522
522
        dir = source.bzrdir
523
523
        target = dir.clone(self.get_url('target'), revision_id='1')
524
524
        self.assertEqual('1', target.open_branch().last_revision())
525
 
        
 
525
 
526
526
    def test_clone_bzrdir_tree_branch_repo(self):
527
527
        tree = self.make_branch_and_tree('source')
528
528
        self.build_tree(['source/foo'])
595
595
            target.open_repository())
596
596
 
597
597
    def test_clone_bzrdir_tree_branch_reference(self):
598
 
        # a tree with a branch reference (aka a checkout) 
 
598
        # a tree with a branch reference (aka a checkout)
599
599
        # should stay a checkout on clone.
600
600
        referenced_branch = self.make_branch('referencced')
601
601
        dir = self.make_bzrdir('source')
725
725
        target.open_repository()
726
726
        target.open_branch()
727
727
        target.open_workingtree()
728
 
    
 
728
 
729
729
    def test_sprout_bzrdir_repository(self):
730
730
        tree = self.make_branch_and_tree('commit_tree')
731
731
        self.build_tree(['foo'], transport=tree.bzrdir.transport.clone('..'))
756
756
            # If we happen to have a tree, we'll guarantee everything
757
757
            # except for the tree root is the same.
758
758
            inventory_f = file(dir.transport.base+'inventory', 'rb')
759
 
            self.assertContainsRe(inventory_f.read(), 
 
759
            self.assertContainsRe(inventory_f.read(),
760
760
                                  '<inventory file_id="TREE_ROOT[^"]*"'
761
761
                                  ' format="5">\n</inventory>\n')
762
762
            inventory_f.close()
855
855
        # test for revision limiting, [smoke test, not corner case checks].
856
856
        # make a repository with some revisions,
857
857
        # and sprout it with a revision limit.
858
 
        # 
 
858
        #
859
859
        tree = self.make_branch_and_tree('commit_tree')
860
860
        self.build_tree(['commit_tree/foo'])
861
861
        tree.add('foo')
948
948
        self.assertNotEqual(dir.transport.base, target.transport.base)
949
949
        # we want target to have a branch that is in-place.
950
950
        self.assertEqual(target, target.open_branch().bzrdir)
951
 
        # and as we dont support repositories being detached yet, a repo in 
 
951
        # and as we dont support repositories being detached yet, a repo in
952
952
        # place
953
953
        target.open_repository()
954
954
 
973
973
        # we want target to have a branch that is in-place.
974
974
        self.assertEqual(target, target.open_branch().bzrdir)
975
975
        # and we want no repository as the target is shared
976
 
        self.assertRaises(errors.NoRepositoryPresent, 
 
976
        self.assertRaises(errors.NoRepositoryPresent,
977
977
                          target.open_repository)
978
978
        # and we want revision '1' in the shared repo
979
979
        self.assertTrue(shared_repo.has_revision('1'))
1008
1008
        # test for revision limiting, [smoke test, not corner case checks].
1009
1009
        # make a repository with some revisions,
1010
1010
        # and sprout it with a revision limit.
1011
 
        # 
 
1011
        #
1012
1012
        tree = self.make_branch_and_tree('commit_tree')
1013
1013
        self.build_tree(['commit_tree/foo'])
1014
1014
        tree.add('foo')
1020
1020
        dir = source.bzrdir
1021
1021
        target = self.sproutOrSkip(dir, self.get_url('target'), revision_id='1')
1022
1022
        self.assertEqual('1', target.open_branch().last_revision())
1023
 
        
 
1023
 
1024
1024
    def test_sprout_bzrdir_tree_branch_repo(self):
1025
1025
        tree = self.make_branch_and_tree('source')
1026
1026
        self.build_tree(['foo'], transport=tree.bzrdir.transport.clone('..'))
1063
1063
        self.assertNotEqual(dir.transport.base, target.transport.base)
1064
1064
        # we want target to have a branch that is in-place.
1065
1065
        self.assertEqual(target, target.open_branch().bzrdir)
1066
 
        # and as we dont support repositories being detached yet, a repo in 
 
1066
        # and as we dont support repositories being detached yet, a repo in
1067
1067
        # place
1068
1068
        target.open_repository()
1069
1069
        result_tree = target.open_workingtree()
1092
1092
        self.assertNotEqual(dir.transport.base, target.transport.base)
1093
1093
        # we want target to have a branch that is in-place.
1094
1094
        self.assertEqual(target, target.open_branch().bzrdir)
1095
 
        # and as we dont support repositories being detached yet, a repo in 
 
1095
        # and as we dont support repositories being detached yet, a repo in
1096
1096
        # place
1097
1097
        target.open_repository()
1098
1098
        # we trust that the working tree sprouting works via the other tests.
1184
1184
        made_branch = made_control.create_branch()
1185
1185
        self.failUnless(isinstance(made_branch, bzrlib.branch.Branch))
1186
1186
        self.assertEqual(made_control, made_branch.bzrdir)
1187
 
        
 
1187
 
1188
1188
    def test_open_branch(self):
1189
1189
        if not self.bzrdir_format.is_supported():
1190
1190
            # unsupported formats are not loopback testable
1215
1215
        self.assertEqual(made_control, made_repo.bzrdir)
1216
1216
 
1217
1217
    def test_create_repository_shared(self):
1218
 
        # a bzrdir can create a shared repository or 
 
1218
        # a bzrdir can create a shared repository or
1219
1219
        # fail appropriately
1220
1220
        if not self.bzrdir_format.is_supported():
1221
1221
            # unsupported formats are not loopback testable
1233
1233
        self.assertTrue(made_repo.is_shared())
1234
1234
 
1235
1235
    def test_create_repository_nonshared(self):
1236
 
        # a bzrdir can create a non-shared repository 
 
1236
        # a bzrdir can create a non-shared repository
1237
1237
        if not self.bzrdir_format.is_supported():
1238
1238
            # unsupported formats are not loopback testable
1239
1239
            # because the default open will not open them and
1243
1243
        made_control = self.bzrdir_format.initialize(t.base)
1244
1244
        made_repo = made_control.create_repository(shared=False)
1245
1245
        self.assertFalse(made_repo.is_shared())
1246
 
        
 
1246
 
1247
1247
    def test_open_repository(self):
1248
1248
        if not self.bzrdir_format.is_supported():
1249
1249
            # unsupported formats are not loopback testable
1272
1272
        made_tree = self.createWorkingTreeOrSkip(made_control)
1273
1273
        self.failUnless(isinstance(made_tree, workingtree.WorkingTree))
1274
1274
        self.assertEqual(made_control, made_tree.bzrdir)
1275
 
        
 
1275
 
1276
1276
    def test_create_workingtree_revision(self):
1277
1277
        # a bzrdir can construct a working tree for itself @ a specific revision.
1278
1278
        t = self.get_transport()
1289
1289
        except errors.NotLocalUrl:
1290
1290
            raise TestSkipped("Can't make working tree on transport %r" % t)
1291
1291
        self.assertEqual(['a'], made_tree.get_parent_ids())
1292
 
        
 
1292
 
1293
1293
    def test_open_workingtree(self):
1294
1294
        if not self.bzrdir_format.is_supported():
1295
1295
            # unsupported formats are not loopback testable
1397
1397
            self.get_url('intermediate/child'))
1398
1398
        try:
1399
1399
            child_repo = innermost_control.open_repository()
1400
 
            # if there is a repository, then the format cannot ever hit this 
 
1400
            # if there is a repository, then the format cannot ever hit this
1401
1401
            # code path.
1402
1402
            return
1403
1403
        except errors.NoRepositoryPresent:
1418
1418
        made_control = self.bzrdir_format.initialize(url)
1419
1419
        try:
1420
1420
            child_repo = made_control.open_repository()
1421
 
            # if there is a repository, then the format cannot ever hit this 
 
1421
            # if there is a repository, then the format cannot ever hit this
1422
1422
            # code path.
1423
1423
            return
1424
1424
        except errors.NoRepositoryPresent:
1426
1426
        found_repo = made_control.find_repository()
1427
1427
        self.assertEqual(repo.bzrdir.root_transport.base,
1428
1428
                         found_repo.bzrdir.root_transport.base)
1429
 
        
 
1429
 
1430
1430
    def test_find_repository_standalone_with_containing_shared_repository(self):
1431
1431
        # find repo inside a standalone repo inside a shared repo finds the standalone repo
1432
1432
        try:
1459
1459
                            containing_repo.bzrdir.root_transport.base)
1460
1460
 
1461
1461
    def test_find_repository_with_nested_dirs_works(self):
1462
 
        # find repo inside a bzrdir inside a bzrdir inside a shared repo 
 
1462
        # find repo inside a bzrdir inside a bzrdir inside a shared repo
1463
1463
        # finds the outer shared repo.
1464
1464
        try:
1465
1465
            repo = self.make_repository('.', shared=True)
1472
1472
        made_control = self.bzrdir_format.initialize(url)
1473
1473
        try:
1474
1474
            child_repo = made_control.open_repository()
1475
 
            # if there is a repository, then the format cannot ever hit this 
 
1475
            # if there is a repository, then the format cannot ever hit this
1476
1476
            # code path.
1477
1477
            return
1478
1478
        except errors.NoRepositoryPresent:
1481
1481
            self.get_url('intermediate/child'))
1482
1482
        try:
1483
1483
            child_repo = innermost_control.open_repository()
1484
 
            # if there is a repository, then the format cannot ever hit this 
 
1484
            # if there is a repository, then the format cannot ever hit this
1485
1485
            # code path.
1486
1486
            return
1487
1487
        except errors.NoRepositoryPresent:
1489
1489
        found_repo = innermost_control.find_repository()
1490
1490
        self.assertEqual(repo.bzrdir.root_transport.base,
1491
1491
                         found_repo.bzrdir.root_transport.base)
1492
 
        
 
1492
 
1493
1493
    def test_can_and_needs_format_conversion(self):
1494
1494
        # check that we can ask an instance if its upgradable
1495
1495
        dir = self.make_bzrdir('.')
1496
1496
        if dir.can_convert_format():
1497
 
            # if its default updatable there must be an updater 
 
1497
            # if its default updatable there must be an updater
1498
1498
            # (we force the latest known format as downgrades may not be
1499
1499
            # available
1500
1500
            self.assertTrue(isinstance(dir._format.get_converter(
1512
1512
        new_path = urlutils.local_path_from_url(new_url)
1513
1513
        self.failUnlessExists(old_path)
1514
1514
        self.failUnlessExists(new_path)
1515
 
        for (((dir_relpath1, _), entries1), 
 
1515
        for (((dir_relpath1, _), entries1),
1516
1516
             ((dir_relpath2, _), entries2)) in izip(
1517
 
                osutils.walkdirs(old_path), 
 
1517
                osutils.walkdirs(old_path),
1518
1518
                osutils.walkdirs(new_path)):
1519
1519
            self.assertEquals(dir_relpath1, dir_relpath2)
1520
1520
            for f1, f2 in zip(entries1, entries2):
1531
1531
        dir.create_branch()
1532
1532
        self.createWorkingTreeOrSkip(dir)
1533
1533
        if dir.can_convert_format():
1534
 
            # if its default updatable there must be an updater 
 
1534
            # if its default updatable there must be an updater
1535
1535
            # (we force the latest known format as downgrades may not be
1536
1536
            # available
1537
1537
            pb = ui.ui_factory.nested_progress_bar()
1567
1567
            transport=transport)
1568
1568
        self.failUnless(transport.has('.bzr'))
1569
1569
        self.assertRaises((errors.FileExists, errors.DirectoryNotEmpty),
1570
 
            bd.retire_bzrdir, limit=0) 
 
1570
            bd.retire_bzrdir, limit=0)
1571
1571
 
1572
1572
 
1573
1573
class TestBreakLock(TestCaseWithBzrDir):
1662
1662
        self.assertRaises(errors.LockBroken, master.unlock)
1663
1663
 
1664
1664
    def test_break_lock_tree(self):
1665
 
        # break lock with a tree should unlock the tree but not try the 
1666
 
        # branch explicitly. However this is very hard to test for as we 
1667
 
        # dont have a tree reference class, nor is one needed; 
 
1665
        # break lock with a tree should unlock the tree but not try the
 
1666
        # branch explicitly. However this is very hard to test for as we
 
1667
        # dont have a tree reference class, nor is one needed;
1668
1668
        # the worst case if this code unlocks twice is an extra question
1669
1669
        # being asked.
1670
1670
        tree = self.make_branch_and_tree('.')
1708
1708
class ChrootedBzrDirTests(ChrootedTestCase):
1709
1709
 
1710
1710
    def test_find_repository_no_repository(self):
1711
 
        # loopback test to check the current format fails to find a 
 
1711
        # loopback test to check the current format fails to find a
1712
1712
        # share repository correctly.
1713
1713
        if not self.bzrdir_format.is_supported():
1714
1714
            # unsupported formats are not loopback testable
1723
1723
        made_control = self.bzrdir_format.initialize(self.get_url('subdir'))
1724
1724
        try:
1725
1725
            repo = made_control.open_repository()
1726
 
            # if there is a repository, then the format cannot ever hit this 
 
1726
            # if there is a repository, then the format cannot ever hit this
1727
1727
            # code path.
1728
1728
            return
1729
1729
        except errors.NoRepositoryPresent: