/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

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

Merge disable-medusa-for-python-2.6 into pyftpdlib

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/bzrdir_implementations/test_bzrdir.py
126
126
                for rev_id in left_repo.all_revision_ids():
127
127
                    self.assertEqual(left_repo.get_revision(rev_id),
128
128
                        right_repo.get_revision(rev_id))
129
 
                # inventories
130
 
                left_inv_weave = left_repo.inventories
131
 
                right_inv_weave = right_repo.inventories
132
 
                self.assertEqual(set(left_inv_weave.keys()),
133
 
                    set(right_inv_weave.keys()))
134
 
                # XXX: currently this does not handle indirectly referenced
135
 
                # inventories (e.g. where the inventory is a delta basis for
136
 
                # one that is fully present but that the revid for that
137
 
                # inventory is not yet present.)
138
 
                self.assertEqual(set(left_inv_weave.keys()),
139
 
                    set(left_repo.revisions.keys()))
140
 
                left_trees = left_repo.revision_trees(all_revs)
141
 
                right_trees = right_repo.revision_trees(all_revs)
142
 
                for left_tree, right_tree in izip(left_trees, right_trees):
143
 
                    self.assertEqual(left_tree.inventory, right_tree.inventory)
 
129
                # Assert the revision trees (and thus the inventories) are equal
 
130
                sort_key = lambda rev_tree: rev_tree.get_revision_id()
 
131
                rev_trees_a = sorted(
 
132
                    left_repo.revision_trees(all_revs), key=sort_key)
 
133
                rev_trees_b = sorted(
 
134
                    right_repo.revision_trees(all_revs), key=sort_key)
 
135
                for tree_a, tree_b in zip(rev_trees_a, rev_trees_b):
 
136
                    self.assertEqual([], list(tree_a.iter_changes(tree_b)))
144
137
                # texts
145
138
                text_index = left_repo._generate_text_key_index()
146
139
                self.assertEqual(text_index,
178
171
            raise TestSkipped("bzrdir on transport %r has no working tree"
179
172
                              % a_bzrdir.transport)
180
173
 
 
174
    def openWorkingTreeIfLocal(self, a_bzrdir):
 
175
        """If a_bzrdir is on a local transport, call open_workingtree() on it.
 
176
        """
 
177
        if not isinstance(a_bzrdir.root_transport, LocalTransport):
 
178
            # it's not local, but that's ok
 
179
            return
 
180
        a_bzrdir.open_workingtree()
 
181
 
181
182
    def createWorkingTreeOrSkip(self, a_bzrdir):
182
183
        """Create a working tree on a_bzrdir, or raise TestSkipped.
183
184
 
553
554
        # Ensure no format data is cached
554
555
        a_dir = bzrlib.branch.Branch.open_from_transport(
555
556
            self.get_transport('source')).bzrdir
556
 
        target_transport = a_dir.root_transport.clone('..').clone('target')
 
557
        target_transport = self.get_transport('target')
557
558
        target_bzrdir = a_dir.clone_on_transport(target_transport)
558
559
        target_repo = target_bzrdir.open_repository()
559
560
        source_branch = bzrlib.branch.Branch.open(
655
656
 
656
657
    def test_clone_respects_stacked(self):
657
658
        branch = self.make_branch('parent')
658
 
        child_transport = branch.bzrdir.root_transport.clone('../child')
 
659
        child_transport = self.get_transport('child')
659
660
        child = branch.bzrdir.clone_on_transport(child_transport,
660
661
                                                 stacked_on=branch.base)
661
662
        self.assertEqual(child.open_branch().get_stacked_on_url(), branch.base)
688
689
 
689
690
    def test_sprout_bzrdir_empty(self):
690
691
        dir = self.make_bzrdir('source')
691
 
        target = self.sproutOrSkip(dir, self.get_url('target'))
 
692
        target = dir.sprout(self.get_url('target'))
692
693
        self.assertNotEqual(dir.transport.base, target.transport.base)
693
694
        # creates a new repository branch and tree
694
695
        target.open_repository()
695
696
        target.open_branch()
696
 
        target.open_workingtree()
 
697
        self.openWorkingTreeIfLocal(target)
697
698
 
698
699
    def test_sprout_bzrdir_empty_under_shared_repo(self):
699
700
        # sprouting an empty dir into a repo uses the repo
702
703
            self.make_repository('target', shared=True)
703
704
        except errors.IncompatibleFormat:
704
705
            return
705
 
        target = self.sproutOrSkip(dir, self.get_url('target/child'))
 
706
        target = dir.sprout(self.get_url('target/child'))
706
707
        self.assertRaises(errors.NoRepositoryPresent, target.open_repository)
707
708
        target.open_branch()
708
709
        try:
720
721
            self.make_repository('target', shared=True)
721
722
        except errors.IncompatibleFormat:
722
723
            return
723
 
        target = self.sproutOrSkip(dir, self.get_url('target/child'),
724
 
                                   force_new_repo=True)
 
724
        target = dir.sprout(self.get_url('target/child'), force_new_repo=True)
725
725
        target.open_repository()
726
726
        target.open_branch()
727
 
        target.open_workingtree()
 
727
        self.openWorkingTreeIfLocal(target)
728
728
 
729
729
    def test_sprout_bzrdir_repository(self):
730
730
        tree = self.make_branch_and_tree('commit_tree')
741
741
                dir.open_branch().last_revision())))
742
742
        except errors.NotBranchError:
743
743
            pass
744
 
        target = self.sproutOrSkip(dir, self.get_url('target'))
 
744
        target = dir.sprout(self.get_url('target'))
745
745
        self.assertNotEqual(dir.transport.base, target.transport.base)
746
746
        # testing inventory isn't reasonable for repositories
747
747
        self.assertDirectoriesEqual(dir.root_transport, target.root_transport,
779
779
            shared_repo = self.make_repository('target', shared=True)
780
780
        except errors.IncompatibleFormat:
781
781
            return
782
 
        target = self.sproutOrSkip(dir, self.get_url('target/child'))
 
782
        target = dir.sprout(self.get_url('target/child'))
783
783
        self.assertNotEqual(dir.transport.base, target.transport.base)
784
784
        self.assertTrue(shared_repo.has_revision('1'))
785
785
 
798
798
        tree.branch.repository.copy_content_into(shared_repo)
799
799
        dir = self.make_bzrdir('shared/source')
800
800
        dir.create_branch()
801
 
        target = self.sproutOrSkip(dir, self.get_url('shared/target'))
 
801
        target = dir.sprout(self.get_url('shared/target'))
802
802
        self.assertNotEqual(dir.transport.base, target.transport.base)
803
803
        self.assertNotEqual(dir.transport.base, shared_repo.bzrdir.transport.base)
804
804
        self.assertTrue(shared_repo.has_revision('1'))
822
822
        self.assertTrue(shared_repo.has_revision('1'))
823
823
        dir = self.make_bzrdir('shared/source')
824
824
        dir.create_branch()
825
 
        target = self.sproutOrSkip(dir, self.get_url('target'))
 
825
        target = dir.sprout(self.get_url('target'))
826
826
        self.assertNotEqual(dir.transport.base, target.transport.base)
827
827
        self.assertNotEqual(dir.transport.base, shared_repo.bzrdir.transport.base)
828
828
        branch = target.open_branch()
846
846
            shared_repo = self.make_repository('target', shared=True)
847
847
        except errors.IncompatibleFormat:
848
848
            return
849
 
        target = self.sproutOrSkip(dir, self.get_url('target/child'),
850
 
                                   force_new_repo=True)
 
849
        target = dir.sprout(self.get_url('target/child'), force_new_repo=True)
851
850
        self.assertNotEqual(dir.transport.base, target.transport.base)
852
851
        self.assertFalse(shared_repo.has_revision('1'))
853
852
 
878
877
        tree.branch.repository.copy_content_into(source.repository)
879
878
        tree.bzrdir.open_branch().copy_content_into(source)
880
879
        dir = source.bzrdir
881
 
        target = self.sproutOrSkip(dir, self.get_url('target'))
 
880
        target = dir.sprout(self.get_url('target'))
882
881
        self.assertNotEqual(dir.transport.base, target.transport.base)
 
882
        target_repo = target.open_repository()
 
883
        self.assertRepositoryHasSameItems(source.repository, target_repo)
883
884
        self.assertDirectoriesEqual(dir.root_transport, target.root_transport,
884
885
                                    [
885
886
                                     './.bzr/basis-inventory-cache',
890
891
                                     './.bzr/checkout/stat-cache',
891
892
                                     './.bzr/inventory',
892
893
                                     './.bzr/parent',
893
 
                                     './.bzr/repository/inventory.knit',
 
894
                                     './.bzr/repository',
894
895
                                     './.bzr/stat-cache',
895
896
                                     './foo',
896
897
                                     ])
910
911
            shared_repo = self.make_repository('target', shared=True)
911
912
        except errors.IncompatibleFormat:
912
913
            return
913
 
        target = self.sproutOrSkip(dir, self.get_url('target/child'))
 
914
        target = dir.sprout(self.get_url('target/child'))
914
915
        self.assertTrue(shared_repo.has_revision('1'))
915
916
 
916
917
    def test_sprout_bzrdir_branch_and_repo_shared_force_new_repo(self):
928
929
            shared_repo = self.make_repository('target', shared=True)
929
930
        except errors.IncompatibleFormat:
930
931
            return
931
 
        target = self.sproutOrSkip(dir, self.get_url('target/child'),
932
 
                                   force_new_repo=True)
 
932
        target = dir.sprout(self.get_url('target/child'), force_new_repo=True)
933
933
        self.assertNotEqual(dir.transport.base, target.transport.base)
934
934
        self.assertFalse(shared_repo.has_revision('1'))
935
935
 
936
936
    def test_sprout_bzrdir_branch_reference(self):
937
937
        # sprouting should create a repository if needed and a sprouted branch.
938
 
        referenced_branch = self.make_branch('referencced')
 
938
        referenced_branch = self.make_branch('referenced')
939
939
        dir = self.make_bzrdir('source')
940
940
        try:
941
941
            reference = bzrlib.branch.BranchReferenceFormat().initialize(dir,
944
944
            # this is ok too, not all formats have to support references.
945
945
            return
946
946
        self.assertRaises(errors.NoRepositoryPresent, dir.open_repository)
947
 
        target = self.sproutOrSkip(dir, self.get_url('target'))
 
947
        target = dir.sprout(self.get_url('target'))
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)
968
968
            shared_repo = self.make_repository('target', shared=True)
969
969
        except errors.IncompatibleFormat:
970
970
            return
971
 
        target = self.sproutOrSkip(dir, self.get_url('target/child'))
 
971
        target = dir.sprout(self.get_url('target/child'))
972
972
        self.assertNotEqual(dir.transport.base, target.transport.base)
973
973
        # we want target to have a branch that is in-place.
974
974
        self.assertEqual(target, target.open_branch().bzrdir)
994
994
            shared_repo = self.make_repository('target', shared=True)
995
995
        except errors.IncompatibleFormat:
996
996
            return
997
 
        target = self.sproutOrSkip(dir, self.get_url('target/child'),
998
 
                                   force_new_repo=True)
 
997
        target = dir.sprout(self.get_url('target/child'), force_new_repo=True)
999
998
        self.assertNotEqual(dir.transport.base, target.transport.base)
1000
999
        # we want target to have a branch that is in-place.
1001
1000
        self.assertEqual(target, target.open_branch().bzrdir)
1018
1017
        tree.branch.repository.copy_content_into(source.repository)
1019
1018
        tree.bzrdir.open_branch().copy_content_into(source)
1020
1019
        dir = source.bzrdir
1021
 
        target = self.sproutOrSkip(dir, self.get_url('target'), revision_id='1')
 
1020
        target = dir.sprout(self.get_url('target'), revision_id='1')
1022
1021
        self.assertEqual('1', target.open_branch().last_revision())
1023
1022
 
1024
1023
    def test_sprout_bzrdir_tree_branch_repo(self):
1059
1058
        tree = self.createWorkingTreeOrSkip(dir)
1060
1059
        self.build_tree(['source/subdir/'])
1061
1060
        tree.add('subdir')
1062
 
        target = self.sproutOrSkip(dir, self.get_url('target'))
 
1061
        target = dir.sprout(self.get_url('target'))
1063
1062
        self.assertNotEqual(dir.transport.base, target.transport.base)
1064
1063
        # we want target to have a branch that is in-place.
1065
1064
        self.assertEqual(target, target.open_branch().bzrdir)
1133
1132
        tree.commit('revision 2', rev_id='2', allow_pointless=True)
1134
1133
        dir = tree.bzrdir
1135
1134
        if isinstance(dir, (bzrdir.BzrDirPreSplitOut,)):
1136
 
            self.assertRaises(errors.MustHaveWorkingTree, self.sproutOrSkip,
1137
 
                              dir, self.get_url('target'),
 
1135
            self.assertRaises(errors.MustHaveWorkingTree, dir.sprout,
 
1136
                              self.get_url('target'),
1138
1137
                              create_tree_if_local=False)
1139
1138
            return
1140
 
        target = self.sproutOrSkip(dir, self.get_url('target'),
1141
 
                                   create_tree_if_local=False)
 
1139
        target = dir.sprout(self.get_url('target'), create_tree_if_local=False)
1142
1140
        self.failIfExists('target/foo')
1143
1141
        self.assertEqual(tree.branch.last_revision(),
1144
1142
                         target.open_branch().last_revision())
1165
1163
                         opened_dir._format)
1166
1164
        self.failUnless(isinstance(opened_dir, bzrdir.BzrDir))
1167
1165
 
 
1166
    def test_format_network_name(self):
 
1167
        # All control formats must have a network name.
 
1168
        dir = self.make_bzrdir('.')
 
1169
        format = dir._format
 
1170
        # We want to test that the network_name matches the actual format on
 
1171
        # disk. For local control dirsthat means that using network_name as a
 
1172
        # key in the registry gives back the same format. For remote obects
 
1173
        # we check that the network_name of the RemoteBzrDirFormat we have
 
1174
        # locally matches the actual format present on disk.
 
1175
        if isinstance(format, bzrdir.RemoteBzrDirFormat):
 
1176
            dir._ensure_real()
 
1177
            real_dir = dir._real_bzrdir
 
1178
            network_name = format.network_name()
 
1179
            self.assertEqual(real_dir._format.network_name(), network_name)
 
1180
        else:
 
1181
            registry = bzrdir.network_format_registry
 
1182
            network_name = format.network_name()
 
1183
            looked_up_format = registry.get(network_name)
 
1184
            self.assertEqual(format.__class__, looked_up_format.__class__)
 
1185
        # The network name must be a byte string.
 
1186
        self.assertIsInstance(network_name, str)
 
1187
 
1168
1188
    def test_open_not_bzrdir(self):
1169
1189
        # test the formats specific behaviour for no-content or similar dirs.
1170
1190
        self.assertRaises(NotBranchError,