/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/per_repository/test_repository.py

  • Committer: Vincent Ladeuil
  • Date: 2011-11-24 15:48:29 UTC
  • mfrom: (6289 +trunk)
  • mto: This revision was merged to the branch mainline in revision 6337.
  • Revision ID: v.ladeuil+lp@free.fr-20111124154829-avowjpsxdl8yp2vz
merge trunk resolving conflicts

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/per_repository/test_repository.py
21
21
 
22
22
from bzrlib import (
23
23
    branch as _mod_branch,
24
 
    bzrdir,
 
24
    controldir,
25
25
    delta as _mod_delta,
26
26
    errors,
27
27
    gpg,
68
68
        """Test the format.fast_deltas attribute."""
69
69
        self.assertFormatAttribute('fast_deltas', (True, False))
70
70
 
 
71
    def test_attribute_supports_nesting_repositories(self):
 
72
        """Test the format.supports_nesting_repositories."""
 
73
        self.assertFormatAttribute('supports_nesting_repositories',
 
74
            (True, False))
 
75
 
 
76
    def test_attribute_supports_unreferenced_revisions(self):
 
77
        """Test the format.supports_unreferenced_revisions."""
 
78
        self.assertFormatAttribute('supports_unreferenced_revisions',
 
79
            (True, False))
 
80
 
71
81
    def test_attribute__fetch_reconcile(self):
72
82
        """Test the _fetch_reconcile attribute."""
73
83
        self.assertFormatAttribute('_fetch_reconcile', (True, False))
150
160
        made_repo = self.repository_format.initialize(made_control)
151
161
        self.assertEqual(made_control, made_repo.bzrdir)
152
162
 
153
 
        # find it via bzrdir opening:
154
 
        opened_control = bzrdir.BzrDir.open(readonly_t.base)
 
163
        # find it via controldir opening:
 
164
        opened_control = controldir.ControlDir.open(readonly_t.base)
155
165
        direct_opened_repo = opened_control.open_repository()
156
166
        self.assertEqual(direct_opened_repo.__class__, made_repo.__class__)
157
167
        self.assertEqual(opened_control, direct_opened_repo.bzrdir)
277
287
        self.assertIsInstance(delta, _mod_delta.TreeDelta)
278
288
        self.assertEqual([('vla', 'file2', 'file')], delta.added)
279
289
 
280
 
    def test_get_revision_delta_filtered(self):
281
 
        tree_a = self.make_branch_and_tree('a')
282
 
        self.build_tree(['a/foo', 'a/bar/', 'a/bar/b1', 'a/bar/b2', 'a/baz'])
283
 
        tree_a.add(['foo', 'bar', 'bar/b1', 'bar/b2', 'baz'],
284
 
                   ['foo-id', 'bar-id', 'b1-id', 'b2-id', 'baz-id'])
285
 
        tree_a.commit('rev1', rev_id='rev1')
286
 
        self.build_tree(['a/bar/b3'])
287
 
        tree_a.add('bar/b3', 'b3-id')
288
 
        tree_a.commit('rev2', rev_id='rev2')
289
 
 
290
 
        # Test multiple files
291
 
        delta = tree_a.branch.repository.get_revision_delta('rev1',
292
 
            specific_fileids=['foo-id', 'baz-id'])
293
 
        self.assertIsInstance(delta, _mod_delta.TreeDelta)
294
 
        self.assertEqual([
295
 
            ('baz', 'baz-id', 'file'),
296
 
            ('foo', 'foo-id', 'file'),
297
 
            ], delta.added)
298
 
        # Test a directory
299
 
        delta = tree_a.branch.repository.get_revision_delta('rev1',
300
 
            specific_fileids=['bar-id'])
301
 
        self.assertIsInstance(delta, _mod_delta.TreeDelta)
302
 
        self.assertEqual([
303
 
            ('bar', 'bar-id', 'directory'),
304
 
            ('bar/b1', 'b1-id', 'file'),
305
 
            ('bar/b2', 'b2-id', 'file'),
306
 
            ], delta.added)
307
 
        # Test a file in a directory
308
 
        delta = tree_a.branch.repository.get_revision_delta('rev1',
309
 
            specific_fileids=['b2-id'])
310
 
        self.assertIsInstance(delta, _mod_delta.TreeDelta)
311
 
        self.assertEqual([
312
 
            ('bar', 'bar-id', 'directory'),
313
 
            ('bar/b2', 'b2-id', 'file'),
314
 
            ], delta.added)
315
 
        # Try another revision
316
 
        delta = tree_a.branch.repository.get_revision_delta('rev2',
317
 
                specific_fileids=['b3-id'])
318
 
        self.assertIsInstance(delta, _mod_delta.TreeDelta)
319
 
        self.assertEqual([
320
 
            ('bar', 'bar-id', 'directory'),
321
 
            ('bar/b3', 'b3-id', 'file'),
322
 
            ], delta.added)
323
 
        delta = tree_a.branch.repository.get_revision_delta('rev2',
324
 
                specific_fileids=['foo-id'])
325
 
        self.assertIsInstance(delta, _mod_delta.TreeDelta)
326
 
        self.assertEqual([], delta.added)
327
 
 
328
290
    def test_clone_bzrdir_repository_revision(self):
329
291
        # make a repository with some revisions,
330
292
        # and clone it, this should not have unreferenced revisions.
347
309
            return
348
310
        try:
349
311
            made_repo.set_make_working_trees(False)
350
 
        except NotImplementedError:
 
312
        except errors.UnsupportedOperation:
351
313
            # the repository does not support having its tree-making flag
352
314
            # toggled.
353
315
            return
360
322
        self.assertFalse(result.open_repository().make_working_trees())
361
323
 
362
324
    def test_upgrade_preserves_signatures(self):
 
325
        if not self.repository_format.supports_revision_signatures:
 
326
            raise tests.TestNotApplicable(
 
327
                "repository does not support signing revisions")
363
328
        wt = self.make_branch_and_tree('source')
364
329
        wt.commit('A', allow_pointless=True, rev_id='A')
365
330
        repo = wt.branch.repository
369
334
            repo.sign_revision('A', gpg.LoopbackGPGStrategy(None))
370
335
        except errors.UnsupportedOperation:
371
336
            self.assertFalse(repo._format.supports_revision_signatures)
372
 
            raise TestNotApplicable("signatures not supported by repository format")
 
337
            raise tests.TestNotApplicable("signatures not supported by repository format")
373
338
        repo.commit_write_group()
374
339
        repo.unlock()
375
340
        old_signature = repo.get_signature_text('A')
376
341
        try:
377
 
            old_format = bzrdir.BzrDirFormat.get_default_format()
 
342
            old_format = controldir.ControlDirFormat.get_default_format()
378
343
            # This gives metadir branches something they can convert to.
379
344
            # it would be nice to have a 'latest' vs 'default' concept.
380
 
            format = bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
 
345
            format = controldir.format_registry.make_bzrdir(
 
346
                'dirstate-with-subtree')
381
347
            upgrade.upgrade(repo.bzrdir.root_transport.base, format=format)
382
348
        except errors.UpToDateFormat:
383
349
            # this is in the most current format already.
598
564
                'This might be a signature')
599
565
 
600
566
    # XXX: this helper duplicated from tests.test_repository
601
 
    def make_remote_repository(self, path, shared=False):
 
567
    def make_remote_repository(self, path, shared=None):
602
568
        """Make a RemoteRepository object backed by a real repository that will
603
569
        be created at the given path."""
604
570
        repo = self.make_repository(path, shared=shared)
605
571
        smart_server = test_server.SmartTCPServer_for_testing()
606
572
        self.start_server(smart_server, self.get_server())
607
 
        remote_transport = transport.get_transport(
 
573
        remote_transport = transport.get_transport_from_url(
608
574
            smart_server.get_url()).clone(path)
609
 
        remote_bzrdir = bzrdir.BzrDir.open_from_transport(remote_transport)
 
575
        if not repo.bzrdir._format.supports_transport(remote_transport):
 
576
            raise tests.TestNotApplicable(
 
577
                "format does not support transport")
 
578
        remote_bzrdir = controldir.ControlDir.open_from_transport(
 
579
            remote_transport)
610
580
        remote_repo = remote_bzrdir.open_repository()
611
581
        return remote_repo
612
582
 
619
589
        except errors.TransportNotPossible:
620
590
            raise tests.TestNotApplicable(
621
591
                "Cannot lock_read old formats like AllInOne over HPSS.")
622
 
        remote_backing_repo = bzrdir.BzrDir.open(
 
592
        remote_backing_repo = controldir.ControlDir.open(
623
593
            self.get_vfs_only_url('remote')).open_repository()
624
 
        self.assertEqual(remote_backing_repo._format, local_repo._format)
 
594
        self.assertEqual(
 
595
            remote_backing_repo._format.network_name(),
 
596
            local_repo._format.network_name())
625
597
 
626
598
    def test_sprout_branch_from_hpss_preserves_repo_format(self):
627
599
        """branch.sprout from a smart server preserves the repository format.
637
609
            raise tests.TestNotApplicable(
638
610
                "Cannot lock_read old formats like AllInOne over HPSS.")
639
611
        local_repo = local_bzrdir.open_repository()
640
 
        remote_backing_repo = bzrdir.BzrDir.open(
 
612
        remote_backing_repo = controldir.ControlDir.open(
641
613
            self.get_vfs_only_url('remote')).open_repository()
642
614
        self.assertEqual(remote_backing_repo._format, local_repo._format)
643
615
 
650
622
                "Format can not be used over HPSS")
651
623
        # Make a shared repo
652
624
        remote_repo = self.make_remote_repository('remote', shared=True)
653
 
        remote_backing_repo = bzrdir.BzrDir.open(
 
625
        remote_backing_repo = controldir.ControlDir.open(
654
626
            self.get_vfs_only_url('remote')).open_repository()
655
627
        # Make a branch in that repo in an old format that isn't the default
656
628
        # branch format for the repo.
658
630
        format = remote_backing_repo.bzrdir.cloning_metadir()
659
631
        format._branch_format = BzrBranchFormat5()
660
632
        remote_transport = remote_repo.bzrdir.root_transport.clone('branch')
661
 
        remote_backing_repo.bzrdir.create_branch_convenience(
 
633
        controldir.ControlDir.create_branch_convenience(
662
634
            remote_transport.base, force_new_repo=False, format=format)
663
 
        remote_branch = bzrdir.BzrDir.open_from_transport(
 
635
        remote_branch = controldir.ControlDir.open_from_transport(
664
636
            remote_transport).open_branch()
665
637
        try:
666
638
            local_bzrdir = remote_branch.bzrdir.sprout('local')
691
663
        except errors.IncompatibleFormat:
692
664
            raise tests.TestNotApplicable('Cannot make a shared repository')
693
665
        if repo.bzrdir._format.fixed_components:
694
 
            raise tests.KnownFailure(
 
666
            self.knownFailure(
695
667
                "pre metadir branches do not upgrade on push "
696
668
                "with stacking policy")
697
669
        if isinstance(repo._format,
747
719
        repo = self.make_repository('repo')
748
720
        repo._make_parents_provider().get_parent_map
749
721
 
750
 
    def make_repository_and_foo_bar(self, shared):
 
722
    def make_repository_and_foo_bar(self, shared=None):
751
723
        made_control = self.make_bzrdir('repository')
752
724
        repo = made_control.create_repository(shared=shared)
753
 
        bzrdir.BzrDir.create_branch_convenience(self.get_url('repository/foo'),
754
 
                                                force_new_repo=False)
755
 
        bzrdir.BzrDir.create_branch_convenience(self.get_url('repository/bar'),
756
 
                                                force_new_repo=True)
 
725
        if not repo._format.supports_nesting_repositories:
 
726
            raise tests.TestNotApplicable("repository does not support "
 
727
                "nesting repositories")
 
728
        controldir.ControlDir.create_branch_convenience(
 
729
            self.get_url('repository/foo'), force_new_repo=False)
 
730
        controldir.ControlDir.create_branch_convenience(
 
731
            self.get_url('repository/bar'), force_new_repo=True)
757
732
        baz = self.make_bzrdir('repository/baz')
758
733
        qux = self.make_branch('repository/baz/qux')
759
734
        quxx = self.make_branch('repository/baz/qux/quxx')
760
735
        return repo
761
736
 
762
737
    def test_find_branches(self):
763
 
        repo = self.make_repository_and_foo_bar(shared=False)
 
738
        repo = self.make_repository_and_foo_bar()
764
739
        branches = repo.find_branches()
765
740
        self.assertContainsRe(branches[-1].base, 'repository/foo/$')
766
741
        self.assertContainsRe(branches[-3].base, 'repository/baz/qux/$')
789
764
 
790
765
    def test_find_branches_using_standalone(self):
791
766
        branch = self.make_branch('branch')
 
767
        if not branch.repository._format.supports_nesting_repositories:
 
768
            raise tests.TestNotApplicable("format does not support nesting "
 
769
                "repositories")
792
770
        contained = self.make_branch('branch/contained')
793
771
        branches = branch.repository.find_branches(using=True)
794
772
        self.assertEqual([branch.base], [b.base for b in branches])
797
775
                         [b.base for b in branches])
798
776
 
799
777
    def test_find_branches_using_empty_standalone_repo(self):
800
 
        repo = self.make_repository('repo')
801
 
        self.assertFalse(repo.is_shared())
 
778
        try:
 
779
            repo = self.make_repository('repo', shared=False)
 
780
        except errors.IncompatibleFormat:
 
781
            raise tests.TestNotApplicable("format does not support standalone "
 
782
                "repositories")
802
783
        try:
803
784
            repo.bzrdir.open_branch()
804
785
        except errors.NotBranchError:
811
792
        repo = self.make_repository('repo')
812
793
        try:
813
794
            repo.set_make_working_trees(True)
814
 
        except errors.RepositoryUpgradeRequired, e:
 
795
        except (errors.RepositoryUpgradeRequired, errors.UnsupportedOperation), e:
815
796
            raise tests.TestNotApplicable('Format does not support this flag.')
816
797
        self.assertTrue(repo.make_working_trees())
817
798
 
819
800
        repo = self.make_repository('repo')
820
801
        try:
821
802
            repo.set_make_working_trees(False)
822
 
        except errors.RepositoryUpgradeRequired, e:
 
803
        except (errors.RepositoryUpgradeRequired, errors.UnsupportedOperation), e:
823
804
            raise tests.TestNotApplicable('Format does not support this flag.')
824
805
        self.assertFalse(repo.make_working_trees())
825
806
 
923
904
        wt.add(['foo'], [FOO_ID])
924
905
        wt.commit('this is my new commit', rev_id=REV_ID)
925
906
        # now access over vfat; should be safe
926
 
        branch = bzrdir.BzrDir.open(self.get_url('repo')).open_branch()
 
907
        branch = controldir.ControlDir.open(self.get_url('repo')).open_branch()
927
908
        revtree = branch.repository.revision_tree(REV_ID)
928
909
        revtree.lock_read()
929
910
        self.addCleanup(revtree.unlock)
947
928
        repo = self.make_repository('repo')
948
929
        self.assertIsInstance(repo.user_url, str)
949
930
        self.assertEqual(repo.user_url, repo.user_transport.base)
950
 
        # for all current bzrdir implementations the user dir must be 
 
931
        # for all current bzrdir implementations the user dir must be
951
932
        # above the control dir but we might need to relax that?
952
933
        self.assertEqual(repo.control_url.find(repo.user_url), 0)
953
934
        self.assertEqual(repo.control_url, repo.control_transport.base)
 
935
 
 
936
 
 
937
class TestDeltaRevisionFiltered(per_repository.TestCaseWithRepository):
 
938
 
 
939
    def setUp(self):
 
940
        super(TestDeltaRevisionFiltered, self).setUp()
 
941
        tree_a = self.make_branch_and_tree('a')
 
942
        self.build_tree(['a/foo', 'a/bar/', 'a/bar/b1', 'a/bar/b2', 'a/baz'])
 
943
        tree_a.add(['foo', 'bar', 'bar/b1', 'bar/b2', 'baz'],
 
944
                   ['foo-id', 'bar-id', 'b1-id', 'b2-id', 'baz-id'])
 
945
        tree_a.commit('rev1', rev_id='rev1')
 
946
        self.build_tree(['a/bar/b3'])
 
947
        tree_a.add('bar/b3', 'b3-id')
 
948
        tree_a.commit('rev2', rev_id='rev2')
 
949
        self.repository = tree_a.branch.repository
 
950
 
 
951
    def test_multiple_files(self):
 
952
        # Test multiple files
 
953
        delta = self.repository.get_revision_delta('rev1',
 
954
            specific_fileids=['foo-id', 'baz-id'])
 
955
        self.assertIsInstance(delta, _mod_delta.TreeDelta)
 
956
        self.assertEqual([
 
957
            ('baz', 'baz-id', 'file'),
 
958
            ('foo', 'foo-id', 'file'),
 
959
            ], delta.added)
 
960
 
 
961
    def test_directory(self):
 
962
        # Test a directory
 
963
        delta = self.repository.get_revision_delta('rev1',
 
964
            specific_fileids=['bar-id'])
 
965
        self.assertIsInstance(delta, _mod_delta.TreeDelta)
 
966
        self.assertEqual([
 
967
            ('bar', 'bar-id', 'directory'),
 
968
            ('bar/b1', 'b1-id', 'file'),
 
969
            ('bar/b2', 'b2-id', 'file'),
 
970
            ], delta.added)
 
971
 
 
972
    def test_unrelated(self):
 
973
        # Try another revision
 
974
        delta = self.repository.get_revision_delta('rev2',
 
975
                specific_fileids=['foo-id'])
 
976
        self.assertIsInstance(delta, _mod_delta.TreeDelta)
 
977
        self.assertEqual([], delta.added)
 
978
 
 
979
    def test_file_in_directory(self):
 
980
        # Test a file in a directory, both of which were added
 
981
        delta = self.repository.get_revision_delta('rev1',
 
982
            specific_fileids=['b2-id'])
 
983
        self.assertIsInstance(delta, _mod_delta.TreeDelta)
 
984
        self.assertEqual([
 
985
            ('bar', 'bar-id', 'directory'),
 
986
            ('bar/b2', 'b2-id', 'file'),
 
987
            ], delta.added)
 
988
 
 
989
    def test_file_in_unchanged_directory(self):
 
990
        delta = self.repository.get_revision_delta('rev2',
 
991
            specific_fileids=['b3-id'])
 
992
        self.assertIsInstance(delta, _mod_delta.TreeDelta)
 
993
        if delta.added == [
 
994
            ('bar', 'bar-id', 'directory'),
 
995
            ('bar/b3', 'b3-id', 'file')]:
 
996
            self.knownFailure("bzr incorrectly reports 'bar' as added - "
 
997
                              "bug 878217")
 
998
        self.assertEqual([
 
999
            ('bar/b3', 'b3-id', 'file'),
 
1000
            ], delta.added)