← 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: Tarmac
  • Author(s): Vincent Ladeuil
  • Date: 2017-01-30 14:42:05 UTC
  • mfrom: (6620.1.1 trunk)
  • Revision ID: tarmac-20170130144205-r8fh2xpmiuxyozpv
Merge  2.7 into trunk including fix for bug #1657238 [r=vila]

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,
73
73
        self.assertFormatAttribute('supports_nesting_repositories',
74
74
            (True, False))
75
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
 
76
81
    def test_attribute__fetch_reconcile(self):
77
82
        """Test the _fetch_reconcile attribute."""
78
83
        self.assertFormatAttribute('_fetch_reconcile', (True, False))
155
160
        made_repo = self.repository_format.initialize(made_control)
156
161
        self.assertEqual(made_control, made_repo.bzrdir)
157
162
 
158
 
        # find it via bzrdir opening:
159
 
        opened_control = bzrdir.BzrDir.open(readonly_t.base)
 
163
        # find it via controldir opening:
 
164
        opened_control = controldir.ControlDir.open(readonly_t.base)
160
165
        direct_opened_repo = opened_control.open_repository()
161
166
        self.assertEqual(direct_opened_repo.__class__, made_repo.__class__)
162
167
        self.assertEqual(opened_control, direct_opened_repo.bzrdir)
174
179
        except NotImplementedError:
175
180
            return
176
181
        self.assertEqual(self.repository_format,
177
 
                         repository.RepositoryFormat.find_format(opened_control))
 
182
             repository.RepositoryFormatMetaDir.find_format(opened_control))
178
183
 
179
184
    def test_format_matchingbzrdir(self):
180
185
        self.assertEqual(self.repository_format,
282
287
        self.assertIsInstance(delta, _mod_delta.TreeDelta)
283
288
        self.assertEqual([('vla', 'file2', 'file')], delta.added)
284
289
 
285
 
    def test_get_revision_delta_filtered(self):
286
 
        tree_a = self.make_branch_and_tree('a')
287
 
        self.build_tree(['a/foo', 'a/bar/', 'a/bar/b1', 'a/bar/b2', 'a/baz'])
288
 
        tree_a.add(['foo', 'bar', 'bar/b1', 'bar/b2', 'baz'],
289
 
                   ['foo-id', 'bar-id', 'b1-id', 'b2-id', 'baz-id'])
290
 
        tree_a.commit('rev1', rev_id='rev1')
291
 
        self.build_tree(['a/bar/b3'])
292
 
        tree_a.add('bar/b3', 'b3-id')
293
 
        tree_a.commit('rev2', rev_id='rev2')
294
 
 
295
 
        # Test multiple files
296
 
        delta = tree_a.branch.repository.get_revision_delta('rev1',
297
 
            specific_fileids=['foo-id', 'baz-id'])
298
 
        self.assertIsInstance(delta, _mod_delta.TreeDelta)
299
 
        self.assertEqual([
300
 
            ('baz', 'baz-id', 'file'),
301
 
            ('foo', 'foo-id', 'file'),
302
 
            ], delta.added)
303
 
        # Test a directory
304
 
        delta = tree_a.branch.repository.get_revision_delta('rev1',
305
 
            specific_fileids=['bar-id'])
306
 
        self.assertIsInstance(delta, _mod_delta.TreeDelta)
307
 
        self.assertEqual([
308
 
            ('bar', 'bar-id', 'directory'),
309
 
            ('bar/b1', 'b1-id', 'file'),
310
 
            ('bar/b2', 'b2-id', 'file'),
311
 
            ], delta.added)
312
 
        # Test a file in a directory
313
 
        delta = tree_a.branch.repository.get_revision_delta('rev1',
314
 
            specific_fileids=['b2-id'])
315
 
        self.assertIsInstance(delta, _mod_delta.TreeDelta)
316
 
        self.assertEqual([
317
 
            ('bar', 'bar-id', 'directory'),
318
 
            ('bar/b2', 'b2-id', 'file'),
319
 
            ], delta.added)
320
 
        # Try another revision
321
 
        delta = tree_a.branch.repository.get_revision_delta('rev2',
322
 
                specific_fileids=['b3-id'])
323
 
        self.assertIsInstance(delta, _mod_delta.TreeDelta)
324
 
        self.assertEqual([
325
 
            ('bar', 'bar-id', 'directory'),
326
 
            ('bar/b3', 'b3-id', 'file'),
327
 
            ], delta.added)
328
 
        delta = tree_a.branch.repository.get_revision_delta('rev2',
329
 
                specific_fileids=['foo-id'])
330
 
        self.assertIsInstance(delta, _mod_delta.TreeDelta)
331
 
        self.assertEqual([], delta.added)
332
 
 
333
290
    def test_clone_bzrdir_repository_revision(self):
334
291
        # make a repository with some revisions,
335
292
        # and clone it, this should not have unreferenced revisions.
365
322
        self.assertFalse(result.open_repository().make_working_trees())
366
323
 
367
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")
368
328
        wt = self.make_branch_and_tree('source')
369
329
        wt.commit('A', allow_pointless=True, rev_id='A')
370
330
        repo = wt.branch.repository
379
339
        repo.unlock()
380
340
        old_signature = repo.get_signature_text('A')
381
341
        try:
382
 
            old_format = bzrdir.BzrDirFormat.get_default_format()
 
342
            old_format = controldir.ControlDirFormat.get_default_format()
383
343
            # This gives metadir branches something they can convert to.
384
344
            # it would be nice to have a 'latest' vs 'default' concept.
385
 
            format = bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
 
345
            format = controldir.format_registry.make_bzrdir(
 
346
                'development-subtree')
386
347
            upgrade.upgrade(repo.bzrdir.root_transport.base, format=format)
387
348
        except errors.UpToDateFormat:
388
349
            # this is in the most current format already.
591
552
        b = builder.get_branch()
592
553
        b.lock_write()
593
554
        self.addCleanup(b.unlock)
594
 
        b.repository.start_write_group()
595
 
        self.addCleanup(b.repository.abort_write_group)
596
555
        if b.repository._format.supports_revision_signatures:
 
556
            b.repository.start_write_group()
597
557
            b.repository.add_signature_text('A', 'This might be a signature')
 
558
            b.repository.commit_write_group()
598
559
            self.assertEqual('This might be a signature',
599
560
                             b.repository.get_signature_text('A'))
600
561
        else:
 
562
            b.repository.start_write_group()
 
563
            self.addCleanup(b.repository.abort_write_group)
601
564
            self.assertRaises(errors.UnsupportedOperation,
602
565
                b.repository.add_signature_text, 'A',
603
566
                'This might be a signature')
604
567
 
605
568
    # XXX: this helper duplicated from tests.test_repository
606
 
    def make_remote_repository(self, path, shared=False):
 
569
    def make_remote_repository(self, path, shared=None):
607
570
        """Make a RemoteRepository object backed by a real repository that will
608
571
        be created at the given path."""
609
572
        repo = self.make_repository(path, shared=shared)
611
574
        self.start_server(smart_server, self.get_server())
612
575
        remote_transport = transport.get_transport_from_url(
613
576
            smart_server.get_url()).clone(path)
614
 
        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)
615
582
        remote_repo = remote_bzrdir.open_repository()
616
583
        return remote_repo
617
584
 
624
591
        except errors.TransportNotPossible:
625
592
            raise tests.TestNotApplicable(
626
593
                "Cannot lock_read old formats like AllInOne over HPSS.")
627
 
        remote_backing_repo = bzrdir.BzrDir.open(
 
594
        remote_backing_repo = controldir.ControlDir.open(
628
595
            self.get_vfs_only_url('remote')).open_repository()
629
 
        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())
630
599
 
631
600
    def test_sprout_branch_from_hpss_preserves_repo_format(self):
632
601
        """branch.sprout from a smart server preserves the repository format.
642
611
            raise tests.TestNotApplicable(
643
612
                "Cannot lock_read old formats like AllInOne over HPSS.")
644
613
        local_repo = local_bzrdir.open_repository()
645
 
        remote_backing_repo = bzrdir.BzrDir.open(
 
614
        remote_backing_repo = controldir.ControlDir.open(
646
615
            self.get_vfs_only_url('remote')).open_repository()
647
616
        self.assertEqual(remote_backing_repo._format, local_repo._format)
648
617
 
655
624
                "Format can not be used over HPSS")
656
625
        # Make a shared repo
657
626
        remote_repo = self.make_remote_repository('remote', shared=True)
658
 
        remote_backing_repo = bzrdir.BzrDir.open(
 
627
        remote_backing_repo = controldir.ControlDir.open(
659
628
            self.get_vfs_only_url('remote')).open_repository()
660
629
        # Make a branch in that repo in an old format that isn't the default
661
630
        # branch format for the repo.
662
 
        from bzrlib.branch import BzrBranchFormat5
 
631
        from bzrlib.branchfmt.fullhistory import BzrBranchFormat5
663
632
        format = remote_backing_repo.bzrdir.cloning_metadir()
664
633
        format._branch_format = BzrBranchFormat5()
665
634
        remote_transport = remote_repo.bzrdir.root_transport.clone('branch')
666
 
        remote_backing_repo.bzrdir.create_branch_convenience(
 
635
        controldir.ControlDir.create_branch_convenience(
667
636
            remote_transport.base, force_new_repo=False, format=format)
668
 
        remote_branch = bzrdir.BzrDir.open_from_transport(
 
637
        remote_branch = controldir.ControlDir.open_from_transport(
669
638
            remote_transport).open_branch()
670
639
        try:
671
640
            local_bzrdir = remote_branch.bzrdir.sprout('local')
758
727
        if not repo._format.supports_nesting_repositories:
759
728
            raise tests.TestNotApplicable("repository does not support "
760
729
                "nesting repositories")
761
 
        bzrdir.BzrDir.create_branch_convenience(self.get_url('repository/foo'),
762
 
                                                force_new_repo=False)
763
 
        bzrdir.BzrDir.create_branch_convenience(self.get_url('repository/bar'),
764
 
                                                force_new_repo=True)
 
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)
765
734
        baz = self.make_bzrdir('repository/baz')
766
735
        qux = self.make_branch('repository/baz/qux')
767
736
        quxx = self.make_branch('repository/baz/qux/quxx')
808
777
                         [b.base for b in branches])
809
778
 
810
779
    def test_find_branches_using_empty_standalone_repo(self):
811
 
        repo = self.make_repository('repo', shared=False)
 
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")
812
785
        try:
813
786
            repo.bzrdir.open_branch()
814
787
        except errors.NotBranchError:
933
906
        wt.add(['foo'], [FOO_ID])
934
907
        wt.commit('this is my new commit', rev_id=REV_ID)
935
908
        # now access over vfat; should be safe
936
 
        branch = bzrdir.BzrDir.open(self.get_url('repo')).open_branch()
 
909
        branch = controldir.ControlDir.open(self.get_url('repo')).open_branch()
937
910
        revtree = branch.repository.revision_tree(REV_ID)
938
911
        revtree.lock_read()
939
912
        self.addCleanup(revtree.unlock)
957
930
        repo = self.make_repository('repo')
958
931
        self.assertIsInstance(repo.user_url, str)
959
932
        self.assertEqual(repo.user_url, repo.user_transport.base)
960
 
        # for all current bzrdir implementations the user dir must be 
 
933
        # for all current bzrdir implementations the user dir must be
961
934
        # above the control dir but we might need to relax that?
962
935
        self.assertEqual(repo.control_url.find(repo.user_url), 0)
963
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)