/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/test_bzrdir.py

  • Committer: Jelmer Vernooij
  • Date: 2019-03-04 00:16:27 UTC
  • mfrom: (7293 work)
  • mto: This revision was merged to the branch mainline in revision 7318.
  • Revision ID: jelmer@jelmer.uk-20190304001627-v6u7o6pf97tukhek
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_bzrdir.py
60
60
    TestCaseWithTransport,
61
61
    TestSkipped,
62
62
    )
63
 
from . import(
 
63
from . import (
64
64
    http_server,
65
65
    http_utils,
66
66
    )
99
99
    def make_format_registry(self):
100
100
        my_format_registry = controldir.ControlDirFormatRegistry()
101
101
        my_format_registry.register('deprecated', DeprecatedBzrDirFormat,
102
 
            'Some format.  Slower and unawesome and deprecated.',
103
 
            deprecated=True)
 
102
                                    'Some format.  Slower and unawesome and deprecated.',
 
103
                                    deprecated=True)
104
104
        my_format_registry.register_lazy('lazy', 'breezy.tests.test_bzrdir',
105
 
            'DeprecatedBzrDirFormat', 'Format registered lazily',
106
 
            deprecated=True)
 
105
                                         'DeprecatedBzrDirFormat', 'Format registered lazily',
 
106
                                         deprecated=True)
107
107
        bzr.register_metadir(my_format_registry, 'knit',
108
 
            'breezy.bzr.knitrepo.RepositoryFormatKnit1',
109
 
            'Format using knits',
110
 
            )
 
108
                             'breezy.bzr.knitrepo.RepositoryFormatKnit1',
 
109
                             'Format using knits',
 
110
                             )
111
111
        my_format_registry.set_default('knit')
112
112
        bzr.register_metadir(my_format_registry,
113
 
            'branch6',
114
 
            'breezy.bzr.knitrepo.RepositoryFormatKnit3',
115
 
            'Experimental successor to knit.  Use at your own risk.',
116
 
            branch_format='breezy.bzr.branch.BzrBranchFormat6',
117
 
            experimental=True)
 
113
                             'branch6',
 
114
                             'breezy.bzr.knitrepo.RepositoryFormatKnit3',
 
115
                             'Experimental successor to knit.  Use at your own risk.',
 
116
                             branch_format='breezy.bzr.branch.BzrBranchFormat6',
 
117
                             experimental=True)
118
118
        bzr.register_metadir(my_format_registry,
119
 
            'hidden format',
120
 
            'breezy.bzr.knitrepo.RepositoryFormatKnit3',
121
 
            'Experimental successor to knit.  Use at your own risk.',
122
 
            branch_format='breezy.bzr.branch.BzrBranchFormat6', hidden=True)
 
119
                             'hidden format',
 
120
                             'breezy.bzr.knitrepo.RepositoryFormatKnit3',
 
121
                             'Experimental successor to knit.  Use at your own risk.',
 
122
                             branch_format='breezy.bzr.branch.BzrBranchFormat6', hidden=True)
123
123
        my_format_registry.register('hiddendeprecated', DeprecatedBzrDirFormat,
124
 
            'Old format.  Slower and does not support things. ', hidden=True)
 
124
                                    'Old format.  Slower and does not support things. ', hidden=True)
125
125
        my_format_registry.register_lazy('hiddenlazy', 'breezy.tests.test_bzrdir',
126
 
            'DeprecatedBzrDirFormat', 'Format registered lazily',
127
 
            deprecated=True, hidden=True)
 
126
                                         'DeprecatedBzrDirFormat', 'Format registered lazily',
 
127
                                         deprecated=True, hidden=True)
128
128
        return my_format_registry
129
129
 
130
130
    def test_format_registry(self):
135
135
        self.assertIsInstance(my_bzrdir, DeprecatedBzrDirFormat)
136
136
        my_bzrdir = my_format_registry.make_controldir('default')
137
137
        self.assertIsInstance(my_bzrdir.repository_format,
138
 
            knitrepo.RepositoryFormatKnit1)
 
138
                              knitrepo.RepositoryFormatKnit1)
139
139
        my_bzrdir = my_format_registry.make_controldir('knit')
140
140
        self.assertIsInstance(my_bzrdir.repository_format,
141
 
            knitrepo.RepositoryFormatKnit1)
 
141
                              knitrepo.RepositoryFormatKnit1)
142
142
        my_bzrdir = my_format_registry.make_controldir('branch6')
143
143
        self.assertIsInstance(my_bzrdir.get_branch_format(),
144
144
                              breezy.bzr.branch.BzrBranchFormat6)
166
166
        experimental, deprecated = rest.split('Deprecated formats')
167
167
        self.assertContainsRe(new, 'formats-help')
168
168
        self.assertContainsRe(new,
169
 
                ':knit:\n    \\(native\\) \\(default\\) Format using knits\n')
 
169
                              ':knit:\n    \\(native\\) \\(default\\) Format using knits\n')
170
170
        self.assertContainsRe(experimental,
171
 
                ':branch6:\n    \\(native\\) Experimental successor to knit')
 
171
                              ':branch6:\n    \\(native\\) Experimental successor to knit')
172
172
        self.assertContainsRe(deprecated,
173
 
                ':lazy:\n    \\(native\\) Format registered lazily\n')
 
173
                              ':lazy:\n    \\(native\\) Format registered lazily\n')
174
174
        self.assertNotContainsRe(new, 'hidden')
175
175
 
176
176
    def test_set_default_repository(self):
177
177
        default_factory = controldir.format_registry.get('default')
178
178
        old_default = [k for k, v in controldir.format_registry.iteritems()
179
179
                       if v == default_factory and k != 'default'][0]
180
 
        controldir.format_registry.set_default_repository('dirstate-with-subtree')
 
180
        controldir.format_registry.set_default_repository(
 
181
            'dirstate-with-subtree')
181
182
        try:
182
183
            self.assertIs(controldir.format_registry.get('dirstate-with-subtree'),
183
184
                          controldir.format_registry.get('default'))
190
191
    def test_aliases(self):
191
192
        a_registry = controldir.ControlDirFormatRegistry()
192
193
        a_registry.register('deprecated', DeprecatedBzrDirFormat,
193
 
            'Old format.  Slower and does not support stuff',
194
 
            deprecated=True)
 
194
                            'Old format.  Slower and does not support stuff',
 
195
                            deprecated=True)
195
196
        a_registry.register_alias('deprecatedalias', 'deprecated')
196
197
        self.assertEqual({'deprecatedalias': 'deprecated'},
197
198
                         a_registry.aliases())
282
283
        # is the right format object found for a branch?
283
284
        # create a branch with a few known format objects.
284
285
        bzr.BzrProber.formats.register(BzrDirFormatTest1.get_format_string(),
285
 
            BzrDirFormatTest1())
 
286
                                       BzrDirFormatTest1())
286
287
        self.addCleanup(bzr.BzrProber.formats.remove,
287
 
            BzrDirFormatTest1.get_format_string())
 
288
                        BzrDirFormatTest1.get_format_string())
288
289
        bzr.BzrProber.formats.register(BzrDirFormatTest2.get_format_string(),
289
 
            BzrDirFormatTest2())
 
290
                                       BzrDirFormatTest2())
290
291
        self.addCleanup(bzr.BzrProber.formats.remove,
291
 
            BzrDirFormatTest2.get_format_string())
 
292
                        BzrDirFormatTest2.get_format_string())
292
293
        t = self.get_transport()
293
294
        self.build_tree(["foo/", "bar/"], transport=t)
 
295
 
294
296
        def check_format(format, url):
295
297
            format.initialize(url)
296
298
            t = _mod_transport.get_transport_from_path(url)
312
314
                          bzrdir.BzrDirFormat.find_format,
313
315
                          _mod_transport.get_transport_from_path('.'))
314
316
 
 
317
    def test_find_format_line_endings(self):
 
318
        t = self.get_transport()
 
319
        t.mkdir('.bzr')
 
320
        t.put_bytes('.bzr/branch-format', b'Corrupt line endings\r\n')
 
321
        self.assertRaises(errors.LineEndingError,
 
322
                          bzrdir.BzrDirFormat.find_format,
 
323
                          _mod_transport.get_transport_from_path('.'))
 
324
 
315
325
    def test_register_unregister_format(self):
316
326
        format = SampleBzrDirFormat()
317
327
        url = self.get_url()
322
332
        # which bzrdir.Open will refuse (not supported)
323
333
        self.assertRaises(UnsupportedFormatError, bzrdir.BzrDir.open, url)
324
334
        # which bzrdir.open_containing will refuse (not supported)
325
 
        self.assertRaises(UnsupportedFormatError, bzrdir.BzrDir.open_containing, url)
 
335
        self.assertRaises(UnsupportedFormatError,
 
336
                          bzrdir.BzrDir.open_containing, url)
326
337
        # but open_downlevel will work
327
338
        t = _mod_transport.get_transport_from_url(url)
328
339
        self.assertEqual(format.open(t), bzrdir.BzrDir.open_unsupported(url))
329
340
        # unregister the format
330
341
        bzr.BzrProber.formats.remove(format.get_format_string())
331
342
        # now open_downlevel should fail too.
332
 
        self.assertRaises(UnknownFormatError, bzrdir.BzrDir.open_unsupported, url)
 
343
        self.assertRaises(UnknownFormatError,
 
344
                          bzrdir.BzrDir.open_unsupported, url)
333
345
 
334
346
    def test_create_branch_and_repo_uses_default(self):
335
347
        format = SampleBzrDirFormat()
378
390
                          bzrdir.BzrDir.create_standalone_workingtree,
379
391
                          self.get_readonly_url('child'), format=format)
380
392
        tree = bzrdir.BzrDir.create_standalone_workingtree('child',
381
 
            format=format)
 
393
                                                           format=format)
382
394
        tree.controldir.open_repository()
383
395
 
384
396
    def test_create_branch_convenience(self):
414
426
        format = controldir.format_registry.make_controldir('knit')
415
427
        self.make_repository('.', shared=True, format=format)
416
428
        branch = bzrdir.BzrDir.create_branch_convenience('child',
417
 
            format=format)
 
429
                                                         format=format)
418
430
        branch.controldir.open_workingtree()
419
431
        self.assertRaises(errors.NoRepositoryPresent,
420
432
                          branch.controldir.open_repository)
425
437
        format = controldir.format_registry.make_controldir('knit')
426
438
        self.make_repository('.', shared=True, format=format)
427
439
        branch = bzrdir.BzrDir.create_branch_convenience('child',
428
 
            force_new_tree=False, format=format)
 
440
                                                         force_new_tree=False, format=format)
429
441
        self.assertRaises(errors.NoWorkingTree,
430
442
                          branch.controldir.open_workingtree)
431
443
        self.assertRaises(errors.NoRepositoryPresent,
451
463
        repo = self.make_repository('.', shared=True, format=format)
452
464
        repo.set_make_working_trees(False)
453
465
        branch = bzrdir.BzrDir.create_branch_convenience('child',
454
 
            force_new_tree=True, format=format)
 
466
                                                         force_new_tree=True, format=format)
455
467
        branch.controldir.open_workingtree()
456
468
        self.assertRaises(errors.NoRepositoryPresent,
457
469
                          branch.controldir.open_repository)
462
474
        format = controldir.format_registry.make_controldir('knit')
463
475
        self.make_repository('.', shared=True, format=format)
464
476
        branch = bzrdir.BzrDir.create_branch_convenience('child',
465
 
            force_new_repo=True, format=format)
 
477
                                                         force_new_repo=True, format=format)
466
478
        branch.controldir.open_repository()
467
479
        branch.controldir.open_workingtree()
468
480
 
503
515
 
504
516
    def test_clone_on_transport_obeys_stacking_policy(self):
505
517
        child_branch, new_child_transport = self.prepare_default_stacking()
506
 
        new_child = child_branch.controldir.clone_on_transport(new_child_transport)
 
518
        new_child = child_branch.controldir.clone_on_transport(
 
519
            new_child_transport)
507
520
        self.assertEqual(child_branch.base,
508
521
                         new_child.open_branch().get_stacked_on_url())
509
522
 
531
544
        # Should end up with a 1.9 format (stackable)
532
545
        repo, control, require_stacking, repo_policy = \
533
546
            old_fmt.initialize_on_transport_ex(t,
534
 
                    repo_format_name=repo_name, stacked_on='../trunk',
535
 
                    stack_on_pwd=t.base)
 
547
                                               repo_format_name=repo_name, stacked_on='../trunk',
 
548
                                               stack_on_pwd=t.base)
536
549
        if repo is not None:
537
550
            # Repositories are open write-locked
538
551
            self.assertTrue(repo.is_write_locked())
543
556
        opened = bzrdir.BzrDir.open(t.base)
544
557
        if not isinstance(old_fmt, remote.RemoteBzrDirFormat):
545
558
            self.assertEqual(control._format.network_name(),
546
 
                old_fmt.network_name())
 
559
                             old_fmt.network_name())
547
560
            self.assertEqual(control._format.network_name(),
548
 
                opened._format.network_name())
 
561
                             opened._format.network_name())
549
562
        self.assertEqual(control.__class__, opened.__class__)
550
563
        self.assertLength(1, repo._fallback_repositories)
551
564
 
558
571
    def test_clone_ignores_policy_for_unsupported_formats(self):
559
572
        child_branch, new_child_transport = self.prepare_default_stacking(
560
573
            child_format='pack-0.92')
561
 
        new_child = child_branch.controldir.clone_on_transport(new_child_transport)
 
574
        new_child = child_branch.controldir.clone_on_transport(
 
575
            new_child_transport)
562
576
        self.assertRaises(branch.UnstackableBranchFormat,
563
577
                          new_child.open_branch().get_stacked_on_url)
564
578
 
573
587
        child_branch, new_child_transport = self.prepare_default_stacking(
574
588
            child_format='pack-0.92')
575
589
        new_child = child_branch.controldir.sprout(new_child_transport.base,
576
 
                                               stacked=True)
 
590
                                                   stacked=True)
577
591
        self.assertEqual(child_branch.controldir.root_transport.base,
578
592
                         new_child.open_branch().get_stacked_on_url())
579
593
        repo = new_child.open_repository()
584
598
        child_branch, new_child_transport = self.prepare_default_stacking(
585
599
            child_format='pack-0.92')
586
600
        new_child = child_branch.controldir.clone_on_transport(new_child_transport,
587
 
            stacked_on=child_branch.controldir.root_transport.base)
 
601
                                                               stacked_on=child_branch.controldir.root_transport.base)
588
602
        self.assertEqual(child_branch.controldir.root_transport.base,
589
603
                         new_child.open_branch().get_stacked_on_url())
590
604
        repo = new_child.open_repository()
595
609
        child_branch, new_child_transport = self.prepare_default_stacking(
596
610
            child_format='rich-root-pack')
597
611
        new_child = child_branch.controldir.sprout(new_child_transport.base,
598
 
                                               stacked=True)
 
612
                                                   stacked=True)
599
613
        repo = new_child.open_repository()
600
614
        self.assertTrue(repo._format.supports_external_lookups)
601
615
        self.assertTrue(repo.supports_rich_root())
616
630
        stack_on = self.make_branch('stack_on', format='1.6')
617
631
        stacked = self.make_branch('stack_on/stacked', format='1.6')
618
632
        policy = bzrdir.UseExistingRepository(stacked.repository,
619
 
            '.', stack_on.base)
 
633
                                              '.', stack_on.base)
620
634
        policy.configure_branch(stacked)
621
635
        self.assertEqual('..', stacked.get_stacked_on_url())
622
636
 
624
638
        stack_on = self.make_branch('stack_on', format='1.6')
625
639
        stacked = self.make_branch('stack_on/stacked', format='1.6')
626
640
        policy = bzrdir.UseExistingRepository(stacked.repository,
627
 
            '.', self.get_readonly_url('stack_on'))
 
641
                                              '.', self.get_readonly_url('stack_on'))
628
642
        policy.configure_branch(stacked)
629
643
        self.assertEqual(self.get_readonly_url('stack_on'),
630
644
                         stacked.get_stacked_on_url())
644
658
            self.transport_readonly_server = http_server.HttpServer
645
659
 
646
660
    def local_branch_path(self, branch):
647
 
         return os.path.realpath(urlutils.local_path_from_url(branch.base))
 
661
        return os.path.realpath(urlutils.local_path_from_url(branch.base))
648
662
 
649
663
    def test_open_containing(self):
650
664
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing,
652
666
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing,
653
667
                          self.get_readonly_url('g/p/q'))
654
668
        control = bzrdir.BzrDir.create(self.get_url())
655
 
        branch, relpath = bzrdir.BzrDir.open_containing(self.get_readonly_url(''))
 
669
        branch, relpath = bzrdir.BzrDir.open_containing(
 
670
            self.get_readonly_url(''))
656
671
        self.assertEqual('', relpath)
657
 
        branch, relpath = bzrdir.BzrDir.open_containing(self.get_readonly_url('g/p/q'))
 
672
        branch, relpath = bzrdir.BzrDir.open_containing(
 
673
            self.get_readonly_url('g/p/q'))
658
674
        self.assertEqual('g/p/q', relpath)
659
675
 
660
676
    def test_open_containing_tree_branch_or_repository_empty(self):
661
677
        self.assertRaises(errors.NotBranchError,
662
 
            bzrdir.BzrDir.open_containing_tree_branch_or_repository,
663
 
            self.get_readonly_url(''))
 
678
                          bzrdir.BzrDir.open_containing_tree_branch_or_repository,
 
679
                          self.get_readonly_url(''))
664
680
 
665
681
    def test_open_containing_tree_branch_or_repository_all(self):
666
682
        self.make_branch_and_tree('topdir')
746
762
 
747
763
    def test_open_containing_from_transport(self):
748
764
        self.assertRaises(NotBranchError,
749
 
            bzrdir.BzrDir.open_containing_from_transport,
750
 
            _mod_transport.get_transport_from_url(self.get_readonly_url('')))
 
765
                          bzrdir.BzrDir.open_containing_from_transport,
 
766
                          _mod_transport.get_transport_from_url(self.get_readonly_url('')))
751
767
        self.assertRaises(NotBranchError,
752
 
            bzrdir.BzrDir.open_containing_from_transport,
753
 
            _mod_transport.get_transport_from_url(
754
 
                self.get_readonly_url('g/p/q')))
 
768
                          bzrdir.BzrDir.open_containing_from_transport,
 
769
                          _mod_transport.get_transport_from_url(
 
770
                              self.get_readonly_url('g/p/q')))
755
771
        control = bzrdir.BzrDir.create(self.get_url())
756
772
        branch, relpath = bzrdir.BzrDir.open_containing_from_transport(
757
773
            _mod_transport.get_transport_from_url(
829
845
        tree = self.make_branch_and_tree('tree1',
830
846
                                         format='development-subtree')
831
847
        sub_tree = self.make_branch_and_tree('tree1/subtree',
832
 
            format='development-subtree')
 
848
                                             format='development-subtree')
833
849
        sub_tree.set_root_id(b'subtree-root')
834
850
        tree.add_reference(sub_tree)
835
851
        self.build_tree(['tree1/subtree/file'])
839
855
        tree2.lock_read()
840
856
        self.addCleanup(tree2.unlock)
841
857
        self.assertPathExists('tree2/subtree/file')
842
 
        self.assertEqual(
843
 
                'tree-reference',
844
 
                tree2.kind('subtree', 'subtree-root'))
 
858
        self.assertEqual('tree-reference', tree2.kind('subtree'))
845
859
 
846
860
    def test_cloning_metadir(self):
847
861
        """Ensure that cloning metadir is suitable"""
850
864
        branch = self.make_branch('branch', format='knit')
851
865
        format = branch.controldir.cloning_metadir()
852
866
        self.assertIsInstance(format.workingtree_format,
853
 
            workingtree_4.WorkingTreeFormat6)
 
867
                              workingtree_4.WorkingTreeFormat6)
854
868
 
855
869
    def test_sprout_recursive_treeless(self):
856
870
        tree = self.make_branch_and_tree('tree1',
857
 
            format='development-subtree')
 
871
                                         format='development-subtree')
858
872
        sub_tree = self.make_branch_and_tree('tree1/subtree',
859
 
            format='development-subtree')
 
873
                                             format='development-subtree')
860
874
        tree.add_reference(sub_tree)
861
875
        self.build_tree(['tree1/subtree/file'])
862
876
        sub_tree.add('file')
868
882
        # FIXME: subtree/.bzr is left here which allows the test to pass (or
869
883
        # fail :-( ) -- vila 20100909
870
884
        repo = self.make_repository('repo', shared=True,
871
 
            format='development-subtree')
 
885
                                    format='development-subtree')
872
886
        repo.set_make_working_trees(False)
873
887
        # FIXME: we just deleted the workingtree and now we want to use it ????
874
888
        # At a minimum, we should use tree.branch below (but this fails too
892
906
    def test_find_controldirs(self):
893
907
        foo, bar, baz = self.make_foo_bar_baz()
894
908
        t = self.get_transport()
895
 
        self.assertEqualBzrdirs([baz, foo, bar], bzrdir.BzrDir.find_controldirs(t))
 
909
        self.assertEqualBzrdirs(
 
910
            [baz, foo, bar], bzrdir.BzrDir.find_controldirs(t))
896
911
 
897
912
    def make_fake_permission_denied_transport(self, transport, paths):
898
913
        """Create a transport that raises PermissionDenied for some paths."""
919
934
            self.make_fake_permission_denied_transport(t, ['foo'])
920
935
        # local transport
921
936
        self.assertBranchUrlsEndWith('/baz/',
922
 
            bzrdir.BzrDir.find_controldirs(path_filter_transport))
 
937
                                     bzrdir.BzrDir.find_controldirs(path_filter_transport))
923
938
        # smart server
924
939
        smart_transport = self.make_smart_server('.',
925
 
            backing_server=path_filter_server)
 
940
                                                 backing_server=path_filter_server)
926
941
        self.assertBranchUrlsEndWith('/baz/',
927
 
            bzrdir.BzrDir.find_controldirs(smart_transport))
 
942
                                     bzrdir.BzrDir.find_controldirs(smart_transport))
928
943
 
929
944
    def test_find_controldirs_list_current(self):
930
945
        def list_current(transport):
982
997
        abranch = bzrdir.BzrDir.create(abranch_url).create_branch()
983
998
        t.delete_tree('arepo/.bzr')
984
999
        self.assertRaises(errors.NoRepositoryPresent,
985
 
            branch.Branch.open, abranch_url)
 
1000
                          branch.Branch.open, abranch_url)
986
1001
        self.make_branch('baz')
987
1002
        for actual_bzrdir in bzrdir.BzrDir.find_branches(t):
988
1003
            self.assertEndsWith(actual_bzrdir.user_url, '/baz/')
999
1014
        self.assertEqual(branch_base,
1000
1015
                         dir.get_branch_transport(BzrBranchFormat5()).base)
1001
1016
        repository_base = t.clone('repository').base
1002
 
        self.assertEqual(repository_base, dir.get_repository_transport(None).base)
 
1017
        self.assertEqual(
 
1018
            repository_base, dir.get_repository_transport(None).base)
1003
1019
        repository_format = repository.format_registry.get_default()
1004
1020
        self.assertEqual(repository_base,
1005
1021
                         dir.get_repository_transport(repository_format).base)
1006
1022
        checkout_base = t.clone('checkout').base
1007
 
        self.assertEqual(checkout_base, dir.get_workingtree_transport(None).base)
 
1023
        self.assertEqual(
 
1024
            checkout_base, dir.get_workingtree_transport(None).base)
1008
1025
        self.assertEqual(checkout_base,
1009
1026
                         dir.get_workingtree_transport(workingtree_3.WorkingTreeFormat3()).base)
1010
1027
 
1026
1043
        otherdir = controldir.format_registry.make_controldir('knit')
1027
1044
        self.assertEqual(otherdir, mydir)
1028
1045
        self.assertFalse(otherdir != mydir)
1029
 
        otherdir2 = controldir.format_registry.make_controldir('development-subtree')
 
1046
        otherdir2 = controldir.format_registry.make_controldir(
 
1047
            'development-subtree')
1030
1048
        self.assertNotEqual(otherdir2, mydir)
1031
1049
        self.assertFalse(otherdir2 == mydir)
1032
1050
 
1088
1106
        # outside a repo the default convenience output is a repo+branch_tree
1089
1107
        format = controldir.format_registry.make_controldir('knit')
1090
1108
        self.assertRaises(errors.NotLocalUrl,
1091
 
            bzrdir.BzrDir.create_branch_convenience,
1092
 
            self.get_url('foo'),
1093
 
            force_new_tree=True,
1094
 
            format=format)
 
1109
                          bzrdir.BzrDir.create_branch_convenience,
 
1110
                          self.get_url('foo'),
 
1111
                          force_new_tree=True,
 
1112
                          format=format)
1095
1113
        t = self.get_transport()
1096
1114
        self.assertFalse(t.has('foo'))
1097
1115
 
1183
1201
        return result
1184
1202
 
1185
1203
 
1186
 
 
1187
1204
class TestHTTPRedirections_nosmart(TestHTTPRedirectionsBase,
1188
 
                                  http_utils.TestCaseWithTwoWebservers):
 
1205
                                   http_utils.TestCaseWithTwoWebservers):
1189
1206
    """Tests redirections for the nosmart decorator"""
1190
1207
 
1191
1208
    _transport = NoSmartTransportDecorator
1216
1233
 
1217
1234
    def get_ls(self):
1218
1235
        f = subprocess.Popen(self.ls, stdout=subprocess.PIPE,
1219
 
            stderr=subprocess.PIPE)
 
1236
                             stderr=subprocess.PIPE)
1220
1237
        out, err = f.communicate()
1221
1238
        self.assertEqual(0, f.returncode, 'Calling %s failed: %s'
1222
1239
                         % (self.ls, err))
1224
1241
 
1225
1242
    def test_dot_bzr_hidden(self):
1226
1243
        if sys.platform == 'win32' and not win32utils.has_win32file:
1227
 
            raise TestSkipped('unable to make file hidden without pywin32 library')
 
1244
            raise TestSkipped(
 
1245
                'unable to make file hidden without pywin32 library')
1228
1246
        b = bzrdir.BzrDir.create('.')
1229
1247
        self.build_tree(['a'])
1230
1248
        self.assertEqual([b'a'], self.get_ls())
1231
1249
 
1232
1250
    def test_dot_bzr_hidden_with_url(self):
1233
1251
        if sys.platform == 'win32' and not win32utils.has_win32file:
1234
 
            raise TestSkipped('unable to make file hidden without pywin32 library')
 
1252
            raise TestSkipped(
 
1253
                'unable to make file hidden without pywin32 library')
1235
1254
        b = bzrdir.BzrDir.create(urlutils.local_path_to_url('.'))
1236
1255
        self.build_tree(['a'])
1237
1256
        self.assertEqual([b'a'], self.get_ls())
1356
1375
 
1357
1376
    def test_pre_open_actual_exceptions_raised(self):
1358
1377
        count = [0]
 
1378
 
1359
1379
        def fail_once(transport):
1360
1380
            count[0] += 1
1361
1381
            if count[0] == 1:
1370
1390
        from ..controldir import RepoInitHookParams
1371
1391
        calls = []
1372
1392
        bzrdir.BzrDir.hooks.install_named_hook('post_repo_init',
1373
 
            calls.append, None)
 
1393
                                               calls.append, None)
1374
1394
        self.make_repository('foo')
1375
1395
        self.assertLength(1, calls)
1376
1396
        params = calls[0]
1381
1401
    def test_post_repo_init_hook_repr(self):
1382
1402
        param_reprs = []
1383
1403
        bzrdir.BzrDir.hooks.install_named_hook('post_repo_init',
1384
 
            lambda params: param_reprs.append(repr(params)), None)
 
1404
                                               lambda params: param_reprs.append(repr(params)), None)
1385
1405
        self.make_repository('foo')
1386
1406
        self.assertLength(1, param_reprs)
1387
1407
        param_repr = param_reprs[0]
1397
1417
        super(TestGenerateBackupName, self).setUp()
1398
1418
        self._transport = self.get_transport()
1399
1419
        bzrdir.BzrDir.create(self.get_url(),
1400
 
            possible_transports=[self._transport])
 
1420
                             possible_transports=[self._transport])
1401
1421
        self._bzrdir = bzrdir.BzrDir.open_from_transport(self._transport)
1402
1422
 
1403
1423
    def test_new(self):
1457
1477
            errors.AlreadyBranchError, tree.controldir.create_branch,
1458
1478
            name='foo')
1459
1479
 
 
1480
    def test_supports_relative_reference(self):
 
1481
        tree = self.make_branch_and_tree('.', format='development-colo')
 
1482
        target1 = tree.controldir.create_branch(name='target1')
 
1483
        target2 = tree.controldir.create_branch(name='target2')
 
1484
        source = tree.controldir.set_branch_reference(target1, name='source')
 
1485
        self.assertEqual(
 
1486
            target1.user_url, tree.controldir.open_branch('source').user_url)
 
1487
        source.controldir.get_branch_transport(None, 'source').put_bytes(
 
1488
            'location', b'file:,branch=target2')
 
1489
        self.assertEqual(
 
1490
            target2.user_url, tree.controldir.open_branch('source').user_url)
 
1491
 
1460
1492
 
1461
1493
class SampleBzrFormat(bzrdir.BzrFormat):
1462
1494
 
1472
1504
        format = SampleBzrFormat()
1473
1505
        format.features = {b"foo": b"required"}
1474
1506
        self.assertEqual(format.as_string(),
1475
 
            b"First line\n"
1476
 
            b"required foo\n")
 
1507
                         b"First line\n"
 
1508
                         b"required foo\n")
1477
1509
        format.features[b"another"] = b"optional"
1478
1510
        self.assertEqual(format.as_string(),
1479
 
            b"First line\n"
1480
 
            b"optional another\n"
1481
 
            b"required foo\n")
 
1511
                         b"First line\n"
 
1512
                         b"optional another\n"
 
1513
                         b"required foo\n")
1482
1514
 
1483
1515
    def test_network_name(self):
1484
1516
        # The network string should include the feature info
1503
1535
    def test_from_string_format_string_mismatch(self):
1504
1536
        # The first line has to match the format string
1505
1537
        self.assertRaises(AssertionError, SampleBzrFormat.from_string,
1506
 
            b"Second line\nrequired foo\n")
 
1538
                          b"Second line\nrequired foo\n")
1507
1539
 
1508
1540
    def test_from_string_missing_space(self):
1509
1541
        # At least one space is required in the feature lines
1510
1542
        self.assertRaises(errors.ParseFormatError, SampleBzrFormat.from_string,
1511
 
            b"First line\nfoo\n")
 
1543
                          b"First line\nfoo\n")
1512
1544
 
1513
1545
    def test_from_string_with_spaces(self):
1514
1546
        # Feature with spaces (in case we add stuff like this in the future)
1540
1572
        format = SampleBzrFormat()
1541
1573
        format.features = {b"nested-trees": b"required"}
1542
1574
        self.assertRaises(bzrdir.MissingFeature, format.check_support_status,
1543
 
            True)
 
1575
                          True)
1544
1576
        self.addCleanup(SampleBzrFormat.unregister_feature, b"nested-trees")
1545
1577
        SampleBzrFormat.register_feature(b"nested-trees")
1546
1578
        format.check_support_status(True)
1550
1582
        format = SampleBzrFormat()
1551
1583
        format.features = {b"nested-trees": b"unknown"}
1552
1584
        self.assertRaises(bzrdir.MissingFeature, format.check_support_status,
1553
 
            True)
 
1585
                          True)
1554
1586
        self.addCleanup(SampleBzrFormat.unregister_feature, b"nested-trees")
1555
1587
        SampleBzrFormat.register_feature(b"nested-trees")
1556
1588
        format.check_support_status(True)
1560
1592
        self.addCleanup(SampleBzrFormat.unregister_feature, b"nested-trees")
1561
1593
        SampleBzrFormat.register_feature(b"nested-trees")
1562
1594
        self.assertRaises(bzrdir.FeatureAlreadyRegistered,
1563
 
            SampleBzrFormat.register_feature, b"nested-trees")
 
1595
                          SampleBzrFormat.register_feature, b"nested-trees")
1564
1596
 
1565
1597
    def test_feature_with_space(self):
1566
1598
        # spaces are not allowed in feature names
1567
1599
        self.assertRaises(ValueError, SampleBzrFormat.register_feature,
1568
 
            b"nested trees")
 
1600
                          b"nested trees")