/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: 2017-11-28 22:51:09 UTC
  • mfrom: (6825.4.1 log-inventory)
  • Revision ID: jelmer@jelmer.uk-20171128225109-98eiilw604i7613o
Merge lp:~jelmer/brz/log-inventory.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_bzrdir.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2013, 2016 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
23
23
import subprocess
24
24
import sys
25
25
 
26
 
from bzrlib import (
27
 
    bzrdir,
 
26
from .. import (
 
27
    branch,
 
28
    bzr,
 
29
    config,
 
30
    controldir,
28
31
    errors,
29
32
    help_topics,
 
33
    lock,
30
34
    repository,
 
35
    revision as _mod_revision,
31
36
    osutils,
32
 
    remote,
 
37
    transport as _mod_transport,
33
38
    urlutils,
34
39
    win32utils,
35
 
    workingtree,
36
 
    )
37
 
import bzrlib.branch
38
 
from bzrlib.errors import (NotBranchError,
39
 
                           NoColocatedBranchSupport,
40
 
                           UnknownFormatError,
41
 
                           UnsupportedFormatError,
42
 
                           )
43
 
from bzrlib.tests import (
 
40
    )
 
41
from ..bzr import (
 
42
    branch as bzrbranch,
 
43
    bzrdir,
 
44
    remote,
 
45
    workingtree_3,
 
46
    workingtree_4,
 
47
    )
 
48
import breezy.branch
 
49
import breezy.bzr.branch
 
50
from ..bzr.fullhistory import BzrBranchFormat5
 
51
from ..errors import (
 
52
    NotBranchError,
 
53
    NoColocatedBranchSupport,
 
54
    UnknownFormatError,
 
55
    UnsupportedFormatError,
 
56
    )
 
57
from . import (
44
58
    TestCase,
45
59
    TestCaseWithMemoryTransport,
46
60
    TestCaseWithTransport,
47
61
    TestSkipped,
48
62
    )
49
 
from bzrlib.tests import(
 
63
from . import(
50
64
    http_server,
51
65
    http_utils,
52
66
    )
53
 
from bzrlib.tests.test_http import TestWithTransport_pycurl
54
 
from bzrlib.transport import (
55
 
    get_transport,
 
67
from ..transport import (
56
68
    memory,
 
69
    pathfilter,
57
70
    )
58
 
from bzrlib.transport.http._urllib import HttpTransport_urllib
59
 
from bzrlib.transport.nosmart import NoSmartTransportDecorator
60
 
from bzrlib.transport.readonly import ReadonlyTransportDecorator
61
 
from bzrlib.repofmt import knitrepo, weaverepo, pack_repo
 
71
from ..transport.http._urllib import HttpTransport_urllib
 
72
from ..transport.nosmart import NoSmartTransportDecorator
 
73
from ..transport.readonly import ReadonlyTransportDecorator
 
74
from ..bzr import knitrepo, knitpack_repo
62
75
 
63
76
 
64
77
class TestDefaultFormat(TestCase):
65
78
 
66
79
    def test_get_set_default_format(self):
67
80
        old_format = bzrdir.BzrDirFormat.get_default_format()
68
 
        # default is BzrDirFormat6
69
 
        self.failUnless(isinstance(old_format, bzrdir.BzrDirMetaFormat1))
70
 
        bzrdir.BzrDirFormat._set_default_format(SampleBzrDirFormat())
 
81
        # default is BzrDirMetaFormat1
 
82
        self.assertIsInstance(old_format, bzrdir.BzrDirMetaFormat1)
 
83
        controldir.ControlDirFormat._set_default_format(SampleBzrDirFormat())
71
84
        # creating a bzr dir should now create an instrumented dir.
72
85
        try:
73
86
            result = bzrdir.BzrDir.create('memory:///')
74
 
            self.failUnless(isinstance(result, SampleBzrDir))
 
87
            self.assertIsInstance(result, SampleBzrDir)
75
88
        finally:
76
 
            bzrdir.BzrDirFormat._set_default_format(old_format)
 
89
            controldir.ControlDirFormat._set_default_format(old_format)
77
90
        self.assertEqual(old_format, bzrdir.BzrDirFormat.get_default_format())
78
91
 
79
92
 
 
93
class DeprecatedBzrDirFormat(bzrdir.BzrDirFormat):
 
94
    """A deprecated bzr dir format."""
 
95
 
 
96
 
80
97
class TestFormatRegistry(TestCase):
81
98
 
82
99
    def make_format_registry(self):
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',
90
 
            'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
 
100
        my_format_registry = controldir.ControlDirFormatRegistry()
 
101
        my_format_registry.register('deprecated', DeprecatedBzrDirFormat,
 
102
            'Some format.  Slower and unawesome and deprecated.',
 
103
            deprecated=True)
 
104
        my_format_registry.register_lazy('lazy', 'breezy.tests.test_bzrdir',
 
105
            'DeprecatedBzrDirFormat', 'Format registered lazily',
 
106
            deprecated=True)
 
107
        bzr.register_metadir(my_format_registry, 'knit',
 
108
            'breezy.bzr.knitrepo.RepositoryFormatKnit1',
91
109
            'Format using knits',
92
110
            )
93
111
        my_format_registry.set_default('knit')
94
 
        my_format_registry.register_metadir(
 
112
        bzr.register_metadir(my_format_registry,
95
113
            'branch6',
96
 
            'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
 
114
            'breezy.bzr.knitrepo.RepositoryFormatKnit3',
97
115
            'Experimental successor to knit.  Use at your own risk.',
98
 
            branch_format='bzrlib.branch.BzrBranchFormat6',
 
116
            branch_format='breezy.bzr.branch.BzrBranchFormat6',
99
117
            experimental=True)
100
 
        my_format_registry.register_metadir(
 
118
        bzr.register_metadir(my_format_registry,
101
119
            'hidden format',
102
 
            'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
 
120
            'breezy.bzr.knitrepo.RepositoryFormatKnit3',
103
121
            'Experimental successor to knit.  Use at your own risk.',
104
 
            branch_format='bzrlib.branch.BzrBranchFormat6', 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
            branch_format='breezy.bzr.branch.BzrBranchFormat6', hidden=True)
 
123
        my_format_registry.register('hiddendeprecated', DeprecatedBzrDirFormat,
 
124
            'Old format.  Slower and does not support things. ', hidden=True)
 
125
        my_format_registry.register_lazy('hiddenlazy', 'breezy.tests.test_bzrdir',
 
126
            'DeprecatedBzrDirFormat', 'Format registered lazily',
 
127
            deprecated=True, hidden=True)
111
128
        return my_format_registry
112
129
 
113
130
    def test_format_registry(self):
114
131
        my_format_registry = self.make_format_registry()
115
 
        my_bzrdir = my_format_registry.make_bzrdir('lazy')
116
 
        self.assertIsInstance(my_bzrdir, bzrdir.BzrDirFormat6)
117
 
        my_bzrdir = my_format_registry.make_bzrdir('weave')
118
 
        self.assertIsInstance(my_bzrdir, bzrdir.BzrDirFormat6)
119
 
        my_bzrdir = my_format_registry.make_bzrdir('default')
120
 
        self.assertIsInstance(my_bzrdir.repository_format,
121
 
            knitrepo.RepositoryFormatKnit1)
122
 
        my_bzrdir = my_format_registry.make_bzrdir('knit')
123
 
        self.assertIsInstance(my_bzrdir.repository_format,
124
 
            knitrepo.RepositoryFormatKnit1)
125
 
        my_bzrdir = my_format_registry.make_bzrdir('branch6')
 
132
        my_bzrdir = my_format_registry.make_controldir('lazy')
 
133
        self.assertIsInstance(my_bzrdir, DeprecatedBzrDirFormat)
 
134
        my_bzrdir = my_format_registry.make_controldir('deprecated')
 
135
        self.assertIsInstance(my_bzrdir, DeprecatedBzrDirFormat)
 
136
        my_bzrdir = my_format_registry.make_controldir('default')
 
137
        self.assertIsInstance(my_bzrdir.repository_format,
 
138
            knitrepo.RepositoryFormatKnit1)
 
139
        my_bzrdir = my_format_registry.make_controldir('knit')
 
140
        self.assertIsInstance(my_bzrdir.repository_format,
 
141
            knitrepo.RepositoryFormatKnit1)
 
142
        my_bzrdir = my_format_registry.make_controldir('branch6')
126
143
        self.assertIsInstance(my_bzrdir.get_branch_format(),
127
 
                              bzrlib.branch.BzrBranchFormat6)
 
144
                              breezy.bzr.branch.BzrBranchFormat6)
128
145
 
129
146
    def test_get_help(self):
130
147
        my_format_registry = self.make_format_registry()
134
151
                         my_format_registry.get_help('knit'))
135
152
        self.assertEqual('Format using knits',
136
153
                         my_format_registry.get_help('default'))
137
 
        self.assertEqual('Pre-0.8 format.  Slower and does not support'
138
 
                         ' checkouts or shared repositories',
139
 
                         my_format_registry.get_help('weave'))
 
154
        self.assertEqual('Some format.  Slower and unawesome and deprecated.',
 
155
                         my_format_registry.get_help('deprecated'))
140
156
 
141
157
    def test_help_topic(self):
142
158
        topics = help_topics.HelpTopicRegistry()
150
166
        experimental, deprecated = rest.split('Deprecated formats')
151
167
        self.assertContainsRe(new, 'formats-help')
152
168
        self.assertContainsRe(new,
153
 
                ':knit:\n    \(native\) \(default\) Format using knits\n')
 
169
                ':knit:\n    \\(native\\) \\(default\\) Format using knits\n')
154
170
        self.assertContainsRe(experimental,
155
 
                ':branch6:\n    \(native\) Experimental successor to knit')
 
171
                ':branch6:\n    \\(native\\) Experimental successor to knit')
156
172
        self.assertContainsRe(deprecated,
157
 
                ':lazy:\n    \(native\) Format registered lazily\n')
 
173
                ':lazy:\n    \\(native\\) Format registered lazily\n')
158
174
        self.assertNotContainsRe(new, 'hidden')
159
175
 
160
176
    def test_set_default_repository(self):
161
 
        default_factory = bzrdir.format_registry.get('default')
162
 
        old_default = [k for k, v in bzrdir.format_registry.iteritems()
 
177
        default_factory = controldir.format_registry.get('default')
 
178
        old_default = [k for k, v in controldir.format_registry.iteritems()
163
179
                       if v == default_factory and k != 'default'][0]
164
 
        bzrdir.format_registry.set_default_repository('dirstate-with-subtree')
 
180
        controldir.format_registry.set_default_repository('dirstate-with-subtree')
165
181
        try:
166
 
            self.assertIs(bzrdir.format_registry.get('dirstate-with-subtree'),
167
 
                          bzrdir.format_registry.get('default'))
 
182
            self.assertIs(controldir.format_registry.get('dirstate-with-subtree'),
 
183
                          controldir.format_registry.get('default'))
168
184
            self.assertIs(
169
 
                repository.RepositoryFormat.get_default_format().__class__,
 
185
                repository.format_registry.get_default().__class__,
170
186
                knitrepo.RepositoryFormatKnit3)
171
187
        finally:
172
 
            bzrdir.format_registry.set_default_repository(old_default)
 
188
            controldir.format_registry.set_default_repository(old_default)
173
189
 
174
190
    def test_aliases(self):
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())
183
 
 
184
 
 
185
 
class SampleBranch(bzrlib.branch.Branch):
 
191
        a_registry = controldir.ControlDirFormatRegistry()
 
192
        a_registry.register('deprecated', DeprecatedBzrDirFormat,
 
193
            'Old format.  Slower and does not support stuff',
 
194
            deprecated=True)
 
195
        a_registry.register('deprecatedalias', DeprecatedBzrDirFormat,
 
196
            'Old format.  Slower and does not support stuff',
 
197
            deprecated=True, alias=True)
 
198
        self.assertEqual(frozenset(['deprecatedalias']), a_registry.aliases())
 
199
 
 
200
 
 
201
class SampleBranch(breezy.branch.Branch):
186
202
    """A dummy branch for guess what, dummy use."""
187
203
 
188
204
    def __init__(self, dir):
189
 
        self.bzrdir = dir
190
 
 
191
 
 
192
 
class SampleRepository(bzrlib.repository.Repository):
 
205
        self.controldir = dir
 
206
 
 
207
 
 
208
class SampleRepository(breezy.repository.Repository):
193
209
    """A dummy repo."""
194
210
 
195
211
    def __init__(self, dir):
196
 
        self.bzrdir = dir
 
212
        self.controldir = dir
197
213
 
198
214
 
199
215
class SampleBzrDir(bzrdir.BzrDir):
200
216
    """A sample BzrDir implementation to allow testing static methods."""
201
217
 
202
218
    def create_repository(self, shared=False):
203
 
        """See BzrDir.create_repository."""
 
219
        """See ControlDir.create_repository."""
204
220
        return "A repository"
205
221
 
206
222
    def open_repository(self):
207
 
        """See BzrDir.open_repository."""
 
223
        """See ControlDir.open_repository."""
208
224
        return SampleRepository(self)
209
225
 
210
226
    def create_branch(self, name=None):
211
 
        """See BzrDir.create_branch."""
 
227
        """See ControlDir.create_branch."""
212
228
        if name is not None:
213
229
            raise NoColocatedBranchSupport(self)
214
230
        return SampleBranch(self)
215
231
 
216
232
    def create_workingtree(self):
217
 
        """See BzrDir.create_workingtree."""
 
233
        """See ControlDir.create_workingtree."""
218
234
        return "A tree"
219
235
 
220
236
 
241
257
    def open(self, transport, _found=None):
242
258
        return "opened branch."
243
259
 
 
260
    @classmethod
 
261
    def from_string(cls, format_string):
 
262
        return cls()
 
263
 
 
264
 
 
265
class BzrDirFormatTest1(bzrdir.BzrDirMetaFormat1):
 
266
 
 
267
    @staticmethod
 
268
    def get_format_string():
 
269
        return "Test format 1"
 
270
 
 
271
 
 
272
class BzrDirFormatTest2(bzrdir.BzrDirMetaFormat1):
 
273
 
 
274
    @staticmethod
 
275
    def get_format_string():
 
276
        return "Test format 2"
 
277
 
244
278
 
245
279
class TestBzrDirFormat(TestCaseWithTransport):
246
280
    """Tests for the BzrDirFormat facility."""
248
282
    def test_find_format(self):
249
283
        # is the right format object found for a branch?
250
284
        # create a branch with a few known format objects.
251
 
        # this is not quite the same as
252
 
        t = get_transport(self.get_url())
 
285
        bzr.BzrProber.formats.register(BzrDirFormatTest1.get_format_string(),
 
286
            BzrDirFormatTest1())
 
287
        self.addCleanup(bzr.BzrProber.formats.remove,
 
288
            BzrDirFormatTest1.get_format_string())
 
289
        bzr.BzrProber.formats.register(BzrDirFormatTest2.get_format_string(),
 
290
            BzrDirFormatTest2())
 
291
        self.addCleanup(bzr.BzrProber.formats.remove,
 
292
            BzrDirFormatTest2.get_format_string())
 
293
        t = self.get_transport()
253
294
        self.build_tree(["foo/", "bar/"], transport=t)
254
295
        def check_format(format, url):
255
296
            format.initialize(url)
256
 
            t = get_transport(url)
 
297
            t = _mod_transport.get_transport_from_path(url)
257
298
            found_format = bzrdir.BzrDirFormat.find_format(t)
258
 
            self.failUnless(isinstance(found_format, format.__class__))
259
 
        check_format(bzrdir.BzrDirFormat5(), "foo")
260
 
        check_format(bzrdir.BzrDirFormat6(), "bar")
 
299
            self.assertIsInstance(found_format, format.__class__)
 
300
        check_format(BzrDirFormatTest1(), "foo")
 
301
        check_format(BzrDirFormatTest2(), "bar")
261
302
 
262
303
    def test_find_format_nothing_there(self):
263
304
        self.assertRaises(NotBranchError,
264
305
                          bzrdir.BzrDirFormat.find_format,
265
 
                          get_transport('.'))
 
306
                          _mod_transport.get_transport_from_path('.'))
266
307
 
267
308
    def test_find_format_unknown_format(self):
268
 
        t = get_transport(self.get_url())
 
309
        t = self.get_transport()
269
310
        t.mkdir('.bzr')
270
311
        t.put_bytes('.bzr/branch-format', '')
271
312
        self.assertRaises(UnknownFormatError,
272
313
                          bzrdir.BzrDirFormat.find_format,
273
 
                          get_transport('.'))
 
314
                          _mod_transport.get_transport_from_path('.'))
274
315
 
275
316
    def test_register_unregister_format(self):
276
317
        format = SampleBzrDirFormat()
278
319
        # make a bzrdir
279
320
        format.initialize(url)
280
321
        # register a format for it.
281
 
        bzrdir.BzrDirFormat.register_format(format)
 
322
        bzr.BzrProber.formats.register(format.get_format_string(), format)
282
323
        # which bzrdir.Open will refuse (not supported)
283
324
        self.assertRaises(UnsupportedFormatError, bzrdir.BzrDir.open, url)
284
325
        # which bzrdir.open_containing will refuse (not supported)
285
326
        self.assertRaises(UnsupportedFormatError, bzrdir.BzrDir.open_containing, url)
286
327
        # but open_downlevel will work
287
 
        t = get_transport(url)
 
328
        t = _mod_transport.get_transport_from_url(url)
288
329
        self.assertEqual(format.open(t), bzrdir.BzrDir.open_unsupported(url))
289
330
        # unregister the format
290
 
        bzrdir.BzrDirFormat.unregister_format(format)
 
331
        bzr.BzrProber.formats.remove(format.get_format_string())
291
332
        # now open_downlevel should fail too.
292
333
        self.assertRaises(UnknownFormatError, bzrdir.BzrDir.open_unsupported, url)
293
334
 
300
341
    def test_create_branch_and_repo_under_shared(self):
301
342
        # creating a branch and repo in a shared repo uses the
302
343
        # shared repository
303
 
        format = bzrdir.format_registry.make_bzrdir('knit')
 
344
        format = controldir.format_registry.make_controldir('knit')
304
345
        self.make_repository('.', shared=True, format=format)
305
346
        branch = bzrdir.BzrDir.create_branch_and_repo(
306
347
            self.get_url('child'), format=format)
307
348
        self.assertRaises(errors.NoRepositoryPresent,
308
 
                          branch.bzrdir.open_repository)
 
349
                          branch.controldir.open_repository)
309
350
 
310
351
    def test_create_branch_and_repo_under_shared_force_new(self):
311
352
        # creating a branch and repo in a shared repo can be forced to
312
353
        # make a new repo
313
 
        format = bzrdir.format_registry.make_bzrdir('knit')
 
354
        format = controldir.format_registry.make_controldir('knit')
314
355
        self.make_repository('.', shared=True, format=format)
315
356
        branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url('child'),
316
357
                                                      force_new_repo=True,
317
358
                                                      format=format)
318
 
        branch.bzrdir.open_repository()
 
359
        branch.controldir.open_repository()
319
360
 
320
361
    def test_create_standalone_working_tree(self):
321
362
        format = SampleBzrDirFormat()
330
371
 
331
372
    def test_create_standalone_working_tree_under_shared_repo(self):
332
373
        # create standalone working tree always makes a repo.
333
 
        format = bzrdir.format_registry.make_bzrdir('knit')
 
374
        format = controldir.format_registry.make_controldir('knit')
334
375
        self.make_repository('.', shared=True, format=format)
335
376
        # note this is deliberately readonly, as this failure should
336
377
        # occur before any writes.
339
380
                          self.get_readonly_url('child'), format=format)
340
381
        tree = bzrdir.BzrDir.create_standalone_workingtree('child',
341
382
            format=format)
342
 
        tree.bzrdir.open_repository()
 
383
        tree.controldir.open_repository()
343
384
 
344
385
    def test_create_branch_convenience(self):
345
386
        # outside a repo the default convenience output is a repo+branch_tree
346
 
        format = bzrdir.format_registry.make_bzrdir('knit')
 
387
        format = controldir.format_registry.make_controldir('knit')
347
388
        branch = bzrdir.BzrDir.create_branch_convenience('.', format=format)
348
 
        branch.bzrdir.open_workingtree()
349
 
        branch.bzrdir.open_repository()
 
389
        branch.controldir.open_workingtree()
 
390
        branch.controldir.open_repository()
350
391
 
351
392
    def test_create_branch_convenience_possible_transports(self):
352
393
        """Check that the optional 'possible_transports' is recognized"""
353
 
        format = bzrdir.format_registry.make_bzrdir('knit')
 
394
        format = controldir.format_registry.make_controldir('knit')
354
395
        t = self.get_transport()
355
396
        branch = bzrdir.BzrDir.create_branch_convenience(
356
397
            '.', format=format, possible_transports=[t])
357
 
        branch.bzrdir.open_workingtree()
358
 
        branch.bzrdir.open_repository()
 
398
        branch.controldir.open_workingtree()
 
399
        branch.controldir.open_repository()
359
400
 
360
401
    def test_create_branch_convenience_root(self):
361
402
        """Creating a branch at the root of a fs should work."""
362
403
        self.vfs_transport_factory = memory.MemoryServer
363
404
        # outside a repo the default convenience output is a repo+branch_tree
364
 
        format = bzrdir.format_registry.make_bzrdir('knit')
 
405
        format = controldir.format_registry.make_controldir('knit')
365
406
        branch = bzrdir.BzrDir.create_branch_convenience(self.get_url(),
366
407
                                                         format=format)
367
408
        self.assertRaises(errors.NoWorkingTree,
368
 
                          branch.bzrdir.open_workingtree)
369
 
        branch.bzrdir.open_repository()
 
409
                          branch.controldir.open_workingtree)
 
410
        branch.controldir.open_repository()
370
411
 
371
412
    def test_create_branch_convenience_under_shared_repo(self):
372
413
        # inside a repo the default convenience output is a branch+ follow the
373
414
        # repo tree policy
374
 
        format = bzrdir.format_registry.make_bzrdir('knit')
 
415
        format = controldir.format_registry.make_controldir('knit')
375
416
        self.make_repository('.', shared=True, format=format)
376
417
        branch = bzrdir.BzrDir.create_branch_convenience('child',
377
418
            format=format)
378
 
        branch.bzrdir.open_workingtree()
 
419
        branch.controldir.open_workingtree()
379
420
        self.assertRaises(errors.NoRepositoryPresent,
380
 
                          branch.bzrdir.open_repository)
 
421
                          branch.controldir.open_repository)
381
422
 
382
423
    def test_create_branch_convenience_under_shared_repo_force_no_tree(self):
383
424
        # inside a repo the default convenience output is a branch+ follow the
384
425
        # repo tree policy but we can override that
385
 
        format = bzrdir.format_registry.make_bzrdir('knit')
 
426
        format = controldir.format_registry.make_controldir('knit')
386
427
        self.make_repository('.', shared=True, format=format)
387
428
        branch = bzrdir.BzrDir.create_branch_convenience('child',
388
429
            force_new_tree=False, format=format)
389
430
        self.assertRaises(errors.NoWorkingTree,
390
 
                          branch.bzrdir.open_workingtree)
 
431
                          branch.controldir.open_workingtree)
391
432
        self.assertRaises(errors.NoRepositoryPresent,
392
 
                          branch.bzrdir.open_repository)
 
433
                          branch.controldir.open_repository)
393
434
 
394
435
    def test_create_branch_convenience_under_shared_repo_no_tree_policy(self):
395
436
        # inside a repo the default convenience output is a branch+ follow the
396
437
        # repo tree policy
397
 
        format = bzrdir.format_registry.make_bzrdir('knit')
 
438
        format = controldir.format_registry.make_controldir('knit')
398
439
        repo = self.make_repository('.', shared=True, format=format)
399
440
        repo.set_make_working_trees(False)
400
441
        branch = bzrdir.BzrDir.create_branch_convenience('child',
401
442
                                                         format=format)
402
443
        self.assertRaises(errors.NoWorkingTree,
403
 
                          branch.bzrdir.open_workingtree)
 
444
                          branch.controldir.open_workingtree)
404
445
        self.assertRaises(errors.NoRepositoryPresent,
405
 
                          branch.bzrdir.open_repository)
 
446
                          branch.controldir.open_repository)
406
447
 
407
448
    def test_create_branch_convenience_under_shared_repo_no_tree_policy_force_tree(self):
408
449
        # inside a repo the default convenience output is a branch+ follow the
409
450
        # repo tree policy but we can override that
410
 
        format = bzrdir.format_registry.make_bzrdir('knit')
 
451
        format = controldir.format_registry.make_controldir('knit')
411
452
        repo = self.make_repository('.', shared=True, format=format)
412
453
        repo.set_make_working_trees(False)
413
454
        branch = bzrdir.BzrDir.create_branch_convenience('child',
414
455
            force_new_tree=True, format=format)
415
 
        branch.bzrdir.open_workingtree()
 
456
        branch.controldir.open_workingtree()
416
457
        self.assertRaises(errors.NoRepositoryPresent,
417
 
                          branch.bzrdir.open_repository)
 
458
                          branch.controldir.open_repository)
418
459
 
419
460
    def test_create_branch_convenience_under_shared_repo_force_new_repo(self):
420
461
        # inside a repo the default convenience output is overridable to give
421
462
        # repo+branch+tree
422
 
        format = bzrdir.format_registry.make_bzrdir('knit')
 
463
        format = controldir.format_registry.make_controldir('knit')
423
464
        self.make_repository('.', shared=True, format=format)
424
465
        branch = bzrdir.BzrDir.create_branch_convenience('child',
425
466
            force_new_repo=True, format=format)
426
 
        branch.bzrdir.open_repository()
427
 
        branch.bzrdir.open_workingtree()
 
467
        branch.controldir.open_repository()
 
468
        branch.controldir.open_workingtree()
428
469
 
429
470
 
430
471
class TestRepositoryAcquisitionPolicy(TestCaseWithTransport):
431
472
 
432
473
    def test_acquire_repository_standalone(self):
433
474
        """The default acquisition policy should create a standalone branch."""
434
 
        my_bzrdir = self.make_bzrdir('.')
 
475
        my_bzrdir = self.make_controldir('.')
435
476
        repo_policy = my_bzrdir.determine_repository_policy()
436
477
        repo, is_new = repo_policy.acquire_repository()
437
 
        self.assertEqual(repo.bzrdir.root_transport.base,
 
478
        self.assertEqual(repo.controldir.root_transport.base,
438
479
                         my_bzrdir.root_transport.base)
439
480
        self.assertFalse(repo.is_shared())
440
481
 
441
482
    def test_determine_stacking_policy(self):
442
 
        parent_bzrdir = self.make_bzrdir('.')
443
 
        child_bzrdir = self.make_bzrdir('child')
 
483
        parent_bzrdir = self.make_controldir('.')
 
484
        child_bzrdir = self.make_controldir('child')
444
485
        parent_bzrdir.get_config().set_default_stack_on('http://example.org')
445
486
        repo_policy = child_bzrdir.determine_repository_policy()
446
487
        self.assertEqual('http://example.org', repo_policy._stack_on)
447
488
 
448
489
    def test_determine_stacking_policy_relative(self):
449
 
        parent_bzrdir = self.make_bzrdir('.')
450
 
        child_bzrdir = self.make_bzrdir('child')
 
490
        parent_bzrdir = self.make_controldir('.')
 
491
        child_bzrdir = self.make_controldir('child')
451
492
        parent_bzrdir.get_config().set_default_stack_on('child2')
452
493
        repo_policy = child_bzrdir.determine_repository_policy()
453
494
        self.assertEqual('child2', repo_policy._stack_on)
455
496
                         repo_policy._stack_on_pwd)
456
497
 
457
498
    def prepare_default_stacking(self, child_format='1.6'):
458
 
        parent_bzrdir = self.make_bzrdir('.')
 
499
        parent_bzrdir = self.make_controldir('.')
459
500
        child_branch = self.make_branch('child', format=child_format)
460
501
        parent_bzrdir.get_config().set_default_stack_on(child_branch.base)
461
502
        new_child_transport = parent_bzrdir.transport.clone('child2')
463
504
 
464
505
    def test_clone_on_transport_obeys_stacking_policy(self):
465
506
        child_branch, new_child_transport = self.prepare_default_stacking()
466
 
        new_child = child_branch.bzrdir.clone_on_transport(new_child_transport)
 
507
        new_child = child_branch.controldir.clone_on_transport(new_child_transport)
467
508
        self.assertEqual(child_branch.base,
468
509
                         new_child.open_branch().get_stacked_on_url())
469
510
 
470
511
    def test_default_stacking_with_stackable_branch_unstackable_repo(self):
471
512
        # Make stackable source branch with an unstackable repo format.
472
 
        source_bzrdir = self.make_bzrdir('source')
473
 
        pack_repo.RepositoryFormatKnitPack1().initialize(source_bzrdir)
474
 
        source_branch = bzrlib.branch.BzrBranchFormat7().initialize(
 
513
        source_bzrdir = self.make_controldir('source')
 
514
        knitpack_repo.RepositoryFormatKnitPack1().initialize(source_bzrdir)
 
515
        source_branch = breezy.bzr.branch.BzrBranchFormat7().initialize(
475
516
            source_bzrdir)
476
517
        # Make a directory with a default stacking policy
477
 
        parent_bzrdir = self.make_bzrdir('parent')
 
518
        parent_bzrdir = self.make_controldir('parent')
478
519
        stacked_on = self.make_branch('parent/stacked-on', format='pack-0.92')
479
520
        parent_bzrdir.get_config().set_default_stack_on(stacked_on.base)
480
521
        # Clone source into directory
481
522
        target = source_bzrdir.clone(self.get_url('parent/target'))
482
523
 
 
524
    def test_format_initialize_on_transport_ex_stacked_on(self):
 
525
        # trunk is a stackable format.  Note that its in the same server area
 
526
        # which is what launchpad does, but not sufficient to exercise the
 
527
        # general case.
 
528
        trunk = self.make_branch('trunk', format='1.9')
 
529
        t = self.get_transport('stacked')
 
530
        old_fmt = controldir.format_registry.make_controldir('pack-0.92')
 
531
        repo_name = old_fmt.repository_format.network_name()
 
532
        # Should end up with a 1.9 format (stackable)
 
533
        repo, control, require_stacking, repo_policy = \
 
534
            old_fmt.initialize_on_transport_ex(t,
 
535
                    repo_format_name=repo_name, stacked_on='../trunk',
 
536
                    stack_on_pwd=t.base)
 
537
        if repo is not None:
 
538
            # Repositories are open write-locked
 
539
            self.assertTrue(repo.is_write_locked())
 
540
            self.addCleanup(repo.unlock)
 
541
        else:
 
542
            repo = control.open_repository()
 
543
        self.assertIsInstance(control, bzrdir.BzrDir)
 
544
        opened = bzrdir.BzrDir.open(t.base)
 
545
        if not isinstance(old_fmt, remote.RemoteBzrDirFormat):
 
546
            self.assertEqual(control._format.network_name(),
 
547
                old_fmt.network_name())
 
548
            self.assertEqual(control._format.network_name(),
 
549
                opened._format.network_name())
 
550
        self.assertEqual(control.__class__, opened.__class__)
 
551
        self.assertLength(1, repo._fallback_repositories)
 
552
 
483
553
    def test_sprout_obeys_stacking_policy(self):
484
554
        child_branch, new_child_transport = self.prepare_default_stacking()
485
 
        new_child = child_branch.bzrdir.sprout(new_child_transport.base)
 
555
        new_child = child_branch.controldir.sprout(new_child_transport.base)
486
556
        self.assertEqual(child_branch.base,
487
557
                         new_child.open_branch().get_stacked_on_url())
488
558
 
489
559
    def test_clone_ignores_policy_for_unsupported_formats(self):
490
560
        child_branch, new_child_transport = self.prepare_default_stacking(
491
561
            child_format='pack-0.92')
492
 
        new_child = child_branch.bzrdir.clone_on_transport(new_child_transport)
493
 
        self.assertRaises(errors.UnstackableBranchFormat,
 
562
        new_child = child_branch.controldir.clone_on_transport(new_child_transport)
 
563
        self.assertRaises(branch.UnstackableBranchFormat,
494
564
                          new_child.open_branch().get_stacked_on_url)
495
565
 
496
566
    def test_sprout_ignores_policy_for_unsupported_formats(self):
497
567
        child_branch, new_child_transport = self.prepare_default_stacking(
498
568
            child_format='pack-0.92')
499
 
        new_child = child_branch.bzrdir.sprout(new_child_transport.base)
500
 
        self.assertRaises(errors.UnstackableBranchFormat,
 
569
        new_child = child_branch.controldir.sprout(new_child_transport.base)
 
570
        self.assertRaises(branch.UnstackableBranchFormat,
501
571
                          new_child.open_branch().get_stacked_on_url)
502
572
 
503
573
    def test_sprout_upgrades_format_if_stacked_specified(self):
504
574
        child_branch, new_child_transport = self.prepare_default_stacking(
505
575
            child_format='pack-0.92')
506
 
        new_child = child_branch.bzrdir.sprout(new_child_transport.base,
 
576
        new_child = child_branch.controldir.sprout(new_child_transport.base,
507
577
                                               stacked=True)
508
 
        self.assertEqual(child_branch.bzrdir.root_transport.base,
 
578
        self.assertEqual(child_branch.controldir.root_transport.base,
509
579
                         new_child.open_branch().get_stacked_on_url())
510
580
        repo = new_child.open_repository()
511
581
        self.assertTrue(repo._format.supports_external_lookups)
514
584
    def test_clone_on_transport_upgrades_format_if_stacked_on_specified(self):
515
585
        child_branch, new_child_transport = self.prepare_default_stacking(
516
586
            child_format='pack-0.92')
517
 
        new_child = child_branch.bzrdir.clone_on_transport(new_child_transport,
518
 
            stacked_on=child_branch.bzrdir.root_transport.base)
519
 
        self.assertEqual(child_branch.bzrdir.root_transport.base,
 
587
        new_child = child_branch.controldir.clone_on_transport(new_child_transport,
 
588
            stacked_on=child_branch.controldir.root_transport.base)
 
589
        self.assertEqual(child_branch.controldir.root_transport.base,
520
590
                         new_child.open_branch().get_stacked_on_url())
521
591
        repo = new_child.open_repository()
522
592
        self.assertTrue(repo._format.supports_external_lookups)
525
595
    def test_sprout_upgrades_to_rich_root_format_if_needed(self):
526
596
        child_branch, new_child_transport = self.prepare_default_stacking(
527
597
            child_format='rich-root-pack')
528
 
        new_child = child_branch.bzrdir.sprout(new_child_transport.base,
 
598
        new_child = child_branch.controldir.sprout(new_child_transport.base,
529
599
                                               stacked=True)
530
600
        repo = new_child.open_repository()
531
601
        self.assertTrue(repo._format.supports_external_lookups)
604
674
                         self.local_branch_path(branch))
605
675
        self.assertEqual(
606
676
            osutils.realpath(os.path.join('topdir', '.bzr', 'repository')),
607
 
            repo.bzrdir.transport.local_abspath('repository'))
 
677
            repo.controldir.transport.local_abspath('repository'))
608
678
        self.assertEqual(relpath, 'foo')
609
679
 
610
680
    def test_open_containing_tree_branch_or_repository_no_tree(self):
617
687
                         self.local_branch_path(branch))
618
688
        self.assertEqual(
619
689
            osutils.realpath(os.path.join('branch', '.bzr', 'repository')),
620
 
            repo.bzrdir.transport.local_abspath('repository'))
 
690
            repo.controldir.transport.local_abspath('repository'))
621
691
        self.assertEqual(relpath, 'foo')
622
692
 
623
693
    def test_open_containing_tree_branch_or_repository_repo(self):
629
699
        self.assertEqual(branch, None)
630
700
        self.assertEqual(
631
701
            osutils.realpath(os.path.join('repo', '.bzr', 'repository')),
632
 
            repo.bzrdir.transport.local_abspath('repository'))
 
702
            repo.controldir.transport.local_abspath('repository'))
633
703
        self.assertEqual(relpath, '')
634
704
 
635
705
    def test_open_containing_tree_branch_or_repository_shared_repo(self):
644
714
                         self.local_branch_path(branch))
645
715
        self.assertEqual(
646
716
            osutils.realpath(os.path.join('shared', '.bzr', 'repository')),
647
 
            repo.bzrdir.transport.local_abspath('repository'))
 
717
            repo.controldir.transport.local_abspath('repository'))
648
718
        self.assertEqual(relpath, '')
649
719
 
650
720
    def test_open_containing_tree_branch_or_repository_branch_subdir(self):
659
729
                         self.local_branch_path(branch))
660
730
        self.assertEqual(
661
731
            osutils.realpath(os.path.join('foo', '.bzr', 'repository')),
662
 
            repo.bzrdir.transport.local_abspath('repository'))
 
732
            repo.controldir.transport.local_abspath('repository'))
663
733
        self.assertEqual(relpath, 'bar')
664
734
 
665
735
    def test_open_containing_tree_branch_or_repository_repo_subdir(self):
672
742
        self.assertEqual(branch, None)
673
743
        self.assertEqual(
674
744
            osutils.realpath(os.path.join('bar', '.bzr', 'repository')),
675
 
            repo.bzrdir.transport.local_abspath('repository'))
 
745
            repo.controldir.transport.local_abspath('repository'))
676
746
        self.assertEqual(relpath, 'baz')
677
747
 
678
748
    def test_open_containing_from_transport(self):
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')))
 
749
        self.assertRaises(NotBranchError,
 
750
            bzrdir.BzrDir.open_containing_from_transport,
 
751
            _mod_transport.get_transport_from_url(self.get_readonly_url('')))
 
752
        self.assertRaises(NotBranchError,
 
753
            bzrdir.BzrDir.open_containing_from_transport,
 
754
            _mod_transport.get_transport_from_url(
 
755
                self.get_readonly_url('g/p/q')))
683
756
        control = bzrdir.BzrDir.create(self.get_url())
684
757
        branch, relpath = bzrdir.BzrDir.open_containing_from_transport(
685
 
            get_transport(self.get_readonly_url('')))
 
758
            _mod_transport.get_transport_from_url(
 
759
                self.get_readonly_url('')))
686
760
        self.assertEqual('', relpath)
687
761
        branch, relpath = bzrdir.BzrDir.open_containing_from_transport(
688
 
            get_transport(self.get_readonly_url('g/p/q')))
 
762
            _mod_transport.get_transport_from_url(
 
763
                self.get_readonly_url('g/p/q')))
689
764
        self.assertEqual('g/p/q', relpath)
690
765
 
691
766
    def test_open_containing_tree_or_branch(self):
696
771
                         os.path.realpath(tree.basedir))
697
772
        self.assertEqual(os.path.realpath('topdir'),
698
773
                         self.local_branch_path(branch))
699
 
        self.assertIs(tree.bzrdir, branch.bzrdir)
 
774
        self.assertIs(tree.controldir, branch.controldir)
700
775
        self.assertEqual('foo', relpath)
701
776
        # opening from non-local should not return the tree
702
777
        tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
719
794
                         os.path.realpath(tree.basedir))
720
795
        self.assertEqual(os.path.realpath('topdir'),
721
796
                         self.local_branch_path(branch))
722
 
        self.assertIs(tree.bzrdir, branch.bzrdir)
 
797
        self.assertIs(tree.controldir, branch.controldir)
723
798
        # opening from non-local should not return the tree
724
799
        tree, branch = bzrdir.BzrDir.open_tree_or_branch(
725
800
            self.get_readonly_url('topdir'))
735
810
        # transport pointing at bzrdir should give a bzrdir with root transport
736
811
        # set to the given transport
737
812
        control = bzrdir.BzrDir.create(self.get_url())
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)
 
813
        t = self.get_transport()
 
814
        opened_bzrdir = bzrdir.BzrDir.open_from_transport(t)
 
815
        self.assertEqual(t.base, opened_bzrdir.root_transport.base)
741
816
        self.assertIsInstance(opened_bzrdir, bzrdir.BzrDir)
742
817
 
743
818
    def test_open_from_transport_no_bzrdir(self):
744
 
        transport = get_transport(self.get_url())
745
 
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport,
746
 
                          transport)
 
819
        t = self.get_transport()
 
820
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport, t)
747
821
 
748
822
    def test_open_from_transport_bzrdir_in_parent(self):
749
823
        control = bzrdir.BzrDir.create(self.get_url())
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)
 
824
        t = self.get_transport()
 
825
        t.mkdir('subdir')
 
826
        t = t.clone('subdir')
 
827
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport, t)
755
828
 
756
829
    def test_sprout_recursive(self):
757
830
        tree = self.make_branch_and_tree('tree1',
758
 
                                         format='dirstate-with-subtree')
 
831
                                         format='development-subtree')
759
832
        sub_tree = self.make_branch_and_tree('tree1/subtree',
760
 
            format='dirstate-with-subtree')
 
833
            format='development-subtree')
761
834
        sub_tree.set_root_id('subtree-root')
762
835
        tree.add_reference(sub_tree)
763
836
        self.build_tree(['tree1/subtree/file'])
764
837
        sub_tree.add('file')
765
838
        tree.commit('Initial commit')
766
 
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
 
839
        tree2 = tree.controldir.sprout('tree2').open_workingtree()
767
840
        tree2.lock_read()
768
841
        self.addCleanup(tree2.unlock)
769
 
        self.failUnlessExists('tree2/subtree/file')
770
 
        self.assertEqual('tree-reference', tree2.kind('subtree-root'))
 
842
        self.assertPathExists('tree2/subtree/file')
 
843
        self.assertEqual(
 
844
                'tree-reference',
 
845
                tree2.kind('subtree', 'subtree-root'))
771
846
 
772
847
    def test_cloning_metadir(self):
773
848
        """Ensure that cloning metadir is suitable"""
774
 
        bzrdir = self.make_bzrdir('bzrdir')
 
849
        bzrdir = self.make_controldir('bzrdir')
775
850
        bzrdir.cloning_metadir()
776
851
        branch = self.make_branch('branch', format='knit')
777
 
        format = branch.bzrdir.cloning_metadir()
 
852
        format = branch.controldir.cloning_metadir()
778
853
        self.assertIsInstance(format.workingtree_format,
779
 
            workingtree.WorkingTreeFormat3)
 
854
            workingtree_4.WorkingTreeFormat6)
780
855
 
781
856
    def test_sprout_recursive_treeless(self):
782
857
        tree = self.make_branch_and_tree('tree1',
783
 
            format='dirstate-with-subtree')
 
858
            format='development-subtree')
784
859
        sub_tree = self.make_branch_and_tree('tree1/subtree',
785
 
            format='dirstate-with-subtree')
 
860
            format='development-subtree')
786
861
        tree.add_reference(sub_tree)
787
862
        self.build_tree(['tree1/subtree/file'])
788
863
        sub_tree.add('file')
789
864
        tree.commit('Initial commit')
790
 
        tree.bzrdir.destroy_workingtree()
 
865
        # The following line force the orhaning to reveal bug #634470
 
866
        tree.branch.get_config_stack().set(
 
867
            'bzr.transform.orphan_policy', 'move')
 
868
        tree.controldir.destroy_workingtree()
 
869
        # FIXME: subtree/.bzr is left here which allows the test to pass (or
 
870
        # fail :-( ) -- vila 20100909
791
871
        repo = self.make_repository('repo', shared=True,
792
 
            format='dirstate-with-subtree')
 
872
            format='development-subtree')
793
873
        repo.set_make_working_trees(False)
794
 
        tree.bzrdir.sprout('repo/tree2')
795
 
        self.failUnlessExists('repo/tree2/subtree')
796
 
        self.failIfExists('repo/tree2/subtree/file')
 
874
        # FIXME: we just deleted the workingtree and now we want to use it ????
 
875
        # At a minimum, we should use tree.branch below (but this fails too
 
876
        # currently) or stop calling this test 'treeless'. Specifically, I've
 
877
        # turn the line below into an assertRaises when 'subtree/.bzr' is
 
878
        # orphaned and sprout tries to access the branch there (which is left
 
879
        # by bzrdir.BzrDirMeta1.destroy_workingtree when it ignores the
 
880
        # [DeletingParent('Not deleting', u'subtree', None)] conflict). See bug
 
881
        # #634470.  -- vila 20100909
 
882
        self.assertRaises(errors.NotBranchError,
 
883
                          tree.controldir.sprout, 'repo/tree2')
 
884
#        self.assertPathExists('repo/tree2/subtree')
 
885
#        self.assertPathDoesNotExist('repo/tree2/subtree/file')
797
886
 
798
887
    def make_foo_bar_baz(self):
799
 
        foo = bzrdir.BzrDir.create_branch_convenience('foo').bzrdir
800
 
        bar = self.make_branch('foo/bar').bzrdir
801
 
        baz = self.make_branch('baz').bzrdir
 
888
        foo = bzrdir.BzrDir.create_branch_convenience('foo').controldir
 
889
        bar = self.make_branch('foo/bar').controldir
 
890
        baz = self.make_branch('baz').controldir
802
891
        return foo, bar, baz
803
892
 
804
 
    def test_find_bzrdirs(self):
805
 
        foo, bar, baz = self.make_foo_bar_baz()
806
 
        transport = get_transport(self.get_url())
807
 
        self.assertEqualBzrdirs([baz, foo, bar],
808
 
                                bzrdir.BzrDir.find_bzrdirs(transport))
809
 
 
810
 
    def test_find_bzrdirs_list_current(self):
 
893
    def test_find_controldirs(self):
 
894
        foo, bar, baz = self.make_foo_bar_baz()
 
895
        t = self.get_transport()
 
896
        self.assertEqualBzrdirs([baz, foo, bar], bzrdir.BzrDir.find_controldirs(t))
 
897
 
 
898
    def make_fake_permission_denied_transport(self, transport, paths):
 
899
        """Create a transport that raises PermissionDenied for some paths."""
 
900
        def filter(path):
 
901
            if path in paths:
 
902
                raise errors.PermissionDenied(path)
 
903
            return path
 
904
        path_filter_server = pathfilter.PathFilteringServer(transport, filter)
 
905
        path_filter_server.start_server()
 
906
        self.addCleanup(path_filter_server.stop_server)
 
907
        path_filter_transport = pathfilter.PathFilteringTransport(
 
908
            path_filter_server, '.')
 
909
        return (path_filter_server, path_filter_transport)
 
910
 
 
911
    def assertBranchUrlsEndWith(self, expect_url_suffix, actual_bzrdirs):
 
912
        """Check that each branch url ends with the given suffix."""
 
913
        for actual_bzrdir in actual_bzrdirs:
 
914
            self.assertEndsWith(actual_bzrdir.user_url, expect_url_suffix)
 
915
 
 
916
    def test_find_controldirs_permission_denied(self):
 
917
        foo, bar, baz = self.make_foo_bar_baz()
 
918
        t = self.get_transport()
 
919
        path_filter_server, path_filter_transport = \
 
920
            self.make_fake_permission_denied_transport(t, ['foo'])
 
921
        # local transport
 
922
        self.assertBranchUrlsEndWith('/baz/',
 
923
            bzrdir.BzrDir.find_controldirs(path_filter_transport))
 
924
        # smart server
 
925
        smart_transport = self.make_smart_server('.',
 
926
            backing_server=path_filter_server)
 
927
        self.assertBranchUrlsEndWith('/baz/',
 
928
            bzrdir.BzrDir.find_controldirs(smart_transport))
 
929
 
 
930
    def test_find_controldirs_list_current(self):
811
931
        def list_current(transport):
812
932
            return [s for s in transport.list_dir('') if s != 'baz']
813
933
 
814
934
        foo, bar, baz = self.make_foo_bar_baz()
815
 
        transport = get_transport(self.get_url())
816
 
        self.assertEqualBzrdirs([foo, bar],
817
 
                                bzrdir.BzrDir.find_bzrdirs(transport,
818
 
                                    list_current=list_current))
819
 
 
820
 
 
821
 
    def test_find_bzrdirs_evaluate(self):
 
935
        t = self.get_transport()
 
936
        self.assertEqualBzrdirs(
 
937
            [foo, bar],
 
938
            bzrdir.BzrDir.find_controldirs(t, list_current=list_current))
 
939
 
 
940
    def test_find_controldirs_evaluate(self):
822
941
        def evaluate(bzrdir):
823
942
            try:
824
943
                repo = bzrdir.open_repository()
825
 
            except NoRepositoryPresent:
 
944
            except errors.NoRepositoryPresent:
826
945
                return True, bzrdir.root_transport.base
827
946
            else:
828
947
                return False, bzrdir.root_transport.base
829
948
 
830
949
        foo, bar, baz = self.make_foo_bar_baz()
831
 
        transport = get_transport(self.get_url())
 
950
        t = self.get_transport()
832
951
        self.assertEqual([baz.root_transport.base, foo.root_transport.base],
833
 
                         list(bzrdir.BzrDir.find_bzrdirs(transport,
834
 
                                                         evaluate=evaluate)))
 
952
                         list(bzrdir.BzrDir.find_controldirs(t, evaluate=evaluate)))
835
953
 
836
954
    def assertEqualBzrdirs(self, first, second):
837
955
        first = list(first)
843
961
    def test_find_branches(self):
844
962
        root = self.make_repository('', shared=True)
845
963
        foo, bar, baz = self.make_foo_bar_baz()
846
 
        qux = self.make_bzrdir('foo/qux')
847
 
        transport = get_transport(self.get_url())
848
 
        branches = bzrdir.BzrDir.find_branches(transport)
 
964
        qux = self.make_controldir('foo/qux')
 
965
        t = self.get_transport()
 
966
        branches = bzrdir.BzrDir.find_branches(t)
849
967
        self.assertEqual(baz.root_transport.base, branches[0].base)
850
968
        self.assertEqual(foo.root_transport.base, branches[1].base)
851
969
        self.assertEqual(bar.root_transport.base, branches[2].base)
852
970
 
853
971
        # ensure this works without a top-level repo
854
 
        branches = bzrdir.BzrDir.find_branches(transport.clone('foo'))
 
972
        branches = bzrdir.BzrDir.find_branches(t.clone('foo'))
855
973
        self.assertEqual(foo.root_transport.base, branches[0].base)
856
974
        self.assertEqual(bar.root_transport.base, branches[1].base)
857
975
 
858
976
 
 
977
class TestMissingRepoBranchesSkipped(TestCaseWithMemoryTransport):
 
978
 
 
979
    def test_find_controldirs_missing_repo(self):
 
980
        t = self.get_transport()
 
981
        arepo = self.make_repository('arepo', shared=True)
 
982
        abranch_url = arepo.user_url + '/abranch'
 
983
        abranch = bzrdir.BzrDir.create(abranch_url).create_branch()
 
984
        t.delete_tree('arepo/.bzr')
 
985
        self.assertRaises(errors.NoRepositoryPresent,
 
986
            branch.Branch.open, abranch_url)
 
987
        self.make_branch('baz')
 
988
        for actual_bzrdir in bzrdir.BzrDir.find_branches(t):
 
989
            self.assertEndsWith(actual_bzrdir.user_url, '/baz/')
 
990
 
 
991
 
859
992
class TestMeta1DirFormat(TestCaseWithTransport):
860
993
    """Tests specific to the meta1 dir format."""
861
994
 
865
998
        branch_base = t.clone('branch').base
866
999
        self.assertEqual(branch_base, dir.get_branch_transport(None).base)
867
1000
        self.assertEqual(branch_base,
868
 
                         dir.get_branch_transport(bzrlib.branch.BzrBranchFormat5()).base)
 
1001
                         dir.get_branch_transport(BzrBranchFormat5()).base)
869
1002
        repository_base = t.clone('repository').base
870
1003
        self.assertEqual(repository_base, dir.get_repository_transport(None).base)
 
1004
        repository_format = repository.format_registry.get_default()
871
1005
        self.assertEqual(repository_base,
872
 
                         dir.get_repository_transport(weaverepo.RepositoryFormat7()).base)
 
1006
                         dir.get_repository_transport(repository_format).base)
873
1007
        checkout_base = t.clone('checkout').base
874
1008
        self.assertEqual(checkout_base, dir.get_workingtree_transport(None).base)
875
1009
        self.assertEqual(checkout_base,
876
 
                         dir.get_workingtree_transport(workingtree.WorkingTreeFormat3()).base)
 
1010
                         dir.get_workingtree_transport(workingtree_3.WorkingTreeFormat3()).base)
877
1011
 
878
1012
    def test_meta1dir_uses_lockdir(self):
879
1013
        """Meta1 format uses a LockDir to guard the whole directory, not a file."""
887
1021
        Metadirs should compare equal iff they have the same repo, branch and
888
1022
        tree formats.
889
1023
        """
890
 
        mydir = bzrdir.format_registry.make_bzrdir('knit')
 
1024
        mydir = controldir.format_registry.make_controldir('knit')
891
1025
        self.assertEqual(mydir, mydir)
892
1026
        self.assertFalse(mydir != mydir)
893
 
        otherdir = bzrdir.format_registry.make_bzrdir('knit')
 
1027
        otherdir = controldir.format_registry.make_controldir('knit')
894
1028
        self.assertEqual(otherdir, mydir)
895
1029
        self.assertFalse(otherdir != mydir)
896
 
        otherdir2 = bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
 
1030
        otherdir2 = controldir.format_registry.make_controldir('development-subtree')
897
1031
        self.assertNotEqual(otherdir2, mydir)
898
1032
        self.assertFalse(otherdir2 == mydir)
899
1033
 
 
1034
    def test_with_features(self):
 
1035
        tree = self.make_branch_and_tree('tree', format='2a')
 
1036
        tree.controldir.update_feature_flags({"bar": "required"})
 
1037
        self.assertRaises(bzrdir.MissingFeature, bzrdir.BzrDir.open, 'tree')
 
1038
        bzrdir.BzrDirMetaFormat1.register_feature('bar')
 
1039
        self.addCleanup(bzrdir.BzrDirMetaFormat1.unregister_feature, 'bar')
 
1040
        dir = bzrdir.BzrDir.open('tree')
 
1041
        self.assertEqual("required", dir._format.features.get("bar"))
 
1042
        tree.controldir.update_feature_flags({"bar": None, "nonexistant": None})
 
1043
        dir = bzrdir.BzrDir.open('tree')
 
1044
        self.assertEqual({}, dir._format.features)
 
1045
 
900
1046
    def test_needs_conversion_different_working_tree(self):
901
1047
        # meta1dirs need an conversion if any element is not the default.
902
 
        new_format = bzrdir.format_registry.make_bzrdir('dirstate')
 
1048
        new_format = controldir.format_registry.make_controldir('dirstate')
903
1049
        tree = self.make_branch_and_tree('tree', format='knit')
904
 
        self.assertTrue(tree.bzrdir.needs_format_conversion(
 
1050
        self.assertTrue(tree.controldir.needs_format_conversion(
905
1051
            new_format))
906
1052
 
907
1053
    def test_initialize_on_format_uses_smart_transport(self):
908
1054
        self.setup_smart_server_with_call_log()
909
 
        new_format = bzrdir.format_registry.make_bzrdir('dirstate')
 
1055
        new_format = controldir.format_registry.make_controldir('dirstate')
910
1056
        transport = self.get_transport('target')
911
1057
        transport.ensure_base()
912
1058
        self.reset_smart_call_log()
921
1067
        self.assertEqual(2, rpc_count)
922
1068
 
923
1069
 
924
 
class TestFormat5(TestCaseWithTransport):
925
 
    """Tests specific to the version 5 bzrdir format."""
926
 
 
927
 
    def test_same_lockfiles_between_tree_repo_branch(self):
928
 
        # this checks that only a single lockfiles instance is created
929
 
        # for format 5 objects
930
 
        dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
931
 
        def check_dir_components_use_same_lock(dir):
932
 
            ctrl_1 = dir.open_repository().control_files
933
 
            ctrl_2 = dir.open_branch().control_files
934
 
            ctrl_3 = dir.open_workingtree()._control_files
935
 
            self.assertTrue(ctrl_1 is ctrl_2)
936
 
            self.assertTrue(ctrl_2 is ctrl_3)
937
 
        check_dir_components_use_same_lock(dir)
938
 
        # and if we open it normally.
939
 
        dir = bzrdir.BzrDir.open(self.get_url())
940
 
        check_dir_components_use_same_lock(dir)
941
 
 
942
 
    def test_can_convert(self):
943
 
        # format 5 dirs are convertable
944
 
        dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
945
 
        self.assertTrue(dir.can_convert_format())
946
 
 
947
 
    def test_needs_conversion(self):
948
 
        # format 5 dirs need a conversion if they are not the default,
949
 
        # and they aren't
950
 
        dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
951
 
        # don't need to convert it to itself
952
 
        self.assertFalse(dir.needs_format_conversion(bzrdir.BzrDirFormat5()))
953
 
        # do need to convert it to the current default
954
 
        self.assertTrue(dir.needs_format_conversion(
955
 
            bzrdir.BzrDirFormat.get_default_format()))
956
 
 
957
 
 
958
 
class TestFormat6(TestCaseWithTransport):
959
 
    """Tests specific to the version 6 bzrdir format."""
960
 
 
961
 
    def test_same_lockfiles_between_tree_repo_branch(self):
962
 
        # this checks that only a single lockfiles instance is created
963
 
        # for format 6 objects
964
 
        dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
965
 
        def check_dir_components_use_same_lock(dir):
966
 
            ctrl_1 = dir.open_repository().control_files
967
 
            ctrl_2 = dir.open_branch().control_files
968
 
            ctrl_3 = dir.open_workingtree()._control_files
969
 
            self.assertTrue(ctrl_1 is ctrl_2)
970
 
            self.assertTrue(ctrl_2 is ctrl_3)
971
 
        check_dir_components_use_same_lock(dir)
972
 
        # and if we open it normally.
973
 
        dir = bzrdir.BzrDir.open(self.get_url())
974
 
        check_dir_components_use_same_lock(dir)
975
 
 
976
 
    def test_can_convert(self):
977
 
        # format 6 dirs are convertable
978
 
        dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
979
 
        self.assertTrue(dir.can_convert_format())
980
 
 
981
 
    def test_needs_conversion(self):
982
 
        # format 6 dirs need an conversion if they are not the default.
983
 
        dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
984
 
        self.assertTrue(dir.needs_format_conversion(
985
 
            bzrdir.BzrDirFormat.get_default_format()))
986
 
 
987
 
 
988
 
class NotBzrDir(bzrlib.bzrdir.BzrDir):
989
 
    """A non .bzr based control directory."""
990
 
 
991
 
    def __init__(self, transport, format):
992
 
        self._format = format
993
 
        self.root_transport = transport
994
 
        self.transport = transport.clone('.not')
995
 
 
996
 
 
997
 
class NotBzrDirFormat(bzrlib.bzrdir.BzrDirFormat):
998
 
    """A test class representing any non-.bzr based disk format."""
999
 
 
1000
 
    def initialize_on_transport(self, transport):
1001
 
        """Initialize a new .not dir in the base directory of a Transport."""
1002
 
        transport.mkdir('.not')
1003
 
        return self.open(transport)
1004
 
 
1005
 
    def open(self, transport):
1006
 
        """Open this directory."""
1007
 
        return NotBzrDir(transport, self)
1008
 
 
1009
 
    @classmethod
1010
 
    def _known_formats(self):
1011
 
        return set([NotBzrDirFormat()])
1012
 
 
1013
 
    @classmethod
1014
 
    def probe_transport(self, transport):
1015
 
        """Our format is present if the transport ends in '.not/'."""
1016
 
        if transport.has('.not'):
1017
 
            return NotBzrDirFormat()
1018
 
 
1019
 
 
1020
 
class TestNotBzrDir(TestCaseWithTransport):
1021
 
    """Tests for using the bzrdir api with a non .bzr based disk format.
1022
 
 
1023
 
    If/when one of these is in the core, we can let the implementation tests
1024
 
    verify this works.
1025
 
    """
1026
 
 
1027
 
    def test_create_and_find_format(self):
1028
 
        # create a .notbzr dir
1029
 
        format = NotBzrDirFormat()
1030
 
        dir = format.initialize(self.get_url())
1031
 
        self.assertIsInstance(dir, NotBzrDir)
1032
 
        # now probe for it.
1033
 
        bzrlib.bzrdir.BzrDirFormat.register_control_format(format)
1034
 
        try:
1035
 
            found = bzrlib.bzrdir.BzrDirFormat.find_format(
1036
 
                get_transport(self.get_url()))
1037
 
            self.assertIsInstance(found, NotBzrDirFormat)
1038
 
        finally:
1039
 
            bzrlib.bzrdir.BzrDirFormat.unregister_control_format(format)
1040
 
 
1041
 
    def test_included_in_known_formats(self):
1042
 
        bzrlib.bzrdir.BzrDirFormat.register_control_format(NotBzrDirFormat)
1043
 
        try:
1044
 
            formats = bzrlib.bzrdir.BzrDirFormat.known_formats()
1045
 
            for format in formats:
1046
 
                if isinstance(format, NotBzrDirFormat):
1047
 
                    return
1048
 
            self.fail("No NotBzrDirFormat in %s" % formats)
1049
 
        finally:
1050
 
            bzrlib.bzrdir.BzrDirFormat.unregister_control_format(NotBzrDirFormat)
1051
 
 
1052
 
 
1053
1070
class NonLocalTests(TestCaseWithTransport):
1054
1071
    """Tests for bzrdir static behaviour on non local paths."""
1055
1072
 
1059
1076
 
1060
1077
    def test_create_branch_convenience(self):
1061
1078
        # outside a repo the default convenience output is a repo+branch_tree
1062
 
        format = bzrdir.format_registry.make_bzrdir('knit')
 
1079
        format = controldir.format_registry.make_controldir('knit')
1063
1080
        branch = bzrdir.BzrDir.create_branch_convenience(
1064
1081
            self.get_url('foo'), format=format)
1065
1082
        self.assertRaises(errors.NoWorkingTree,
1066
 
                          branch.bzrdir.open_workingtree)
1067
 
        branch.bzrdir.open_repository()
 
1083
                          branch.controldir.open_workingtree)
 
1084
        branch.controldir.open_repository()
1068
1085
 
1069
1086
    def test_create_branch_convenience_force_tree_not_local_fails(self):
1070
1087
        # outside a repo the default convenience output is a repo+branch_tree
1071
 
        format = bzrdir.format_registry.make_bzrdir('knit')
 
1088
        format = controldir.format_registry.make_controldir('knit')
1072
1089
        self.assertRaises(errors.NotLocalUrl,
1073
1090
            bzrdir.BzrDir.create_branch_convenience,
1074
1091
            self.get_url('foo'),
1075
1092
            force_new_tree=True,
1076
1093
            format=format)
1077
 
        t = get_transport(self.get_url('.'))
 
1094
        t = self.get_transport()
1078
1095
        self.assertFalse(t.has('foo'))
1079
1096
 
1080
1097
    def test_clone(self):
1081
1098
        # clone into a nonlocal path works
1082
 
        format = bzrdir.format_registry.make_bzrdir('knit')
 
1099
        format = controldir.format_registry.make_controldir('knit')
1083
1100
        branch = bzrdir.BzrDir.create_branch_convenience('local',
1084
1101
                                                         format=format)
1085
 
        branch.bzrdir.open_workingtree()
1086
 
        result = branch.bzrdir.clone(self.get_url('remote'))
 
1102
        branch.controldir.open_workingtree()
 
1103
        result = branch.controldir.clone(self.get_url('remote'))
1087
1104
        self.assertRaises(errors.NoWorkingTree,
1088
1105
                          result.open_workingtree)
1089
1106
        result.open_branch()
1096
1113
        my_bzrdir = bzrdir.BzrDir.open(self.get_url('branch-knit2'))
1097
1114
        checkout_format = my_bzrdir.checkout_metadir()
1098
1115
        self.assertIsInstance(checkout_format.workingtree_format,
1099
 
                              workingtree.WorkingTreeFormat3)
 
1116
                              workingtree_4.WorkingTreeFormat4)
1100
1117
 
1101
1118
 
1102
1119
class TestHTTPRedirections(object):
1111
1128
    """
1112
1129
 
1113
1130
    def create_transport_readonly_server(self):
 
1131
        # We don't set the http protocol version, relying on the default
1114
1132
        return http_utils.HTTPServerRedirecting()
1115
1133
 
1116
1134
    def create_transport_secondary_server(self):
 
1135
        # We don't set the http protocol version, relying on the default
1117
1136
        return http_utils.HTTPServerRedirecting()
1118
1137
 
1119
1138
    def setUp(self):
1164
1183
 
1165
1184
 
1166
1185
 
1167
 
class TestHTTPRedirections_pycurl(TestWithTransport_pycurl,
1168
 
                                  TestHTTPRedirections,
1169
 
                                  http_utils.TestCaseWithTwoWebservers):
1170
 
    """Tests redirections for pycurl implementation"""
1171
 
 
1172
 
    def _qualified_url(self, host, port):
1173
 
        result = 'http+pycurl://%s:%s' % (host, port)
1174
 
        self.permit_url(result)
1175
 
        return result
1176
 
 
1177
 
 
1178
1186
class TestHTTPRedirections_nosmart(TestHTTPRedirections,
1179
1187
                                  http_utils.TestCaseWithTwoWebservers):
1180
1188
    """Tests redirections for the nosmart decorator"""
1218
1226
            raise TestSkipped('unable to make file hidden without pywin32 library')
1219
1227
        b = bzrdir.BzrDir.create('.')
1220
1228
        self.build_tree(['a'])
1221
 
        self.assertEquals(['a'], self.get_ls())
 
1229
        self.assertEqual(['a'], self.get_ls())
1222
1230
 
1223
1231
    def test_dot_bzr_hidden_with_url(self):
1224
1232
        if sys.platform == 'win32' and not win32utils.has_win32file:
1225
1233
            raise TestSkipped('unable to make file hidden without pywin32 library')
1226
1234
        b = bzrdir.BzrDir.create(urlutils.local_path_to_url('.'))
1227
1235
        self.build_tree(['a'])
1228
 
        self.assertEquals(['a'], self.get_ls())
 
1236
        self.assertEqual(['a'], self.get_ls())
1229
1237
 
1230
1238
 
1231
1239
class _TestBzrDirFormat(bzrdir.BzrDirMetaFormat1):
1244
1252
 
1245
1253
    def __init__(self, *args, **kwargs):
1246
1254
        super(_TestBzrDir, self).__init__(*args, **kwargs)
1247
 
        self.test_branch = _TestBranch()
 
1255
        self.test_branch = _TestBranch(self.transport)
1248
1256
        self.test_branch.repository = self.create_repository()
1249
1257
 
1250
 
    def open_branch(self, unsupported=False):
 
1258
    def open_branch(self, unsupported=False, possible_transports=None):
1251
1259
        return self.test_branch
1252
1260
 
1253
1261
    def cloning_metadir(self, require_stacking=False):
1254
1262
        return _TestBzrDirFormat()
1255
1263
 
1256
1264
 
1257
 
class _TestBranchFormat(bzrlib.branch.BranchFormat):
 
1265
class _TestBranchFormat(breezy.branch.BranchFormat):
1258
1266
    """Test Branch format for TestBzrDirSprout."""
1259
1267
 
1260
1268
 
1261
 
class _TestBranch(bzrlib.branch.Branch):
 
1269
class _TestBranch(breezy.branch.Branch):
1262
1270
    """Test Branch implementation for TestBzrDirSprout."""
1263
1271
 
1264
 
    def __init__(self, *args, **kwargs):
 
1272
    def __init__(self, transport, *args, **kwargs):
1265
1273
        self._format = _TestBranchFormat()
 
1274
        self._transport = transport
 
1275
        self.base = transport.base
1266
1276
        super(_TestBranch, self).__init__(*args, **kwargs)
1267
1277
        self.calls = []
1268
1278
        self._parent = None
1269
1279
 
1270
1280
    def sprout(self, *args, **kwargs):
1271
1281
        self.calls.append('sprout')
1272
 
        return _TestBranch()
 
1282
        return _TestBranch(self._transport)
1273
1283
 
1274
1284
    def copy_content_into(self, destination, revision_id=None):
1275
1285
        self.calls.append('copy_content_into')
1276
1286
 
 
1287
    def last_revision(self):
 
1288
        return _mod_revision.NULL_REVISION
 
1289
 
1277
1290
    def get_parent(self):
1278
1291
        return self._parent
1279
1292
 
 
1293
    def _get_config(self):
 
1294
        return config.TransportConfig(self._transport, 'branch.conf')
 
1295
 
 
1296
    def _get_config_store(self):
 
1297
        return config.BranchStore(self)
 
1298
 
1280
1299
    def set_parent(self, parent):
1281
1300
        self._parent = parent
1282
1301
 
 
1302
    def lock_read(self):
 
1303
        return lock.LogicalLockResult(self.unlock)
 
1304
 
 
1305
    def unlock(self):
 
1306
        return
 
1307
 
1283
1308
 
1284
1309
class TestBzrDirSprout(TestCaseWithMemoryTransport):
1285
1310
 
1313
1338
 
1314
1339
    def test_sprout_parent(self):
1315
1340
        grandparent_tree = self.make_branch('grandparent')
1316
 
        parent = grandparent_tree.bzrdir.sprout('parent').open_branch()
1317
 
        branch_tree = parent.bzrdir.sprout('branch').open_branch()
 
1341
        parent = grandparent_tree.controldir.sprout('parent').open_branch()
 
1342
        branch_tree = parent.controldir.sprout('branch').open_branch()
1318
1343
        self.assertContainsRe(branch_tree.get_parent(), '/parent/$')
1319
1344
 
1320
1345
 
1341
1366
        self.assertEqual('fail', err._preformatted_string)
1342
1367
 
1343
1368
    def test_post_repo_init(self):
1344
 
        from bzrlib.bzrdir import RepoInitHookParams
 
1369
        from ..controldir import RepoInitHookParams
1345
1370
        calls = []
1346
1371
        bzrdir.BzrDir.hooks.install_named_hook('post_repo_init',
1347
1372
            calls.append, None)
1349
1374
        self.assertLength(1, calls)
1350
1375
        params = calls[0]
1351
1376
        self.assertIsInstance(params, RepoInitHookParams)
1352
 
        self.assertTrue(hasattr(params, 'bzrdir'))
 
1377
        self.assertTrue(hasattr(params, 'controldir'))
1353
1378
        self.assertTrue(hasattr(params, 'repository'))
 
1379
 
 
1380
    def test_post_repo_init_hook_repr(self):
 
1381
        param_reprs = []
 
1382
        bzrdir.BzrDir.hooks.install_named_hook('post_repo_init',
 
1383
            lambda params: param_reprs.append(repr(params)), None)
 
1384
        self.make_repository('foo')
 
1385
        self.assertLength(1, param_reprs)
 
1386
        param_repr = param_reprs[0]
 
1387
        self.assertStartsWith(param_repr, '<RepoInitHookParams for ')
 
1388
 
 
1389
 
 
1390
class TestGenerateBackupName(TestCaseWithMemoryTransport):
 
1391
    # FIXME: This may need to be unified with test_osutils.TestBackupNames or
 
1392
    # moved to per_bzrdir or per_transport for better coverage ?
 
1393
    # -- vila 20100909
 
1394
 
 
1395
    def setUp(self):
 
1396
        super(TestGenerateBackupName, self).setUp()
 
1397
        self._transport = self.get_transport()
 
1398
        bzrdir.BzrDir.create(self.get_url(),
 
1399
            possible_transports=[self._transport])
 
1400
        self._bzrdir = bzrdir.BzrDir.open_from_transport(self._transport)
 
1401
 
 
1402
    def test_new(self):
 
1403
        self.assertEqual("a.~1~", self._bzrdir._available_backup_name("a"))
 
1404
 
 
1405
    def test_exiting(self):
 
1406
        self._transport.put_bytes("a.~1~", "some content")
 
1407
        self.assertEqual("a.~2~", self._bzrdir._available_backup_name("a"))
 
1408
 
 
1409
 
 
1410
class TestMeta1DirColoFormat(TestCaseWithTransport):
 
1411
    """Tests specific to the meta1 dir with colocated branches format."""
 
1412
 
 
1413
    def test_supports_colo(self):
 
1414
        format = bzrdir.BzrDirMetaFormat1Colo()
 
1415
        self.assertTrue(format.colocated_branches)
 
1416
 
 
1417
    def test_upgrade_from_2a(self):
 
1418
        tree = self.make_branch_and_tree('.', format='2a')
 
1419
        format = bzrdir.BzrDirMetaFormat1Colo()
 
1420
        self.assertTrue(tree.controldir.needs_format_conversion(format))
 
1421
        converter = tree.controldir._format.get_converter(format)
 
1422
        result = converter.convert(tree.controldir, None)
 
1423
        self.assertIsInstance(result._format, bzrdir.BzrDirMetaFormat1Colo)
 
1424
        self.assertFalse(result.needs_format_conversion(format))
 
1425
 
 
1426
    def test_downgrade_to_2a(self):
 
1427
        tree = self.make_branch_and_tree('.', format='development-colo')
 
1428
        format = bzrdir.BzrDirMetaFormat1()
 
1429
        self.assertTrue(tree.controldir.needs_format_conversion(format))
 
1430
        converter = tree.controldir._format.get_converter(format)
 
1431
        result = converter.convert(tree.controldir, None)
 
1432
        self.assertIsInstance(result._format, bzrdir.BzrDirMetaFormat1)
 
1433
        self.assertFalse(result.needs_format_conversion(format))
 
1434
 
 
1435
    def test_downgrade_to_2a_too_many_branches(self):
 
1436
        tree = self.make_branch_and_tree('.', format='development-colo')
 
1437
        tree.controldir.create_branch(name="another-colocated-branch")
 
1438
        converter = tree.controldir._format.get_converter(
 
1439
            bzrdir.BzrDirMetaFormat1())
 
1440
        result = converter.convert(tree.controldir, bzrdir.BzrDirMetaFormat1())
 
1441
        self.assertIsInstance(result._format, bzrdir.BzrDirMetaFormat1)
 
1442
 
 
1443
    def test_nested(self):
 
1444
        tree = self.make_branch_and_tree('.', format='development-colo')
 
1445
        tree.controldir.create_branch(name='foo')
 
1446
        tree.controldir.create_branch(name='fool/bla')
 
1447
        self.assertRaises(
 
1448
            errors.ParentBranchExists, tree.controldir.create_branch,
 
1449
            name='foo/bar')
 
1450
 
 
1451
    def test_parent(self):
 
1452
        tree = self.make_branch_and_tree('.', format='development-colo')
 
1453
        tree.controldir.create_branch(name='fool/bla')
 
1454
        tree.controldir.create_branch(name='foo/bar')
 
1455
        self.assertRaises(
 
1456
            errors.AlreadyBranchError, tree.controldir.create_branch,
 
1457
            name='foo')
 
1458
 
 
1459
 
 
1460
class SampleBzrFormat(bzrdir.BzrFormat):
 
1461
 
 
1462
    @classmethod
 
1463
    def get_format_string(cls):
 
1464
        return "First line\n"
 
1465
 
 
1466
 
 
1467
class TestBzrFormat(TestCase):
 
1468
    """Tests for BzrFormat."""
 
1469
 
 
1470
    def test_as_string(self):
 
1471
        format = SampleBzrFormat()
 
1472
        format.features = {"foo": "required"}
 
1473
        self.assertEqual(format.as_string(),
 
1474
            "First line\n"
 
1475
            "required foo\n")
 
1476
        format.features["another"] = "optional"
 
1477
        self.assertEqual(format.as_string(),
 
1478
            "First line\n"
 
1479
            "required foo\n"
 
1480
            "optional another\n")
 
1481
 
 
1482
    def test_network_name(self):
 
1483
        # The network string should include the feature info
 
1484
        format = SampleBzrFormat()
 
1485
        format.features = {"foo": "required"}
 
1486
        self.assertEqual(
 
1487
            "First line\nrequired foo\n",
 
1488
            format.network_name())
 
1489
 
 
1490
    def test_from_string_no_features(self):
 
1491
        # No features
 
1492
        format = SampleBzrFormat.from_string(
 
1493
            "First line\n")
 
1494
        self.assertEqual({}, format.features)
 
1495
 
 
1496
    def test_from_string_with_feature(self):
 
1497
        # Proper feature
 
1498
        format = SampleBzrFormat.from_string(
 
1499
            "First line\nrequired foo\n")
 
1500
        self.assertEqual("required", format.features.get("foo"))
 
1501
 
 
1502
    def test_from_string_format_string_mismatch(self):
 
1503
        # The first line has to match the format string
 
1504
        self.assertRaises(AssertionError, SampleBzrFormat.from_string,
 
1505
            "Second line\nrequired foo\n")
 
1506
 
 
1507
    def test_from_string_missing_space(self):
 
1508
        # At least one space is required in the feature lines
 
1509
        self.assertRaises(errors.ParseFormatError, SampleBzrFormat.from_string,
 
1510
            "First line\nfoo\n")
 
1511
 
 
1512
    def test_from_string_with_spaces(self):
 
1513
        # Feature with spaces (in case we add stuff like this in the future)
 
1514
        format = SampleBzrFormat.from_string(
 
1515
            "First line\nrequired foo with spaces\n")
 
1516
        self.assertEqual("required", format.features.get("foo with spaces"))
 
1517
 
 
1518
    def test_eq(self):
 
1519
        format1 = SampleBzrFormat()
 
1520
        format1.features = {"nested-trees": "optional"}
 
1521
        format2 = SampleBzrFormat()
 
1522
        format2.features = {"nested-trees": "optional"}
 
1523
        self.assertEqual(format1, format1)
 
1524
        self.assertEqual(format1, format2)
 
1525
        format3 = SampleBzrFormat()
 
1526
        self.assertNotEqual(format1, format3)
 
1527
 
 
1528
    def test_check_support_status_optional(self):
 
1529
        # Optional, so silently ignore
 
1530
        format = SampleBzrFormat()
 
1531
        format.features = {"nested-trees": "optional"}
 
1532
        format.check_support_status(True)
 
1533
        self.addCleanup(SampleBzrFormat.unregister_feature, "nested-trees")
 
1534
        SampleBzrFormat.register_feature("nested-trees")
 
1535
        format.check_support_status(True)
 
1536
 
 
1537
    def test_check_support_status_required(self):
 
1538
        # Optional, so trigger an exception
 
1539
        format = SampleBzrFormat()
 
1540
        format.features = {"nested-trees": "required"}
 
1541
        self.assertRaises(bzrdir.MissingFeature, format.check_support_status,
 
1542
            True)
 
1543
        self.addCleanup(SampleBzrFormat.unregister_feature, "nested-trees")
 
1544
        SampleBzrFormat.register_feature("nested-trees")
 
1545
        format.check_support_status(True)
 
1546
 
 
1547
    def test_check_support_status_unknown(self):
 
1548
        # treat unknown necessity as required
 
1549
        format = SampleBzrFormat()
 
1550
        format.features = {"nested-trees": "unknown"}
 
1551
        self.assertRaises(bzrdir.MissingFeature, format.check_support_status,
 
1552
            True)
 
1553
        self.addCleanup(SampleBzrFormat.unregister_feature, "nested-trees")
 
1554
        SampleBzrFormat.register_feature("nested-trees")
 
1555
        format.check_support_status(True)
 
1556
 
 
1557
    def test_feature_already_registered(self):
 
1558
        # a feature can only be registered once
 
1559
        self.addCleanup(SampleBzrFormat.unregister_feature, "nested-trees")
 
1560
        SampleBzrFormat.register_feature("nested-trees")
 
1561
        self.assertRaises(bzrdir.FeatureAlreadyRegistered,
 
1562
            SampleBzrFormat.register_feature, "nested-trees")
 
1563
 
 
1564
    def test_feature_with_space(self):
 
1565
        # spaces are not allowed in feature names
 
1566
        self.assertRaises(ValueError, SampleBzrFormat.register_feature,
 
1567
            "nested trees")