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

  • Committer: Aaron Bentley
  • Date: 2007-03-03 17:17:53 UTC
  • mfrom: (2309 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2316.
  • Revision ID: aaron.bentley@utoronto.ca-20070303171753-o0s1yrxx5sn12p2k
Merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_bzrdir.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 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
19
19
For interface contract tests, see tests/bzr_dir_implementations.
20
20
"""
21
21
 
 
22
import os.path
22
23
from StringIO import StringIO
23
24
 
 
25
from bzrlib import (
 
26
    help_topics,
 
27
    symbol_versioning,
 
28
    urlutils,
 
29
    workingtree,
 
30
    )
24
31
import bzrlib.branch
25
32
import bzrlib.bzrdir as bzrdir
26
33
import bzrlib.errors as errors
29
36
                           UnsupportedFormatError,
30
37
                           )
31
38
import bzrlib.repository as repository
32
 
from bzrlib.tests import TestCase, TestCaseWithTransport
 
39
from bzrlib.tests import TestCase, TestCaseWithTransport, test_sftp_transport
 
40
from bzrlib.tests.HttpServer import HttpServer
33
41
from bzrlib.transport import get_transport
34
 
from bzrlib.transport.http import HttpServer
35
42
from bzrlib.transport.memory import MemoryServer
36
 
import bzrlib.workingtree as workingtree
 
43
from bzrlib.repofmt import knitrepo, weaverepo
37
44
 
38
45
 
39
46
class TestDefaultFormat(TestCase):
42
49
        old_format = bzrdir.BzrDirFormat.get_default_format()
43
50
        # default is BzrDirFormat6
44
51
        self.failUnless(isinstance(old_format, bzrdir.BzrDirMetaFormat1))
45
 
        bzrdir.BzrDirFormat.set_default_format(SampleBzrDirFormat())
 
52
        self.applyDeprecated(symbol_versioning.zero_fourteen, 
 
53
                             bzrdir.BzrDirFormat.set_default_format, 
 
54
                             SampleBzrDirFormat())
46
55
        # creating a bzr dir should now create an instrumented dir.
47
56
        try:
48
57
            result = bzrdir.BzrDir.create('memory:///')
49
58
            self.failUnless(isinstance(result, SampleBzrDir))
50
59
        finally:
51
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
60
            self.applyDeprecated(symbol_versioning.zero_fourteen,
 
61
                bzrdir.BzrDirFormat.set_default_format, old_format)
52
62
        self.assertEqual(old_format, bzrdir.BzrDirFormat.get_default_format())
53
63
 
54
64
 
 
65
class TestFormatRegistry(TestCase):
 
66
 
 
67
    def make_format_registry(self):
 
68
        my_format_registry = bzrdir.BzrDirFormatRegistry()
 
69
        my_format_registry.register('weave', bzrdir.BzrDirFormat6,
 
70
            'Pre-0.8 format.  Slower and does not support checkouts or shared'
 
71
            ' repositories', deprecated=True)
 
72
        my_format_registry.register_lazy('lazy', 'bzrlib.bzrdir', 
 
73
            'BzrDirFormat6', 'Format registered lazily', deprecated=True)
 
74
        my_format_registry.register_metadir('knit',
 
75
            'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
 
76
            'Format using knits',
 
77
            )
 
78
        my_format_registry.set_default('knit')
 
79
        my_format_registry.register_metadir(
 
80
            'experimental-knit2',
 
81
            'bzrlib.repofmt.knitrepo.RepositoryFormatKnit2',
 
82
            'Experimental successor to knit.  Use at your own risk.',
 
83
            )
 
84
        my_format_registry.register_metadir(
 
85
            'branch6',
 
86
            'bzrlib.repofmt.knitrepo.RepositoryFormatKnit2',
 
87
            'Experimental successor to knit.  Use at your own risk.',
 
88
            branch_format='BzrBranchFormat6')
 
89
        return my_format_registry
 
90
 
 
91
    def test_format_registry(self):
 
92
        my_format_registry = self.make_format_registry()
 
93
        my_bzrdir = my_format_registry.make_bzrdir('lazy')
 
94
        self.assertIsInstance(my_bzrdir, bzrdir.BzrDirFormat6)
 
95
        my_bzrdir = my_format_registry.make_bzrdir('weave')
 
96
        self.assertIsInstance(my_bzrdir, bzrdir.BzrDirFormat6)
 
97
        my_bzrdir = my_format_registry.make_bzrdir('default')
 
98
        self.assertIsInstance(my_bzrdir.repository_format, 
 
99
            knitrepo.RepositoryFormatKnit1)
 
100
        my_bzrdir = my_format_registry.make_bzrdir('knit')
 
101
        self.assertIsInstance(my_bzrdir.repository_format, 
 
102
            knitrepo.RepositoryFormatKnit1)
 
103
        my_bzrdir = my_format_registry.make_bzrdir('branch6')
 
104
        self.assertIsInstance(my_bzrdir.get_branch_format(),
 
105
                              bzrlib.branch.BzrBranchFormat6)
 
106
 
 
107
    def test_get_help(self):
 
108
        my_format_registry = self.make_format_registry()
 
109
        self.assertEqual('Format registered lazily',
 
110
                         my_format_registry.get_help('lazy'))
 
111
        self.assertEqual('Format using knits', 
 
112
                         my_format_registry.get_help('knit'))
 
113
        self.assertEqual('Format using knits', 
 
114
                         my_format_registry.get_help('default'))
 
115
        self.assertEqual('Pre-0.8 format.  Slower and does not support'
 
116
                         ' checkouts or shared repositories', 
 
117
                         my_format_registry.get_help('weave'))
 
118
        
 
119
    def test_help_topic(self):
 
120
        topics = help_topics.HelpTopicRegistry()
 
121
        topics.register('formats', self.make_format_registry().help_topic, 
 
122
                        'Directory formats')
 
123
        topic = topics.get_detail('formats')
 
124
        new, deprecated = topic.split('Deprecated formats')
 
125
        self.assertContainsRe(new, 'Bazaar directory formats')
 
126
        self.assertContainsRe(new, 
 
127
            '  knit/default:\n    \(native\) Format using knits\n')
 
128
        self.assertContainsRe(deprecated, 
 
129
            '  lazy:\n    \(native\) Format registered lazily\n')
 
130
 
 
131
    def test_set_default_repository(self):
 
132
        default_factory = bzrdir.format_registry.get('default')
 
133
        old_default = [k for k, v in bzrdir.format_registry.iteritems()
 
134
                       if v == default_factory and k != 'default'][0]
 
135
        bzrdir.format_registry.set_default_repository('experimental-knit2')
 
136
        try:
 
137
            self.assertIs(bzrdir.format_registry.get('experimental-knit2'),
 
138
                          bzrdir.format_registry.get('default'))
 
139
            self.assertIs(
 
140
                repository.RepositoryFormat.get_default_format().__class__,
 
141
                knitrepo.RepositoryFormatKnit2)
 
142
        finally:
 
143
            bzrdir.format_registry.set_default_repository(old_default)
 
144
 
 
145
 
55
146
class SampleBranch(bzrlib.branch.Branch):
56
147
    """A dummy branch for guess what, dummy use."""
57
148
 
155
246
 
156
247
    def test_create_repository(self):
157
248
        format = SampleBzrDirFormat()
158
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
159
 
        bzrdir.BzrDirFormat.set_default_format(format)
160
 
        try:
161
 
            repo = bzrdir.BzrDir.create_repository(self.get_url())
162
 
            self.assertEqual('A repository', repo)
163
 
        finally:
164
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
249
        repo = bzrdir.BzrDir.create_repository(self.get_url(), format=format)
 
250
        self.assertEqual('A repository', repo)
165
251
 
166
252
    def test_create_repository_shared(self):
167
253
        old_format = bzrdir.BzrDirFormat.get_default_format()
176
262
    def test_create_repository_under_shared(self):
177
263
        # an explicit create_repository always does so.
178
264
        # we trust the format is right from the 'create_repository test'
179
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
180
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
181
 
        try:
182
 
            self.make_repository('.', shared=True)
183
 
            repo = bzrdir.BzrDir.create_repository(self.get_url('child'))
184
 
            self.assertTrue(isinstance(repo, repository.Repository))
185
 
            self.assertTrue(repo.bzrdir.root_transport.base.endswith('child/'))
186
 
        finally:
187
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
265
        format = bzrdir.format_registry.make_bzrdir('knit')
 
266
        self.make_repository('.', shared=True, format=format)
 
267
        repo = bzrdir.BzrDir.create_repository(self.get_url('child'),
 
268
                                               format=format)
 
269
        self.assertTrue(isinstance(repo, repository.Repository))
 
270
        self.assertTrue(repo.bzrdir.root_transport.base.endswith('child/'))
188
271
 
189
272
    def test_create_branch_and_repo_uses_default(self):
190
273
        format = SampleBzrDirFormat()
191
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
192
 
        bzrdir.BzrDirFormat.set_default_format(format)
193
 
        try:
194
 
            branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url())
195
 
            self.assertTrue(isinstance(branch, SampleBranch))
196
 
        finally:
197
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
274
        branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url(), 
 
275
                                                      format=format)
 
276
        self.assertTrue(isinstance(branch, SampleBranch))
198
277
 
199
278
    def test_create_branch_and_repo_under_shared(self):
200
279
        # creating a branch and repo in a shared repo uses the
201
280
        # shared repository
202
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
203
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
204
 
        try:
205
 
            self.make_repository('.', shared=True)
206
 
            branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url('child'))
207
 
            self.assertRaises(errors.NoRepositoryPresent,
208
 
                              branch.bzrdir.open_repository)
209
 
        finally:
210
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
281
        format = bzrdir.format_registry.make_bzrdir('knit')
 
282
        self.make_repository('.', shared=True, format=format)
 
283
        branch = bzrdir.BzrDir.create_branch_and_repo(
 
284
            self.get_url('child'), format=format)
 
285
        self.assertRaises(errors.NoRepositoryPresent,
 
286
                          branch.bzrdir.open_repository)
211
287
 
212
288
    def test_create_branch_and_repo_under_shared_force_new(self):
213
289
        # creating a branch and repo in a shared repo can be forced to 
214
290
        # make a new repo
215
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
216
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
217
 
        try:
218
 
            self.make_repository('.', shared=True)
219
 
            branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url('child'),
220
 
                                                          force_new_repo=True)
221
 
            branch.bzrdir.open_repository()
222
 
        finally:
223
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
291
        format = bzrdir.format_registry.make_bzrdir('knit')
 
292
        self.make_repository('.', shared=True, format=format)
 
293
        branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url('child'),
 
294
                                                      force_new_repo=True,
 
295
                                                      format=format)
 
296
        branch.bzrdir.open_repository()
224
297
 
225
298
    def test_create_standalone_working_tree(self):
226
299
        format = SampleBzrDirFormat()
227
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
228
 
        bzrdir.BzrDirFormat.set_default_format(format)
229
 
        try:
230
 
            # note this is deliberately readonly, as this failure should 
231
 
            # occur before any writes.
232
 
            self.assertRaises(errors.NotLocalUrl,
233
 
                              bzrdir.BzrDir.create_standalone_workingtree,
234
 
                              self.get_readonly_url())
235
 
            tree = bzrdir.BzrDir.create_standalone_workingtree('.')
236
 
            self.assertEqual('A tree', tree)
237
 
        finally:
238
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
300
        # note this is deliberately readonly, as this failure should 
 
301
        # occur before any writes.
 
302
        self.assertRaises(errors.NotLocalUrl,
 
303
                          bzrdir.BzrDir.create_standalone_workingtree,
 
304
                          self.get_readonly_url(), format=format)
 
305
        tree = bzrdir.BzrDir.create_standalone_workingtree('.', 
 
306
                                                           format=format)
 
307
        self.assertEqual('A tree', tree)
239
308
 
240
309
    def test_create_standalone_working_tree_under_shared_repo(self):
241
310
        # create standalone working tree always makes a repo.
242
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
243
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
244
 
        try:
245
 
            self.make_repository('.', shared=True)
246
 
            # note this is deliberately readonly, as this failure should 
247
 
            # occur before any writes.
248
 
            self.assertRaises(errors.NotLocalUrl,
249
 
                              bzrdir.BzrDir.create_standalone_workingtree,
250
 
                              self.get_readonly_url('child'))
251
 
            tree = bzrdir.BzrDir.create_standalone_workingtree('child')
252
 
            tree.bzrdir.open_repository()
253
 
        finally:
254
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
311
        format = bzrdir.format_registry.make_bzrdir('knit')
 
312
        self.make_repository('.', shared=True, format=format)
 
313
        # note this is deliberately readonly, as this failure should 
 
314
        # occur before any writes.
 
315
        self.assertRaises(errors.NotLocalUrl,
 
316
                          bzrdir.BzrDir.create_standalone_workingtree,
 
317
                          self.get_readonly_url('child'), format=format)
 
318
        tree = bzrdir.BzrDir.create_standalone_workingtree('child', 
 
319
            format=format)
 
320
        tree.bzrdir.open_repository()
255
321
 
256
322
    def test_create_branch_convenience(self):
257
323
        # outside a repo the default convenience output is a repo+branch_tree
258
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
259
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
260
 
        try:
261
 
            branch = bzrdir.BzrDir.create_branch_convenience('.')
262
 
            branch.bzrdir.open_workingtree()
263
 
            branch.bzrdir.open_repository()
264
 
        finally:
265
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
324
        format = bzrdir.format_registry.make_bzrdir('knit')
 
325
        branch = bzrdir.BzrDir.create_branch_convenience('.', format=format)
 
326
        branch.bzrdir.open_workingtree()
 
327
        branch.bzrdir.open_repository()
266
328
 
267
329
    def test_create_branch_convenience_root(self):
268
330
        """Creating a branch at the root of a fs should work."""
269
331
        self.transport_server = MemoryServer
270
332
        # outside a repo the default convenience output is a repo+branch_tree
271
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
272
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
273
 
        try:
274
 
            branch = bzrdir.BzrDir.create_branch_convenience(self.get_url())
275
 
            self.assertRaises(errors.NoWorkingTree,
276
 
                              branch.bzrdir.open_workingtree)
277
 
            branch.bzrdir.open_repository()
278
 
        finally:
279
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
333
        format = bzrdir.format_registry.make_bzrdir('knit')
 
334
        branch = bzrdir.BzrDir.create_branch_convenience(self.get_url(), 
 
335
                                                         format=format)
 
336
        self.assertRaises(errors.NoWorkingTree,
 
337
                          branch.bzrdir.open_workingtree)
 
338
        branch.bzrdir.open_repository()
280
339
 
281
340
    def test_create_branch_convenience_under_shared_repo(self):
282
341
        # inside a repo the default convenience output is a branch+ follow the
283
342
        # repo tree policy
284
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
285
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
286
 
        try:
287
 
            self.make_repository('.', shared=True)
288
 
            branch = bzrdir.BzrDir.create_branch_convenience('child')
289
 
            branch.bzrdir.open_workingtree()
290
 
            self.assertRaises(errors.NoRepositoryPresent,
291
 
                              branch.bzrdir.open_repository)
292
 
        finally:
293
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
343
        format = bzrdir.format_registry.make_bzrdir('knit')
 
344
        self.make_repository('.', shared=True, format=format)
 
345
        branch = bzrdir.BzrDir.create_branch_convenience('child',
 
346
            format=format)
 
347
        branch.bzrdir.open_workingtree()
 
348
        self.assertRaises(errors.NoRepositoryPresent,
 
349
                          branch.bzrdir.open_repository)
294
350
            
295
351
    def test_create_branch_convenience_under_shared_repo_force_no_tree(self):
296
352
        # inside a repo the default convenience output is a branch+ follow the
297
353
        # repo tree policy but we can override that
298
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
299
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
300
 
        try:
301
 
            self.make_repository('.', shared=True)
302
 
            branch = bzrdir.BzrDir.create_branch_convenience('child',
303
 
                force_new_tree=False)
304
 
            self.assertRaises(errors.NoWorkingTree,
305
 
                              branch.bzrdir.open_workingtree)
306
 
            self.assertRaises(errors.NoRepositoryPresent,
307
 
                              branch.bzrdir.open_repository)
308
 
        finally:
309
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
354
        format = bzrdir.format_registry.make_bzrdir('knit')
 
355
        self.make_repository('.', shared=True, format=format)
 
356
        branch = bzrdir.BzrDir.create_branch_convenience('child',
 
357
            force_new_tree=False, format=format)
 
358
        self.assertRaises(errors.NoWorkingTree,
 
359
                          branch.bzrdir.open_workingtree)
 
360
        self.assertRaises(errors.NoRepositoryPresent,
 
361
                          branch.bzrdir.open_repository)
310
362
            
311
363
    def test_create_branch_convenience_under_shared_repo_no_tree_policy(self):
312
364
        # inside a repo the default convenience output is a branch+ follow the
313
365
        # repo tree policy
314
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
315
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
316
 
        try:
317
 
            repo = self.make_repository('.', shared=True)
318
 
            repo.set_make_working_trees(False)
319
 
            branch = bzrdir.BzrDir.create_branch_convenience('child')
320
 
            self.assertRaises(errors.NoWorkingTree,
321
 
                              branch.bzrdir.open_workingtree)
322
 
            self.assertRaises(errors.NoRepositoryPresent,
323
 
                              branch.bzrdir.open_repository)
324
 
        finally:
325
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
366
        format = bzrdir.format_registry.make_bzrdir('knit')
 
367
        repo = self.make_repository('.', shared=True, format=format)
 
368
        repo.set_make_working_trees(False)
 
369
        branch = bzrdir.BzrDir.create_branch_convenience('child', 
 
370
                                                         format=format)
 
371
        self.assertRaises(errors.NoWorkingTree,
 
372
                          branch.bzrdir.open_workingtree)
 
373
        self.assertRaises(errors.NoRepositoryPresent,
 
374
                          branch.bzrdir.open_repository)
326
375
 
327
376
    def test_create_branch_convenience_under_shared_repo_no_tree_policy_force_tree(self):
328
377
        # inside a repo the default convenience output is a branch+ follow the
329
378
        # repo tree policy but we can override that
330
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
331
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
332
 
        try:
333
 
            repo = self.make_repository('.', shared=True)
334
 
            repo.set_make_working_trees(False)
335
 
            branch = bzrdir.BzrDir.create_branch_convenience('child',
336
 
                force_new_tree=True)
337
 
            branch.bzrdir.open_workingtree()
338
 
            self.assertRaises(errors.NoRepositoryPresent,
339
 
                              branch.bzrdir.open_repository)
340
 
        finally:
341
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
379
        format = bzrdir.format_registry.make_bzrdir('knit')
 
380
        repo = self.make_repository('.', shared=True, format=format)
 
381
        repo.set_make_working_trees(False)
 
382
        branch = bzrdir.BzrDir.create_branch_convenience('child',
 
383
            force_new_tree=True, format=format)
 
384
        branch.bzrdir.open_workingtree()
 
385
        self.assertRaises(errors.NoRepositoryPresent,
 
386
                          branch.bzrdir.open_repository)
342
387
 
343
388
    def test_create_branch_convenience_under_shared_repo_force_new_repo(self):
344
389
        # inside a repo the default convenience output is overridable to give
345
390
        # repo+branch+tree
346
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
347
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
348
 
        try:
349
 
            self.make_repository('.', shared=True)
350
 
            branch = bzrdir.BzrDir.create_branch_convenience('child',
351
 
                force_new_repo=True)
352
 
            branch.bzrdir.open_repository()
353
 
            branch.bzrdir.open_workingtree()
354
 
        finally:
355
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
391
        format = bzrdir.format_registry.make_bzrdir('knit')
 
392
        self.make_repository('.', shared=True, format=format)
 
393
        branch = bzrdir.BzrDir.create_branch_convenience('child',
 
394
            force_new_repo=True, format=format)
 
395
        branch.bzrdir.open_repository()
 
396
        branch.bzrdir.open_workingtree()
356
397
 
357
398
 
358
399
class ChrootedTests(TestCaseWithTransport):
392
433
            get_transport(self.get_readonly_url('g/p/q')))
393
434
        self.assertEqual('g/p/q', relpath)
394
435
 
 
436
    def test_open_containing_tree_or_branch(self):
 
437
        def local_branch_path(branch):
 
438
             return os.path.realpath(
 
439
                urlutils.local_path_from_url(branch.base))
 
440
 
 
441
        self.make_branch_and_tree('topdir')
 
442
        tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
 
443
            'topdir/foo')
 
444
        self.assertEqual(os.path.realpath('topdir'),
 
445
                         os.path.realpath(tree.basedir))
 
446
        self.assertEqual(os.path.realpath('topdir'),
 
447
                         local_branch_path(branch))
 
448
        self.assertIs(tree.bzrdir, branch.bzrdir)
 
449
        self.assertEqual('foo', relpath)
 
450
        self.make_branch('topdir/foo')
 
451
        tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
 
452
            'topdir/foo')
 
453
        self.assertIs(tree, None)
 
454
        self.assertEqual(os.path.realpath('topdir/foo'),
 
455
                         local_branch_path(branch))
 
456
        self.assertEqual('', relpath)
 
457
 
395
458
    def test_open_from_transport(self):
396
459
        # transport pointing at bzrdir should give a bzrdir with root transport
397
460
        # set to the given transport
428
491
        repository_base = t.clone('repository').base
429
492
        self.assertEqual(repository_base, dir.get_repository_transport(None).base)
430
493
        self.assertEqual(repository_base,
431
 
                         dir.get_repository_transport(repository.RepositoryFormat7()).base)
 
494
                         dir.get_repository_transport(weaverepo.RepositoryFormat7()).base)
432
495
        checkout_base = t.clone('checkout').base
433
496
        self.assertEqual(checkout_base, dir.get_workingtree_transport(None).base)
434
497
        self.assertEqual(checkout_base,
468
531
        # format 5 dirs need a conversion if they are not the default.
469
532
        # and they start of not the default.
470
533
        old_format = bzrdir.BzrDirFormat.get_default_format()
471
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirFormat5())
 
534
        bzrdir.BzrDirFormat._set_default_format(bzrdir.BzrDirFormat5())
472
535
        try:
473
536
            dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
474
537
            self.assertFalse(dir.needs_format_conversion())
475
538
        finally:
476
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
539
            bzrdir.BzrDirFormat._set_default_format(old_format)
477
540
        self.assertTrue(dir.needs_format_conversion())
478
541
 
479
542
 
503
566
    def test_needs_conversion(self):
504
567
        # format 6 dirs need an conversion if they are not the default.
505
568
        old_format = bzrdir.BzrDirFormat.get_default_format()
506
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
 
569
        bzrdir.BzrDirFormat._set_default_format(bzrdir.BzrDirMetaFormat1())
507
570
        try:
508
571
            dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
509
572
            self.assertTrue(dir.needs_format_conversion())
510
573
        finally:
511
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
574
            bzrdir.BzrDirFormat._set_default_format(old_format)
512
575
 
513
576
 
514
577
class NotBzrDir(bzrlib.bzrdir.BzrDir):
585
648
    
586
649
    def test_create_branch_convenience(self):
587
650
        # outside a repo the default convenience output is a repo+branch_tree
588
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
589
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
590
 
        try:
591
 
            branch = bzrdir.BzrDir.create_branch_convenience(self.get_url('foo'))
592
 
            self.assertRaises(errors.NoWorkingTree,
593
 
                              branch.bzrdir.open_workingtree)
594
 
            branch.bzrdir.open_repository()
595
 
        finally:
596
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
651
        format = bzrdir.format_registry.make_bzrdir('knit')
 
652
        branch = bzrdir.BzrDir.create_branch_convenience(
 
653
            self.get_url('foo'), format=format)
 
654
        self.assertRaises(errors.NoWorkingTree,
 
655
                          branch.bzrdir.open_workingtree)
 
656
        branch.bzrdir.open_repository()
597
657
 
598
658
    def test_create_branch_convenience_force_tree_not_local_fails(self):
599
659
        # outside a repo the default convenience output is a repo+branch_tree
600
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
601
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
602
 
        try:
603
 
            self.assertRaises(errors.NotLocalUrl,
604
 
                bzrdir.BzrDir.create_branch_convenience,
605
 
                self.get_url('foo'),
606
 
                force_new_tree=True)
607
 
            t = get_transport(self.get_url('.'))
608
 
            self.assertFalse(t.has('foo'))
609
 
        finally:
610
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
660
        format = bzrdir.format_registry.make_bzrdir('knit')
 
661
        self.assertRaises(errors.NotLocalUrl,
 
662
            bzrdir.BzrDir.create_branch_convenience,
 
663
            self.get_url('foo'),
 
664
            force_new_tree=True,
 
665
            format=format)
 
666
        t = get_transport(self.get_url('.'))
 
667
        self.assertFalse(t.has('foo'))
611
668
 
612
669
    def test_clone(self):
613
670
        # clone into a nonlocal path works
614
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
615
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
616
 
        try:
617
 
            branch = bzrdir.BzrDir.create_branch_convenience('local')
618
 
        finally:
619
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
671
        format = bzrdir.format_registry.make_bzrdir('knit')
 
672
        branch = bzrdir.BzrDir.create_branch_convenience('local',
 
673
                                                         format=format)
620
674
        branch.bzrdir.open_workingtree()
621
675
        result = branch.bzrdir.clone(self.get_url('remote'))
622
676
        self.assertRaises(errors.NoWorkingTree,
624
678
        result.open_branch()
625
679
        result.open_repository()
626
680
 
 
681
 
 
682
class TestRemoteSFTP(test_sftp_transport.TestCaseWithSFTPServer):
 
683
 
 
684
    def test_open_containing_tree_or_branch(self):
 
685
        tree = self.make_branch_and_tree('tree')
 
686
        bzrdir.BzrDir.open_containing_tree_or_branch(self.get_url('tree'))