← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_bzrdir.py

  • Committer: Robert Collins
  • Date: 2010-05-06 07:48:22 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506074822-0bsgf2j4h8jx0xkk
Added ``bzrlib.tests.matchers`` as a place to put matchers, along with
our first in-tree matcher. See the module docstring for details.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_bzrdir.py
1
 
# Copyright (C) 2006-2011 Canonical Ltd
 
1
# Copyright (C) 2006-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
24
24
import sys
25
25
 
26
26
from bzrlib import (
27
 
    branch,
28
27
    bzrdir,
29
 
    controldir,
30
28
    errors,
31
29
    help_topics,
32
 
    lock,
33
30
    repository,
34
 
    revision as _mod_revision,
35
31
    osutils,
36
32
    remote,
37
 
    symbol_versioning,
38
 
    transport as _mod_transport,
39
33
    urlutils,
40
34
    win32utils,
41
35
    workingtree,
42
36
    )
43
37
import bzrlib.branch
44
 
from bzrlib.errors import (
45
 
    NotBranchError,
46
 
    NoColocatedBranchSupport,
47
 
    UnknownFormatError,
48
 
    UnsupportedFormatError,
49
 
    )
 
38
from bzrlib.errors import (NotBranchError,
 
39
                           NoColocatedBranchSupport,
 
40
                           UnknownFormatError,
 
41
                           UnsupportedFormatError,
 
42
                           )
50
43
from bzrlib.tests import (
51
44
    TestCase,
52
45
    TestCaseWithMemoryTransport,
59
52
    )
60
53
from bzrlib.tests.test_http import TestWithTransport_pycurl
61
54
from bzrlib.transport import (
 
55
    get_transport,
62
56
    memory,
63
 
    pathfilter,
64
57
    )
65
58
from bzrlib.transport.http._urllib import HttpTransport_urllib
66
59
from bzrlib.transport.nosmart import NoSmartTransportDecorator
67
60
from bzrlib.transport.readonly import ReadonlyTransportDecorator
68
 
from bzrlib.repofmt import knitrepo, pack_repo
 
61
from bzrlib.repofmt import knitrepo, weaverepo, pack_repo
69
62
 
70
63
 
71
64
class TestDefaultFormat(TestCase):
72
65
 
73
66
    def test_get_set_default_format(self):
74
67
        old_format = bzrdir.BzrDirFormat.get_default_format()
75
 
        # default is BzrDirMetaFormat1
 
68
        # default is BzrDirFormat6
76
69
        self.failUnless(isinstance(old_format, bzrdir.BzrDirMetaFormat1))
77
 
        controldir.ControlDirFormat._set_default_format(SampleBzrDirFormat())
 
70
        bzrdir.BzrDirFormat._set_default_format(SampleBzrDirFormat())
78
71
        # creating a bzr dir should now create an instrumented dir.
79
72
        try:
80
73
            result = bzrdir.BzrDir.create('memory:///')
81
74
            self.failUnless(isinstance(result, SampleBzrDir))
82
75
        finally:
83
 
            controldir.ControlDirFormat._set_default_format(old_format)
 
76
            bzrdir.BzrDirFormat._set_default_format(old_format)
84
77
        self.assertEqual(old_format, bzrdir.BzrDirFormat.get_default_format())
85
78
 
86
79
 
87
 
class DeprecatedBzrDirFormat(bzrdir.BzrDirFormat):
88
 
    """A deprecated bzr dir format."""
89
 
 
90
 
 
91
80
class TestFormatRegistry(TestCase):
92
81
 
93
82
    def make_format_registry(self):
94
 
        my_format_registry = controldir.ControlDirFormatRegistry()
95
 
        my_format_registry.register('deprecated', DeprecatedBzrDirFormat,
96
 
            'Some format.  Slower and unawesome and deprecated.',
97
 
            deprecated=True)
98
 
        my_format_registry.register_lazy('lazy', 'bzrlib.tests.test_bzrdir',
99
 
            'DeprecatedBzrDirFormat', 'Format registered lazily',
100
 
            deprecated=True)
101
 
        bzrdir.register_metadir(my_format_registry, 'knit',
 
83
        my_format_registry = bzrdir.BzrDirFormatRegistry()
 
84
        my_format_registry.register('weave', bzrdir.BzrDirFormat6,
 
85
            'Pre-0.8 format.  Slower and does not support checkouts or shared'
 
86
            ' repositories', deprecated=True)
 
87
        my_format_registry.register_lazy('lazy', 'bzrlib.bzrdir',
 
88
            'BzrDirFormat6', 'Format registered lazily', deprecated=True)
 
89
        my_format_registry.register_metadir('knit',
102
90
            'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
103
91
            'Format using knits',
104
92
            )
105
93
        my_format_registry.set_default('knit')
106
 
        bzrdir.register_metadir(my_format_registry,
 
94
        my_format_registry.register_metadir(
107
95
            'branch6',
108
96
            'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
109
97
            'Experimental successor to knit.  Use at your own risk.',
110
98
            branch_format='bzrlib.branch.BzrBranchFormat6',
111
99
            experimental=True)
112
 
        bzrdir.register_metadir(my_format_registry,
 
100
        my_format_registry.register_metadir(
113
101
            'hidden format',
114
102
            'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
115
103
            'Experimental successor to knit.  Use at your own risk.',
116
104
            branch_format='bzrlib.branch.BzrBranchFormat6', hidden=True)
117
 
        my_format_registry.register('hiddendeprecated', DeprecatedBzrDirFormat,
118
 
            'Old format.  Slower and does not support things. ', hidden=True)
119
 
        my_format_registry.register_lazy('hiddenlazy', 'bzrlib.tests.test_bzrdir',
120
 
            'DeprecatedBzrDirFormat', 'Format registered lazily',
121
 
            deprecated=True, hidden=True)
 
105
        my_format_registry.register('hiddenweave', bzrdir.BzrDirFormat6,
 
106
            'Pre-0.8 format.  Slower and does not support checkouts or shared'
 
107
            ' repositories', hidden=True)
 
108
        my_format_registry.register_lazy('hiddenlazy', 'bzrlib.bzrdir',
 
109
            'BzrDirFormat6', 'Format registered lazily', deprecated=True,
 
110
            hidden=True)
122
111
        return my_format_registry
123
112
 
124
113
    def test_format_registry(self):
125
114
        my_format_registry = self.make_format_registry()
126
115
        my_bzrdir = my_format_registry.make_bzrdir('lazy')
127
 
        self.assertIsInstance(my_bzrdir, DeprecatedBzrDirFormat)
128
 
        my_bzrdir = my_format_registry.make_bzrdir('deprecated')
129
 
        self.assertIsInstance(my_bzrdir, DeprecatedBzrDirFormat)
 
116
        self.assertIsInstance(my_bzrdir, bzrdir.BzrDirFormat6)
 
117
        my_bzrdir = my_format_registry.make_bzrdir('weave')
 
118
        self.assertIsInstance(my_bzrdir, bzrdir.BzrDirFormat6)
130
119
        my_bzrdir = my_format_registry.make_bzrdir('default')
131
120
        self.assertIsInstance(my_bzrdir.repository_format,
132
121
            knitrepo.RepositoryFormatKnit1)
145
134
                         my_format_registry.get_help('knit'))
146
135
        self.assertEqual('Format using knits',
147
136
                         my_format_registry.get_help('default'))
148
 
        self.assertEqual('Some format.  Slower and unawesome and deprecated.',
149
 
                         my_format_registry.get_help('deprecated'))
 
137
        self.assertEqual('Pre-0.8 format.  Slower and does not support'
 
138
                         ' checkouts or shared repositories',
 
139
                         my_format_registry.get_help('weave'))
150
140
 
151
141
    def test_help_topic(self):
152
142
        topics = help_topics.HelpTopicRegistry()
176
166
            self.assertIs(bzrdir.format_registry.get('dirstate-with-subtree'),
177
167
                          bzrdir.format_registry.get('default'))
178
168
            self.assertIs(
179
 
                repository.format_registry.get_default().__class__,
 
169
                repository.RepositoryFormat.get_default_format().__class__,
180
170
                knitrepo.RepositoryFormatKnit3)
181
171
        finally:
182
172
            bzrdir.format_registry.set_default_repository(old_default)
183
173
 
184
174
    def test_aliases(self):
185
 
        a_registry = controldir.ControlDirFormatRegistry()
186
 
        a_registry.register('deprecated', DeprecatedBzrDirFormat,
187
 
            'Old format.  Slower and does not support stuff',
188
 
            deprecated=True)
189
 
        a_registry.register('deprecatedalias', DeprecatedBzrDirFormat,
190
 
            'Old format.  Slower and does not support stuff',
191
 
            deprecated=True, alias=True)
192
 
        self.assertEqual(frozenset(['deprecatedalias']), a_registry.aliases())
 
175
        a_registry = bzrdir.BzrDirFormatRegistry()
 
176
        a_registry.register('weave', bzrdir.BzrDirFormat6,
 
177
            'Pre-0.8 format.  Slower and does not support checkouts or shared'
 
178
            ' repositories', deprecated=True)
 
179
        a_registry.register('weavealias', bzrdir.BzrDirFormat6,
 
180
            'Pre-0.8 format.  Slower and does not support checkouts or shared'
 
181
            ' repositories', deprecated=True, alias=True)
 
182
        self.assertEqual(frozenset(['weavealias']), a_registry.aliases())
193
183
 
194
184
 
195
185
class SampleBranch(bzrlib.branch.Branch):
252
242
        return "opened branch."
253
243
 
254
244
 
255
 
class BzrDirFormatTest1(bzrdir.BzrDirMetaFormat1):
256
 
 
257
 
    @staticmethod
258
 
    def get_format_string():
259
 
        return "Test format 1"
260
 
 
261
 
 
262
 
class BzrDirFormatTest2(bzrdir.BzrDirMetaFormat1):
263
 
 
264
 
    @staticmethod
265
 
    def get_format_string():
266
 
        return "Test format 2"
267
 
 
268
 
 
269
245
class TestBzrDirFormat(TestCaseWithTransport):
270
246
    """Tests for the BzrDirFormat facility."""
271
247
 
272
248
    def test_find_format(self):
273
249
        # is the right format object found for a branch?
274
250
        # create a branch with a few known format objects.
275
 
        bzrdir.BzrDirFormat.register_format(BzrDirFormatTest1())
276
 
        self.addCleanup(bzrdir.BzrDirFormat.unregister_format, BzrDirFormatTest1())
277
 
        bzrdir.BzrDirFormat.register_format(BzrDirFormatTest2())
278
 
        self.addCleanup(bzrdir.BzrDirFormat.unregister_format, BzrDirFormatTest2())
279
 
        t = self.get_transport()
 
251
        # this is not quite the same as
 
252
        t = get_transport(self.get_url())
280
253
        self.build_tree(["foo/", "bar/"], transport=t)
281
254
        def check_format(format, url):
282
255
            format.initialize(url)
283
 
            t = _mod_transport.get_transport(url)
 
256
            t = get_transport(url)
284
257
            found_format = bzrdir.BzrDirFormat.find_format(t)
285
258
            self.failUnless(isinstance(found_format, format.__class__))
286
 
        check_format(BzrDirFormatTest1(), "foo")
287
 
        check_format(BzrDirFormatTest2(), "bar")
 
259
        check_format(bzrdir.BzrDirFormat5(), "foo")
 
260
        check_format(bzrdir.BzrDirFormat6(), "bar")
288
261
 
289
262
    def test_find_format_nothing_there(self):
290
263
        self.assertRaises(NotBranchError,
291
264
                          bzrdir.BzrDirFormat.find_format,
292
 
                          _mod_transport.get_transport('.'))
 
265
                          get_transport('.'))
293
266
 
294
267
    def test_find_format_unknown_format(self):
295
 
        t = self.get_transport()
 
268
        t = get_transport(self.get_url())
296
269
        t.mkdir('.bzr')
297
270
        t.put_bytes('.bzr/branch-format', '')
298
271
        self.assertRaises(UnknownFormatError,
299
272
                          bzrdir.BzrDirFormat.find_format,
300
 
                          _mod_transport.get_transport('.'))
 
273
                          get_transport('.'))
301
274
 
302
275
    def test_register_unregister_format(self):
303
276
        format = SampleBzrDirFormat()
311
284
        # which bzrdir.open_containing will refuse (not supported)
312
285
        self.assertRaises(UnsupportedFormatError, bzrdir.BzrDir.open_containing, url)
313
286
        # but open_downlevel will work
314
 
        t = _mod_transport.get_transport(url)
 
287
        t = get_transport(url)
315
288
        self.assertEqual(format.open(t), bzrdir.BzrDir.open_unsupported(url))
316
289
        # unregister the format
317
290
        bzrdir.BzrDirFormat.unregister_format(format)
703
676
        self.assertEqual(relpath, 'baz')
704
677
 
705
678
    def test_open_containing_from_transport(self):
706
 
        self.assertRaises(NotBranchError,
707
 
            bzrdir.BzrDir.open_containing_from_transport,
708
 
            _mod_transport.get_transport(self.get_readonly_url('')))
709
 
        self.assertRaises(NotBranchError,
710
 
            bzrdir.BzrDir.open_containing_from_transport,
711
 
            _mod_transport.get_transport(self.get_readonly_url('g/p/q')))
 
679
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing_from_transport,
 
680
                          get_transport(self.get_readonly_url('')))
 
681
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing_from_transport,
 
682
                          get_transport(self.get_readonly_url('g/p/q')))
712
683
        control = bzrdir.BzrDir.create(self.get_url())
713
684
        branch, relpath = bzrdir.BzrDir.open_containing_from_transport(
714
 
            _mod_transport.get_transport(self.get_readonly_url('')))
 
685
            get_transport(self.get_readonly_url('')))
715
686
        self.assertEqual('', relpath)
716
687
        branch, relpath = bzrdir.BzrDir.open_containing_from_transport(
717
 
            _mod_transport.get_transport(self.get_readonly_url('g/p/q')))
 
688
            get_transport(self.get_readonly_url('g/p/q')))
718
689
        self.assertEqual('g/p/q', relpath)
719
690
 
720
691
    def test_open_containing_tree_or_branch(self):
764
735
        # transport pointing at bzrdir should give a bzrdir with root transport
765
736
        # set to the given transport
766
737
        control = bzrdir.BzrDir.create(self.get_url())
767
 
        t = self.get_transport()
768
 
        opened_bzrdir = bzrdir.BzrDir.open_from_transport(t)
769
 
        self.assertEqual(t.base, opened_bzrdir.root_transport.base)
 
738
        transport = get_transport(self.get_url())
 
739
        opened_bzrdir = bzrdir.BzrDir.open_from_transport(transport)
 
740
        self.assertEqual(transport.base, opened_bzrdir.root_transport.base)
770
741
        self.assertIsInstance(opened_bzrdir, bzrdir.BzrDir)
771
742
 
772
743
    def test_open_from_transport_no_bzrdir(self):
773
 
        t = self.get_transport()
774
 
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport, t)
 
744
        transport = get_transport(self.get_url())
 
745
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport,
 
746
                          transport)
775
747
 
776
748
    def test_open_from_transport_bzrdir_in_parent(self):
777
749
        control = bzrdir.BzrDir.create(self.get_url())
778
 
        t = self.get_transport()
779
 
        t.mkdir('subdir')
780
 
        t = t.clone('subdir')
781
 
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport, t)
 
750
        transport = get_transport(self.get_url())
 
751
        transport.mkdir('subdir')
 
752
        transport = transport.clone('subdir')
 
753
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport,
 
754
                          transport)
782
755
 
783
756
    def test_sprout_recursive(self):
784
757
        tree = self.make_branch_and_tree('tree1',
814
787
        self.build_tree(['tree1/subtree/file'])
815
788
        sub_tree.add('file')
816
789
        tree.commit('Initial commit')
817
 
        # The following line force the orhaning to reveal bug #634470
818
 
        tree.branch.get_config().set_user_option(
819
 
            'bzr.transform.orphan_policy', 'move')
820
790
        tree.bzrdir.destroy_workingtree()
821
 
        # FIXME: subtree/.bzr is left here which allows the test to pass (or
822
 
        # fail :-( ) -- vila 20100909
823
791
        repo = self.make_repository('repo', shared=True,
824
792
            format='dirstate-with-subtree')
825
793
        repo.set_make_working_trees(False)
826
 
        # FIXME: we just deleted the workingtree and now we want to use it ????
827
 
        # At a minimum, we should use tree.branch below (but this fails too
828
 
        # currently) or stop calling this test 'treeless'. Specifically, I've
829
 
        # turn the line below into an assertRaises when 'subtree/.bzr' is
830
 
        # orphaned and sprout tries to access the branch there (which is left
831
 
        # by bzrdir.BzrDirMeta1.destroy_workingtree when it ignores the
832
 
        # [DeletingParent('Not deleting', u'subtree', None)] conflict). See bug
833
 
        # #634470.  -- vila 20100909
834
 
        self.assertRaises(errors.NotBranchError,
835
 
                          tree.bzrdir.sprout, 'repo/tree2')
836
 
#        self.failUnlessExists('repo/tree2/subtree')
837
 
#        self.failIfExists('repo/tree2/subtree/file')
 
794
        tree.bzrdir.sprout('repo/tree2')
 
795
        self.failUnlessExists('repo/tree2/subtree')
 
796
        self.failIfExists('repo/tree2/subtree/file')
838
797
 
839
798
    def make_foo_bar_baz(self):
840
799
        foo = bzrdir.BzrDir.create_branch_convenience('foo').bzrdir
844
803
 
845
804
    def test_find_bzrdirs(self):
846
805
        foo, bar, baz = self.make_foo_bar_baz()
847
 
        t = self.get_transport()
848
 
        self.assertEqualBzrdirs([baz, foo, bar], bzrdir.BzrDir.find_bzrdirs(t))
849
 
 
850
 
    def make_fake_permission_denied_transport(self, transport, paths):
851
 
        """Create a transport that raises PermissionDenied for some paths."""
852
 
        def filter(path):
853
 
            if path in paths:
854
 
                raise errors.PermissionDenied(path)
855
 
            return path
856
 
        path_filter_server = pathfilter.PathFilteringServer(transport, filter)
857
 
        path_filter_server.start_server()
858
 
        self.addCleanup(path_filter_server.stop_server)
859
 
        path_filter_transport = pathfilter.PathFilteringTransport(
860
 
            path_filter_server, '.')
861
 
        return (path_filter_server, path_filter_transport)
862
 
 
863
 
    def assertBranchUrlsEndWith(self, expect_url_suffix, actual_bzrdirs):
864
 
        """Check that each branch url ends with the given suffix."""
865
 
        for actual_bzrdir in actual_bzrdirs:
866
 
            self.assertEndsWith(actual_bzrdir.user_url, expect_url_suffix)
867
 
 
868
 
    def test_find_bzrdirs_permission_denied(self):
869
 
        foo, bar, baz = self.make_foo_bar_baz()
870
 
        t = self.get_transport()
871
 
        path_filter_server, path_filter_transport = \
872
 
            self.make_fake_permission_denied_transport(t, ['foo'])
873
 
        # local transport
874
 
        self.assertBranchUrlsEndWith('/baz/',
875
 
            bzrdir.BzrDir.find_bzrdirs(path_filter_transport))
876
 
        # smart server
877
 
        smart_transport = self.make_smart_server('.',
878
 
            backing_server=path_filter_server)
879
 
        self.assertBranchUrlsEndWith('/baz/',
880
 
            bzrdir.BzrDir.find_bzrdirs(smart_transport))
 
806
        transport = get_transport(self.get_url())
 
807
        self.assertEqualBzrdirs([baz, foo, bar],
 
808
                                bzrdir.BzrDir.find_bzrdirs(transport))
881
809
 
882
810
    def test_find_bzrdirs_list_current(self):
883
811
        def list_current(transport):
884
812
            return [s for s in transport.list_dir('') if s != 'baz']
885
813
 
886
814
        foo, bar, baz = self.make_foo_bar_baz()
887
 
        t = self.get_transport()
888
 
        self.assertEqualBzrdirs(
889
 
            [foo, bar],
890
 
            bzrdir.BzrDir.find_bzrdirs(t, list_current=list_current))
 
815
        transport = get_transport(self.get_url())
 
816
        self.assertEqualBzrdirs([foo, bar],
 
817
                                bzrdir.BzrDir.find_bzrdirs(transport,
 
818
                                    list_current=list_current))
 
819
 
891
820
 
892
821
    def test_find_bzrdirs_evaluate(self):
893
822
        def evaluate(bzrdir):
899
828
                return False, bzrdir.root_transport.base
900
829
 
901
830
        foo, bar, baz = self.make_foo_bar_baz()
902
 
        t = self.get_transport()
 
831
        transport = get_transport(self.get_url())
903
832
        self.assertEqual([baz.root_transport.base, foo.root_transport.base],
904
 
                         list(bzrdir.BzrDir.find_bzrdirs(t, evaluate=evaluate)))
 
833
                         list(bzrdir.BzrDir.find_bzrdirs(transport,
 
834
                                                         evaluate=evaluate)))
905
835
 
906
836
    def assertEqualBzrdirs(self, first, second):
907
837
        first = list(first)
914
844
        root = self.make_repository('', shared=True)
915
845
        foo, bar, baz = self.make_foo_bar_baz()
916
846
        qux = self.make_bzrdir('foo/qux')
917
 
        t = self.get_transport()
918
 
        branches = bzrdir.BzrDir.find_branches(t)
 
847
        transport = get_transport(self.get_url())
 
848
        branches = bzrdir.BzrDir.find_branches(transport)
919
849
        self.assertEqual(baz.root_transport.base, branches[0].base)
920
850
        self.assertEqual(foo.root_transport.base, branches[1].base)
921
851
        self.assertEqual(bar.root_transport.base, branches[2].base)
922
852
 
923
853
        # ensure this works without a top-level repo
924
 
        branches = bzrdir.BzrDir.find_branches(t.clone('foo'))
 
854
        branches = bzrdir.BzrDir.find_branches(transport.clone('foo'))
925
855
        self.assertEqual(foo.root_transport.base, branches[0].base)
926
856
        self.assertEqual(bar.root_transport.base, branches[1].base)
927
857
 
928
858
 
929
 
class TestMissingRepoBranchesSkipped(TestCaseWithMemoryTransport):
930
 
 
931
 
    def test_find_bzrdirs_missing_repo(self):
932
 
        t = self.get_transport()
933
 
        arepo = self.make_repository('arepo', shared=True)
934
 
        abranch_url = arepo.user_url + '/abranch'
935
 
        abranch = bzrdir.BzrDir.create(abranch_url).create_branch()
936
 
        t.delete_tree('arepo/.bzr')
937
 
        self.assertRaises(errors.NoRepositoryPresent,
938
 
            branch.Branch.open, abranch_url)
939
 
        self.make_branch('baz')
940
 
        for actual_bzrdir in bzrdir.BzrDir.find_branches(t):
941
 
            self.assertEndsWith(actual_bzrdir.user_url, '/baz/')
942
 
 
943
 
 
944
859
class TestMeta1DirFormat(TestCaseWithTransport):
945
860
    """Tests specific to the meta1 dir format."""
946
861
 
953
868
                         dir.get_branch_transport(bzrlib.branch.BzrBranchFormat5()).base)
954
869
        repository_base = t.clone('repository').base
955
870
        self.assertEqual(repository_base, dir.get_repository_transport(None).base)
956
 
        repository_format = repository.format_registry.get_default()
957
871
        self.assertEqual(repository_base,
958
 
                         dir.get_repository_transport(repository_format).base)
 
872
                         dir.get_repository_transport(weaverepo.RepositoryFormat7()).base)
959
873
        checkout_base = t.clone('checkout').base
960
874
        self.assertEqual(checkout_base, dir.get_workingtree_transport(None).base)
961
875
        self.assertEqual(checkout_base,
1096
1010
    def _known_formats(self):
1097
1011
        return set([NotBzrDirFormat()])
1098
1012
 
1099
 
 
1100
 
class NotBzrDirProber(controldir.Prober):
1101
 
 
 
1013
    @classmethod
1102
1014
    def probe_transport(self, transport):
1103
1015
        """Our format is present if the transport ends in '.not/'."""
1104
1016
        if transport.has('.not'):
1118
1030
        dir = format.initialize(self.get_url())
1119
1031
        self.assertIsInstance(dir, NotBzrDir)
1120
1032
        # now probe for it.
1121
 
        controldir.ControlDirFormat.register_prober(NotBzrDirProber)
 
1033
        bzrlib.bzrdir.BzrDirFormat.register_control_format(format)
1122
1034
        try:
1123
 
            found = bzrlib.bzrdir.BzrDirFormat.find_format(self.get_transport())
 
1035
            found = bzrlib.bzrdir.BzrDirFormat.find_format(
 
1036
                get_transport(self.get_url()))
1124
1037
            self.assertIsInstance(found, NotBzrDirFormat)
1125
1038
        finally:
1126
 
            controldir.ControlDirFormat.unregister_prober(NotBzrDirProber)
 
1039
            bzrlib.bzrdir.BzrDirFormat.unregister_control_format(format)
1127
1040
 
1128
1041
    def test_included_in_known_formats(self):
1129
 
        not_format = NotBzrDirFormat()
1130
 
        bzrlib.controldir.ControlDirFormat.register_format(not_format)
 
1042
        bzrlib.bzrdir.BzrDirFormat.register_control_format(NotBzrDirFormat)
1131
1043
        try:
1132
1044
            formats = bzrlib.bzrdir.BzrDirFormat.known_formats()
1133
1045
            for format in formats:
1135
1047
                    return
1136
1048
            self.fail("No NotBzrDirFormat in %s" % formats)
1137
1049
        finally:
1138
 
            bzrlib.controldir.ControlDirFormat.unregister_format(not_format)
 
1050
            bzrlib.bzrdir.BzrDirFormat.unregister_control_format(NotBzrDirFormat)
1139
1051
 
1140
1052
 
1141
1053
class NonLocalTests(TestCaseWithTransport):
1162
1074
            self.get_url('foo'),
1163
1075
            force_new_tree=True,
1164
1076
            format=format)
1165
 
        t = self.get_transport()
 
1077
        t = get_transport(self.get_url('.'))
1166
1078
        self.assertFalse(t.has('foo'))
1167
1079
 
1168
1080
    def test_clone(self):
1199
1111
    """
1200
1112
 
1201
1113
    def create_transport_readonly_server(self):
1202
 
        # We don't set the http protocol version, relying on the default
1203
1114
        return http_utils.HTTPServerRedirecting()
1204
1115
 
1205
1116
    def create_transport_secondary_server(self):
1206
 
        # We don't set the http protocol version, relying on the default
1207
1117
        return http_utils.HTTPServerRedirecting()
1208
1118
 
1209
1119
    def setUp(self):
1364
1274
    def copy_content_into(self, destination, revision_id=None):
1365
1275
        self.calls.append('copy_content_into')
1366
1276
 
1367
 
    def last_revision(self):
1368
 
        return _mod_revision.NULL_REVISION
1369
 
 
1370
1277
    def get_parent(self):
1371
1278
        return self._parent
1372
1279
 
1373
1280
    def set_parent(self, parent):
1374
1281
        self._parent = parent
1375
1282
 
1376
 
    def lock_read(self):
1377
 
        return lock.LogicalLockResult(self.unlock)
1378
 
 
1379
 
    def unlock(self):
1380
 
        return
1381
 
 
1382
1283
 
1383
1284
class TestBzrDirSprout(TestCaseWithMemoryTransport):
1384
1285
 
1450
1351
        self.assertIsInstance(params, RepoInitHookParams)
1451
1352
        self.assertTrue(hasattr(params, 'bzrdir'))
1452
1353
        self.assertTrue(hasattr(params, 'repository'))
1453
 
 
1454
 
    def test_post_repo_init_hook_repr(self):
1455
 
        param_reprs = []
1456
 
        bzrdir.BzrDir.hooks.install_named_hook('post_repo_init',
1457
 
            lambda params: param_reprs.append(repr(params)), None)
1458
 
        self.make_repository('foo')
1459
 
        self.assertLength(1, param_reprs)
1460
 
        param_repr = param_reprs[0]
1461
 
        self.assertStartsWith(param_repr, '<RepoInitHookParams for ')
1462
 
 
1463
 
 
1464
 
class TestGenerateBackupName(TestCaseWithMemoryTransport):
1465
 
    # FIXME: This may need to be unified with test_osutils.TestBackupNames or
1466
 
    # moved to per_bzrdir or per_transport for better coverage ?
1467
 
    # -- vila 20100909
1468
 
 
1469
 
    def setUp(self):
1470
 
        super(TestGenerateBackupName, self).setUp()
1471
 
        self._transport = self.get_transport()
1472
 
        bzrdir.BzrDir.create(self.get_url(),
1473
 
            possible_transports=[self._transport])
1474
 
        self._bzrdir = bzrdir.BzrDir.open_from_transport(self._transport)
1475
 
 
1476
 
    def test_deprecated_generate_backup_name(self):
1477
 
        res = self.applyDeprecated(
1478
 
                symbol_versioning.deprecated_in((2, 3, 0)),
1479
 
                self._bzrdir.generate_backup_name, 'whatever')
1480
 
 
1481
 
    def test_new(self):
1482
 
        self.assertEqual("a.~1~", self._bzrdir._available_backup_name("a"))
1483
 
 
1484
 
    def test_exiting(self):
1485
 
        self._transport.put_bytes("a.~1~", "some content")
1486
 
        self.assertEqual("a.~2~", self._bzrdir._available_backup_name("a"))