← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/per_repository/test_repository.py

  • Committer: Jelmer Vernooij
  • Date: 2012-02-20 12:19:29 UTC
  • mfrom: (6437.23.11 2.5)
  • mto: (6581.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 6582.
  • Revision ID: jelmer@samba.org-20120220121929-7ni2psvjoatm1yp4
Merge bzr/2.5.

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)
169
179
        except NotImplementedError:
170
180
            return
171
181
        self.assertEqual(self.repository_format,
172
 
                         repository.RepositoryFormat.find_format(opened_control))
 
182
             repository.RepositoryFormatMetaDir.find_format(opened_control))
173
183
 
174
184
    def test_format_matchingbzrdir(self):
175
185
        self.assertEqual(self.repository_format,
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.
586
552
        b = builder.get_branch()
587
553
        b.lock_write()
588
554
        self.addCleanup(b.unlock)
589
 
        b.repository.start_write_group()
590
 
        self.addCleanup(b.repository.abort_write_group)
591
555
        if b.repository._format.supports_revision_signatures:
 
556
            b.repository.start_write_group()
592
557
            b.repository.add_signature_text('A', 'This might be a signature')
 
558
            b.repository.commit_write_group()
593
559
            self.assertEqual('This might be a signature',
594
560
                             b.repository.get_signature_text('A'))
595
561
        else:
 
562
            b.repository.start_write_group()
 
563
            self.addCleanup(b.repository.abort_write_group)
596
564
            self.assertRaises(errors.UnsupportedOperation,
597
565
                b.repository.add_signature_text, 'A',
598
566
                'This might be a signature')
599
567
 
600
568
    # XXX: this helper duplicated from tests.test_repository
601
 
    def make_remote_repository(self, path, shared=False):
 
569
    def make_remote_repository(self, path, shared=None):
602
570
        """Make a RemoteRepository object backed by a real repository that will
603
571
        be created at the given path."""
604
572
        repo = self.make_repository(path, shared=shared)
606
574
        self.start_server(smart_server, self.get_server())
607
575
        remote_transport = transport.get_transport_from_url(
608
576
            smart_server.get_url()).clone(path)
609
 
        remote_bzrdir = bzrdir.BzrDir.open_from_transport(remote_transport)
 
577
        if not repo.bzrdir._format.supports_transport(remote_transport):
 
578
            raise tests.TestNotApplicable(
 
579
                "format does not support transport")
 
580
        remote_bzrdir = controldir.ControlDir.open_from_transport(
 
581
            remote_transport)
610
582
        remote_repo = remote_bzrdir.open_repository()
611
583
        return remote_repo
612
584
 
619
591
        except errors.TransportNotPossible:
620
592
            raise tests.TestNotApplicable(
621
593
                "Cannot lock_read old formats like AllInOne over HPSS.")
622
 
        remote_backing_repo = bzrdir.BzrDir.open(
 
594
        remote_backing_repo = controldir.ControlDir.open(
623
595
            self.get_vfs_only_url('remote')).open_repository()
624
 
        self.assertEqual(remote_backing_repo._format, local_repo._format)
 
596
        self.assertEqual(
 
597
            remote_backing_repo._format.network_name(),
 
598
            local_repo._format.network_name())
625
599
 
626
600
    def test_sprout_branch_from_hpss_preserves_repo_format(self):
627
601
        """branch.sprout from a smart server preserves the repository format.
637
611
            raise tests.TestNotApplicable(
638
612
                "Cannot lock_read old formats like AllInOne over HPSS.")
639
613
        local_repo = local_bzrdir.open_repository()
640
 
        remote_backing_repo = bzrdir.BzrDir.open(
 
614
        remote_backing_repo = controldir.ControlDir.open(
641
615
            self.get_vfs_only_url('remote')).open_repository()
642
616
        self.assertEqual(remote_backing_repo._format, local_repo._format)
643
617
 
650
624
                "Format can not be used over HPSS")
651
625
        # Make a shared repo
652
626
        remote_repo = self.make_remote_repository('remote', shared=True)
653
 
        remote_backing_repo = bzrdir.BzrDir.open(
 
627
        remote_backing_repo = controldir.ControlDir.open(
654
628
            self.get_vfs_only_url('remote')).open_repository()
655
629
        # Make a branch in that repo in an old format that isn't the default
656
630
        # branch format for the repo.
658
632
        format = remote_backing_repo.bzrdir.cloning_metadir()
659
633
        format._branch_format = BzrBranchFormat5()
660
634
        remote_transport = remote_repo.bzrdir.root_transport.clone('branch')
661
 
        remote_backing_repo.bzrdir.create_branch_convenience(
 
635
        controldir.ControlDir.create_branch_convenience(
662
636
            remote_transport.base, force_new_repo=False, format=format)
663
 
        remote_branch = bzrdir.BzrDir.open_from_transport(
 
637
        remote_branch = controldir.ControlDir.open_from_transport(
664
638
            remote_transport).open_branch()
665
639
        try:
666
640
            local_bzrdir = remote_branch.bzrdir.sprout('local')
747
721
        repo = self.make_repository('repo')
748
722
        repo._make_parents_provider().get_parent_map
749
723
 
750
 
    def make_repository_and_foo_bar(self, shared):
 
724
    def make_repository_and_foo_bar(self, shared=None):
751
725
        made_control = self.make_bzrdir('repository')
752
726
        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)
 
727
        if not repo._format.supports_nesting_repositories:
 
728
            raise tests.TestNotApplicable("repository does not support "
 
729
                "nesting repositories")
 
730
        controldir.ControlDir.create_branch_convenience(
 
731
            self.get_url('repository/foo'), force_new_repo=False)
 
732
        controldir.ControlDir.create_branch_convenience(
 
733
            self.get_url('repository/bar'), force_new_repo=True)
757
734
        baz = self.make_bzrdir('repository/baz')
758
735
        qux = self.make_branch('repository/baz/qux')
759
736
        quxx = self.make_branch('repository/baz/qux/quxx')
760
737
        return repo
761
738
 
762
739
    def test_find_branches(self):
763
 
        repo = self.make_repository_and_foo_bar(shared=False)
 
740
        repo = self.make_repository_and_foo_bar()
764
741
        branches = repo.find_branches()
765
742
        self.assertContainsRe(branches[-1].base, 'repository/foo/$')
766
743
        self.assertContainsRe(branches[-3].base, 'repository/baz/qux/$')
789
766
 
790
767
    def test_find_branches_using_standalone(self):
791
768
        branch = self.make_branch('branch')
 
769
        if not branch.repository._format.supports_nesting_repositories:
 
770
            raise tests.TestNotApplicable("format does not support nesting "
 
771
                "repositories")
792
772
        contained = self.make_branch('branch/contained')
793
773
        branches = branch.repository.find_branches(using=True)
794
774
        self.assertEqual([branch.base], [b.base for b in branches])
797
777
                         [b.base for b in branches])
798
778
 
799
779
    def test_find_branches_using_empty_standalone_repo(self):
800
 
        repo = self.make_repository('repo')
801
 
        self.assertFalse(repo.is_shared())
 
780
        try:
 
781
            repo = self.make_repository('repo', shared=False)
 
782
        except errors.IncompatibleFormat:
 
783
            raise tests.TestNotApplicable("format does not support standalone "
 
784
                "repositories")
802
785
        try:
803
786
            repo.bzrdir.open_branch()
804
787
        except errors.NotBranchError:
811
794
        repo = self.make_repository('repo')
812
795
        try:
813
796
            repo.set_make_working_trees(True)
814
 
        except errors.RepositoryUpgradeRequired, e:
 
797
        except (errors.RepositoryUpgradeRequired, errors.UnsupportedOperation), e:
815
798
            raise tests.TestNotApplicable('Format does not support this flag.')
816
799
        self.assertTrue(repo.make_working_trees())
817
800
 
819
802
        repo = self.make_repository('repo')
820
803
        try:
821
804
            repo.set_make_working_trees(False)
822
 
        except errors.RepositoryUpgradeRequired, e:
 
805
        except (errors.RepositoryUpgradeRequired, errors.UnsupportedOperation), e:
823
806
            raise tests.TestNotApplicable('Format does not support this flag.')
824
807
        self.assertFalse(repo.make_working_trees())
825
808
 
923
906
        wt.add(['foo'], [FOO_ID])
924
907
        wt.commit('this is my new commit', rev_id=REV_ID)
925
908
        # now access over vfat; should be safe
926
 
        branch = bzrdir.BzrDir.open(self.get_url('repo')).open_branch()
 
909
        branch = controldir.ControlDir.open(self.get_url('repo')).open_branch()
927
910
        revtree = branch.repository.revision_tree(REV_ID)
928
911
        revtree.lock_read()
929
912
        self.addCleanup(revtree.unlock)
947
930
        repo = self.make_repository('repo')
948
931
        self.assertIsInstance(repo.user_url, str)
949
932
        self.assertEqual(repo.user_url, repo.user_transport.base)
950
 
        # for all current bzrdir implementations the user dir must be 
 
933
        # for all current bzrdir implementations the user dir must be
951
934
        # above the control dir but we might need to relax that?
952
935
        self.assertEqual(repo.control_url.find(repo.user_url), 0)
953
936
        self.assertEqual(repo.control_url, repo.control_transport.base)
 
937
 
 
938
 
 
939
class TestDeltaRevisionFiltered(per_repository.TestCaseWithRepository):
 
940
 
 
941
    def setUp(self):
 
942
        super(TestDeltaRevisionFiltered, self).setUp()
 
943
        tree_a = self.make_branch_and_tree('a')
 
944
        self.build_tree(['a/foo', 'a/bar/', 'a/bar/b1', 'a/bar/b2', 'a/baz'])
 
945
        tree_a.add(['foo', 'bar', 'bar/b1', 'bar/b2', 'baz'],
 
946
                   ['foo-id', 'bar-id', 'b1-id', 'b2-id', 'baz-id'])
 
947
        tree_a.commit('rev1', rev_id='rev1')
 
948
        self.build_tree(['a/bar/b3'])
 
949
        tree_a.add('bar/b3', 'b3-id')
 
950
        tree_a.commit('rev2', rev_id='rev2')
 
951
        self.repository = tree_a.branch.repository
 
952
 
 
953
    def test_multiple_files(self):
 
954
        # Test multiple files
 
955
        delta = self.repository.get_revision_delta('rev1',
 
956
            specific_fileids=['foo-id', 'baz-id'])
 
957
        self.assertIsInstance(delta, _mod_delta.TreeDelta)
 
958
        self.assertEqual([
 
959
            ('baz', 'baz-id', 'file'),
 
960
            ('foo', 'foo-id', 'file'),
 
961
            ], delta.added)
 
962
 
 
963
    def test_directory(self):
 
964
        # Test a directory
 
965
        delta = self.repository.get_revision_delta('rev1',
 
966
            specific_fileids=['bar-id'])
 
967
        self.assertIsInstance(delta, _mod_delta.TreeDelta)
 
968
        self.assertEqual([
 
969
            ('bar', 'bar-id', 'directory'),
 
970
            ('bar/b1', 'b1-id', 'file'),
 
971
            ('bar/b2', 'b2-id', 'file'),
 
972
            ], delta.added)
 
973
 
 
974
    def test_unrelated(self):
 
975
        # Try another revision
 
976
        delta = self.repository.get_revision_delta('rev2',
 
977
                specific_fileids=['foo-id'])
 
978
        self.assertIsInstance(delta, _mod_delta.TreeDelta)
 
979
        self.assertEqual([], delta.added)
 
980
 
 
981
    def test_file_in_directory(self):
 
982
        # Test a file in a directory, both of which were added
 
983
        delta = self.repository.get_revision_delta('rev1',
 
984
            specific_fileids=['b2-id'])
 
985
        self.assertIsInstance(delta, _mod_delta.TreeDelta)
 
986
        self.assertEqual([
 
987
            ('bar', 'bar-id', 'directory'),
 
988
            ('bar/b2', 'b2-id', 'file'),
 
989
            ], delta.added)
 
990
 
 
991
    def test_file_in_unchanged_directory(self):
 
992
        delta = self.repository.get_revision_delta('rev2',
 
993
            specific_fileids=['b3-id'])
 
994
        self.assertIsInstance(delta, _mod_delta.TreeDelta)
 
995
        if delta.added == [
 
996
            ('bar', 'bar-id', 'directory'),
 
997
            ('bar/b3', 'b3-id', 'file')]:
 
998
            self.knownFailure("bzr incorrectly reports 'bar' as added - "
 
999
                              "bug 878217")
 
1000
        self.assertEqual([
 
1001
            ('bar/b3', 'b3-id', 'file'),
 
1002
            ], delta.added)