/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 breezy/tests/per_controldir/test_controldir.py

  • Committer: Jelmer Vernooij
  • Date: 2019-05-29 03:22:34 UTC
  • mfrom: (7303 work)
  • mto: This revision was merged to the branch mainline in revision 7306.
  • Revision ID: jelmer@jelmer.uk-20190529032234-mt3fuws8gq03tapi
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/per_controldir/test_controldir.py
108
108
            raise TestNotApplicable("format is initializable")
109
109
        t = self.get_transport()
110
110
        self.assertRaises(errors.UninitializableFormat,
111
 
            self.bzrdir_format.initialize, t.base)
 
111
                          self.bzrdir_format.initialize, t.base)
112
112
 
113
113
    def test_multiple_initialization(self):
114
114
        # loopback test to check the current format initializes to itself.
119
119
            raise TestNotApplicable("format is not initializable")
120
120
        self.bzrdir_format.initialize('.')
121
121
        self.assertRaises(errors.AlreadyControlDirError,
122
 
            self.bzrdir_format.initialize, '.')
 
122
                          self.bzrdir_format.initialize, '.')
123
123
 
124
124
    def test_create_null_workingtree(self):
125
125
        dir = self.make_controldir('dir1')
126
126
        dir.create_repository()
127
127
        dir.create_branch()
128
128
        try:
129
 
            wt = dir.create_workingtree(revision_id=_mod_revision.NULL_REVISION)
 
129
            wt = dir.create_workingtree(
 
130
                revision_id=_mod_revision.NULL_REVISION)
130
131
        except (errors.NotLocalUrl, errors.UnsupportedOperation):
131
132
            raise TestSkipped("cannot make working tree with transport %r"
132
133
                              % dir.transport)
156
157
        try:
157
158
            bzrdir.destroy_branch()
158
159
        except (errors.UnsupportedOperation, errors.TransportNotPossible):
159
 
            raise TestNotApplicable('Format does not support destroying branch')
 
160
            raise TestNotApplicable(
 
161
                'Format does not support destroying branch')
160
162
        self.assertRaises(errors.NotBranchError, bzrdir.open_branch)
161
163
        bzrdir.create_branch()
162
164
        bzrdir.open_branch()
167
169
        try:
168
170
            self.assertRaises(errors.NotBranchError, bzrdir.destroy_branch)
169
171
        except (errors.UnsupportedOperation, errors.TransportNotPossible):
170
 
            raise TestNotApplicable('Format does not support destroying branch')
 
172
            raise TestNotApplicable(
 
173
                'Format does not support destroying branch')
171
174
 
172
175
    def test_destroy_repository(self):
173
176
        repo = self.make_repository('repository')
178
181
            raise TestNotApplicable('Format does not support destroying'
179
182
                                    ' repository')
180
183
        self.assertRaises(errors.NoRepositoryPresent,
181
 
            bzrdir.destroy_repository)
 
184
                          bzrdir.destroy_repository)
182
185
        self.assertRaises(errors.NoRepositoryPresent, bzrdir.open_repository)
183
186
        bzrdir.create_repository()
184
187
        bzrdir.open_repository()
193
196
            # This ControlDir format doesn't support ControlDirs without
194
197
            # working trees, so this test is irrelevant.
195
198
            raise TestNotApplicable("format does not support "
196
 
                "control directories without working tree")
 
199
                                    "control directories without working tree")
197
200
        self.assertRaises(errors.NoWorkingTree, dir.open_workingtree)
198
201
 
199
202
    def test_clone_bzrdir_repository_under_shared(self):
200
203
        tree = self.make_branch_and_tree('commit_tree')
201
204
        self.build_tree(
202
 
                ['foo'], transport=tree.controldir.transport.clone('..'))
 
205
            ['foo'], transport=tree.controldir.transport.clone('..'))
203
206
        tree.add('foo')
204
207
        rev1 = tree.commit('revision 1')
205
208
        dir = self.make_controldir('source')
213
216
            self.make_repository('target', shared=True)
214
217
        except errors.IncompatibleFormat:
215
218
            raise TestNotApplicable(
216
 
                    "repository format does not support shared repositories")
 
219
                "repository format does not support shared repositories")
217
220
        target = dir.clone(self.get_url('target/child'))
218
221
        self.assertNotEqual(dir.transport.base, target.transport.base)
219
222
        self.assertRaises(errors.NoRepositoryPresent, target.open_repository)
224
227
            shared_repo = self.make_repository('shared', shared=True)
225
228
        except errors.IncompatibleFormat:
226
229
            raise TestNotApplicable(
227
 
                    "repository format does not support shared repositories")
 
230
                "repository format does not support shared repositories")
228
231
        if not shared_repo._format.supports_nesting_repositories:
229
232
            raise TestNotApplicable(
230
 
                    "format does not support nesting repositories")
 
233
                "format does not support nesting repositories")
231
234
        # Make a branch, 'commit_tree', and working tree outside of the shared
232
235
        # repository, and commit some revisions to it.
233
236
        tree = self.make_branch_and_tree('commit_tree')
249
252
        # 'source', 'target', and the shared repo all have distinct bzrdirs.
250
253
        self.assertNotEqual(dir.transport.base, target.transport.base)
251
254
        self.assertNotEqual(
252
 
                dir.transport.base, shared_repo.controldir.transport.base)
 
255
            dir.transport.base, shared_repo.controldir.transport.base)
253
256
        # The shared repository will contain revisions from the 'commit_tree'
254
257
        # repository, even revisions that are not part of the history of the
255
258
        # 'commit_tree' branch.
260
263
            shared_repo = self.make_repository('shared', shared=True)
261
264
        except errors.IncompatibleFormat:
262
265
            raise TestNotApplicable(
263
 
                    "repository format does not support shared repositories")
 
266
                "repository format does not support shared repositories")
264
267
        if not shared_repo._format.supports_nesting_repositories:
265
268
            raise TestNotApplicable(
266
 
                    "format does not support nesting repositories")
 
269
                "format does not support nesting repositories")
267
270
        tree = self.make_branch_and_tree('commit_tree')
268
271
        self.build_tree(['commit_tree/foo'])
269
272
        tree.add('foo')
340
343
            shared_repo = self.make_repository('target', shared=True)
341
344
        except errors.IncompatibleFormat:
342
345
            raise TestNotApplicable("repository format does not support "
343
 
                "shared repositories")
 
346
                                    "shared repositories")
344
347
        if not shared_repo._format.supports_nesting_repositories:
345
348
            raise TestNotApplicable("format does not support nesting "
346
 
                "repositories")
 
349
                                    "repositories")
347
350
        dir = source.controldir
348
351
        target = dir.clone(self.get_url('target/child'))
349
352
        self.assertNotEqual(dir.transport.base, target.transport.base)
431
434
        child_transport = self.get_transport('child')
432
435
        try:
433
436
            child = branch.controldir.clone_on_transport(child_transport,
434
 
                                                     stacked_on=branch.base)
 
437
                                                         stacked_on=branch.base)
435
438
        except (_mod_branch.UnstackableBranchFormat,
436
439
                errors.UnstackableRepositoryFormat):
437
440
            raise TestNotApplicable("branch or repository format does "
438
 
                "not support stacking")
 
441
                                    "not support stacking")
439
442
        self.assertEqual(child.open_branch().get_stacked_on_url(), branch.base)
440
443
 
441
444
    def test_set_branch_reference(self):
447
450
        except errors.IncompatibleFormat:
448
451
            # this is ok too, not all formats have to support references.
449
452
            raise TestNotApplicable("control directory does not "
450
 
                "support branch references")
451
 
        self.assertEqual(referenced_branch.user_url, dir.get_branch_reference())
 
453
                                    "support branch references")
 
454
        self.assertEqual(referenced_branch.user_url,
 
455
                         dir.get_branch_reference())
452
456
 
453
457
    def test_set_branch_reference_on_existing_reference(self):
454
458
        """set_branch_reference creates a branch reference"""
460
464
        except errors.IncompatibleFormat:
461
465
            # this is ok too, not all formats have to support references.
462
466
            raise TestNotApplicable("control directory does not "
463
 
                "support branch references")
 
467
                                    "support branch references")
464
468
        reference = dir.set_branch_reference(referenced_branch2)
465
469
        self.assertEqual(
466
470
            referenced_branch2.user_url,
475
479
        except errors.IncompatibleFormat:
476
480
            # this is ok too, not all formats have to support references.
477
481
            raise TestNotApplicable("control directory does not "
478
 
                "support branch references")
 
482
                                    "support branch references")
479
483
        self.assertEqual(
480
484
            referenced_branch.user_url,
481
485
            dir.get_branch_reference())
489
493
        except errors.IncompatibleFormat:
490
494
            # this is ok too, not all formats have to support references.
491
495
            raise TestNotApplicable("control directory does not "
492
 
                "support branch references")
 
496
                                    "support branch references")
493
497
        self.assertEqual(referenced_branch.user_url,
494
 
            dir.get_branch_reference())
 
498
                         dir.get_branch_reference())
495
499
 
496
500
    def test_get_branch_reference_on_non_reference(self):
497
501
        """get_branch_reference should return None for non-reference branches."""
512
516
        if dir.has_branch():
513
517
            # this format does not support branchless bzrdirs.
514
518
            raise TestNotApplicable("format does not support "
515
 
                "branchless control directories")
 
519
                                    "branchless control directories")
516
520
        self.assertRaises(errors.NotBranchError, dir.get_branch_reference)
517
521
 
518
522
    def test_sprout_bzrdir_empty(self):
519
523
        dir = self.make_controldir('source')
520
524
        target = dir.sprout(self.get_url('target'))
521
 
        self.assertNotEqual(dir.control_transport.base, target.control_transport.base)
 
525
        self.assertNotEqual(dir.control_transport.base,
 
526
                            target.control_transport.base)
522
527
        # creates a new repository branch and tree
523
528
        target.open_repository()
524
529
        target.open_branch()
531
536
            self.make_repository('target', shared=True)
532
537
        except errors.IncompatibleFormat:
533
538
            raise TestNotApplicable("format does not support shared "
534
 
                "repositories")
 
539
                                    "repositories")
535
540
        target = dir.sprout(self.get_url('target/child'))
536
541
        self.assertRaises(errors.NoRepositoryPresent, target.open_repository)
537
542
        target.open_branch()
550
555
            self.make_repository('target', shared=True)
551
556
        except errors.IncompatibleFormat:
552
557
            raise TestNotApplicable("format does not support shared "
553
 
                "repositories")
 
558
                                    "repositories")
554
559
        target = dir.sprout(self.get_url('target/child'), force_new_repo=True)
555
560
        target.open_repository()
556
561
        target.open_branch()
572
577
            shared_repo = self.make_repository('target', shared=True)
573
578
        except errors.IncompatibleFormat:
574
579
            raise TestNotApplicable("format does not support "
575
 
                "shared repositories")
 
580
                                    "shared repositories")
576
581
        target = dir.sprout(self.get_url('target/child'))
577
 
        self.assertNotEqual(dir.user_transport.base, target.user_transport.base)
 
582
        self.assertNotEqual(dir.user_transport.base,
 
583
                            target.user_transport.base)
578
584
        self.assertTrue(shared_repo.has_revision(rev1))
579
585
 
580
586
    def test_sprout_bzrdir_repository_branch_both_under_shared(self):
582
588
            shared_repo = self.make_repository('shared', shared=True)
583
589
        except errors.IncompatibleFormat:
584
590
            raise TestNotApplicable("format does not support shared "
585
 
                "repositories")
 
591
                                    "repositories")
586
592
        if not shared_repo._format.supports_nesting_repositories:
587
593
            raise TestNotApplicable("format does not support nesting "
588
 
                "repositories")
 
594
                                    "repositories")
589
595
        tree = self.make_branch_and_tree('commit_tree')
590
596
        self.build_tree(['commit_tree/foo'])
591
597
        tree.add('foo')
599
605
        dir.create_branch()
600
606
        target = dir.sprout(self.get_url('shared/target'))
601
607
        self.assertNotEqual(dir.transport.base, target.transport.base)
602
 
        self.assertNotEqual(dir.transport.base, shared_repo.controldir.transport.base)
 
608
        self.assertNotEqual(dir.transport.base,
 
609
                            shared_repo.controldir.transport.base)
603
610
        self.assertTrue(shared_repo.has_revision(rev1))
604
611
 
605
612
    def test_sprout_bzrdir_repository_branch_only_source_under_shared(self):
607
614
            shared_repo = self.make_repository('shared', shared=True)
608
615
        except errors.IncompatibleFormat:
609
616
            raise TestNotApplicable("format does not support shared "
610
 
                "repositories")
 
617
                                    "repositories")
611
618
        if not shared_repo._format.supports_nesting_repositories:
612
619
            raise TestNotApplicable("format does not support nesting "
613
 
                "repositories")
 
620
                                    "repositories")
614
621
        tree = self.make_branch_and_tree('commit_tree')
615
622
        self.build_tree(['commit_tree/foo'])
616
623
        tree.add('foo')
629
636
        target = dir.sprout(self.get_url('target'))
630
637
        self.assertNotEqual(dir.transport.base, target.transport.base)
631
638
        self.assertNotEqual(
632
 
                dir.transport.base,
633
 
                shared_repo.controldir.transport.base)
 
639
            dir.transport.base,
 
640
            shared_repo.controldir.transport.base)
634
641
        branch = target.open_branch()
635
642
        # The sprouted bzrdir has a branch, so only revisions referenced by
636
643
        # that branch are copied, rather than the whole repository.  It's an
656
663
            shared_repo = self.make_repository('target', shared=True)
657
664
        except errors.IncompatibleFormat:
658
665
            raise TestNotApplicable(
659
 
                    "format does not support shared repositories")
 
666
                "format does not support shared repositories")
660
667
        target = dir.sprout(self.get_url('target/child'), force_new_repo=True)
661
668
        self.assertNotEqual(
662
669
            dir.control_transport.base,
697
704
            shared_repo = self.make_repository('target', shared=True)
698
705
        except errors.IncompatibleFormat:
699
706
            raise TestNotApplicable(
700
 
                    "format does not support shared repositories")
 
707
                "format does not support shared repositories")
701
708
        dir.sprout(self.get_url('target/child'))
702
709
        self.assertTrue(shared_repo.has_revision(rev1))
703
710
 
716
723
            shared_repo = self.make_repository('target', shared=True)
717
724
        except errors.IncompatibleFormat:
718
725
            raise TestNotApplicable(
719
 
                    "format does not support shared repositories")
 
726
                "format does not support shared repositories")
720
727
        target = dir.sprout(self.get_url('target/child'), force_new_repo=True)
721
728
        self.assertNotEqual(
722
 
                dir.control_transport.base, target.control_transport.base)
 
729
            dir.control_transport.base, target.control_transport.base)
723
730
        self.assertFalse(shared_repo.has_revision(rev1))
724
731
 
725
732
    def test_sprout_bzrdir_branch_reference(self):
730
737
            dir.set_branch_reference(referenced_branch)
731
738
        except errors.IncompatibleFormat:
732
739
            raise TestNotApplicable(
733
 
                    "format does not support branch references")
 
740
                "format does not support branch references")
734
741
        self.assertRaises(errors.NoRepositoryPresent, dir.open_repository)
735
742
        target = dir.sprout(self.get_url('target'))
736
743
        self.assertNotEqual(dir.transport.base, target.transport.base)
749
756
            dir.set_branch_reference(referenced_tree.branch)
750
757
        except errors.IncompatibleFormat:
751
758
            raise TestNotApplicable(
752
 
                    "format does not support branch references")
 
759
                "format does not support branch references")
753
760
        self.assertRaises(errors.NoRepositoryPresent, dir.open_repository)
754
761
        try:
755
762
            shared_repo = self.make_repository('target', shared=True)
756
763
        except errors.IncompatibleFormat:
757
764
            raise TestNotApplicable(
758
 
                    "format does not support shared repositories")
 
765
                "format does not support shared repositories")
759
766
        target = dir.sprout(self.get_url('target/child'))
760
767
        self.assertNotEqual(dir.transport.base, target.transport.base)
761
768
        # we want target to have a branch that is in-place.
776
783
        except errors.IncompatibleFormat:
777
784
            # this is ok too, not all formats have to support references.
778
785
            raise TestNotApplicable(
779
 
                    "format does not support branch references")
 
786
                "format does not support branch references")
780
787
        self.assertRaises(errors.NoRepositoryPresent, dir.open_repository)
781
788
        try:
782
789
            shared_repo = self.make_repository('target', shared=True)
783
790
        except errors.IncompatibleFormat:
784
791
            raise TestNotApplicable(
785
 
                    "format does not support shared repositories")
 
792
                "format does not support shared repositories")
786
793
        target = dir.sprout(self.get_url('target/child'), force_new_repo=True)
787
794
        self.assertNotEqual(dir.transport.base, target.transport.base)
788
795
        # we want target to have a branch that is in-place.
813
820
        # when sprouting a branch all revisions named in the tags are copied
814
821
        # too.
815
822
        builder = self.make_branch_builder('source')
816
 
        source, rev1, rev2 = fixtures.build_branch_with_non_ancestral_rev(builder)
 
823
        source, rev1, rev2 = fixtures.build_branch_with_non_ancestral_rev(
 
824
            builder)
817
825
        try:
818
826
            source.tags.set_tag('tag-a', rev2)
819
827
        except errors.TagsNotSupported:
837
845
            source.tags.set_tag('tag-a', b'missing-rev')
838
846
        except (errors.TagsNotSupported, errors.GhostTagsNotSupported):
839
847
            raise TestNotApplicable(
840
 
                    "Branch format does not support tags or tags "
841
 
                    "referencing ghost revisions.")
 
848
                "Branch format does not support tags or tags "
 
849
                "referencing ghost revisions.")
842
850
        # Now source has a tag pointing to an absent revision.  Sprout its
843
851
        # controldir.
844
852
        dir = source.controldir
857
865
            source.tags.set_tag('tag-a', b'missing-rev')
858
866
        except (errors.TagsNotSupported, errors.GhostTagsNotSupported):
859
867
            raise TestNotApplicable(
860
 
                    "Branch format does not support tags or tags "
861
 
                    "referencing missing revisions.")
 
868
                "Branch format does not support tags or tags "
 
869
                "referencing missing revisions.")
862
870
        # Now source has a tag pointing to an absent revision.  Sprout its
863
871
        # controldir.
864
872
        dir = source.controldir
929
937
        except errors.IncompatibleFormat:
930
938
            # this is ok too, not all formats have to support references.
931
939
            raise TestNotApplicable(
932
 
                    "format does not support branch references")
 
940
                "format does not support branch references")
933
941
        self.assertRaises(errors.NoRepositoryPresent, dir.open_repository)
934
942
        tree = self.createWorkingTreeOrSkip(dir)
935
943
        self.build_tree(['source/subdir/'])
955
963
        except errors.IncompatibleFormat:
956
964
            # this is ok too, not all formats have to support references.
957
965
            raise TestNotApplicable(
958
 
                    "format does not support branch references")
 
966
                "format does not support branch references")
959
967
        self.assertRaises(errors.NoRepositoryPresent, dir.open_repository)
960
968
        tree = self.createWorkingTreeOrSkip(dir)
961
969
        self.build_tree(['source/foo'])
987
995
        tree.commit('revision 2', allow_pointless=True)
988
996
        dir = tree.controldir
989
997
        target = self.sproutOrSkip(
990
 
                dir, self.get_url('target'), revision_id=rev1)
 
998
            dir, self.get_url('target'), revision_id=rev1)
991
999
        self.assertEqual([rev1], target.open_workingtree().get_parent_ids())
992
1000
 
993
1001
    def test_sprout_takes_accelerator(self):
998
1006
        rev2 = tree.commit('revision 2', allow_pointless=True)
999
1007
        dir = tree.controldir
1000
1008
        target = self.sproutOrSkip(
1001
 
                dir, self.get_url('target'), accelerator_tree=tree)
 
1009
            dir, self.get_url('target'), accelerator_tree=tree)
1002
1010
        self.assertEqual([rev2], target.open_workingtree().get_parent_ids())
1003
1011
 
1004
1012
    def test_sprout_branch_no_tree(self):
1010
1018
        dir = tree.controldir
1011
1019
        try:
1012
1020
            target = dir.sprout(
1013
 
                    self.get_url('target'), create_tree_if_local=False)
 
1021
                self.get_url('target'), create_tree_if_local=False)
1014
1022
        except controldir.MustHaveWorkingTree:
1015
1023
            raise TestNotApplicable("control dir format requires working tree")
1016
1024
        self.assertPathDoesNotExist('target/foo')
1052
1060
        # in through an unisolated test though - see
1053
1061
        # <https://bugs.launchpad.net/bzr/+bug/504102>
1054
1062
        self.assertEqual(
1055
 
                getattr(self.bzrdir_format, '_network_name', None),
1056
 
                None)
 
1063
            getattr(self.bzrdir_format, '_network_name', None),
 
1064
            None)
1057
1065
        # supported formats must be able to init and open
1058
1066
        t = self.get_transport()
1059
1067
        readonly_t = self.get_readonly_transport()
1086
1094
        t = self.get_transport('dir')
1087
1095
        t.ensure_base()
1088
1096
        self.assertRaises(
1089
 
                errors.FileExists,
1090
 
                self.bzrdir_format.initialize_on_transport_ex, t,
1091
 
                use_existing_dir=False)
 
1097
            errors.FileExists,
 
1098
            self.bzrdir_format.initialize_on_transport_ex, t,
 
1099
            use_existing_dir=False)
1092
1100
 
1093
1101
    def test_format_initialize_on_transport_ex_create_prefix_True(self):
1094
1102
        t = self.get_transport('missing/dir')
1099
1107
            raise TestNotApplicable("format is not initializable")
1100
1108
        t = self.get_transport('missing/dir')
1101
1109
        self.assertRaises(
1102
 
                errors.NoSuchFile, self.assertInitializeEx, t,
1103
 
                create_prefix=False)
 
1110
            errors.NoSuchFile, self.assertInitializeEx, t,
 
1111
            create_prefix=False)
1104
1112
 
1105
1113
    def test_format_initialize_on_transport_ex_force_new_repo_True(self):
1106
1114
        t = self.get_transport('repo')
1107
1115
        repo_fmt = controldir.format_registry.make_controldir('1.9')
1108
1116
        repo_name = repo_fmt.repository_format.network_name()
1109
1117
        repo = repo_fmt.initialize_on_transport_ex(
1110
 
                t, repo_format_name=repo_name, shared_repo=True)[0]
 
1118
            t, repo_format_name=repo_name, shared_repo=True)[0]
1111
1119
        made_repo, control = self.assertInitializeEx(
1112
 
                t.clone('branch'), force_new_repo=True,
1113
 
                repo_format_name=repo_name)
 
1120
            t.clone('branch'), force_new_repo=True,
 
1121
            repo_format_name=repo_name)
1114
1122
        self.assertNotEqual(
 
1123
            repo.controldir.root_transport.base,
 
1124
            made_repo.controldir.root_transport.base)
 
1125
 
 
1126
    def test_format_initialize_on_transport_ex_force_new_repo_False(self):
 
1127
        t = self.get_transport('repo')
 
1128
        repo_fmt = controldir.format_registry.make_controldir('1.9')
 
1129
        repo_name = repo_fmt.repository_format.network_name()
 
1130
        repo = repo_fmt.initialize_on_transport_ex(
 
1131
            t, repo_format_name=repo_name, shared_repo=True)[0]
 
1132
        made_repo, control = self.assertInitializeEx(
 
1133
            t.clone('branch'), force_new_repo=False,
 
1134
            repo_format_name=repo_name)
 
1135
        if not control._format.fixed_components:
 
1136
            self.assertEqual(
1115
1137
                repo.controldir.root_transport.base,
1116
1138
                made_repo.controldir.root_transport.base)
1117
1139
 
1118
 
    def test_format_initialize_on_transport_ex_force_new_repo_False(self):
1119
 
        t = self.get_transport('repo')
1120
 
        repo_fmt = controldir.format_registry.make_controldir('1.9')
1121
 
        repo_name = repo_fmt.repository_format.network_name()
1122
 
        repo = repo_fmt.initialize_on_transport_ex(
1123
 
                t, repo_format_name=repo_name, shared_repo=True)[0]
1124
 
        made_repo, control = self.assertInitializeEx(
1125
 
                t.clone('branch'), force_new_repo=False,
1126
 
                repo_format_name=repo_name)
1127
 
        if not control._format.fixed_components:
1128
 
            self.assertEqual(
1129
 
                    repo.controldir.root_transport.base,
1130
 
                    made_repo.controldir.root_transport.base)
1131
 
 
1132
1140
    def test_format_initialize_on_transport_ex_repo_fmt_name_None(self):
1133
1141
        t = self.get_transport('dir')
1134
1142
        repo, control = self.assertInitializeEx(t)
1158
1166
        """
1159
1167
        if not self.bzrdir_format.is_initializable():
1160
1168
            raise TestNotApplicable(
1161
 
                    "control dir format is not initializable")
 
1169
                "control dir format is not initializable")
1162
1170
        repo, control, require_stacking, repo_policy = \
1163
1171
            self.bzrdir_format.initialize_on_transport_ex(t, **kwargs)
1164
1172
        if repo is not None:
1170
1178
        expected_format = self.bzrdir_format
1171
1179
        if not isinstance(expected_format, RemoteBzrDirFormat):
1172
1180
            self.assertEqual(
1173
 
                    control._format.network_name(),
1174
 
                    expected_format.network_name())
 
1181
                control._format.network_name(),
 
1182
                expected_format.network_name())
1175
1183
            self.assertEqual(
1176
 
                    control._format.network_name(),
1177
 
                    opened._format.network_name())
 
1184
                control._format.network_name(),
 
1185
                opened._format.network_name())
1178
1186
        self.assertEqual(control.__class__, opened.__class__)
1179
1187
        return repo, control
1180
1188
 
1236
1244
                append_revisions_only=True)
1237
1245
        except errors.UpgradeRequired:
1238
1246
            raise TestNotApplicable(
1239
 
                    "format does not support append_revisions_only setting")
 
1247
                "format does not support append_revisions_only setting")
1240
1248
        self.assertIsInstance(made_branch, breezy.branch.Branch)
1241
1249
        self.assertEqual(True, made_branch.get_append_revisions_only())
1242
1250
        self.assertEqual(made_control, made_branch.controldir)
1255
1263
        self.assertEqual(made_control, opened_branch.controldir)
1256
1264
        self.assertIsInstance(opened_branch, made_branch.__class__)
1257
1265
        self.assertIsInstance(
1258
 
                opened_branch._format,
1259
 
                made_branch._format.__class__)
 
1266
            opened_branch._format,
 
1267
            made_branch._format.__class__)
1260
1268
 
1261
1269
    def test_list_branches(self):
1262
1270
        if not self.bzrdir_format.is_initializable():
1310
1318
            # Old bzrdir formats don't support shared repositories
1311
1319
            # and should raise IncompatibleFormat
1312
1320
            raise TestNotApplicable(
1313
 
                    "format does not support shared repositories")
 
1321
                "format does not support shared repositories")
1314
1322
        self.assertTrue(made_repo.is_shared())
1315
1323
 
1316
1324
    def test_create_repository_nonshared(self):
1328
1336
            # Some control dir formats don't support non-shared repositories
1329
1337
            # and should raise IncompatibleFormat
1330
1338
            raise TestNotApplicable(
1331
 
                    "format does not support shared repositories")
 
1339
                "format does not support shared repositories")
1332
1340
        self.assertFalse(made_repo.is_shared())
1333
1341
 
1334
1342
    def test_open_repository(self):
1393
1401
            made_tree = made_control.create_workingtree()
1394
1402
        except (errors.NotLocalUrl, errors.UnsupportedOperation):
1395
1403
            raise TestSkipped(
1396
 
                    "Can't initialize %r on transport %r" % (
1397
 
                        self.bzrdir_format, t))
 
1404
                "Can't initialize %r on transport %r" % (
 
1405
                    self.bzrdir_format, t))
1398
1406
        opened_tree = made_control.open_workingtree()
1399
1407
        self.assertEqual(made_control, opened_tree.controldir)
1400
1408
        self.assertIsInstance(opened_tree, made_tree.__class__)
1411
1419
        except (errors.NotLocalUrl, errors.UnsupportedOperation):
1412
1420
            raise TestSkipped("Can't initialize %r on transport %r"
1413
1421
                              % (self.bzrdir_format, t))
1414
 
        dir = controldir.ControlDir.open(t.base+",branch=foo")
 
1422
        dir = controldir.ControlDir.open(t.base + ",branch=foo")
1415
1423
        self.assertEqual(
1416
 
                {"branch": "foo"}, dir.user_transport.get_segment_parameters())
 
1424
            {"branch": "foo"}, dir.user_transport.get_segment_parameters())
1417
1425
        self.assertEqual("foo", dir._get_selected_branch())
1418
1426
 
1419
1427
    def test_get_selected_branch_none_selected(self):
1460
1468
        except errors.NoRepositoryPresent:
1461
1469
            pass
1462
1470
        self.assertRaises(
1463
 
                errors.NoRepositoryPresent, innermost_control.find_repository)
 
1471
            errors.NoRepositoryPresent, innermost_control.find_repository)
1464
1472
 
1465
1473
    def test_find_repository_containing_shared_repository(self):
1466
1474
        # find repo inside a shared repo with an empty control dir
1470
1478
        except errors.IncompatibleFormat:
1471
1479
            # need a shared repository to test this.
1472
1480
            raise TestNotApplicable(
1473
 
                    "requires format with shared repository support")
 
1481
                "requires format with shared repository support")
1474
1482
        if not repo._format.supports_nesting_repositories:
1475
1483
            raise TestNotApplicable(
1476
 
                    "requires support for nesting repositories")
 
1484
                "requires support for nesting repositories")
1477
1485
        url = self.get_url('childbzrdir')
1478
1486
        self.get_transport().mkdir('childbzrdir')
1479
1487
        made_control = self.bzrdir_format.initialize(url)
1496
1504
        except errors.IncompatibleFormat:
1497
1505
            # need a shared repository to test this.
1498
1506
            raise TestNotApplicable(
1499
 
                    "requires support for shared repositories")
 
1507
                "requires support for shared repositories")
1500
1508
        if not containing_repo._format.supports_nesting_repositories:
1501
1509
            raise TestNotApplicable(
1502
 
                    "format does not support nesting repositories")
 
1510
                "format does not support nesting repositories")
1503
1511
        child_repo = self.make_repository('childrepo')
1504
1512
        opened_control = controldir.ControlDir.open(self.get_url('childrepo'))
1505
1513
        found_repo = opened_control.find_repository()
1513
1521
        except errors.IncompatibleFormat:
1514
1522
            # need a shared repository to test this.
1515
1523
            raise TestNotApplicable(
1516
 
                    "requires support for shared repositories")
 
1524
                "requires support for shared repositories")
1517
1525
        if not containing_repo._format.supports_nesting_repositories:
1518
1526
            raise TestNotApplicable(
1519
 
                    "requires support for nesting repositories")
 
1527
                "requires support for nesting repositories")
1520
1528
        url = self.get_url('childrepo')
1521
1529
        self.get_transport().mkdir('childrepo')
1522
1530
        child_control = self.bzrdir_format.initialize(url)
1524
1532
        opened_control = controldir.ControlDir.open(self.get_url('childrepo'))
1525
1533
        found_repo = opened_control.find_repository()
1526
1534
        self.assertEqual(
1527
 
                child_repo.controldir.root_transport.base,
1528
 
                found_repo.controldir.root_transport.base)
 
1535
            child_repo.controldir.root_transport.base,
 
1536
            found_repo.controldir.root_transport.base)
1529
1537
        self.assertNotEqual(
1530
 
                child_repo.controldir.root_transport.base,
1531
 
                containing_repo.controldir.root_transport.base)
 
1538
            child_repo.controldir.root_transport.base,
 
1539
            containing_repo.controldir.root_transport.base)
1532
1540
 
1533
1541
    def test_find_repository_with_nested_dirs_works(self):
1534
1542
        # find repo inside a bzrdir inside a bzrdir inside a shared repo
1538
1546
        except errors.IncompatibleFormat:
1539
1547
            # need a shared repository to test this.
1540
1548
            raise TestNotApplicable(
1541
 
                    "requires support for shared repositories")
 
1549
                "requires support for shared repositories")
1542
1550
        if not repo._format.supports_nesting_repositories:
1543
1551
            raise TestNotApplicable(
1544
 
                    "requires support for nesting repositories")
 
1552
                "requires support for nesting repositories")
1545
1553
        url = self.get_url('intermediate')
1546
1554
        t = self.get_transport()
1547
1555
        t.mkdir('intermediate')
1669
1677
            thisdir.set_branch_reference(master)
1670
1678
        except errors.IncompatibleFormat:
1671
1679
            raise TestNotApplicable(
1672
 
                    "format does not support branch references")
 
1680
                "format does not support branch references")
1673
1681
        unused_repo = thisdir.create_repository()
1674
1682
        master.lock_write()
1675
1683
        with unused_repo.lock_write():
1684
1692
                master.controldir.break_lock()
1685
1693
            except NotImplementedError:
1686
1694
                # bzrdir does not support break_lock
1687
 
                raise TestNotApplicable("format does not support breaking locks")
 
1695
                raise TestNotApplicable(
 
1696
                    "format does not support breaking locks")
1688
1697
            if this_repo_locked:
1689
1698
                # only two ys should have been read
1690
1699
                self.assertEqual([True], breezy.ui.ui_factory.responses)
1767
1776
        # XXX: TODO this should become a 'bzrdirlocation' api call.
1768
1777
        url = self.get_vfs_only_url('subdir')
1769
1778
        transport.get_transport_from_url(
1770
 
                self.get_vfs_only_url()).mkdir('subdir')
 
1779
            self.get_vfs_only_url()).mkdir('subdir')
1771
1780
        made_control = self.bzrdir_format.initialize(self.get_url('subdir'))
1772
1781
        try:
1773
1782
            made_control.open_repository()
1777
1786
        except errors.NoRepositoryPresent:
1778
1787
            pass
1779
1788
        made_control = controldir.ControlDir.open(
1780
 
                self.get_readonly_url('subdir'))
 
1789
            self.get_readonly_url('subdir'))
1781
1790
        self.assertRaises(errors.NoRepositoryPresent,
1782
1791
                          made_control.find_repository)
1783
1792