1
# Copyright (C) 2005, 2006, 2007 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.
24
from StringIO import StringIO
41
from bzrlib.errors import (NotBranchError,
43
UnsupportedFormatError,
45
from bzrlib.tests import (
47
TestCaseWithMemoryTransport,
48
TestCaseWithTransport,
52
from bzrlib.tests import(
56
from bzrlib.tests.test_http import TestWithTransport_pycurl
57
from bzrlib.transport import get_transport
58
from bzrlib.transport.http._urllib import HttpTransport_urllib
59
from bzrlib.transport.memory import MemoryServer
60
from bzrlib.transport.nosmart import NoSmartTransportDecorator
61
from bzrlib.transport.readonly import ReadonlyTransportDecorator
62
from bzrlib.repofmt import knitrepo, weaverepo
65
class TestDefaultFormat(TestCase):
67
def test_get_set_default_format(self):
68
old_format = bzrdir.BzrDirFormat.get_default_format()
69
# default is BzrDirFormat6
70
self.failUnless(isinstance(old_format, bzrdir.BzrDirMetaFormat1))
71
bzrdir.BzrDirFormat._set_default_format(SampleBzrDirFormat())
72
# creating a bzr dir should now create an instrumented dir.
74
result = bzrdir.BzrDir.create('memory:///')
75
self.failUnless(isinstance(result, SampleBzrDir))
77
bzrdir.BzrDirFormat._set_default_format(old_format)
78
self.assertEqual(old_format, bzrdir.BzrDirFormat.get_default_format())
81
class TestFormatRegistry(TestCase):
83
def make_format_registry(self):
84
my_format_registry = bzrdir.BzrDirFormatRegistry()
85
my_format_registry.register('weave', bzrdir.BzrDirFormat6,
86
'Pre-0.8 format. Slower and does not support checkouts or shared'
87
' repositories', deprecated=True)
88
my_format_registry.register_lazy('lazy', 'bzrlib.bzrdir',
89
'BzrDirFormat6', 'Format registered lazily', deprecated=True)
90
my_format_registry.register_metadir('knit',
91
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
94
my_format_registry.set_default('knit')
95
my_format_registry.register_metadir(
97
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
98
'Experimental successor to knit. Use at your own risk.',
99
branch_format='bzrlib.branch.BzrBranchFormat6',
101
my_format_registry.register_metadir(
103
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
104
'Experimental successor to knit. Use at your own risk.',
105
branch_format='bzrlib.branch.BzrBranchFormat6', hidden=True)
106
my_format_registry.register('hiddenweave', bzrdir.BzrDirFormat6,
107
'Pre-0.8 format. Slower and does not support checkouts or shared'
108
' repositories', hidden=True)
109
my_format_registry.register_lazy('hiddenlazy', 'bzrlib.bzrdir',
110
'BzrDirFormat6', 'Format registered lazily', deprecated=True,
112
return my_format_registry
114
def test_format_registry(self):
115
my_format_registry = self.make_format_registry()
116
my_bzrdir = my_format_registry.make_bzrdir('lazy')
117
self.assertIsInstance(my_bzrdir, bzrdir.BzrDirFormat6)
118
my_bzrdir = my_format_registry.make_bzrdir('weave')
119
self.assertIsInstance(my_bzrdir, bzrdir.BzrDirFormat6)
120
my_bzrdir = my_format_registry.make_bzrdir('default')
121
self.assertIsInstance(my_bzrdir.repository_format,
122
knitrepo.RepositoryFormatKnit1)
123
my_bzrdir = my_format_registry.make_bzrdir('knit')
124
self.assertIsInstance(my_bzrdir.repository_format,
125
knitrepo.RepositoryFormatKnit1)
126
my_bzrdir = my_format_registry.make_bzrdir('branch6')
127
self.assertIsInstance(my_bzrdir.get_branch_format(),
128
bzrlib.branch.BzrBranchFormat6)
130
def test_get_help(self):
131
my_format_registry = self.make_format_registry()
132
self.assertEqual('Format registered lazily',
133
my_format_registry.get_help('lazy'))
134
self.assertEqual('Format using knits',
135
my_format_registry.get_help('knit'))
136
self.assertEqual('Format using knits',
137
my_format_registry.get_help('default'))
138
self.assertEqual('Pre-0.8 format. Slower and does not support'
139
' checkouts or shared repositories',
140
my_format_registry.get_help('weave'))
142
def test_help_topic(self):
143
topics = help_topics.HelpTopicRegistry()
144
registry = self.make_format_registry()
145
topics.register('current-formats', registry.help_topic,
147
topics.register('other-formats', registry.help_topic,
149
new = topics.get_detail('current-formats')
150
rest = topics.get_detail('other-formats')
151
experimental, deprecated = rest.split('Deprecated formats')
152
self.assertContainsRe(new, 'bzr help formats')
153
self.assertContainsRe(new,
154
':knit:\n \(native\) \(default\) Format using knits\n')
155
self.assertContainsRe(experimental,
156
':branch6:\n \(native\) Experimental successor to knit')
157
self.assertContainsRe(deprecated,
158
':lazy:\n \(native\) Format registered lazily\n')
159
self.assertNotContainsRe(new, 'hidden')
161
def test_set_default_repository(self):
162
default_factory = bzrdir.format_registry.get('default')
163
old_default = [k for k, v in bzrdir.format_registry.iteritems()
164
if v == default_factory and k != 'default'][0]
165
bzrdir.format_registry.set_default_repository('dirstate-with-subtree')
167
self.assertIs(bzrdir.format_registry.get('dirstate-with-subtree'),
168
bzrdir.format_registry.get('default'))
170
repository.RepositoryFormat.get_default_format().__class__,
171
knitrepo.RepositoryFormatKnit3)
173
bzrdir.format_registry.set_default_repository(old_default)
175
def test_aliases(self):
176
a_registry = bzrdir.BzrDirFormatRegistry()
177
a_registry.register('weave', bzrdir.BzrDirFormat6,
178
'Pre-0.8 format. Slower and does not support checkouts or shared'
179
' repositories', deprecated=True)
180
a_registry.register('weavealias', bzrdir.BzrDirFormat6,
181
'Pre-0.8 format. Slower and does not support checkouts or shared'
182
' repositories', deprecated=True, alias=True)
183
self.assertEqual(frozenset(['weavealias']), a_registry.aliases())
186
class SampleBranch(bzrlib.branch.Branch):
187
"""A dummy branch for guess what, dummy use."""
189
def __init__(self, dir):
193
class SampleRepository(bzrlib.repository.Repository):
196
def __init__(self, dir):
200
class SampleBzrDir(bzrdir.BzrDir):
201
"""A sample BzrDir implementation to allow testing static methods."""
203
def create_repository(self, shared=False):
204
"""See BzrDir.create_repository."""
205
return "A repository"
207
def open_repository(self):
208
"""See BzrDir.open_repository."""
209
return SampleRepository(self)
211
def create_branch(self):
212
"""See BzrDir.create_branch."""
213
return SampleBranch(self)
215
def create_workingtree(self):
216
"""See BzrDir.create_workingtree."""
220
class SampleBzrDirFormat(bzrdir.BzrDirFormat):
223
this format is initializable, unsupported to aid in testing the
224
open and open_downlevel routines.
227
def get_format_string(self):
228
"""See BzrDirFormat.get_format_string()."""
229
return "Sample .bzr dir format."
231
def initialize_on_transport(self, t):
232
"""Create a bzr dir."""
234
t.put_bytes('.bzr/branch-format', self.get_format_string())
235
return SampleBzrDir(t, self)
237
def is_supported(self):
240
def open(self, transport, _found=None):
241
return "opened branch."
244
class TestBzrDirFormat(TestCaseWithTransport):
245
"""Tests for the BzrDirFormat facility."""
247
def test_find_format(self):
248
# is the right format object found for a branch?
249
# create a branch with a few known format objects.
250
# this is not quite the same as
251
t = get_transport(self.get_url())
252
self.build_tree(["foo/", "bar/"], transport=t)
253
def check_format(format, url):
254
format.initialize(url)
255
t = get_transport(url)
256
found_format = bzrdir.BzrDirFormat.find_format(t)
257
self.failUnless(isinstance(found_format, format.__class__))
258
check_format(bzrdir.BzrDirFormat5(), "foo")
259
check_format(bzrdir.BzrDirFormat6(), "bar")
261
def test_find_format_nothing_there(self):
262
self.assertRaises(NotBranchError,
263
bzrdir.BzrDirFormat.find_format,
266
def test_find_format_unknown_format(self):
267
t = get_transport(self.get_url())
269
t.put_bytes('.bzr/branch-format', '')
270
self.assertRaises(UnknownFormatError,
271
bzrdir.BzrDirFormat.find_format,
274
def test_register_unregister_format(self):
275
format = SampleBzrDirFormat()
278
format.initialize(url)
279
# register a format for it.
280
bzrdir.BzrDirFormat.register_format(format)
281
# which bzrdir.Open will refuse (not supported)
282
self.assertRaises(UnsupportedFormatError, bzrdir.BzrDir.open, url)
283
# which bzrdir.open_containing will refuse (not supported)
284
self.assertRaises(UnsupportedFormatError, bzrdir.BzrDir.open_containing, url)
285
# but open_downlevel will work
286
t = get_transport(url)
287
self.assertEqual(format.open(t), bzrdir.BzrDir.open_unsupported(url))
288
# unregister the format
289
bzrdir.BzrDirFormat.unregister_format(format)
290
# now open_downlevel should fail too.
291
self.assertRaises(UnknownFormatError, bzrdir.BzrDir.open_unsupported, url)
293
def test_create_branch_and_repo_uses_default(self):
294
format = SampleBzrDirFormat()
295
branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url(),
297
self.assertTrue(isinstance(branch, SampleBranch))
299
def test_create_branch_and_repo_under_shared(self):
300
# creating a branch and repo in a shared repo uses the
302
format = bzrdir.format_registry.make_bzrdir('knit')
303
self.make_repository('.', shared=True, format=format)
304
branch = bzrdir.BzrDir.create_branch_and_repo(
305
self.get_url('child'), format=format)
306
self.assertRaises(errors.NoRepositoryPresent,
307
branch.bzrdir.open_repository)
309
def test_create_branch_and_repo_under_shared_force_new(self):
310
# creating a branch and repo in a shared repo can be forced to
312
format = bzrdir.format_registry.make_bzrdir('knit')
313
self.make_repository('.', shared=True, format=format)
314
branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url('child'),
317
branch.bzrdir.open_repository()
319
def test_create_standalone_working_tree(self):
320
format = SampleBzrDirFormat()
321
# note this is deliberately readonly, as this failure should
322
# occur before any writes.
323
self.assertRaises(errors.NotLocalUrl,
324
bzrdir.BzrDir.create_standalone_workingtree,
325
self.get_readonly_url(), format=format)
326
tree = bzrdir.BzrDir.create_standalone_workingtree('.',
328
self.assertEqual('A tree', tree)
330
def test_create_standalone_working_tree_under_shared_repo(self):
331
# create standalone working tree always makes a repo.
332
format = bzrdir.format_registry.make_bzrdir('knit')
333
self.make_repository('.', shared=True, format=format)
334
# note this is deliberately readonly, as this failure should
335
# occur before any writes.
336
self.assertRaises(errors.NotLocalUrl,
337
bzrdir.BzrDir.create_standalone_workingtree,
338
self.get_readonly_url('child'), format=format)
339
tree = bzrdir.BzrDir.create_standalone_workingtree('child',
341
tree.bzrdir.open_repository()
343
def test_create_branch_convenience(self):
344
# outside a repo the default convenience output is a repo+branch_tree
345
format = bzrdir.format_registry.make_bzrdir('knit')
346
branch = bzrdir.BzrDir.create_branch_convenience('.', format=format)
347
branch.bzrdir.open_workingtree()
348
branch.bzrdir.open_repository()
350
def test_create_branch_convenience_possible_transports(self):
351
"""Check that the optional 'possible_transports' is recognized"""
352
format = bzrdir.format_registry.make_bzrdir('knit')
353
t = self.get_transport()
354
branch = bzrdir.BzrDir.create_branch_convenience(
355
'.', format=format, possible_transports=[t])
356
branch.bzrdir.open_workingtree()
357
branch.bzrdir.open_repository()
359
def test_create_branch_convenience_root(self):
360
"""Creating a branch at the root of a fs should work."""
361
self.vfs_transport_factory = MemoryServer
362
# outside a repo the default convenience output is a repo+branch_tree
363
format = bzrdir.format_registry.make_bzrdir('knit')
364
branch = bzrdir.BzrDir.create_branch_convenience(self.get_url(),
366
self.assertRaises(errors.NoWorkingTree,
367
branch.bzrdir.open_workingtree)
368
branch.bzrdir.open_repository()
370
def test_create_branch_convenience_under_shared_repo(self):
371
# inside a repo the default convenience output is a branch+ follow the
373
format = bzrdir.format_registry.make_bzrdir('knit')
374
self.make_repository('.', shared=True, format=format)
375
branch = bzrdir.BzrDir.create_branch_convenience('child',
377
branch.bzrdir.open_workingtree()
378
self.assertRaises(errors.NoRepositoryPresent,
379
branch.bzrdir.open_repository)
381
def test_create_branch_convenience_under_shared_repo_force_no_tree(self):
382
# inside a repo the default convenience output is a branch+ follow the
383
# repo tree policy but we can override that
384
format = bzrdir.format_registry.make_bzrdir('knit')
385
self.make_repository('.', shared=True, format=format)
386
branch = bzrdir.BzrDir.create_branch_convenience('child',
387
force_new_tree=False, format=format)
388
self.assertRaises(errors.NoWorkingTree,
389
branch.bzrdir.open_workingtree)
390
self.assertRaises(errors.NoRepositoryPresent,
391
branch.bzrdir.open_repository)
393
def test_create_branch_convenience_under_shared_repo_no_tree_policy(self):
394
# inside a repo the default convenience output is a branch+ follow the
396
format = bzrdir.format_registry.make_bzrdir('knit')
397
repo = self.make_repository('.', shared=True, format=format)
398
repo.set_make_working_trees(False)
399
branch = bzrdir.BzrDir.create_branch_convenience('child',
401
self.assertRaises(errors.NoWorkingTree,
402
branch.bzrdir.open_workingtree)
403
self.assertRaises(errors.NoRepositoryPresent,
404
branch.bzrdir.open_repository)
406
def test_create_branch_convenience_under_shared_repo_no_tree_policy_force_tree(self):
407
# inside a repo the default convenience output is a branch+ follow the
408
# repo tree policy but we can override that
409
format = bzrdir.format_registry.make_bzrdir('knit')
410
repo = self.make_repository('.', shared=True, format=format)
411
repo.set_make_working_trees(False)
412
branch = bzrdir.BzrDir.create_branch_convenience('child',
413
force_new_tree=True, format=format)
414
branch.bzrdir.open_workingtree()
415
self.assertRaises(errors.NoRepositoryPresent,
416
branch.bzrdir.open_repository)
418
def test_create_branch_convenience_under_shared_repo_force_new_repo(self):
419
# inside a repo the default convenience output is overridable to give
421
format = bzrdir.format_registry.make_bzrdir('knit')
422
self.make_repository('.', shared=True, format=format)
423
branch = bzrdir.BzrDir.create_branch_convenience('child',
424
force_new_repo=True, format=format)
425
branch.bzrdir.open_repository()
426
branch.bzrdir.open_workingtree()
429
class TestRepositoryAcquisitionPolicy(TestCaseWithTransport):
431
def test_acquire_repository_standalone(self):
432
"""The default acquisition policy should create a standalone branch."""
433
my_bzrdir = self.make_bzrdir('.')
434
repo_policy = my_bzrdir.determine_repository_policy()
435
repo, is_new = repo_policy.acquire_repository()
436
self.assertEqual(repo.bzrdir.root_transport.base,
437
my_bzrdir.root_transport.base)
438
self.assertFalse(repo.is_shared())
440
def test_determine_stacking_policy(self):
441
parent_bzrdir = self.make_bzrdir('.')
442
child_bzrdir = self.make_bzrdir('child')
443
parent_bzrdir.get_config().set_default_stack_on('http://example.org')
444
repo_policy = child_bzrdir.determine_repository_policy()
445
self.assertEqual('http://example.org', repo_policy._stack_on)
447
def test_determine_stacking_policy_relative(self):
448
parent_bzrdir = self.make_bzrdir('.')
449
child_bzrdir = self.make_bzrdir('child')
450
parent_bzrdir.get_config().set_default_stack_on('child2')
451
repo_policy = child_bzrdir.determine_repository_policy()
452
self.assertEqual('child2', repo_policy._stack_on)
453
self.assertEqual(parent_bzrdir.root_transport.base,
454
repo_policy._stack_on_pwd)
456
def prepare_default_stacking(self, child_format='1.6'):
457
parent_bzrdir = self.make_bzrdir('.')
458
child_branch = self.make_branch('child', format=child_format)
459
parent_bzrdir.get_config().set_default_stack_on(child_branch.base)
460
new_child_transport = parent_bzrdir.transport.clone('child2')
461
return child_branch, new_child_transport
463
def test_clone_on_transport_obeys_stacking_policy(self):
464
child_branch, new_child_transport = self.prepare_default_stacking()
465
new_child = child_branch.bzrdir.clone_on_transport(new_child_transport)
466
self.assertEqual(child_branch.base,
467
new_child.open_branch().get_stacked_on_url())
469
def test_sprout_obeys_stacking_policy(self):
470
child_branch, new_child_transport = self.prepare_default_stacking()
471
new_child = child_branch.bzrdir.sprout(new_child_transport.base)
472
self.assertEqual(child_branch.base,
473
new_child.open_branch().get_stacked_on_url())
475
def test_clone_ignores_policy_for_unsupported_formats(self):
476
child_branch, new_child_transport = self.prepare_default_stacking(
477
child_format='pack-0.92')
478
new_child = child_branch.bzrdir.clone_on_transport(new_child_transport)
479
self.assertRaises(errors.UnstackableBranchFormat,
480
new_child.open_branch().get_stacked_on_url)
482
def test_sprout_ignores_policy_for_unsupported_formats(self):
483
child_branch, new_child_transport = self.prepare_default_stacking(
484
child_format='pack-0.92')
485
new_child = child_branch.bzrdir.sprout(new_child_transport.base)
486
self.assertRaises(errors.UnstackableBranchFormat,
487
new_child.open_branch().get_stacked_on_url)
489
def test_sprout_upgrades_format_if_stacked_specified(self):
490
child_branch, new_child_transport = self.prepare_default_stacking(
491
child_format='pack-0.92')
492
new_child = child_branch.bzrdir.sprout(new_child_transport.base,
494
self.assertEqual(child_branch.bzrdir.root_transport.base,
495
new_child.open_branch().get_stacked_on_url())
496
repo = new_child.open_repository()
497
self.assertTrue(repo._format.supports_external_lookups)
498
self.assertFalse(repo.supports_rich_root())
500
def test_clone_on_transport_upgrades_format_if_stacked_on_specified(self):
501
child_branch, new_child_transport = self.prepare_default_stacking(
502
child_format='pack-0.92')
503
new_child = child_branch.bzrdir.clone_on_transport(new_child_transport,
504
stacked_on=child_branch.bzrdir.root_transport.base)
505
self.assertEqual(child_branch.bzrdir.root_transport.base,
506
new_child.open_branch().get_stacked_on_url())
507
repo = new_child.open_repository()
508
self.assertTrue(repo._format.supports_external_lookups)
509
self.assertFalse(repo.supports_rich_root())
511
def test_sprout_upgrades_to_rich_root_format_if_needed(self):
512
child_branch, new_child_transport = self.prepare_default_stacking(
513
child_format='rich-root-pack')
514
new_child = child_branch.bzrdir.sprout(new_child_transport.base,
516
repo = new_child.open_repository()
517
self.assertTrue(repo._format.supports_external_lookups)
518
self.assertTrue(repo.supports_rich_root())
520
def test_add_fallback_repo_handles_absolute_urls(self):
521
stack_on = self.make_branch('stack_on', format='1.6')
522
repo = self.make_repository('repo', format='1.6')
523
policy = bzrdir.UseExistingRepository(repo, stack_on.base)
524
policy._add_fallback(repo)
526
def test_add_fallback_repo_handles_relative_urls(self):
527
stack_on = self.make_branch('stack_on', format='1.6')
528
repo = self.make_repository('repo', format='1.6')
529
policy = bzrdir.UseExistingRepository(repo, '.', stack_on.base)
530
policy._add_fallback(repo)
532
def test_configure_relative_branch_stacking_url(self):
533
stack_on = self.make_branch('stack_on', format='1.6')
534
stacked = self.make_branch('stack_on/stacked', format='1.6')
535
policy = bzrdir.UseExistingRepository(stacked.repository,
537
policy.configure_branch(stacked)
538
self.assertEqual('..', stacked.get_stacked_on_url())
540
def test_relative_branch_stacking_to_absolute(self):
541
stack_on = self.make_branch('stack_on', format='1.6')
542
stacked = self.make_branch('stack_on/stacked', format='1.6')
543
policy = bzrdir.UseExistingRepository(stacked.repository,
544
'.', self.get_readonly_url('stack_on'))
545
policy.configure_branch(stacked)
546
self.assertEqual(self.get_readonly_url('stack_on'),
547
stacked.get_stacked_on_url())
550
class ChrootedTests(TestCaseWithTransport):
551
"""A support class that provides readonly urls outside the local namespace.
553
This is done by checking if self.transport_server is a MemoryServer. if it
554
is then we are chrooted already, if it is not then an HttpServer is used
559
super(ChrootedTests, self).setUp()
560
if not self.vfs_transport_factory == MemoryServer:
561
self.transport_readonly_server = http_server.HttpServer
563
def local_branch_path(self, branch):
564
return os.path.realpath(urlutils.local_path_from_url(branch.base))
566
def test_open_containing(self):
567
self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing,
568
self.get_readonly_url(''))
569
self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing,
570
self.get_readonly_url('g/p/q'))
571
control = bzrdir.BzrDir.create(self.get_url())
572
branch, relpath = bzrdir.BzrDir.open_containing(self.get_readonly_url(''))
573
self.assertEqual('', relpath)
574
branch, relpath = bzrdir.BzrDir.open_containing(self.get_readonly_url('g/p/q'))
575
self.assertEqual('g/p/q', relpath)
577
def test_open_containing_tree_branch_or_repository_empty(self):
578
self.assertRaises(errors.NotBranchError,
579
bzrdir.BzrDir.open_containing_tree_branch_or_repository,
580
self.get_readonly_url(''))
582
def test_open_containing_tree_branch_or_repository_all(self):
583
self.make_branch_and_tree('topdir')
584
tree, branch, repo, relpath = \
585
bzrdir.BzrDir.open_containing_tree_branch_or_repository(
587
self.assertEqual(os.path.realpath('topdir'),
588
os.path.realpath(tree.basedir))
589
self.assertEqual(os.path.realpath('topdir'),
590
self.local_branch_path(branch))
592
osutils.realpath(os.path.join('topdir', '.bzr', 'repository')),
593
repo.bzrdir.transport.local_abspath('repository'))
594
self.assertEqual(relpath, 'foo')
596
def test_open_containing_tree_branch_or_repository_no_tree(self):
597
self.make_branch('branch')
598
tree, branch, repo, relpath = \
599
bzrdir.BzrDir.open_containing_tree_branch_or_repository(
601
self.assertEqual(tree, None)
602
self.assertEqual(os.path.realpath('branch'),
603
self.local_branch_path(branch))
605
osutils.realpath(os.path.join('branch', '.bzr', 'repository')),
606
repo.bzrdir.transport.local_abspath('repository'))
607
self.assertEqual(relpath, 'foo')
609
def test_open_containing_tree_branch_or_repository_repo(self):
610
self.make_repository('repo')
611
tree, branch, repo, relpath = \
612
bzrdir.BzrDir.open_containing_tree_branch_or_repository(
614
self.assertEqual(tree, None)
615
self.assertEqual(branch, None)
617
osutils.realpath(os.path.join('repo', '.bzr', 'repository')),
618
repo.bzrdir.transport.local_abspath('repository'))
619
self.assertEqual(relpath, '')
621
def test_open_containing_tree_branch_or_repository_shared_repo(self):
622
self.make_repository('shared', shared=True)
623
bzrdir.BzrDir.create_branch_convenience('shared/branch',
624
force_new_tree=False)
625
tree, branch, repo, relpath = \
626
bzrdir.BzrDir.open_containing_tree_branch_or_repository(
628
self.assertEqual(tree, None)
629
self.assertEqual(os.path.realpath('shared/branch'),
630
self.local_branch_path(branch))
632
osutils.realpath(os.path.join('shared', '.bzr', 'repository')),
633
repo.bzrdir.transport.local_abspath('repository'))
634
self.assertEqual(relpath, '')
636
def test_open_containing_tree_branch_or_repository_branch_subdir(self):
637
self.make_branch_and_tree('foo')
638
self.build_tree(['foo/bar/'])
639
tree, branch, repo, relpath = \
640
bzrdir.BzrDir.open_containing_tree_branch_or_repository(
642
self.assertEqual(os.path.realpath('foo'),
643
os.path.realpath(tree.basedir))
644
self.assertEqual(os.path.realpath('foo'),
645
self.local_branch_path(branch))
647
osutils.realpath(os.path.join('foo', '.bzr', 'repository')),
648
repo.bzrdir.transport.local_abspath('repository'))
649
self.assertEqual(relpath, 'bar')
651
def test_open_containing_tree_branch_or_repository_repo_subdir(self):
652
self.make_repository('bar')
653
self.build_tree(['bar/baz/'])
654
tree, branch, repo, relpath = \
655
bzrdir.BzrDir.open_containing_tree_branch_or_repository(
657
self.assertEqual(tree, None)
658
self.assertEqual(branch, None)
660
osutils.realpath(os.path.join('bar', '.bzr', 'repository')),
661
repo.bzrdir.transport.local_abspath('repository'))
662
self.assertEqual(relpath, 'baz')
664
def test_open_containing_from_transport(self):
665
self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing_from_transport,
666
get_transport(self.get_readonly_url('')))
667
self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing_from_transport,
668
get_transport(self.get_readonly_url('g/p/q')))
669
control = bzrdir.BzrDir.create(self.get_url())
670
branch, relpath = bzrdir.BzrDir.open_containing_from_transport(
671
get_transport(self.get_readonly_url('')))
672
self.assertEqual('', relpath)
673
branch, relpath = bzrdir.BzrDir.open_containing_from_transport(
674
get_transport(self.get_readonly_url('g/p/q')))
675
self.assertEqual('g/p/q', relpath)
677
def test_open_containing_tree_or_branch(self):
678
self.make_branch_and_tree('topdir')
679
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
681
self.assertEqual(os.path.realpath('topdir'),
682
os.path.realpath(tree.basedir))
683
self.assertEqual(os.path.realpath('topdir'),
684
self.local_branch_path(branch))
685
self.assertIs(tree.bzrdir, branch.bzrdir)
686
self.assertEqual('foo', relpath)
687
# opening from non-local should not return the tree
688
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
689
self.get_readonly_url('topdir/foo'))
690
self.assertEqual(None, tree)
691
self.assertEqual('foo', relpath)
693
self.make_branch('topdir/foo')
694
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
696
self.assertIs(tree, None)
697
self.assertEqual(os.path.realpath('topdir/foo'),
698
self.local_branch_path(branch))
699
self.assertEqual('', relpath)
701
def test_open_tree_or_branch(self):
702
self.make_branch_and_tree('topdir')
703
tree, branch = bzrdir.BzrDir.open_tree_or_branch('topdir')
704
self.assertEqual(os.path.realpath('topdir'),
705
os.path.realpath(tree.basedir))
706
self.assertEqual(os.path.realpath('topdir'),
707
self.local_branch_path(branch))
708
self.assertIs(tree.bzrdir, branch.bzrdir)
709
# opening from non-local should not return the tree
710
tree, branch = bzrdir.BzrDir.open_tree_or_branch(
711
self.get_readonly_url('topdir'))
712
self.assertEqual(None, tree)
714
self.make_branch('topdir/foo')
715
tree, branch = bzrdir.BzrDir.open_tree_or_branch('topdir/foo')
716
self.assertIs(tree, None)
717
self.assertEqual(os.path.realpath('topdir/foo'),
718
self.local_branch_path(branch))
720
def test_open_from_transport(self):
721
# transport pointing at bzrdir should give a bzrdir with root transport
722
# set to the given transport
723
control = bzrdir.BzrDir.create(self.get_url())
724
transport = get_transport(self.get_url())
725
opened_bzrdir = bzrdir.BzrDir.open_from_transport(transport)
726
self.assertEqual(transport.base, opened_bzrdir.root_transport.base)
727
self.assertIsInstance(opened_bzrdir, bzrdir.BzrDir)
729
def test_open_from_transport_no_bzrdir(self):
730
transport = get_transport(self.get_url())
731
self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport,
734
def test_open_from_transport_bzrdir_in_parent(self):
735
control = bzrdir.BzrDir.create(self.get_url())
736
transport = get_transport(self.get_url())
737
transport.mkdir('subdir')
738
transport = transport.clone('subdir')
739
self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport,
742
def test_sprout_recursive(self):
743
tree = self.make_branch_and_tree('tree1', format='dirstate-with-subtree')
744
sub_tree = self.make_branch_and_tree('tree1/subtree',
745
format='dirstate-with-subtree')
746
tree.add_reference(sub_tree)
747
self.build_tree(['tree1/subtree/file'])
749
tree.commit('Initial commit')
750
tree.bzrdir.sprout('tree2')
751
self.failUnlessExists('tree2/subtree/file')
753
def test_cloning_metadir(self):
754
"""Ensure that cloning metadir is suitable"""
755
bzrdir = self.make_bzrdir('bzrdir')
756
bzrdir.cloning_metadir()
757
branch = self.make_branch('branch', format='knit')
758
format = branch.bzrdir.cloning_metadir()
759
self.assertIsInstance(format.workingtree_format,
760
workingtree.WorkingTreeFormat3)
762
def test_sprout_recursive_treeless(self):
763
tree = self.make_branch_and_tree('tree1',
764
format='dirstate-with-subtree')
765
sub_tree = self.make_branch_and_tree('tree1/subtree',
766
format='dirstate-with-subtree')
767
tree.add_reference(sub_tree)
768
self.build_tree(['tree1/subtree/file'])
770
tree.commit('Initial commit')
771
tree.bzrdir.destroy_workingtree()
772
repo = self.make_repository('repo', shared=True,
773
format='dirstate-with-subtree')
774
repo.set_make_working_trees(False)
775
tree.bzrdir.sprout('repo/tree2')
776
self.failUnlessExists('repo/tree2/subtree')
777
self.failIfExists('repo/tree2/subtree/file')
779
def make_foo_bar_baz(self):
780
foo = bzrdir.BzrDir.create_branch_convenience('foo').bzrdir
781
bar = self.make_branch('foo/bar').bzrdir
782
baz = self.make_branch('baz').bzrdir
785
def test_find_bzrdirs(self):
786
foo, bar, baz = self.make_foo_bar_baz()
787
transport = get_transport(self.get_url())
788
self.assertEqualBzrdirs([baz, foo, bar],
789
bzrdir.BzrDir.find_bzrdirs(transport))
791
def test_find_bzrdirs_list_current(self):
792
def list_current(transport):
793
return [s for s in transport.list_dir('') if s != 'baz']
795
foo, bar, baz = self.make_foo_bar_baz()
796
transport = get_transport(self.get_url())
797
self.assertEqualBzrdirs([foo, bar],
798
bzrdir.BzrDir.find_bzrdirs(transport,
799
list_current=list_current))
802
def test_find_bzrdirs_evaluate(self):
803
def evaluate(bzrdir):
805
repo = bzrdir.open_repository()
806
except NoRepositoryPresent:
807
return True, bzrdir.root_transport.base
809
return False, bzrdir.root_transport.base
811
foo, bar, baz = self.make_foo_bar_baz()
812
transport = get_transport(self.get_url())
813
self.assertEqual([baz.root_transport.base, foo.root_transport.base],
814
list(bzrdir.BzrDir.find_bzrdirs(transport,
817
def assertEqualBzrdirs(self, first, second):
819
second = list(second)
820
self.assertEqual(len(first), len(second))
821
for x, y in zip(first, second):
822
self.assertEqual(x.root_transport.base, y.root_transport.base)
824
def test_find_branches(self):
825
root = self.make_repository('', shared=True)
826
foo, bar, baz = self.make_foo_bar_baz()
827
qux = self.make_bzrdir('foo/qux')
828
transport = get_transport(self.get_url())
829
branches = bzrdir.BzrDir.find_branches(transport)
830
self.assertEqual(baz.root_transport.base, branches[0].base)
831
self.assertEqual(foo.root_transport.base, branches[1].base)
832
self.assertEqual(bar.root_transport.base, branches[2].base)
834
# ensure this works without a top-level repo
835
branches = bzrdir.BzrDir.find_branches(transport.clone('foo'))
836
self.assertEqual(foo.root_transport.base, branches[0].base)
837
self.assertEqual(bar.root_transport.base, branches[1].base)
840
class TestMeta1DirFormat(TestCaseWithTransport):
841
"""Tests specific to the meta1 dir format."""
843
def test_right_base_dirs(self):
844
dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
846
branch_base = t.clone('branch').base
847
self.assertEqual(branch_base, dir.get_branch_transport(None).base)
848
self.assertEqual(branch_base,
849
dir.get_branch_transport(bzrlib.branch.BzrBranchFormat5()).base)
850
repository_base = t.clone('repository').base
851
self.assertEqual(repository_base, dir.get_repository_transport(None).base)
852
self.assertEqual(repository_base,
853
dir.get_repository_transport(weaverepo.RepositoryFormat7()).base)
854
checkout_base = t.clone('checkout').base
855
self.assertEqual(checkout_base, dir.get_workingtree_transport(None).base)
856
self.assertEqual(checkout_base,
857
dir.get_workingtree_transport(workingtree.WorkingTreeFormat3()).base)
859
def test_meta1dir_uses_lockdir(self):
860
"""Meta1 format uses a LockDir to guard the whole directory, not a file."""
861
dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
863
self.assertIsDirectory('branch-lock', t)
865
def test_comparison(self):
866
"""Equality and inequality behave properly.
868
Metadirs should compare equal iff they have the same repo, branch and
871
mydir = bzrdir.format_registry.make_bzrdir('knit')
872
self.assertEqual(mydir, mydir)
873
self.assertFalse(mydir != mydir)
874
otherdir = bzrdir.format_registry.make_bzrdir('knit')
875
self.assertEqual(otherdir, mydir)
876
self.assertFalse(otherdir != mydir)
877
otherdir2 = bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
878
self.assertNotEqual(otherdir2, mydir)
879
self.assertFalse(otherdir2 == mydir)
881
def test_needs_conversion_different_working_tree(self):
882
# meta1dirs need an conversion if any element is not the default.
883
new_format = bzrdir.format_registry.make_bzrdir('dirstate')
884
tree = self.make_branch_and_tree('tree', format='knit')
885
self.assertTrue(tree.bzrdir.needs_format_conversion(
888
def test_initialize_on_format_uses_smart_transport(self):
889
self.setup_smart_server_with_call_log()
890
new_format = bzrdir.format_registry.make_bzrdir('dirstate')
891
transport = self.get_transport('target')
892
transport.ensure_base()
893
self.reset_smart_call_log()
894
instance = new_format.initialize_on_transport(transport)
895
self.assertIsInstance(instance, remote.RemoteBzrDir)
896
rpc_count = len(self.hpss_calls)
897
# This figure represent the amount of work to perform this use case. It
898
# is entirely ok to reduce this number if a test fails due to rpc_count
899
# being too low. If rpc_count increases, more network roundtrips have
900
# become necessary for this use case. Please do not adjust this number
901
# upwards without agreement from bzr's network support maintainers.
902
self.assertEqual(2, rpc_count)
905
class TestFormat5(TestCaseWithTransport):
906
"""Tests specific to the version 5 bzrdir format."""
908
def test_same_lockfiles_between_tree_repo_branch(self):
909
# this checks that only a single lockfiles instance is created
910
# for format 5 objects
911
dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
912
def check_dir_components_use_same_lock(dir):
913
ctrl_1 = dir.open_repository().control_files
914
ctrl_2 = dir.open_branch().control_files
915
ctrl_3 = dir.open_workingtree()._control_files
916
self.assertTrue(ctrl_1 is ctrl_2)
917
self.assertTrue(ctrl_2 is ctrl_3)
918
check_dir_components_use_same_lock(dir)
919
# and if we open it normally.
920
dir = bzrdir.BzrDir.open(self.get_url())
921
check_dir_components_use_same_lock(dir)
923
def test_can_convert(self):
924
# format 5 dirs are convertable
925
dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
926
self.assertTrue(dir.can_convert_format())
928
def test_needs_conversion(self):
929
# format 5 dirs need a conversion if they are not the default,
931
dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
932
# don't need to convert it to itself
933
self.assertFalse(dir.needs_format_conversion(bzrdir.BzrDirFormat5()))
934
# do need to convert it to the current default
935
self.assertTrue(dir.needs_format_conversion(
936
bzrdir.BzrDirFormat.get_default_format()))
939
class TestFormat6(TestCaseWithTransport):
940
"""Tests specific to the version 6 bzrdir format."""
942
def test_same_lockfiles_between_tree_repo_branch(self):
943
# this checks that only a single lockfiles instance is created
944
# for format 6 objects
945
dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
946
def check_dir_components_use_same_lock(dir):
947
ctrl_1 = dir.open_repository().control_files
948
ctrl_2 = dir.open_branch().control_files
949
ctrl_3 = dir.open_workingtree()._control_files
950
self.assertTrue(ctrl_1 is ctrl_2)
951
self.assertTrue(ctrl_2 is ctrl_3)
952
check_dir_components_use_same_lock(dir)
953
# and if we open it normally.
954
dir = bzrdir.BzrDir.open(self.get_url())
955
check_dir_components_use_same_lock(dir)
957
def test_can_convert(self):
958
# format 6 dirs are convertable
959
dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
960
self.assertTrue(dir.can_convert_format())
962
def test_needs_conversion(self):
963
# format 6 dirs need an conversion if they are not the default.
964
dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
965
self.assertTrue(dir.needs_format_conversion(
966
bzrdir.BzrDirFormat.get_default_format()))
969
class NotBzrDir(bzrlib.bzrdir.BzrDir):
970
"""A non .bzr based control directory."""
972
def __init__(self, transport, format):
973
self._format = format
974
self.root_transport = transport
975
self.transport = transport.clone('.not')
978
class NotBzrDirFormat(bzrlib.bzrdir.BzrDirFormat):
979
"""A test class representing any non-.bzr based disk format."""
981
def initialize_on_transport(self, transport):
982
"""Initialize a new .not dir in the base directory of a Transport."""
983
transport.mkdir('.not')
984
return self.open(transport)
986
def open(self, transport):
987
"""Open this directory."""
988
return NotBzrDir(transport, self)
991
def _known_formats(self):
992
return set([NotBzrDirFormat()])
995
def probe_transport(self, transport):
996
"""Our format is present if the transport ends in '.not/'."""
997
if transport.has('.not'):
998
return NotBzrDirFormat()
1001
class TestNotBzrDir(TestCaseWithTransport):
1002
"""Tests for using the bzrdir api with a non .bzr based disk format.
1004
If/when one of these is in the core, we can let the implementation tests
1008
def test_create_and_find_format(self):
1009
# create a .notbzr dir
1010
format = NotBzrDirFormat()
1011
dir = format.initialize(self.get_url())
1012
self.assertIsInstance(dir, NotBzrDir)
1014
bzrlib.bzrdir.BzrDirFormat.register_control_format(format)
1016
found = bzrlib.bzrdir.BzrDirFormat.find_format(
1017
get_transport(self.get_url()))
1018
self.assertIsInstance(found, NotBzrDirFormat)
1020
bzrlib.bzrdir.BzrDirFormat.unregister_control_format(format)
1022
def test_included_in_known_formats(self):
1023
bzrlib.bzrdir.BzrDirFormat.register_control_format(NotBzrDirFormat)
1025
formats = bzrlib.bzrdir.BzrDirFormat.known_formats()
1026
for format in formats:
1027
if isinstance(format, NotBzrDirFormat):
1029
self.fail("No NotBzrDirFormat in %s" % formats)
1031
bzrlib.bzrdir.BzrDirFormat.unregister_control_format(NotBzrDirFormat)
1034
class NonLocalTests(TestCaseWithTransport):
1035
"""Tests for bzrdir static behaviour on non local paths."""
1038
super(NonLocalTests, self).setUp()
1039
self.vfs_transport_factory = MemoryServer
1041
def test_create_branch_convenience(self):
1042
# outside a repo the default convenience output is a repo+branch_tree
1043
format = bzrdir.format_registry.make_bzrdir('knit')
1044
branch = bzrdir.BzrDir.create_branch_convenience(
1045
self.get_url('foo'), format=format)
1046
self.assertRaises(errors.NoWorkingTree,
1047
branch.bzrdir.open_workingtree)
1048
branch.bzrdir.open_repository()
1050
def test_create_branch_convenience_force_tree_not_local_fails(self):
1051
# outside a repo the default convenience output is a repo+branch_tree
1052
format = bzrdir.format_registry.make_bzrdir('knit')
1053
self.assertRaises(errors.NotLocalUrl,
1054
bzrdir.BzrDir.create_branch_convenience,
1055
self.get_url('foo'),
1056
force_new_tree=True,
1058
t = get_transport(self.get_url('.'))
1059
self.assertFalse(t.has('foo'))
1061
def test_clone(self):
1062
# clone into a nonlocal path works
1063
format = bzrdir.format_registry.make_bzrdir('knit')
1064
branch = bzrdir.BzrDir.create_branch_convenience('local',
1066
branch.bzrdir.open_workingtree()
1067
result = branch.bzrdir.clone(self.get_url('remote'))
1068
self.assertRaises(errors.NoWorkingTree,
1069
result.open_workingtree)
1070
result.open_branch()
1071
result.open_repository()
1073
def test_checkout_metadir(self):
1074
# checkout_metadir has reasonable working tree format even when no
1075
# working tree is present
1076
self.make_branch('branch-knit2', format='dirstate-with-subtree')
1077
my_bzrdir = bzrdir.BzrDir.open(self.get_url('branch-knit2'))
1078
checkout_format = my_bzrdir.checkout_metadir()
1079
self.assertIsInstance(checkout_format.workingtree_format,
1080
workingtree.WorkingTreeFormat3)
1083
class TestHTTPRedirections(object):
1084
"""Test redirection between two http servers.
1086
This MUST be used by daughter classes that also inherit from
1087
TestCaseWithTwoWebservers.
1089
We can't inherit directly from TestCaseWithTwoWebservers or the
1090
test framework will try to create an instance which cannot
1091
run, its implementation being incomplete.
1094
def create_transport_readonly_server(self):
1095
return http_utils.HTTPServerRedirecting()
1097
def create_transport_secondary_server(self):
1098
return http_utils.HTTPServerRedirecting()
1101
super(TestHTTPRedirections, self).setUp()
1102
# The redirections will point to the new server
1103
self.new_server = self.get_readonly_server()
1104
# The requests to the old server will be redirected
1105
self.old_server = self.get_secondary_server()
1106
# Configure the redirections
1107
self.old_server.redirect_to(self.new_server.host, self.new_server.port)
1109
def test_loop(self):
1110
# Both servers redirect to each other creating a loop
1111
self.new_server.redirect_to(self.old_server.host, self.old_server.port)
1112
# Starting from either server should loop
1113
old_url = self._qualified_url(self.old_server.host,
1114
self.old_server.port)
1115
oldt = self._transport(old_url)
1116
self.assertRaises(errors.NotBranchError,
1117
bzrdir.BzrDir.open_from_transport, oldt)
1118
new_url = self._qualified_url(self.new_server.host,
1119
self.new_server.port)
1120
newt = self._transport(new_url)
1121
self.assertRaises(errors.NotBranchError,
1122
bzrdir.BzrDir.open_from_transport, newt)
1124
def test_qualifier_preserved(self):
1125
wt = self.make_branch_and_tree('branch')
1126
old_url = self._qualified_url(self.old_server.host,
1127
self.old_server.port)
1128
start = self._transport(old_url).clone('branch')
1129
bdir = bzrdir.BzrDir.open_from_transport(start)
1130
# Redirection should preserve the qualifier, hence the transport class
1132
self.assertIsInstance(bdir.root_transport, type(start))
1135
class TestHTTPRedirections_urllib(TestHTTPRedirections,
1136
http_utils.TestCaseWithTwoWebservers):
1137
"""Tests redirections for urllib implementation"""
1139
_transport = HttpTransport_urllib
1141
def _qualified_url(self, host, port):
1142
return 'http+urllib://%s:%s' % (host, port)
1146
class TestHTTPRedirections_pycurl(TestWithTransport_pycurl,
1147
TestHTTPRedirections,
1148
http_utils.TestCaseWithTwoWebservers):
1149
"""Tests redirections for pycurl implementation"""
1151
def _qualified_url(self, host, port):
1152
return 'http+pycurl://%s:%s' % (host, port)
1155
class TestHTTPRedirections_nosmart(TestHTTPRedirections,
1156
http_utils.TestCaseWithTwoWebservers):
1157
"""Tests redirections for the nosmart decorator"""
1159
_transport = NoSmartTransportDecorator
1161
def _qualified_url(self, host, port):
1162
return 'nosmart+http://%s:%s' % (host, port)
1165
class TestHTTPRedirections_readonly(TestHTTPRedirections,
1166
http_utils.TestCaseWithTwoWebservers):
1167
"""Tests redirections for readonly decoratror"""
1169
_transport = ReadonlyTransportDecorator
1171
def _qualified_url(self, host, port):
1172
return 'readonly+http://%s:%s' % (host, port)
1175
class TestDotBzrHidden(TestCaseWithTransport):
1178
if sys.platform == 'win32':
1179
ls = [os.environ['COMSPEC'], '/C', 'dir', '/B']
1182
f = subprocess.Popen(self.ls, stdout=subprocess.PIPE,
1183
stderr=subprocess.PIPE)
1184
out, err = f.communicate()
1185
self.assertEqual(0, f.returncode, 'Calling %s failed: %s'
1187
return out.splitlines()
1189
def test_dot_bzr_hidden(self):
1190
if sys.platform == 'win32' and not win32utils.has_win32file:
1191
raise TestSkipped('unable to make file hidden without pywin32 library')
1192
b = bzrdir.BzrDir.create('.')
1193
self.build_tree(['a'])
1194
self.assertEquals(['a'], self.get_ls())
1196
def test_dot_bzr_hidden_with_url(self):
1197
if sys.platform == 'win32' and not win32utils.has_win32file:
1198
raise TestSkipped('unable to make file hidden without pywin32 library')
1199
b = bzrdir.BzrDir.create(urlutils.local_path_to_url('.'))
1200
self.build_tree(['a'])
1201
self.assertEquals(['a'], self.get_ls())
1204
class _TestBzrDirFormat(bzrdir.BzrDirMetaFormat1):
1205
"""Test BzrDirFormat implementation for TestBzrDirSprout."""
1207
def _open(self, transport):
1208
return _TestBzrDir(transport, self)
1211
class _TestBzrDir(bzrdir.BzrDirMeta1):
1212
"""Test BzrDir implementation for TestBzrDirSprout.
1214
When created a _TestBzrDir already has repository and a branch. The branch
1215
is a test double as well.
1218
def __init__(self, *args, **kwargs):
1219
super(_TestBzrDir, self).__init__(*args, **kwargs)
1220
self.test_branch = _TestBranch()
1221
self.test_branch.repository = self.create_repository()
1223
def open_branch(self, unsupported=False):
1224
return self.test_branch
1226
def cloning_metadir(self, require_stacking=False):
1227
return _TestBzrDirFormat()
1230
class _TestBranchFormat(bzrlib.branch.BranchFormat):
1231
"""Test Branch format for TestBzrDirSprout."""
1234
class _TestBranch(bzrlib.branch.Branch):
1235
"""Test Branch implementation for TestBzrDirSprout."""
1237
def __init__(self, *args, **kwargs):
1238
self._format = _TestBranchFormat()
1239
super(_TestBranch, self).__init__(*args, **kwargs)
1243
def sprout(self, *args, **kwargs):
1244
self.calls.append('sprout')
1245
return _TestBranch()
1247
def copy_content_into(self, destination, revision_id=None):
1248
self.calls.append('copy_content_into')
1250
def get_parent(self):
1253
def set_parent(self, parent):
1254
self._parent = parent
1257
class TestBzrDirSprout(TestCaseWithMemoryTransport):
1259
def test_sprout_uses_branch_sprout(self):
1260
"""BzrDir.sprout calls Branch.sprout.
1262
Usually, BzrDir.sprout should delegate to the branch's sprout method
1263
for part of the work. This allows the source branch to control the
1264
choice of format for the new branch.
1266
There are exceptions, but this tests avoids them:
1267
- if there's no branch in the source bzrdir,
1268
- or if the stacking has been requested and the format needs to be
1269
overridden to satisfy that.
1271
# Make an instrumented bzrdir.
1272
t = self.get_transport('source')
1274
source_bzrdir = _TestBzrDirFormat().initialize_on_transport(t)
1275
# The instrumented bzrdir has a test_branch attribute that logs calls
1276
# made to the branch contained in that bzrdir. Initially the test
1277
# branch exists but no calls have been made to it.
1278
self.assertEqual([], source_bzrdir.test_branch.calls)
1281
target_url = self.get_url('target')
1282
result = source_bzrdir.sprout(target_url, recurse='no')
1284
# The bzrdir called the branch's sprout method.
1285
self.assertSubset(['sprout'], source_bzrdir.test_branch.calls)
1287
def test_sprout_parent(self):
1288
grandparent_tree = self.make_branch('grandparent')
1289
parent = grandparent_tree.bzrdir.sprout('parent').open_branch()
1290
branch_tree = parent.bzrdir.sprout('branch').open_branch()
1291
self.assertContainsRe(branch_tree.get_parent(), '/parent/$')
added
removed
bzrlib/tests/test_bzrdir.py
