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.
23
from StringIO import StringIO
35
from bzrlib.errors import (NotBranchError,
37
UnsupportedFormatError,
39
from bzrlib.tests import (
41
TestCaseWithTransport,
44
from bzrlib.tests.HttpServer import HttpServer
45
from bzrlib.tests.HTTPTestUtil import (
46
TestCaseWithTwoWebservers,
47
HTTPServerRedirecting,
49
from bzrlib.tests.test_http import TestWithTransport_pycurl
50
from bzrlib.transport import get_transport
51
from bzrlib.transport.http._urllib import HttpTransport_urllib
52
from bzrlib.transport.memory import MemoryServer
53
from bzrlib.repofmt import knitrepo, weaverepo
56
class TestDefaultFormat(TestCase):
58
def test_get_set_default_format(self):
59
old_format = bzrdir.BzrDirFormat.get_default_format()
60
# default is BzrDirFormat6
61
self.failUnless(isinstance(old_format, bzrdir.BzrDirMetaFormat1))
62
self.applyDeprecated(symbol_versioning.zero_fourteen,
63
bzrdir.BzrDirFormat.set_default_format,
65
# creating a bzr dir should now create an instrumented dir.
67
result = bzrdir.BzrDir.create('memory:///')
68
self.failUnless(isinstance(result, SampleBzrDir))
70
self.applyDeprecated(symbol_versioning.zero_fourteen,
71
bzrdir.BzrDirFormat.set_default_format, old_format)
72
self.assertEqual(old_format, bzrdir.BzrDirFormat.get_default_format())
75
class TestFormatRegistry(TestCase):
77
def make_format_registry(self):
78
my_format_registry = bzrdir.BzrDirFormatRegistry()
79
my_format_registry.register('weave', bzrdir.BzrDirFormat6,
80
'Pre-0.8 format. Slower and does not support checkouts or shared'
81
' repositories', deprecated=True)
82
my_format_registry.register_lazy('lazy', 'bzrlib.bzrdir',
83
'BzrDirFormat6', 'Format registered lazily', deprecated=True)
84
my_format_registry.register_metadir('knit',
85
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
88
my_format_registry.set_default('knit')
89
my_format_registry.register_metadir(
91
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
92
'Experimental successor to knit. Use at your own risk.',
93
branch_format='bzrlib.branch.BzrBranchFormat6')
94
my_format_registry.register_metadir(
96
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
97
'Experimental successor to knit. Use at your own risk.',
98
branch_format='bzrlib.branch.BzrBranchFormat6', hidden=True)
99
my_format_registry.register('hiddenweave', bzrdir.BzrDirFormat6,
100
'Pre-0.8 format. Slower and does not support checkouts or shared'
101
' repositories', hidden=True)
102
my_format_registry.register_lazy('hiddenlazy', 'bzrlib.bzrdir',
103
'BzrDirFormat6', 'Format registered lazily', deprecated=True,
105
return my_format_registry
107
def test_format_registry(self):
108
my_format_registry = self.make_format_registry()
109
my_bzrdir = my_format_registry.make_bzrdir('lazy')
110
self.assertIsInstance(my_bzrdir, bzrdir.BzrDirFormat6)
111
my_bzrdir = my_format_registry.make_bzrdir('weave')
112
self.assertIsInstance(my_bzrdir, bzrdir.BzrDirFormat6)
113
my_bzrdir = my_format_registry.make_bzrdir('default')
114
self.assertIsInstance(my_bzrdir.repository_format,
115
knitrepo.RepositoryFormatKnit1)
116
my_bzrdir = my_format_registry.make_bzrdir('knit')
117
self.assertIsInstance(my_bzrdir.repository_format,
118
knitrepo.RepositoryFormatKnit1)
119
my_bzrdir = my_format_registry.make_bzrdir('branch6')
120
self.assertIsInstance(my_bzrdir.get_branch_format(),
121
bzrlib.branch.BzrBranchFormat6)
123
def test_get_help(self):
124
my_format_registry = self.make_format_registry()
125
self.assertEqual('Format registered lazily',
126
my_format_registry.get_help('lazy'))
127
self.assertEqual('Format using knits',
128
my_format_registry.get_help('knit'))
129
self.assertEqual('Format using knits',
130
my_format_registry.get_help('default'))
131
self.assertEqual('Pre-0.8 format. Slower and does not support'
132
' checkouts or shared repositories',
133
my_format_registry.get_help('weave'))
135
def test_help_topic(self):
136
topics = help_topics.HelpTopicRegistry()
137
topics.register('formats', self.make_format_registry().help_topic,
139
topic = topics.get_detail('formats')
140
new, deprecated = topic.split('Deprecated formats')
141
self.assertContainsRe(new, 'Bazaar directory formats')
142
self.assertContainsRe(new,
143
' knit/default:\n \(native\) Format using knits\n')
144
self.assertContainsRe(deprecated,
145
' lazy:\n \(native\) Format registered lazily\n')
146
self.assertNotContainsRe(new, 'hidden')
148
def test_set_default_repository(self):
149
default_factory = bzrdir.format_registry.get('default')
150
old_default = [k for k, v in bzrdir.format_registry.iteritems()
151
if v == default_factory and k != 'default'][0]
152
bzrdir.format_registry.set_default_repository('dirstate-with-subtree')
154
self.assertIs(bzrdir.format_registry.get('dirstate-with-subtree'),
155
bzrdir.format_registry.get('default'))
157
repository.RepositoryFormat.get_default_format().__class__,
158
knitrepo.RepositoryFormatKnit3)
160
bzrdir.format_registry.set_default_repository(old_default)
163
class SampleBranch(bzrlib.branch.Branch):
164
"""A dummy branch for guess what, dummy use."""
166
def __init__(self, dir):
170
class SampleBzrDir(bzrdir.BzrDir):
171
"""A sample BzrDir implementation to allow testing static methods."""
173
def create_repository(self, shared=False):
174
"""See BzrDir.create_repository."""
175
return "A repository"
177
def open_repository(self):
178
"""See BzrDir.open_repository."""
179
return "A repository"
181
def create_branch(self):
182
"""See BzrDir.create_branch."""
183
return SampleBranch(self)
185
def create_workingtree(self):
186
"""See BzrDir.create_workingtree."""
190
class SampleBzrDirFormat(bzrdir.BzrDirFormat):
193
this format is initializable, unsupported to aid in testing the
194
open and open_downlevel routines.
197
def get_format_string(self):
198
"""See BzrDirFormat.get_format_string()."""
199
return "Sample .bzr dir format."
201
def initialize(self, url, possible_transports=None):
202
"""Create a bzr dir."""
203
t = get_transport(url, possible_transports)
205
t.put_bytes('.bzr/branch-format', self.get_format_string())
206
return SampleBzrDir(t, self)
208
def is_supported(self):
211
def open(self, transport, _found=None):
212
return "opened branch."
215
class TestBzrDirFormat(TestCaseWithTransport):
216
"""Tests for the BzrDirFormat facility."""
218
def test_find_format(self):
219
# is the right format object found for a branch?
220
# create a branch with a few known format objects.
221
# this is not quite the same as
222
t = get_transport(self.get_url())
223
self.build_tree(["foo/", "bar/"], transport=t)
224
def check_format(format, url):
225
format.initialize(url)
226
t = get_transport(url)
227
found_format = bzrdir.BzrDirFormat.find_format(t)
228
self.failUnless(isinstance(found_format, format.__class__))
229
check_format(bzrdir.BzrDirFormat5(), "foo")
230
check_format(bzrdir.BzrDirFormat6(), "bar")
232
def test_find_format_nothing_there(self):
233
self.assertRaises(NotBranchError,
234
bzrdir.BzrDirFormat.find_format,
237
def test_find_format_unknown_format(self):
238
t = get_transport(self.get_url())
240
t.put_bytes('.bzr/branch-format', '')
241
self.assertRaises(UnknownFormatError,
242
bzrdir.BzrDirFormat.find_format,
245
def test_register_unregister_format(self):
246
format = SampleBzrDirFormat()
249
format.initialize(url)
250
# register a format for it.
251
bzrdir.BzrDirFormat.register_format(format)
252
# which bzrdir.Open will refuse (not supported)
253
self.assertRaises(UnsupportedFormatError, bzrdir.BzrDir.open, url)
254
# which bzrdir.open_containing will refuse (not supported)
255
self.assertRaises(UnsupportedFormatError, bzrdir.BzrDir.open_containing, url)
256
# but open_downlevel will work
257
t = get_transport(url)
258
self.assertEqual(format.open(t), bzrdir.BzrDir.open_unsupported(url))
259
# unregister the format
260
bzrdir.BzrDirFormat.unregister_format(format)
261
# now open_downlevel should fail too.
262
self.assertRaises(UnknownFormatError, bzrdir.BzrDir.open_unsupported, url)
264
def test_create_repository(self):
265
format = SampleBzrDirFormat()
266
repo = bzrdir.BzrDir.create_repository(self.get_url(), format=format)
267
self.assertEqual('A repository', repo)
269
def test_create_repository_shared(self):
270
old_format = bzrdir.BzrDirFormat.get_default_format()
271
repo = bzrdir.BzrDir.create_repository('.', shared=True)
272
self.assertTrue(repo.is_shared())
274
def test_create_repository_nonshared(self):
275
old_format = bzrdir.BzrDirFormat.get_default_format()
276
repo = bzrdir.BzrDir.create_repository('.')
277
self.assertFalse(repo.is_shared())
279
def test_create_repository_under_shared(self):
280
# an explicit create_repository always does so.
281
# we trust the format is right from the 'create_repository test'
282
format = bzrdir.format_registry.make_bzrdir('knit')
283
self.make_repository('.', shared=True, format=format)
284
repo = bzrdir.BzrDir.create_repository(self.get_url('child'),
286
self.assertTrue(isinstance(repo, repository.Repository))
287
self.assertTrue(repo.bzrdir.root_transport.base.endswith('child/'))
289
def test_create_branch_and_repo_uses_default(self):
290
format = SampleBzrDirFormat()
291
branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url(),
293
self.assertTrue(isinstance(branch, SampleBranch))
295
def test_create_branch_and_repo_under_shared(self):
296
# creating a branch and repo in a shared repo uses the
298
format = bzrdir.format_registry.make_bzrdir('knit')
299
self.make_repository('.', shared=True, format=format)
300
branch = bzrdir.BzrDir.create_branch_and_repo(
301
self.get_url('child'), format=format)
302
self.assertRaises(errors.NoRepositoryPresent,
303
branch.bzrdir.open_repository)
305
def test_create_branch_and_repo_under_shared_force_new(self):
306
# creating a branch and repo in a shared repo can be forced to
308
format = bzrdir.format_registry.make_bzrdir('knit')
309
self.make_repository('.', shared=True, format=format)
310
branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url('child'),
313
branch.bzrdir.open_repository()
315
def test_create_standalone_working_tree(self):
316
format = SampleBzrDirFormat()
317
# note this is deliberately readonly, as this failure should
318
# occur before any writes.
319
self.assertRaises(errors.NotLocalUrl,
320
bzrdir.BzrDir.create_standalone_workingtree,
321
self.get_readonly_url(), format=format)
322
tree = bzrdir.BzrDir.create_standalone_workingtree('.',
324
self.assertEqual('A tree', tree)
326
def test_create_standalone_working_tree_under_shared_repo(self):
327
# create standalone working tree always makes a repo.
328
format = bzrdir.format_registry.make_bzrdir('knit')
329
self.make_repository('.', shared=True, format=format)
330
# note this is deliberately readonly, as this failure should
331
# occur before any writes.
332
self.assertRaises(errors.NotLocalUrl,
333
bzrdir.BzrDir.create_standalone_workingtree,
334
self.get_readonly_url('child'), format=format)
335
tree = bzrdir.BzrDir.create_standalone_workingtree('child',
337
tree.bzrdir.open_repository()
339
def test_create_branch_convenience(self):
340
# outside a repo the default convenience output is a repo+branch_tree
341
format = bzrdir.format_registry.make_bzrdir('knit')
342
branch = bzrdir.BzrDir.create_branch_convenience('.', format=format)
343
branch.bzrdir.open_workingtree()
344
branch.bzrdir.open_repository()
346
def test_create_branch_convenience_possible_transports(self):
347
"""Check that the optional 'possible_transports' is recognized"""
348
format = bzrdir.format_registry.make_bzrdir('knit')
349
t = self.get_transport()
350
branch = bzrdir.BzrDir.create_branch_convenience(
351
'.', format=format, possible_transports=[t])
352
branch.bzrdir.open_workingtree()
353
branch.bzrdir.open_repository()
355
def test_create_branch_convenience_root(self):
356
"""Creating a branch at the root of a fs should work."""
357
self.vfs_transport_factory = MemoryServer
358
# outside a repo the default convenience output is a repo+branch_tree
359
format = bzrdir.format_registry.make_bzrdir('knit')
360
branch = bzrdir.BzrDir.create_branch_convenience(self.get_url(),
362
self.assertRaises(errors.NoWorkingTree,
363
branch.bzrdir.open_workingtree)
364
branch.bzrdir.open_repository()
366
def test_create_branch_convenience_under_shared_repo(self):
367
# inside a repo the default convenience output is a branch+ follow the
369
format = bzrdir.format_registry.make_bzrdir('knit')
370
self.make_repository('.', shared=True, format=format)
371
branch = bzrdir.BzrDir.create_branch_convenience('child',
373
branch.bzrdir.open_workingtree()
374
self.assertRaises(errors.NoRepositoryPresent,
375
branch.bzrdir.open_repository)
377
def test_create_branch_convenience_under_shared_repo_force_no_tree(self):
378
# inside a repo the default convenience output is a branch+ follow the
379
# repo tree policy but we can override that
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_tree=False, format=format)
384
self.assertRaises(errors.NoWorkingTree,
385
branch.bzrdir.open_workingtree)
386
self.assertRaises(errors.NoRepositoryPresent,
387
branch.bzrdir.open_repository)
389
def test_create_branch_convenience_under_shared_repo_no_tree_policy(self):
390
# inside a repo the default convenience output is a branch+ follow the
392
format = bzrdir.format_registry.make_bzrdir('knit')
393
repo = self.make_repository('.', shared=True, format=format)
394
repo.set_make_working_trees(False)
395
branch = bzrdir.BzrDir.create_branch_convenience('child',
397
self.assertRaises(errors.NoWorkingTree,
398
branch.bzrdir.open_workingtree)
399
self.assertRaises(errors.NoRepositoryPresent,
400
branch.bzrdir.open_repository)
402
def test_create_branch_convenience_under_shared_repo_no_tree_policy_force_tree(self):
403
# inside a repo the default convenience output is a branch+ follow the
404
# repo tree policy but we can override that
405
format = bzrdir.format_registry.make_bzrdir('knit')
406
repo = self.make_repository('.', shared=True, format=format)
407
repo.set_make_working_trees(False)
408
branch = bzrdir.BzrDir.create_branch_convenience('child',
409
force_new_tree=True, format=format)
410
branch.bzrdir.open_workingtree()
411
self.assertRaises(errors.NoRepositoryPresent,
412
branch.bzrdir.open_repository)
414
def test_create_branch_convenience_under_shared_repo_force_new_repo(self):
415
# inside a repo the default convenience output is overridable to give
417
format = bzrdir.format_registry.make_bzrdir('knit')
418
self.make_repository('.', shared=True, format=format)
419
branch = bzrdir.BzrDir.create_branch_convenience('child',
420
force_new_repo=True, format=format)
421
branch.bzrdir.open_repository()
422
branch.bzrdir.open_workingtree()
425
class ChrootedTests(TestCaseWithTransport):
426
"""A support class that provides readonly urls outside the local namespace.
428
This is done by checking if self.transport_server is a MemoryServer. if it
429
is then we are chrooted already, if it is not then an HttpServer is used
434
super(ChrootedTests, self).setUp()
435
if not self.vfs_transport_factory == MemoryServer:
436
self.transport_readonly_server = HttpServer
438
def test_open_containing(self):
439
self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing,
440
self.get_readonly_url(''))
441
self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing,
442
self.get_readonly_url('g/p/q'))
443
control = bzrdir.BzrDir.create(self.get_url())
444
branch, relpath = bzrdir.BzrDir.open_containing(self.get_readonly_url(''))
445
self.assertEqual('', relpath)
446
branch, relpath = bzrdir.BzrDir.open_containing(self.get_readonly_url('g/p/q'))
447
self.assertEqual('g/p/q', relpath)
449
def test_open_containing_from_transport(self):
450
self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing_from_transport,
451
get_transport(self.get_readonly_url('')))
452
self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing_from_transport,
453
get_transport(self.get_readonly_url('g/p/q')))
454
control = bzrdir.BzrDir.create(self.get_url())
455
branch, relpath = bzrdir.BzrDir.open_containing_from_transport(
456
get_transport(self.get_readonly_url('')))
457
self.assertEqual('', relpath)
458
branch, relpath = bzrdir.BzrDir.open_containing_from_transport(
459
get_transport(self.get_readonly_url('g/p/q')))
460
self.assertEqual('g/p/q', relpath)
462
def test_open_containing_tree_or_branch(self):
463
def local_branch_path(branch):
464
return os.path.realpath(
465
urlutils.local_path_from_url(branch.base))
467
self.make_branch_and_tree('topdir')
468
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
470
self.assertEqual(os.path.realpath('topdir'),
471
os.path.realpath(tree.basedir))
472
self.assertEqual(os.path.realpath('topdir'),
473
local_branch_path(branch))
474
self.assertIs(tree.bzrdir, branch.bzrdir)
475
self.assertEqual('foo', relpath)
476
# opening from non-local should not return the tree
477
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
478
self.get_readonly_url('topdir/foo'))
479
self.assertEqual(None, tree)
480
self.assertEqual('foo', relpath)
482
self.make_branch('topdir/foo')
483
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
485
self.assertIs(tree, None)
486
self.assertEqual(os.path.realpath('topdir/foo'),
487
local_branch_path(branch))
488
self.assertEqual('', relpath)
490
def test_open_from_transport(self):
491
# transport pointing at bzrdir should give a bzrdir with root transport
492
# set to the given transport
493
control = bzrdir.BzrDir.create(self.get_url())
494
transport = get_transport(self.get_url())
495
opened_bzrdir = bzrdir.BzrDir.open_from_transport(transport)
496
self.assertEqual(transport.base, opened_bzrdir.root_transport.base)
497
self.assertIsInstance(opened_bzrdir, bzrdir.BzrDir)
499
def test_open_from_transport_no_bzrdir(self):
500
transport = get_transport(self.get_url())
501
self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport,
504
def test_open_from_transport_bzrdir_in_parent(self):
505
control = bzrdir.BzrDir.create(self.get_url())
506
transport = get_transport(self.get_url())
507
transport.mkdir('subdir')
508
transport = transport.clone('subdir')
509
self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport,
512
def test_sprout_recursive(self):
513
tree = self.make_branch_and_tree('tree1', format='dirstate-with-subtree')
514
sub_tree = self.make_branch_and_tree('tree1/subtree',
515
format='dirstate-with-subtree')
516
tree.add_reference(sub_tree)
517
self.build_tree(['tree1/subtree/file'])
519
tree.commit('Initial commit')
520
tree.bzrdir.sprout('tree2')
521
self.failUnlessExists('tree2/subtree/file')
523
def test_cloning_metadir(self):
524
"""Ensure that cloning metadir is suitable"""
525
bzrdir = self.make_bzrdir('bzrdir')
526
bzrdir.cloning_metadir()
527
branch = self.make_branch('branch', format='knit')
528
format = branch.bzrdir.cloning_metadir()
529
self.assertIsInstance(format.workingtree_format,
530
workingtree.WorkingTreeFormat3)
532
def test_sprout_recursive_treeless(self):
533
tree = self.make_branch_and_tree('tree1',
534
format='dirstate-with-subtree')
535
sub_tree = self.make_branch_and_tree('tree1/subtree',
536
format='dirstate-with-subtree')
537
tree.add_reference(sub_tree)
538
self.build_tree(['tree1/subtree/file'])
540
tree.commit('Initial commit')
541
tree.bzrdir.destroy_workingtree()
542
repo = self.make_repository('repo', shared=True,
543
format='dirstate-with-subtree')
544
repo.set_make_working_trees(False)
545
tree.bzrdir.sprout('repo/tree2')
546
self.failUnlessExists('repo/tree2/subtree')
547
self.failIfExists('repo/tree2/subtree/file')
550
class TestMeta1DirFormat(TestCaseWithTransport):
551
"""Tests specific to the meta1 dir format."""
553
def test_right_base_dirs(self):
554
dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
556
branch_base = t.clone('branch').base
557
self.assertEqual(branch_base, dir.get_branch_transport(None).base)
558
self.assertEqual(branch_base,
559
dir.get_branch_transport(bzrlib.branch.BzrBranchFormat5()).base)
560
repository_base = t.clone('repository').base
561
self.assertEqual(repository_base, dir.get_repository_transport(None).base)
562
self.assertEqual(repository_base,
563
dir.get_repository_transport(weaverepo.RepositoryFormat7()).base)
564
checkout_base = t.clone('checkout').base
565
self.assertEqual(checkout_base, dir.get_workingtree_transport(None).base)
566
self.assertEqual(checkout_base,
567
dir.get_workingtree_transport(workingtree.WorkingTreeFormat3()).base)
569
def test_meta1dir_uses_lockdir(self):
570
"""Meta1 format uses a LockDir to guard the whole directory, not a file."""
571
dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
573
self.assertIsDirectory('branch-lock', t)
575
def test_comparison(self):
576
"""Equality and inequality behave properly.
578
Metadirs should compare equal iff they have the same repo, branch and
581
mydir = bzrdir.format_registry.make_bzrdir('knit')
582
self.assertEqual(mydir, mydir)
583
self.assertFalse(mydir != mydir)
584
otherdir = bzrdir.format_registry.make_bzrdir('knit')
585
self.assertEqual(otherdir, mydir)
586
self.assertFalse(otherdir != mydir)
587
otherdir2 = bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
588
self.assertNotEqual(otherdir2, mydir)
589
self.assertFalse(otherdir2 == mydir)
591
def test_needs_conversion_different_working_tree(self):
592
# meta1dirs need an conversion if any element is not the default.
593
old_format = bzrdir.BzrDirFormat.get_default_format()
595
new_default = bzrdir.format_registry.make_bzrdir('dirstate')
596
bzrdir.BzrDirFormat._set_default_format(new_default)
598
tree = self.make_branch_and_tree('tree', format='knit')
599
self.assertTrue(tree.bzrdir.needs_format_conversion())
601
bzrdir.BzrDirFormat._set_default_format(old_format)
604
class TestFormat5(TestCaseWithTransport):
605
"""Tests specific to the version 5 bzrdir format."""
607
def test_same_lockfiles_between_tree_repo_branch(self):
608
# this checks that only a single lockfiles instance is created
609
# for format 5 objects
610
dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
611
def check_dir_components_use_same_lock(dir):
612
ctrl_1 = dir.open_repository().control_files
613
ctrl_2 = dir.open_branch().control_files
614
ctrl_3 = dir.open_workingtree()._control_files
615
self.assertTrue(ctrl_1 is ctrl_2)
616
self.assertTrue(ctrl_2 is ctrl_3)
617
check_dir_components_use_same_lock(dir)
618
# and if we open it normally.
619
dir = bzrdir.BzrDir.open(self.get_url())
620
check_dir_components_use_same_lock(dir)
622
def test_can_convert(self):
623
# format 5 dirs are convertable
624
dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
625
self.assertTrue(dir.can_convert_format())
627
def test_needs_conversion(self):
628
# format 5 dirs need a conversion if they are not the default.
629
# and they start of not the default.
630
old_format = bzrdir.BzrDirFormat.get_default_format()
631
bzrdir.BzrDirFormat._set_default_format(bzrdir.BzrDirFormat5())
633
dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
634
self.assertFalse(dir.needs_format_conversion())
636
bzrdir.BzrDirFormat._set_default_format(old_format)
637
self.assertTrue(dir.needs_format_conversion())
640
class TestFormat6(TestCaseWithTransport):
641
"""Tests specific to the version 6 bzrdir format."""
643
def test_same_lockfiles_between_tree_repo_branch(self):
644
# this checks that only a single lockfiles instance is created
645
# for format 6 objects
646
dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
647
def check_dir_components_use_same_lock(dir):
648
ctrl_1 = dir.open_repository().control_files
649
ctrl_2 = dir.open_branch().control_files
650
ctrl_3 = dir.open_workingtree()._control_files
651
self.assertTrue(ctrl_1 is ctrl_2)
652
self.assertTrue(ctrl_2 is ctrl_3)
653
check_dir_components_use_same_lock(dir)
654
# and if we open it normally.
655
dir = bzrdir.BzrDir.open(self.get_url())
656
check_dir_components_use_same_lock(dir)
658
def test_can_convert(self):
659
# format 6 dirs are convertable
660
dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
661
self.assertTrue(dir.can_convert_format())
663
def test_needs_conversion(self):
664
# format 6 dirs need an conversion if they are not the default.
665
old_format = bzrdir.BzrDirFormat.get_default_format()
666
bzrdir.BzrDirFormat._set_default_format(bzrdir.BzrDirMetaFormat1())
668
dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
669
self.assertTrue(dir.needs_format_conversion())
671
bzrdir.BzrDirFormat._set_default_format(old_format)
674
class NotBzrDir(bzrlib.bzrdir.BzrDir):
675
"""A non .bzr based control directory."""
677
def __init__(self, transport, format):
678
self._format = format
679
self.root_transport = transport
680
self.transport = transport.clone('.not')
683
class NotBzrDirFormat(bzrlib.bzrdir.BzrDirFormat):
684
"""A test class representing any non-.bzr based disk format."""
686
def initialize_on_transport(self, transport):
687
"""Initialize a new .not dir in the base directory of a Transport."""
688
transport.mkdir('.not')
689
return self.open(transport)
691
def open(self, transport):
692
"""Open this directory."""
693
return NotBzrDir(transport, self)
696
def _known_formats(self):
697
return set([NotBzrDirFormat()])
700
def probe_transport(self, transport):
701
"""Our format is present if the transport ends in '.not/'."""
702
if transport.has('.not'):
703
return NotBzrDirFormat()
706
class TestNotBzrDir(TestCaseWithTransport):
707
"""Tests for using the bzrdir api with a non .bzr based disk format.
709
If/when one of these is in the core, we can let the implementation tests
713
def test_create_and_find_format(self):
714
# create a .notbzr dir
715
format = NotBzrDirFormat()
716
dir = format.initialize(self.get_url())
717
self.assertIsInstance(dir, NotBzrDir)
719
bzrlib.bzrdir.BzrDirFormat.register_control_format(format)
721
found = bzrlib.bzrdir.BzrDirFormat.find_format(
722
get_transport(self.get_url()))
723
self.assertIsInstance(found, NotBzrDirFormat)
725
bzrlib.bzrdir.BzrDirFormat.unregister_control_format(format)
727
def test_included_in_known_formats(self):
728
bzrlib.bzrdir.BzrDirFormat.register_control_format(NotBzrDirFormat)
730
formats = bzrlib.bzrdir.BzrDirFormat.known_formats()
731
for format in formats:
732
if isinstance(format, NotBzrDirFormat):
734
self.fail("No NotBzrDirFormat in %s" % formats)
736
bzrlib.bzrdir.BzrDirFormat.unregister_control_format(NotBzrDirFormat)
739
class NonLocalTests(TestCaseWithTransport):
740
"""Tests for bzrdir static behaviour on non local paths."""
743
super(NonLocalTests, self).setUp()
744
self.vfs_transport_factory = MemoryServer
746
def test_create_branch_convenience(self):
747
# outside a repo the default convenience output is a repo+branch_tree
748
format = bzrdir.format_registry.make_bzrdir('knit')
749
branch = bzrdir.BzrDir.create_branch_convenience(
750
self.get_url('foo'), format=format)
751
self.assertRaises(errors.NoWorkingTree,
752
branch.bzrdir.open_workingtree)
753
branch.bzrdir.open_repository()
755
def test_create_branch_convenience_force_tree_not_local_fails(self):
756
# outside a repo the default convenience output is a repo+branch_tree
757
format = bzrdir.format_registry.make_bzrdir('knit')
758
self.assertRaises(errors.NotLocalUrl,
759
bzrdir.BzrDir.create_branch_convenience,
763
t = get_transport(self.get_url('.'))
764
self.assertFalse(t.has('foo'))
766
def test_clone(self):
767
# clone into a nonlocal path works
768
format = bzrdir.format_registry.make_bzrdir('knit')
769
branch = bzrdir.BzrDir.create_branch_convenience('local',
771
branch.bzrdir.open_workingtree()
772
result = branch.bzrdir.clone(self.get_url('remote'))
773
self.assertRaises(errors.NoWorkingTree,
774
result.open_workingtree)
776
result.open_repository()
778
def test_checkout_metadir(self):
779
# checkout_metadir has reasonable working tree format even when no
780
# working tree is present
781
self.make_branch('branch-knit2', format='dirstate-with-subtree')
782
my_bzrdir = bzrdir.BzrDir.open(self.get_url('branch-knit2'))
783
checkout_format = my_bzrdir.checkout_metadir()
784
self.assertIsInstance(checkout_format.workingtree_format,
785
workingtree.WorkingTreeFormat3)
788
class TestHTTPRedirectionLoop(object):
789
"""Test redirection loop between two http servers.
791
This MUST be used by daughter classes that also inherit from
792
TestCaseWithTwoWebservers.
794
We can't inherit directly from TestCaseWithTwoWebservers or the
795
test framework will try to create an instance which cannot
796
run, its implementation being incomplete.
799
# Should be defined by daughter classes to ensure redirection
800
# still use the same transport implementation (not currently
801
# enforced as it's a bit tricky to get right (see the FIXME
802
# in BzrDir.open_from_transport for the unique use case so
806
def create_transport_readonly_server(self):
807
return HTTPServerRedirecting()
809
def create_transport_secondary_server(self):
810
return HTTPServerRedirecting()
813
# Both servers redirect to each server creating a loop
814
super(TestHTTPRedirectionLoop, self).setUp()
815
# The redirections will point to the new server
816
self.new_server = self.get_readonly_server()
817
# The requests to the old server will be redirected
818
self.old_server = self.get_secondary_server()
819
# Configure the redirections
820
self.old_server.redirect_to(self.new_server.host, self.new_server.port)
821
self.new_server.redirect_to(self.old_server.host, self.old_server.port)
823
def _qualified_url(self, host, port):
824
return 'http+%s://%s:%s' % (self._qualifier, host, port)
827
# Starting from either server should loop
828
old_url = self._qualified_url(self.old_server.host,
829
self.old_server.port)
830
oldt = self._transport(old_url)
831
self.assertRaises(errors.NotBranchError,
832
bzrdir.BzrDir.open_from_transport, oldt)
833
new_url = self._qualified_url(self.new_server.host,
834
self.new_server.port)
835
newt = self._transport(new_url)
836
self.assertRaises(errors.NotBranchError,
837
bzrdir.BzrDir.open_from_transport, newt)
840
class TestHTTPRedirections_urllib(TestHTTPRedirectionLoop,
841
TestCaseWithTwoWebservers):
842
"""Tests redirections for urllib implementation"""
844
_qualifier = 'urllib'
845
_transport = HttpTransport_urllib
849
class TestHTTPRedirections_pycurl(TestWithTransport_pycurl,
850
TestHTTPRedirectionLoop,
851
TestCaseWithTwoWebservers):
852
"""Tests redirections for pycurl implementation"""
854
_qualifier = 'pycurl'
added
removed
bzrlib/tests/test_bzrdir.py
