1
# Copyright (C) 2005, 2006 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
"""Tests for the BzrDir facility and any format specific tests.
19
For interface contract tests, see tests/bzr_dir_implementations.
22
from StringIO import StringIO
29
import bzrlib.bzrdir as bzrdir
30
import bzrlib.errors as errors
31
from bzrlib.errors import (NotBranchError,
33
UnsupportedFormatError,
35
import bzrlib.repository as repository
36
from bzrlib.tests import TestCase, TestCaseWithTransport
37
from bzrlib.tests.HttpServer import HttpServer
38
from bzrlib.transport import get_transport
39
from bzrlib.transport.memory import MemoryServer
40
import bzrlib.workingtree as workingtree
43
class TestDefaultFormat(TestCase):
45
def test_get_set_default_format(self):
46
old_format = bzrdir.BzrDirFormat.get_default_format()
47
# default is BzrDirFormat6
48
self.failUnless(isinstance(old_format, bzrdir.BzrDirMetaFormat1))
49
self.applyDeprecated(symbol_versioning.zero_fourteen,
50
bzrdir.BzrDirFormat.set_default_format,
52
# creating a bzr dir should now create an instrumented dir.
54
result = bzrdir.BzrDir.create('memory:///')
55
self.failUnless(isinstance(result, SampleBzrDir))
57
self.applyDeprecated(symbol_versioning.zero_fourteen,
58
bzrdir.BzrDirFormat.set_default_format, old_format)
59
self.assertEqual(old_format, bzrdir.BzrDirFormat.get_default_format())
62
class TestFormatRegistry(TestCase):
64
def make_format_registry(self):
65
my_format_registry = bzrdir.BzrDirFormatRegistry()
66
my_format_registry.register('weave', bzrdir.BzrDirFormat6,
67
'Pre-0.8 format. Slower and does not support checkouts or shared'
68
' repositories', deprecated=True)
69
my_format_registry.register_lazy('lazy', 'bzrlib.bzrdir',
70
'BzrDirFormat6', 'Format registered lazily', deprecated=True)
71
my_format_registry.register_metadir('knit', 'RepositoryFormatKnit1',
73
my_format_registry.set_default('knit')
74
my_format_registry.register_metadir('metaweave', 'RepositoryFormat7',
75
'Transitional format in 0.8. Slower than knit.', deprecated=True)
76
my_format_registry.register_metadir('experimental-knit2',
77
'RepositoryFormatKnit2',
78
'Experimental successor to knit. Use at your own risk.')
79
my_format_registry.register_metadir('branch6',
80
'RepositoryFormatKnit2',
81
'Experimental successor to knit. Use at your own risk.',
82
branch_format='BzrBranchFormat6')
83
return my_format_registry
85
def test_format_registry(self):
86
my_format_registry = self.make_format_registry()
87
my_bzrdir = my_format_registry.make_bzrdir('lazy')
88
self.assertIsInstance(my_bzrdir, bzrdir.BzrDirFormat6)
89
my_bzrdir = my_format_registry.make_bzrdir('weave')
90
self.assertIsInstance(my_bzrdir, bzrdir.BzrDirFormat6)
91
my_bzrdir = my_format_registry.make_bzrdir('default')
92
self.assertIsInstance(my_bzrdir.repository_format,
93
repository.RepositoryFormatKnit1)
94
my_bzrdir = my_format_registry.make_bzrdir('knit')
95
self.assertIsInstance(my_bzrdir.repository_format,
96
repository.RepositoryFormatKnit1)
97
my_bzrdir = my_format_registry.make_bzrdir('metaweave')
98
self.assertIsInstance(my_bzrdir.repository_format,
99
repository.RepositoryFormat7)
100
my_bzrdir = my_format_registry.make_bzrdir('branch6')
101
self.assertIsInstance(my_bzrdir.branch_format,
102
bzrlib.branch.BzrBranchFormat6)
104
def test_get_help(self):
105
my_format_registry = self.make_format_registry()
106
self.assertEqual('Format registered lazily',
107
my_format_registry.get_help('lazy'))
108
self.assertEqual('Format using knits',
109
my_format_registry.get_help('knit'))
110
self.assertEqual('Format using knits',
111
my_format_registry.get_help('default'))
112
self.assertEqual('Pre-0.8 format. Slower and does not support'
113
' checkouts or shared repositories',
114
my_format_registry.get_help('weave'))
116
def test_help_topic(self):
117
topics = help_topics.HelpTopicRegistry()
118
topics.register('formats', self.make_format_registry().help_topic,
120
topic = topics.get_detail('formats')
121
new, deprecated = topic.split('Deprecated formats')
122
self.assertContainsRe(new, 'Bazaar directory formats')
123
self.assertContainsRe(new,
124
' knit/default:\n \(native\) Format using knits\n')
125
self.assertContainsRe(deprecated,
126
' lazy:\n \(native\) Format registered lazily\n')
128
def test_set_default_repository(self):
129
default_factory = bzrdir.format_registry.get('default')
130
old_default = [k for k, v in bzrdir.format_registry.iteritems()
131
if v == default_factory and k != 'default'][0]
132
bzrdir.format_registry.set_default_repository('metaweave')
134
self.assertIs(bzrdir.format_registry.get('metaweave'),
135
bzrdir.format_registry.get('default'))
137
repository.RepositoryFormat.get_default_format().__class__,
138
repository.RepositoryFormat7)
140
bzrdir.format_registry.set_default_repository(old_default)
142
class SampleBranch(bzrlib.branch.Branch):
143
"""A dummy branch for guess what, dummy use."""
145
def __init__(self, dir):
149
class SampleBzrDir(bzrdir.BzrDir):
150
"""A sample BzrDir implementation to allow testing static methods."""
152
def create_repository(self, shared=False):
153
"""See BzrDir.create_repository."""
154
return "A repository"
156
def open_repository(self):
157
"""See BzrDir.open_repository."""
158
return "A repository"
160
def create_branch(self):
161
"""See BzrDir.create_branch."""
162
return SampleBranch(self)
164
def create_workingtree(self):
165
"""See BzrDir.create_workingtree."""
169
class SampleBzrDirFormat(bzrdir.BzrDirFormat):
172
this format is initializable, unsupported to aid in testing the
173
open and open_downlevel routines.
176
def get_format_string(self):
177
"""See BzrDirFormat.get_format_string()."""
178
return "Sample .bzr dir format."
180
def initialize(self, url):
181
"""Create a bzr dir."""
182
t = get_transport(url)
184
t.put_bytes('.bzr/branch-format', self.get_format_string())
185
return SampleBzrDir(t, self)
187
def is_supported(self):
190
def open(self, transport, _found=None):
191
return "opened branch."
194
class TestBzrDirFormat(TestCaseWithTransport):
195
"""Tests for the BzrDirFormat facility."""
197
def test_find_format(self):
198
# is the right format object found for a branch?
199
# create a branch with a few known format objects.
200
# this is not quite the same as
201
t = get_transport(self.get_url())
202
self.build_tree(["foo/", "bar/"], transport=t)
203
def check_format(format, url):
204
format.initialize(url)
205
t = get_transport(url)
206
found_format = bzrdir.BzrDirFormat.find_format(t)
207
self.failUnless(isinstance(found_format, format.__class__))
208
check_format(bzrdir.BzrDirFormat5(), "foo")
209
check_format(bzrdir.BzrDirFormat6(), "bar")
211
def test_find_format_nothing_there(self):
212
self.assertRaises(NotBranchError,
213
bzrdir.BzrDirFormat.find_format,
216
def test_find_format_unknown_format(self):
217
t = get_transport(self.get_url())
219
t.put_bytes('.bzr/branch-format', '')
220
self.assertRaises(UnknownFormatError,
221
bzrdir.BzrDirFormat.find_format,
224
def test_register_unregister_format(self):
225
format = SampleBzrDirFormat()
228
format.initialize(url)
229
# register a format for it.
230
bzrdir.BzrDirFormat.register_format(format)
231
# which bzrdir.Open will refuse (not supported)
232
self.assertRaises(UnsupportedFormatError, bzrdir.BzrDir.open, url)
233
# which bzrdir.open_containing will refuse (not supported)
234
self.assertRaises(UnsupportedFormatError, bzrdir.BzrDir.open_containing, url)
235
# but open_downlevel will work
236
t = get_transport(url)
237
self.assertEqual(format.open(t), bzrdir.BzrDir.open_unsupported(url))
238
# unregister the format
239
bzrdir.BzrDirFormat.unregister_format(format)
240
# now open_downlevel should fail too.
241
self.assertRaises(UnknownFormatError, bzrdir.BzrDir.open_unsupported, url)
243
def test_create_repository(self):
244
format = SampleBzrDirFormat()
245
repo = bzrdir.BzrDir.create_repository(self.get_url(), format=format)
246
self.assertEqual('A repository', repo)
248
def test_create_repository_shared(self):
249
old_format = bzrdir.BzrDirFormat.get_default_format()
250
repo = bzrdir.BzrDir.create_repository('.', shared=True)
251
self.assertTrue(repo.is_shared())
253
def test_create_repository_nonshared(self):
254
old_format = bzrdir.BzrDirFormat.get_default_format()
255
repo = bzrdir.BzrDir.create_repository('.')
256
self.assertFalse(repo.is_shared())
258
def test_create_repository_under_shared(self):
259
# an explicit create_repository always does so.
260
# we trust the format is right from the 'create_repository test'
261
format = bzrdir.format_registry.make_bzrdir('knit')
262
self.make_repository('.', shared=True, format=format)
263
repo = bzrdir.BzrDir.create_repository(self.get_url('child'),
265
self.assertTrue(isinstance(repo, repository.Repository))
266
self.assertTrue(repo.bzrdir.root_transport.base.endswith('child/'))
268
def test_create_branch_and_repo_uses_default(self):
269
format = SampleBzrDirFormat()
270
branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url(),
272
self.assertTrue(isinstance(branch, SampleBranch))
274
def test_create_branch_and_repo_under_shared(self):
275
# creating a branch and repo in a shared repo uses the
277
format = bzrdir.format_registry.make_bzrdir('knit')
278
self.make_repository('.', shared=True, format=format)
279
branch = bzrdir.BzrDir.create_branch_and_repo(
280
self.get_url('child'), format=format)
281
self.assertRaises(errors.NoRepositoryPresent,
282
branch.bzrdir.open_repository)
284
def test_create_branch_and_repo_under_shared_force_new(self):
285
# creating a branch and repo in a shared repo can be forced to
287
format = bzrdir.format_registry.make_bzrdir('knit')
288
self.make_repository('.', shared=True, format=format)
289
branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url('child'),
292
branch.bzrdir.open_repository()
294
def test_create_standalone_working_tree(self):
295
format = SampleBzrDirFormat()
296
# note this is deliberately readonly, as this failure should
297
# occur before any writes.
298
self.assertRaises(errors.NotLocalUrl,
299
bzrdir.BzrDir.create_standalone_workingtree,
300
self.get_readonly_url(), format=format)
301
tree = bzrdir.BzrDir.create_standalone_workingtree('.',
303
self.assertEqual('A tree', tree)
305
def test_create_standalone_working_tree_under_shared_repo(self):
306
# create standalone working tree always makes a repo.
307
format = bzrdir.format_registry.make_bzrdir('knit')
308
self.make_repository('.', shared=True, format=format)
309
# note this is deliberately readonly, as this failure should
310
# occur before any writes.
311
self.assertRaises(errors.NotLocalUrl,
312
bzrdir.BzrDir.create_standalone_workingtree,
313
self.get_readonly_url('child'), format=format)
314
tree = bzrdir.BzrDir.create_standalone_workingtree('child',
316
tree.bzrdir.open_repository()
318
def test_create_branch_convenience(self):
319
# outside a repo the default convenience output is a repo+branch_tree
320
format = bzrdir.format_registry.make_bzrdir('knit')
321
branch = bzrdir.BzrDir.create_branch_convenience('.', format=format)
322
branch.bzrdir.open_workingtree()
323
branch.bzrdir.open_repository()
325
def test_create_branch_convenience_root(self):
326
"""Creating a branch at the root of a fs should work."""
327
self.transport_server = MemoryServer
328
# outside a repo the default convenience output is a repo+branch_tree
329
format = bzrdir.format_registry.make_bzrdir('knit')
330
branch = bzrdir.BzrDir.create_branch_convenience(self.get_url(),
332
self.assertRaises(errors.NoWorkingTree,
333
branch.bzrdir.open_workingtree)
334
branch.bzrdir.open_repository()
336
def test_create_branch_convenience_under_shared_repo(self):
337
# inside a repo the default convenience output is a branch+ follow the
339
format = bzrdir.format_registry.make_bzrdir('knit')
340
self.make_repository('.', shared=True, format=format)
341
branch = bzrdir.BzrDir.create_branch_convenience('child',
343
branch.bzrdir.open_workingtree()
344
self.assertRaises(errors.NoRepositoryPresent,
345
branch.bzrdir.open_repository)
347
def test_create_branch_convenience_under_shared_repo_force_no_tree(self):
348
# inside a repo the default convenience output is a branch+ follow the
349
# repo tree policy but we can override that
350
format = bzrdir.format_registry.make_bzrdir('knit')
351
self.make_repository('.', shared=True, format=format)
352
branch = bzrdir.BzrDir.create_branch_convenience('child',
353
force_new_tree=False, format=format)
354
self.assertRaises(errors.NoWorkingTree,
355
branch.bzrdir.open_workingtree)
356
self.assertRaises(errors.NoRepositoryPresent,
357
branch.bzrdir.open_repository)
359
def test_create_branch_convenience_under_shared_repo_no_tree_policy(self):
360
# inside a repo the default convenience output is a branch+ follow the
362
format = bzrdir.format_registry.make_bzrdir('knit')
363
repo = self.make_repository('.', shared=True, format=format)
364
repo.set_make_working_trees(False)
365
branch = bzrdir.BzrDir.create_branch_convenience('child',
367
self.assertRaises(errors.NoWorkingTree,
368
branch.bzrdir.open_workingtree)
369
self.assertRaises(errors.NoRepositoryPresent,
370
branch.bzrdir.open_repository)
372
def test_create_branch_convenience_under_shared_repo_no_tree_policy_force_tree(self):
373
# inside a repo the default convenience output is a branch+ follow the
374
# repo tree policy but we can override that
375
format = bzrdir.format_registry.make_bzrdir('knit')
376
repo = self.make_repository('.', shared=True, format=format)
377
repo.set_make_working_trees(False)
378
branch = bzrdir.BzrDir.create_branch_convenience('child',
379
force_new_tree=True, format=format)
380
branch.bzrdir.open_workingtree()
381
self.assertRaises(errors.NoRepositoryPresent,
382
branch.bzrdir.open_repository)
384
def test_create_branch_convenience_under_shared_repo_force_new_repo(self):
385
# inside a repo the default convenience output is overridable to give
387
format = bzrdir.format_registry.make_bzrdir('knit')
388
self.make_repository('.', shared=True, format=format)
389
branch = bzrdir.BzrDir.create_branch_convenience('child',
390
force_new_repo=True, format=format)
391
branch.bzrdir.open_repository()
392
branch.bzrdir.open_workingtree()
395
class ChrootedTests(TestCaseWithTransport):
396
"""A support class that provides readonly urls outside the local namespace.
398
This is done by checking if self.transport_server is a MemoryServer. if it
399
is then we are chrooted already, if it is not then an HttpServer is used
404
super(ChrootedTests, self).setUp()
405
if not self.transport_server == MemoryServer:
406
self.transport_readonly_server = HttpServer
408
def test_open_containing(self):
409
self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing,
410
self.get_readonly_url(''))
411
self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing,
412
self.get_readonly_url('g/p/q'))
413
control = bzrdir.BzrDir.create(self.get_url())
414
branch, relpath = bzrdir.BzrDir.open_containing(self.get_readonly_url(''))
415
self.assertEqual('', relpath)
416
branch, relpath = bzrdir.BzrDir.open_containing(self.get_readonly_url('g/p/q'))
417
self.assertEqual('g/p/q', relpath)
419
def test_open_containing_from_transport(self):
420
self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing_from_transport,
421
get_transport(self.get_readonly_url('')))
422
self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing_from_transport,
423
get_transport(self.get_readonly_url('g/p/q')))
424
control = bzrdir.BzrDir.create(self.get_url())
425
branch, relpath = bzrdir.BzrDir.open_containing_from_transport(
426
get_transport(self.get_readonly_url('')))
427
self.assertEqual('', relpath)
428
branch, relpath = bzrdir.BzrDir.open_containing_from_transport(
429
get_transport(self.get_readonly_url('g/p/q')))
430
self.assertEqual('g/p/q', relpath)
432
def test_open_from_transport(self):
433
# transport pointing at bzrdir should give a bzrdir with root transport
434
# set to the given transport
435
control = bzrdir.BzrDir.create(self.get_url())
436
transport = get_transport(self.get_url())
437
opened_bzrdir = bzrdir.BzrDir.open_from_transport(transport)
438
self.assertEqual(transport.base, opened_bzrdir.root_transport.base)
439
self.assertIsInstance(opened_bzrdir, bzrdir.BzrDir)
441
def test_open_from_transport_no_bzrdir(self):
442
transport = get_transport(self.get_url())
443
self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport,
446
def test_open_from_transport_bzrdir_in_parent(self):
447
control = bzrdir.BzrDir.create(self.get_url())
448
transport = get_transport(self.get_url())
449
transport.mkdir('subdir')
450
transport = transport.clone('subdir')
451
self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport,
455
class TestMeta1DirFormat(TestCaseWithTransport):
456
"""Tests specific to the meta1 dir format."""
458
def test_right_base_dirs(self):
459
dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
461
branch_base = t.clone('branch').base
462
self.assertEqual(branch_base, dir.get_branch_transport(None).base)
463
self.assertEqual(branch_base,
464
dir.get_branch_transport(bzrlib.branch.BzrBranchFormat5()).base)
465
repository_base = t.clone('repository').base
466
self.assertEqual(repository_base, dir.get_repository_transport(None).base)
467
self.assertEqual(repository_base,
468
dir.get_repository_transport(repository.RepositoryFormat7()).base)
469
checkout_base = t.clone('checkout').base
470
self.assertEqual(checkout_base, dir.get_workingtree_transport(None).base)
471
self.assertEqual(checkout_base,
472
dir.get_workingtree_transport(workingtree.WorkingTreeFormat3()).base)
474
def test_meta1dir_uses_lockdir(self):
475
"""Meta1 format uses a LockDir to guard the whole directory, not a file."""
476
dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
478
self.assertIsDirectory('branch-lock', t)
481
class TestFormat5(TestCaseWithTransport):
482
"""Tests specific to the version 5 bzrdir format."""
484
def test_same_lockfiles_between_tree_repo_branch(self):
485
# this checks that only a single lockfiles instance is created
486
# for format 5 objects
487
dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
488
def check_dir_components_use_same_lock(dir):
489
ctrl_1 = dir.open_repository().control_files
490
ctrl_2 = dir.open_branch().control_files
491
ctrl_3 = dir.open_workingtree()._control_files
492
self.assertTrue(ctrl_1 is ctrl_2)
493
self.assertTrue(ctrl_2 is ctrl_3)
494
check_dir_components_use_same_lock(dir)
495
# and if we open it normally.
496
dir = bzrdir.BzrDir.open(self.get_url())
497
check_dir_components_use_same_lock(dir)
499
def test_can_convert(self):
500
# format 5 dirs are convertable
501
dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
502
self.assertTrue(dir.can_convert_format())
504
def test_needs_conversion(self):
505
# format 5 dirs need a conversion if they are not the default.
506
# and they start of not the default.
507
old_format = bzrdir.BzrDirFormat.get_default_format()
508
bzrdir.BzrDirFormat._set_default_format(bzrdir.BzrDirFormat5())
510
dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
511
self.assertFalse(dir.needs_format_conversion())
513
bzrdir.BzrDirFormat._set_default_format(old_format)
514
self.assertTrue(dir.needs_format_conversion())
517
class TestFormat6(TestCaseWithTransport):
518
"""Tests specific to the version 6 bzrdir format."""
520
def test_same_lockfiles_between_tree_repo_branch(self):
521
# this checks that only a single lockfiles instance is created
522
# for format 6 objects
523
dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
524
def check_dir_components_use_same_lock(dir):
525
ctrl_1 = dir.open_repository().control_files
526
ctrl_2 = dir.open_branch().control_files
527
ctrl_3 = dir.open_workingtree()._control_files
528
self.assertTrue(ctrl_1 is ctrl_2)
529
self.assertTrue(ctrl_2 is ctrl_3)
530
check_dir_components_use_same_lock(dir)
531
# and if we open it normally.
532
dir = bzrdir.BzrDir.open(self.get_url())
533
check_dir_components_use_same_lock(dir)
535
def test_can_convert(self):
536
# format 6 dirs are convertable
537
dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
538
self.assertTrue(dir.can_convert_format())
540
def test_needs_conversion(self):
541
# format 6 dirs need an conversion if they are not the default.
542
old_format = bzrdir.BzrDirFormat.get_default_format()
543
bzrdir.BzrDirFormat._set_default_format(bzrdir.BzrDirMetaFormat1())
545
dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
546
self.assertTrue(dir.needs_format_conversion())
548
bzrdir.BzrDirFormat._set_default_format(old_format)
551
class NotBzrDir(bzrlib.bzrdir.BzrDir):
552
"""A non .bzr based control directory."""
554
def __init__(self, transport, format):
555
self._format = format
556
self.root_transport = transport
557
self.transport = transport.clone('.not')
560
class NotBzrDirFormat(bzrlib.bzrdir.BzrDirFormat):
561
"""A test class representing any non-.bzr based disk format."""
563
def initialize_on_transport(self, transport):
564
"""Initialize a new .not dir in the base directory of a Transport."""
565
transport.mkdir('.not')
566
return self.open(transport)
568
def open(self, transport):
569
"""Open this directory."""
570
return NotBzrDir(transport, self)
573
def _known_formats(self):
574
return set([NotBzrDirFormat()])
577
def probe_transport(self, transport):
578
"""Our format is present if the transport ends in '.not/'."""
579
if transport.has('.not'):
580
return NotBzrDirFormat()
583
class TestNotBzrDir(TestCaseWithTransport):
584
"""Tests for using the bzrdir api with a non .bzr based disk format.
586
If/when one of these is in the core, we can let the implementation tests
590
def test_create_and_find_format(self):
591
# create a .notbzr dir
592
format = NotBzrDirFormat()
593
dir = format.initialize(self.get_url())
594
self.assertIsInstance(dir, NotBzrDir)
596
bzrlib.bzrdir.BzrDirFormat.register_control_format(format)
598
found = bzrlib.bzrdir.BzrDirFormat.find_format(
599
get_transport(self.get_url()))
600
self.assertIsInstance(found, NotBzrDirFormat)
602
bzrlib.bzrdir.BzrDirFormat.unregister_control_format(format)
604
def test_included_in_known_formats(self):
605
bzrlib.bzrdir.BzrDirFormat.register_control_format(NotBzrDirFormat)
607
formats = bzrlib.bzrdir.BzrDirFormat.known_formats()
608
for format in formats:
609
if isinstance(format, NotBzrDirFormat):
611
self.fail("No NotBzrDirFormat in %s" % formats)
613
bzrlib.bzrdir.BzrDirFormat.unregister_control_format(NotBzrDirFormat)
616
class NonLocalTests(TestCaseWithTransport):
617
"""Tests for bzrdir static behaviour on non local paths."""
620
super(NonLocalTests, self).setUp()
621
self.transport_server = MemoryServer
623
def test_create_branch_convenience(self):
624
# outside a repo the default convenience output is a repo+branch_tree
625
format = bzrdir.format_registry.make_bzrdir('knit')
626
branch = bzrdir.BzrDir.create_branch_convenience(
627
self.get_url('foo'), format=format)
628
self.assertRaises(errors.NoWorkingTree,
629
branch.bzrdir.open_workingtree)
630
branch.bzrdir.open_repository()
632
def test_create_branch_convenience_force_tree_not_local_fails(self):
633
# outside a repo the default convenience output is a repo+branch_tree
634
format = bzrdir.format_registry.make_bzrdir('knit')
635
self.assertRaises(errors.NotLocalUrl,
636
bzrdir.BzrDir.create_branch_convenience,
640
t = get_transport(self.get_url('.'))
641
self.assertFalse(t.has('foo'))
643
def test_clone(self):
644
# clone into a nonlocal path works
645
format = bzrdir.format_registry.make_bzrdir('knit')
646
branch = bzrdir.BzrDir.create_branch_convenience('local',
648
branch.bzrdir.open_workingtree()
649
result = branch.bzrdir.clone(self.get_url('remote'))
650
self.assertRaises(errors.NoWorkingTree,
651
result.open_workingtree)
653
result.open_repository()
added
removed
bzrlib/tests/test_bzrdir.py
