/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: Martin Pool
  • Date: 2007-02-15 01:23:29 UTC
  • mfrom: (2284 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2309.
  • Revision ID: mbp@sourcefrog.net-20070215012329-blt2xfhup97r6w8h
merge up from bzr.dev to get metadir changes

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
 
24
25
from bzrlib import (
25
26
    help_topics,
 
27
    symbol_versioning,
 
28
    urlutils,
 
29
    workingtree,
26
30
    )
27
31
import bzrlib.branch
28
32
import bzrlib.bzrdir as bzrdir
32
36
                           UnsupportedFormatError,
33
37
                           )
34
38
import bzrlib.repository as repository
35
 
from bzrlib.tests import TestCase, TestCaseWithTransport
 
39
from bzrlib.tests import TestCase, TestCaseWithTransport, test_sftp_transport
36
40
from bzrlib.tests.HttpServer import HttpServer
37
41
from bzrlib.transport import get_transport
38
42
from bzrlib.transport.memory import MemoryServer
39
 
import bzrlib.workingtree as workingtree
 
43
from bzrlib.repofmt import knitrepo, weaverepo
40
44
 
41
45
 
42
46
class TestDefaultFormat(TestCase):
45
49
        old_format = bzrdir.BzrDirFormat.get_default_format()
46
50
        # default is BzrDirFormat6
47
51
        self.failUnless(isinstance(old_format, bzrdir.BzrDirMetaFormat1))
48
 
        bzrdir.BzrDirFormat.set_default_format(SampleBzrDirFormat())
 
52
        self.applyDeprecated(symbol_versioning.zero_fourteen, 
 
53
                             bzrdir.BzrDirFormat.set_default_format, 
 
54
                             SampleBzrDirFormat())
49
55
        # creating a bzr dir should now create an instrumented dir.
50
56
        try:
51
57
            result = bzrdir.BzrDir.create('memory:///')
52
58
            self.failUnless(isinstance(result, SampleBzrDir))
53
59
        finally:
54
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
60
            self.applyDeprecated(symbol_versioning.zero_fourteen,
 
61
                bzrdir.BzrDirFormat.set_default_format, old_format)
55
62
        self.assertEqual(old_format, bzrdir.BzrDirFormat.get_default_format())
56
63
 
57
64
 
65
72
        my_format_registry.register_lazy('lazy', 'bzrlib.bzrdir', 
66
73
            'BzrDirFormat6', 'Format registered lazily', deprecated=True)
67
74
        my_format_registry.register_metadir('knit', 'RepositoryFormatKnit1',
68
 
            'Format using knits')
 
75
            'Format using knits',
 
76
            repo_module='bzrlib.repofmt.knitrepo')
69
77
        my_format_registry.set_default('knit')
70
 
        my_format_registry.register_metadir('metaweave', 'RepositoryFormat7',
71
 
            'Transitional format in 0.8.  Slower than knit.', deprecated=True)
72
 
        my_format_registry.register_metadir('experimental-knit2', 
 
78
        my_format_registry.register_metadir('experimental-knit2',
73
79
                                            'RepositoryFormatKnit2',
74
 
            'Experimental successor to knit.  Use at your own risk.')
 
80
            'Experimental successor to knit.  Use at your own risk.',
 
81
            repo_module='bzrlib.repofmt.knitrepo')
75
82
        return my_format_registry
76
83
 
77
84
    def test_format_registry(self):
82
89
        self.assertIsInstance(my_bzrdir, bzrdir.BzrDirFormat6)
83
90
        my_bzrdir = my_format_registry.make_bzrdir('default')
84
91
        self.assertIsInstance(my_bzrdir.repository_format, 
85
 
            repository.RepositoryFormatKnit1)
 
92
            knitrepo.RepositoryFormatKnit1)
86
93
        my_bzrdir = my_format_registry.make_bzrdir('knit')
87
94
        self.assertIsInstance(my_bzrdir.repository_format, 
88
 
            repository.RepositoryFormatKnit1)
89
 
        my_bzrdir = my_format_registry.make_bzrdir('metaweave')
90
 
        self.assertIsInstance(my_bzrdir.repository_format, 
91
 
            repository.RepositoryFormat7)
 
95
            knitrepo.RepositoryFormatKnit1)
92
96
 
93
97
    def test_get_help(self):
94
98
        my_format_registry = self.make_format_registry()
114
118
        self.assertContainsRe(deprecated, 
115
119
            '  lazy:\n    \(native\) Format registered lazily\n')
116
120
 
 
121
    def test_set_default_repository(self):
 
122
        default_factory = bzrdir.format_registry.get('default')
 
123
        old_default = [k for k, v in bzrdir.format_registry.iteritems()
 
124
                       if v == default_factory and k != 'default'][0]
 
125
        bzrdir.format_registry.set_default_repository('experimental-knit2')
 
126
        try:
 
127
            self.assertIs(bzrdir.format_registry.get('experimental-knit2'),
 
128
                          bzrdir.format_registry.get('default'))
 
129
            self.assertIs(
 
130
                repository.RepositoryFormat.get_default_format().__class__,
 
131
                knitrepo.RepositoryFormatKnit2)
 
132
        finally:
 
133
            bzrdir.format_registry.set_default_repository(old_default)
 
134
 
117
135
class SampleBranch(bzrlib.branch.Branch):
118
136
    """A dummy branch for guess what, dummy use."""
119
137
 
217
235
 
218
236
    def test_create_repository(self):
219
237
        format = SampleBzrDirFormat()
220
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
221
 
        bzrdir.BzrDirFormat.set_default_format(format)
222
 
        try:
223
 
            repo = bzrdir.BzrDir.create_repository(self.get_url())
224
 
            self.assertEqual('A repository', repo)
225
 
        finally:
226
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
238
        repo = bzrdir.BzrDir.create_repository(self.get_url(), format=format)
 
239
        self.assertEqual('A repository', repo)
227
240
 
228
241
    def test_create_repository_shared(self):
229
242
        old_format = bzrdir.BzrDirFormat.get_default_format()
238
251
    def test_create_repository_under_shared(self):
239
252
        # an explicit create_repository always does so.
240
253
        # we trust the format is right from the 'create_repository test'
241
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
242
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
243
 
        try:
244
 
            self.make_repository('.', shared=True)
245
 
            repo = bzrdir.BzrDir.create_repository(self.get_url('child'))
246
 
            self.assertTrue(isinstance(repo, repository.Repository))
247
 
            self.assertTrue(repo.bzrdir.root_transport.base.endswith('child/'))
248
 
        finally:
249
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
254
        format = bzrdir.format_registry.make_bzrdir('knit')
 
255
        self.make_repository('.', shared=True, format=format)
 
256
        repo = bzrdir.BzrDir.create_repository(self.get_url('child'),
 
257
                                               format=format)
 
258
        self.assertTrue(isinstance(repo, repository.Repository))
 
259
        self.assertTrue(repo.bzrdir.root_transport.base.endswith('child/'))
250
260
 
251
261
    def test_create_branch_and_repo_uses_default(self):
252
262
        format = SampleBzrDirFormat()
253
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
254
 
        bzrdir.BzrDirFormat.set_default_format(format)
255
 
        try:
256
 
            branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url())
257
 
            self.assertTrue(isinstance(branch, SampleBranch))
258
 
        finally:
259
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
263
        branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url(), 
 
264
                                                      format=format)
 
265
        self.assertTrue(isinstance(branch, SampleBranch))
260
266
 
261
267
    def test_create_branch_and_repo_under_shared(self):
262
268
        # creating a branch and repo in a shared repo uses the
263
269
        # shared repository
264
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
265
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
266
 
        try:
267
 
            self.make_repository('.', shared=True)
268
 
            branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url('child'))
269
 
            self.assertRaises(errors.NoRepositoryPresent,
270
 
                              branch.bzrdir.open_repository)
271
 
        finally:
272
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
270
        format = bzrdir.format_registry.make_bzrdir('knit')
 
271
        self.make_repository('.', shared=True, format=format)
 
272
        branch = bzrdir.BzrDir.create_branch_and_repo(
 
273
            self.get_url('child'), format=format)
 
274
        self.assertRaises(errors.NoRepositoryPresent,
 
275
                          branch.bzrdir.open_repository)
273
276
 
274
277
    def test_create_branch_and_repo_under_shared_force_new(self):
275
278
        # creating a branch and repo in a shared repo can be forced to 
276
279
        # make a new repo
277
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
278
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
279
 
        try:
280
 
            self.make_repository('.', shared=True)
281
 
            branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url('child'),
282
 
                                                          force_new_repo=True)
283
 
            branch.bzrdir.open_repository()
284
 
        finally:
285
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
280
        format = bzrdir.format_registry.make_bzrdir('knit')
 
281
        self.make_repository('.', shared=True, format=format)
 
282
        branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url('child'),
 
283
                                                      force_new_repo=True,
 
284
                                                      format=format)
 
285
        branch.bzrdir.open_repository()
286
286
 
287
287
    def test_create_standalone_working_tree(self):
288
288
        format = SampleBzrDirFormat()
289
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
290
 
        bzrdir.BzrDirFormat.set_default_format(format)
291
 
        try:
292
 
            # note this is deliberately readonly, as this failure should 
293
 
            # occur before any writes.
294
 
            self.assertRaises(errors.NotLocalUrl,
295
 
                              bzrdir.BzrDir.create_standalone_workingtree,
296
 
                              self.get_readonly_url())
297
 
            tree = bzrdir.BzrDir.create_standalone_workingtree('.')
298
 
            self.assertEqual('A tree', tree)
299
 
        finally:
300
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
289
        # note this is deliberately readonly, as this failure should 
 
290
        # occur before any writes.
 
291
        self.assertRaises(errors.NotLocalUrl,
 
292
                          bzrdir.BzrDir.create_standalone_workingtree,
 
293
                          self.get_readonly_url(), format=format)
 
294
        tree = bzrdir.BzrDir.create_standalone_workingtree('.', 
 
295
                                                           format=format)
 
296
        self.assertEqual('A tree', tree)
301
297
 
302
298
    def test_create_standalone_working_tree_under_shared_repo(self):
303
299
        # create standalone working tree always makes a repo.
304
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
305
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
306
 
        try:
307
 
            self.make_repository('.', shared=True)
308
 
            # note this is deliberately readonly, as this failure should 
309
 
            # occur before any writes.
310
 
            self.assertRaises(errors.NotLocalUrl,
311
 
                              bzrdir.BzrDir.create_standalone_workingtree,
312
 
                              self.get_readonly_url('child'))
313
 
            tree = bzrdir.BzrDir.create_standalone_workingtree('child')
314
 
            tree.bzrdir.open_repository()
315
 
        finally:
316
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
300
        format = bzrdir.format_registry.make_bzrdir('knit')
 
301
        self.make_repository('.', shared=True, format=format)
 
302
        # note this is deliberately readonly, as this failure should 
 
303
        # occur before any writes.
 
304
        self.assertRaises(errors.NotLocalUrl,
 
305
                          bzrdir.BzrDir.create_standalone_workingtree,
 
306
                          self.get_readonly_url('child'), format=format)
 
307
        tree = bzrdir.BzrDir.create_standalone_workingtree('child', 
 
308
            format=format)
 
309
        tree.bzrdir.open_repository()
317
310
 
318
311
    def test_create_branch_convenience(self):
319
312
        # outside a repo the default convenience output is a repo+branch_tree
320
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
321
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
322
 
        try:
323
 
            branch = bzrdir.BzrDir.create_branch_convenience('.')
324
 
            branch.bzrdir.open_workingtree()
325
 
            branch.bzrdir.open_repository()
326
 
        finally:
327
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
313
        format = bzrdir.format_registry.make_bzrdir('knit')
 
314
        branch = bzrdir.BzrDir.create_branch_convenience('.', format=format)
 
315
        branch.bzrdir.open_workingtree()
 
316
        branch.bzrdir.open_repository()
328
317
 
329
318
    def test_create_branch_convenience_root(self):
330
319
        """Creating a branch at the root of a fs should work."""
331
320
        self.transport_server = MemoryServer
332
321
        # outside a repo the default convenience output is a repo+branch_tree
333
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
334
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
335
 
        try:
336
 
            branch = bzrdir.BzrDir.create_branch_convenience(self.get_url())
337
 
            self.assertRaises(errors.NoWorkingTree,
338
 
                              branch.bzrdir.open_workingtree)
339
 
            branch.bzrdir.open_repository()
340
 
        finally:
341
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
322
        format = bzrdir.format_registry.make_bzrdir('knit')
 
323
        branch = bzrdir.BzrDir.create_branch_convenience(self.get_url(), 
 
324
                                                         format=format)
 
325
        self.assertRaises(errors.NoWorkingTree,
 
326
                          branch.bzrdir.open_workingtree)
 
327
        branch.bzrdir.open_repository()
342
328
 
343
329
    def test_create_branch_convenience_under_shared_repo(self):
344
330
        # inside a repo the default convenience output is a branch+ follow the
345
331
        # repo tree policy
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
 
            branch.bzrdir.open_workingtree()
352
 
            self.assertRaises(errors.NoRepositoryPresent,
353
 
                              branch.bzrdir.open_repository)
354
 
        finally:
355
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
332
        format = bzrdir.format_registry.make_bzrdir('knit')
 
333
        self.make_repository('.', shared=True, format=format)
 
334
        branch = bzrdir.BzrDir.create_branch_convenience('child',
 
335
            format=format)
 
336
        branch.bzrdir.open_workingtree()
 
337
        self.assertRaises(errors.NoRepositoryPresent,
 
338
                          branch.bzrdir.open_repository)
356
339
            
357
340
    def test_create_branch_convenience_under_shared_repo_force_no_tree(self):
358
341
        # inside a repo the default convenience output is a branch+ follow the
359
342
        # repo tree policy but we can override that
360
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
361
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
362
 
        try:
363
 
            self.make_repository('.', shared=True)
364
 
            branch = bzrdir.BzrDir.create_branch_convenience('child',
365
 
                force_new_tree=False)
366
 
            self.assertRaises(errors.NoWorkingTree,
367
 
                              branch.bzrdir.open_workingtree)
368
 
            self.assertRaises(errors.NoRepositoryPresent,
369
 
                              branch.bzrdir.open_repository)
370
 
        finally:
371
 
            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
            force_new_tree=False, format=format)
 
347
        self.assertRaises(errors.NoWorkingTree,
 
348
                          branch.bzrdir.open_workingtree)
 
349
        self.assertRaises(errors.NoRepositoryPresent,
 
350
                          branch.bzrdir.open_repository)
372
351
            
373
352
    def test_create_branch_convenience_under_shared_repo_no_tree_policy(self):
374
353
        # inside a repo the default convenience output is a branch+ follow the
375
354
        # repo tree policy
376
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
377
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
378
 
        try:
379
 
            repo = self.make_repository('.', shared=True)
380
 
            repo.set_make_working_trees(False)
381
 
            branch = bzrdir.BzrDir.create_branch_convenience('child')
382
 
            self.assertRaises(errors.NoWorkingTree,
383
 
                              branch.bzrdir.open_workingtree)
384
 
            self.assertRaises(errors.NoRepositoryPresent,
385
 
                              branch.bzrdir.open_repository)
386
 
        finally:
387
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
355
        format = bzrdir.format_registry.make_bzrdir('knit')
 
356
        repo = self.make_repository('.', shared=True, format=format)
 
357
        repo.set_make_working_trees(False)
 
358
        branch = bzrdir.BzrDir.create_branch_convenience('child', 
 
359
                                                         format=format)
 
360
        self.assertRaises(errors.NoWorkingTree,
 
361
                          branch.bzrdir.open_workingtree)
 
362
        self.assertRaises(errors.NoRepositoryPresent,
 
363
                          branch.bzrdir.open_repository)
388
364
 
389
365
    def test_create_branch_convenience_under_shared_repo_no_tree_policy_force_tree(self):
390
366
        # inside a repo the default convenience output is a branch+ follow the
391
367
        # repo tree policy but we can override that
392
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
393
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
394
 
        try:
395
 
            repo = self.make_repository('.', shared=True)
396
 
            repo.set_make_working_trees(False)
397
 
            branch = bzrdir.BzrDir.create_branch_convenience('child',
398
 
                force_new_tree=True)
399
 
            branch.bzrdir.open_workingtree()
400
 
            self.assertRaises(errors.NoRepositoryPresent,
401
 
                              branch.bzrdir.open_repository)
402
 
        finally:
403
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
368
        format = bzrdir.format_registry.make_bzrdir('knit')
 
369
        repo = self.make_repository('.', shared=True, format=format)
 
370
        repo.set_make_working_trees(False)
 
371
        branch = bzrdir.BzrDir.create_branch_convenience('child',
 
372
            force_new_tree=True, format=format)
 
373
        branch.bzrdir.open_workingtree()
 
374
        self.assertRaises(errors.NoRepositoryPresent,
 
375
                          branch.bzrdir.open_repository)
404
376
 
405
377
    def test_create_branch_convenience_under_shared_repo_force_new_repo(self):
406
378
        # inside a repo the default convenience output is overridable to give
407
379
        # repo+branch+tree
408
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
409
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
410
 
        try:
411
 
            self.make_repository('.', shared=True)
412
 
            branch = bzrdir.BzrDir.create_branch_convenience('child',
413
 
                force_new_repo=True)
414
 
            branch.bzrdir.open_repository()
415
 
            branch.bzrdir.open_workingtree()
416
 
        finally:
417
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
380
        format = bzrdir.format_registry.make_bzrdir('knit')
 
381
        self.make_repository('.', shared=True, format=format)
 
382
        branch = bzrdir.BzrDir.create_branch_convenience('child',
 
383
            force_new_repo=True, format=format)
 
384
        branch.bzrdir.open_repository()
 
385
        branch.bzrdir.open_workingtree()
418
386
 
419
387
 
420
388
class ChrootedTests(TestCaseWithTransport):
454
422
            get_transport(self.get_readonly_url('g/p/q')))
455
423
        self.assertEqual('g/p/q', relpath)
456
424
 
 
425
    def test_open_containing_tree_or_branch(self):
 
426
        def local_branch_path(branch):
 
427
             return os.path.realpath(
 
428
                urlutils.local_path_from_url(branch.base))
 
429
 
 
430
        self.make_branch_and_tree('topdir')
 
431
        tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
 
432
            'topdir/foo')
 
433
        self.assertEqual(os.path.realpath('topdir'),
 
434
                         os.path.realpath(tree.basedir))
 
435
        self.assertEqual(os.path.realpath('topdir'),
 
436
                         local_branch_path(branch))
 
437
        self.assertIs(tree.bzrdir, branch.bzrdir)
 
438
        self.assertEqual('foo', relpath)
 
439
        self.make_branch('topdir/foo')
 
440
        tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
 
441
            'topdir/foo')
 
442
        self.assertIs(tree, None)
 
443
        self.assertEqual(os.path.realpath('topdir/foo'),
 
444
                         local_branch_path(branch))
 
445
        self.assertEqual('', relpath)
 
446
 
457
447
    def test_open_from_transport(self):
458
448
        # transport pointing at bzrdir should give a bzrdir with root transport
459
449
        # set to the given transport
490
480
        repository_base = t.clone('repository').base
491
481
        self.assertEqual(repository_base, dir.get_repository_transport(None).base)
492
482
        self.assertEqual(repository_base,
493
 
                         dir.get_repository_transport(repository.RepositoryFormat7()).base)
 
483
                         dir.get_repository_transport(weaverepo.RepositoryFormat7()).base)
494
484
        checkout_base = t.clone('checkout').base
495
485
        self.assertEqual(checkout_base, dir.get_workingtree_transport(None).base)
496
486
        self.assertEqual(checkout_base,
530
520
        # format 5 dirs need a conversion if they are not the default.
531
521
        # and they start of not the default.
532
522
        old_format = bzrdir.BzrDirFormat.get_default_format()
533
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirFormat5())
 
523
        bzrdir.BzrDirFormat._set_default_format(bzrdir.BzrDirFormat5())
534
524
        try:
535
525
            dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
536
526
            self.assertFalse(dir.needs_format_conversion())
537
527
        finally:
538
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
528
            bzrdir.BzrDirFormat._set_default_format(old_format)
539
529
        self.assertTrue(dir.needs_format_conversion())
540
530
 
541
531
 
565
555
    def test_needs_conversion(self):
566
556
        # format 6 dirs need an conversion if they are not the default.
567
557
        old_format = bzrdir.BzrDirFormat.get_default_format()
568
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
 
558
        bzrdir.BzrDirFormat._set_default_format(bzrdir.BzrDirMetaFormat1())
569
559
        try:
570
560
            dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
571
561
            self.assertTrue(dir.needs_format_conversion())
572
562
        finally:
573
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
563
            bzrdir.BzrDirFormat._set_default_format(old_format)
574
564
 
575
565
 
576
566
class NotBzrDir(bzrlib.bzrdir.BzrDir):
647
637
    
648
638
    def test_create_branch_convenience(self):
649
639
        # outside a repo the default convenience output is a repo+branch_tree
650
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
651
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
652
 
        try:
653
 
            branch = bzrdir.BzrDir.create_branch_convenience(self.get_url('foo'))
654
 
            self.assertRaises(errors.NoWorkingTree,
655
 
                              branch.bzrdir.open_workingtree)
656
 
            branch.bzrdir.open_repository()
657
 
        finally:
658
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
640
        format = bzrdir.format_registry.make_bzrdir('knit')
 
641
        branch = bzrdir.BzrDir.create_branch_convenience(
 
642
            self.get_url('foo'), format=format)
 
643
        self.assertRaises(errors.NoWorkingTree,
 
644
                          branch.bzrdir.open_workingtree)
 
645
        branch.bzrdir.open_repository()
659
646
 
660
647
    def test_create_branch_convenience_force_tree_not_local_fails(self):
661
648
        # outside a repo the default convenience output is a repo+branch_tree
662
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
663
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
664
 
        try:
665
 
            self.assertRaises(errors.NotLocalUrl,
666
 
                bzrdir.BzrDir.create_branch_convenience,
667
 
                self.get_url('foo'),
668
 
                force_new_tree=True)
669
 
            t = get_transport(self.get_url('.'))
670
 
            self.assertFalse(t.has('foo'))
671
 
        finally:
672
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
649
        format = bzrdir.format_registry.make_bzrdir('knit')
 
650
        self.assertRaises(errors.NotLocalUrl,
 
651
            bzrdir.BzrDir.create_branch_convenience,
 
652
            self.get_url('foo'),
 
653
            force_new_tree=True,
 
654
            format=format)
 
655
        t = get_transport(self.get_url('.'))
 
656
        self.assertFalse(t.has('foo'))
673
657
 
674
658
    def test_clone(self):
675
659
        # clone into a nonlocal path works
676
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
677
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
678
 
        try:
679
 
            branch = bzrdir.BzrDir.create_branch_convenience('local')
680
 
        finally:
681
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
660
        format = bzrdir.format_registry.make_bzrdir('knit')
 
661
        branch = bzrdir.BzrDir.create_branch_convenience('local',
 
662
                                                         format=format)
682
663
        branch.bzrdir.open_workingtree()
683
664
        result = branch.bzrdir.clone(self.get_url('remote'))
684
665
        self.assertRaises(errors.NoWorkingTree,
686
667
        result.open_branch()
687
668
        result.open_repository()
688
669
 
 
670
 
 
671
class TestRemoteSFTP(test_sftp_transport.TestCaseWithSFTPServer):
 
672
 
 
673
    def test_open_containing_tree_or_branch(self):
 
674
        tree = self.make_branch_and_tree('tree')
 
675
        bzrdir.BzrDir.open_containing_tree_or_branch(self.get_url('tree'))