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
38
from bzrlib.errors import (NotBranchError,
40
UnsupportedFormatError,
42
from bzrlib.symbol_versioning import (
45
from bzrlib.tests import (
47
TestCaseWithTransport,
51
from bzrlib.tests.HttpServer import HttpServer
52
from bzrlib.tests.HTTPTestUtil import (
53
TestCaseWithTwoWebservers,
54
HTTPServerRedirecting,
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.repofmt import knitrepo, weaverepo
63
class TestDefaultFormat(TestCase):
65
def test_get_set_default_format(self):
66
old_format = bzrdir.BzrDirFormat.get_default_format()
67
# default is BzrDirFormat6
68
self.failUnless(isinstance(old_format, bzrdir.BzrDirMetaFormat1))
69
self.applyDeprecated(symbol_versioning.zero_fourteen,
70
bzrdir.BzrDirFormat.set_default_format,
72
# creating a bzr dir should now create an instrumented dir.
74
result = bzrdir.BzrDir.create('memory:///')
75
self.failUnless(isinstance(result, SampleBzrDir))
77
self.applyDeprecated(symbol_versioning.zero_fourteen,
78
bzrdir.BzrDirFormat.set_default_format, old_format)
79
self.assertEqual(old_format, bzrdir.BzrDirFormat.get_default_format())
82
class TestFormatRegistry(TestCase):
84
def make_format_registry(self):
85
my_format_registry = bzrdir.BzrDirFormatRegistry()
86
my_format_registry.register('weave', bzrdir.BzrDirFormat6,
87
'Pre-0.8 format. Slower and does not support checkouts or shared'
88
' repositories', deprecated=True)
89
my_format_registry.register_lazy('lazy', 'bzrlib.bzrdir',
90
'BzrDirFormat6', 'Format registered lazily', deprecated=True)
91
my_format_registry.register_metadir('knit',
92
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
95
my_format_registry.set_default('knit')
96
my_format_registry.register_metadir(
98
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
99
'Experimental successor to knit. Use at your own risk.',
100
branch_format='bzrlib.branch.BzrBranchFormat6',
102
my_format_registry.register_metadir(
104
'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
105
'Experimental successor to knit. Use at your own risk.',
106
branch_format='bzrlib.branch.BzrBranchFormat6', hidden=True)
107
my_format_registry.register('hiddenweave', bzrdir.BzrDirFormat6,
108
'Pre-0.8 format. Slower and does not support checkouts or shared'
109
' repositories', hidden=True)
110
my_format_registry.register_lazy('hiddenlazy', 'bzrlib.bzrdir',
111
'BzrDirFormat6', 'Format registered lazily', deprecated=True,
113
return my_format_registry
115
def test_format_registry(self):
116
my_format_registry = self.make_format_registry()
117
my_bzrdir = my_format_registry.make_bzrdir('lazy')
118
self.assertIsInstance(my_bzrdir, bzrdir.BzrDirFormat6)
119
my_bzrdir = my_format_registry.make_bzrdir('weave')
120
self.assertIsInstance(my_bzrdir, bzrdir.BzrDirFormat6)
121
my_bzrdir = my_format_registry.make_bzrdir('default')
122
self.assertIsInstance(my_bzrdir.repository_format,
123
knitrepo.RepositoryFormatKnit1)
124
my_bzrdir = my_format_registry.make_bzrdir('knit')
125
self.assertIsInstance(my_bzrdir.repository_format,
126
knitrepo.RepositoryFormatKnit1)
127
my_bzrdir = my_format_registry.make_bzrdir('branch6')
128
self.assertIsInstance(my_bzrdir.get_branch_format(),
129
bzrlib.branch.BzrBranchFormat6)
131
def test_get_help(self):
132
my_format_registry = self.make_format_registry()
133
self.assertEqual('Format registered lazily',
134
my_format_registry.get_help('lazy'))
135
self.assertEqual('Format using knits',
136
my_format_registry.get_help('knit'))
137
self.assertEqual('Format using knits',
138
my_format_registry.get_help('default'))
139
self.assertEqual('Pre-0.8 format. Slower and does not support'
140
' checkouts or shared repositories',
141
my_format_registry.get_help('weave'))
143
def test_help_topic(self):
144
topics = help_topics.HelpTopicRegistry()
145
topics.register('formats', self.make_format_registry().help_topic,
147
topic = topics.get_detail('formats')
148
new, rest = topic.split('Experimental formats')
149
experimental, deprecated = rest.split('Deprecated formats')
150
self.assertContainsRe(new, 'These formats can be used')
151
self.assertContainsRe(new,
152
':knit:\n \(native\) \(default\) Format using knits\n')
153
self.assertContainsRe(experimental,
154
':branch6:\n \(native\) Experimental successor to knit')
155
self.assertContainsRe(deprecated,
156
':lazy:\n \(native\) Format registered lazily\n')
157
self.assertNotContainsRe(new, 'hidden')
159
def test_set_default_repository(self):
160
default_factory = bzrdir.format_registry.get('default')
161
old_default = [k for k, v in bzrdir.format_registry.iteritems()
162
if v == default_factory and k != 'default'][0]
163
bzrdir.format_registry.set_default_repository('dirstate-with-subtree')
165
self.assertIs(bzrdir.format_registry.get('dirstate-with-subtree'),
166
bzrdir.format_registry.get('default'))
168
repository.RepositoryFormat.get_default_format().__class__,
169
knitrepo.RepositoryFormatKnit3)
171
bzrdir.format_registry.set_default_repository(old_default)
174
class SampleBranch(bzrlib.branch.Branch):
175
"""A dummy branch for guess what, dummy use."""
177
def __init__(self, dir):
181
class SampleBzrDir(bzrdir.BzrDir):
182
"""A sample BzrDir implementation to allow testing static methods."""
184
def create_repository(self, shared=False):
185
"""See BzrDir.create_repository."""
186
return "A repository"
188
def open_repository(self):
189
"""See BzrDir.open_repository."""
190
return "A repository"
192
def create_branch(self):
193
"""See BzrDir.create_branch."""
194
return SampleBranch(self)
196
def create_workingtree(self):
197
"""See BzrDir.create_workingtree."""
201
class SampleBzrDirFormat(bzrdir.BzrDirFormat):
204
this format is initializable, unsupported to aid in testing the
205
open and open_downlevel routines.
208
def get_format_string(self):
209
"""See BzrDirFormat.get_format_string()."""
210
return "Sample .bzr dir format."
212
def initialize_on_transport(self, t):
213
"""Create a bzr dir."""
215
t.put_bytes('.bzr/branch-format', self.get_format_string())
216
return SampleBzrDir(t, self)
218
def is_supported(self):
221
def open(self, transport, _found=None):
222
return "opened branch."
225
class TestBzrDirFormat(TestCaseWithTransport):
226
"""Tests for the BzrDirFormat facility."""
228
def test_find_format(self):
229
# is the right format object found for a branch?
230
# create a branch with a few known format objects.
231
# this is not quite the same as
232
t = get_transport(self.get_url())
233
self.build_tree(["foo/", "bar/"], transport=t)
234
def check_format(format, url):
235
format.initialize(url)
236
t = get_transport(url)
237
found_format = bzrdir.BzrDirFormat.find_format(t)
238
self.failUnless(isinstance(found_format, format.__class__))
239
check_format(bzrdir.BzrDirFormat5(), "foo")
240
check_format(bzrdir.BzrDirFormat6(), "bar")
242
def test_find_format_nothing_there(self):
243
self.assertRaises(NotBranchError,
244
bzrdir.BzrDirFormat.find_format,
247
def test_find_format_unknown_format(self):
248
t = get_transport(self.get_url())
250
t.put_bytes('.bzr/branch-format', '')
251
self.assertRaises(UnknownFormatError,
252
bzrdir.BzrDirFormat.find_format,
255
def test_register_unregister_format(self):
256
format = SampleBzrDirFormat()
259
format.initialize(url)
260
# register a format for it.
261
bzrdir.BzrDirFormat.register_format(format)
262
# which bzrdir.Open will refuse (not supported)
263
self.assertRaises(UnsupportedFormatError, bzrdir.BzrDir.open, url)
264
# which bzrdir.open_containing will refuse (not supported)
265
self.assertRaises(UnsupportedFormatError, bzrdir.BzrDir.open_containing, url)
266
# but open_downlevel will work
267
t = get_transport(url)
268
self.assertEqual(format.open(t), bzrdir.BzrDir.open_unsupported(url))
269
# unregister the format
270
bzrdir.BzrDirFormat.unregister_format(format)
271
# now open_downlevel should fail too.
272
self.assertRaises(UnknownFormatError, bzrdir.BzrDir.open_unsupported, url)
274
def test_create_repository_deprecated(self):
275
# new interface is to make the bzrdir, then a repository within that.
276
format = SampleBzrDirFormat()
277
repo = self.applyDeprecated(zero_ninetyone,
278
bzrdir.BzrDir.create_repository,
279
self.get_url(), format=format)
280
self.assertEqual('A repository', repo)
282
def test_create_repository_shared(self):
283
# new interface is to make the bzrdir, then a repository within that.
284
old_format = bzrdir.BzrDirFormat.get_default_format()
285
repo = self.applyDeprecated(zero_ninetyone,
286
bzrdir.BzrDir.create_repository,
288
self.assertTrue(repo.is_shared())
290
def test_create_repository_nonshared(self):
291
# new interface is to make the bzrdir, then a repository within that.
292
old_format = bzrdir.BzrDirFormat.get_default_format()
293
repo = self.applyDeprecated(zero_ninetyone,
294
bzrdir.BzrDir.create_repository,
296
self.assertFalse(repo.is_shared())
298
def test_create_repository_under_shared(self):
299
# an explicit create_repository always does so.
300
# we trust the format is right from the 'create_repository test'
301
# new interface is to make the bzrdir, then a repository within that.
302
format = bzrdir.format_registry.make_bzrdir('knit')
303
self.make_repository('.', shared=True, format=format)
304
repo = self.applyDeprecated(zero_ninetyone,
305
bzrdir.BzrDir.create_repository,
306
self.get_url('child'),
308
self.assertTrue(isinstance(repo, repository.Repository))
309
self.assertTrue(repo.bzrdir.root_transport.base.endswith('child/'))
311
def test_create_branch_and_repo_uses_default(self):
312
format = SampleBzrDirFormat()
313
branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url(),
315
self.assertTrue(isinstance(branch, SampleBranch))
317
def test_create_branch_and_repo_under_shared(self):
318
# creating a branch and repo in a shared repo uses the
320
format = bzrdir.format_registry.make_bzrdir('knit')
321
self.make_repository('.', shared=True, format=format)
322
branch = bzrdir.BzrDir.create_branch_and_repo(
323
self.get_url('child'), format=format)
324
self.assertRaises(errors.NoRepositoryPresent,
325
branch.bzrdir.open_repository)
327
def test_create_branch_and_repo_under_shared_force_new(self):
328
# creating a branch and repo in a shared repo can be forced to
330
format = bzrdir.format_registry.make_bzrdir('knit')
331
self.make_repository('.', shared=True, format=format)
332
branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url('child'),
335
branch.bzrdir.open_repository()
337
def test_create_standalone_working_tree(self):
338
format = SampleBzrDirFormat()
339
# note this is deliberately readonly, as this failure should
340
# occur before any writes.
341
self.assertRaises(errors.NotLocalUrl,
342
bzrdir.BzrDir.create_standalone_workingtree,
343
self.get_readonly_url(), format=format)
344
tree = bzrdir.BzrDir.create_standalone_workingtree('.',
346
self.assertEqual('A tree', tree)
348
def test_create_standalone_working_tree_under_shared_repo(self):
349
# create standalone working tree always makes a repo.
350
format = bzrdir.format_registry.make_bzrdir('knit')
351
self.make_repository('.', shared=True, format=format)
352
# note this is deliberately readonly, as this failure should
353
# occur before any writes.
354
self.assertRaises(errors.NotLocalUrl,
355
bzrdir.BzrDir.create_standalone_workingtree,
356
self.get_readonly_url('child'), format=format)
357
tree = bzrdir.BzrDir.create_standalone_workingtree('child',
359
tree.bzrdir.open_repository()
361
def test_create_branch_convenience(self):
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('.', format=format)
365
branch.bzrdir.open_workingtree()
366
branch.bzrdir.open_repository()
368
def test_create_branch_convenience_possible_transports(self):
369
"""Check that the optional 'possible_transports' is recognized"""
370
format = bzrdir.format_registry.make_bzrdir('knit')
371
t = self.get_transport()
372
branch = bzrdir.BzrDir.create_branch_convenience(
373
'.', format=format, possible_transports=[t])
374
branch.bzrdir.open_workingtree()
375
branch.bzrdir.open_repository()
377
def test_create_branch_convenience_root(self):
378
"""Creating a branch at the root of a fs should work."""
379
self.vfs_transport_factory = MemoryServer
380
# outside a repo the default convenience output is a repo+branch_tree
381
format = bzrdir.format_registry.make_bzrdir('knit')
382
branch = bzrdir.BzrDir.create_branch_convenience(self.get_url(),
384
self.assertRaises(errors.NoWorkingTree,
385
branch.bzrdir.open_workingtree)
386
branch.bzrdir.open_repository()
388
def test_create_branch_convenience_under_shared_repo(self):
389
# inside a repo the default convenience output is a branch+ follow the
391
format = bzrdir.format_registry.make_bzrdir('knit')
392
self.make_repository('.', shared=True, format=format)
393
branch = bzrdir.BzrDir.create_branch_convenience('child',
395
branch.bzrdir.open_workingtree()
396
self.assertRaises(errors.NoRepositoryPresent,
397
branch.bzrdir.open_repository)
399
def test_create_branch_convenience_under_shared_repo_force_no_tree(self):
400
# inside a repo the default convenience output is a branch+ follow the
401
# repo tree policy but we can override that
402
format = bzrdir.format_registry.make_bzrdir('knit')
403
self.make_repository('.', shared=True, format=format)
404
branch = bzrdir.BzrDir.create_branch_convenience('child',
405
force_new_tree=False, format=format)
406
self.assertRaises(errors.NoWorkingTree,
407
branch.bzrdir.open_workingtree)
408
self.assertRaises(errors.NoRepositoryPresent,
409
branch.bzrdir.open_repository)
411
def test_create_branch_convenience_under_shared_repo_no_tree_policy(self):
412
# inside a repo the default convenience output is a branch+ follow the
414
format = bzrdir.format_registry.make_bzrdir('knit')
415
repo = self.make_repository('.', shared=True, format=format)
416
repo.set_make_working_trees(False)
417
branch = bzrdir.BzrDir.create_branch_convenience('child',
419
self.assertRaises(errors.NoWorkingTree,
420
branch.bzrdir.open_workingtree)
421
self.assertRaises(errors.NoRepositoryPresent,
422
branch.bzrdir.open_repository)
424
def test_create_branch_convenience_under_shared_repo_no_tree_policy_force_tree(self):
425
# inside a repo the default convenience output is a branch+ follow the
426
# repo tree policy but we can override that
427
format = bzrdir.format_registry.make_bzrdir('knit')
428
repo = self.make_repository('.', shared=True, format=format)
429
repo.set_make_working_trees(False)
430
branch = bzrdir.BzrDir.create_branch_convenience('child',
431
force_new_tree=True, format=format)
432
branch.bzrdir.open_workingtree()
433
self.assertRaises(errors.NoRepositoryPresent,
434
branch.bzrdir.open_repository)
436
def test_create_branch_convenience_under_shared_repo_force_new_repo(self):
437
# inside a repo the default convenience output is overridable to give
439
format = bzrdir.format_registry.make_bzrdir('knit')
440
self.make_repository('.', shared=True, format=format)
441
branch = bzrdir.BzrDir.create_branch_convenience('child',
442
force_new_repo=True, format=format)
443
branch.bzrdir.open_repository()
444
branch.bzrdir.open_workingtree()
447
class ChrootedTests(TestCaseWithTransport):
448
"""A support class that provides readonly urls outside the local namespace.
450
This is done by checking if self.transport_server is a MemoryServer. if it
451
is then we are chrooted already, if it is not then an HttpServer is used
456
super(ChrootedTests, self).setUp()
457
if not self.vfs_transport_factory == MemoryServer:
458
self.transport_readonly_server = HttpServer
460
def test_open_containing(self):
461
self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing,
462
self.get_readonly_url(''))
463
self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing,
464
self.get_readonly_url('g/p/q'))
465
control = bzrdir.BzrDir.create(self.get_url())
466
branch, relpath = bzrdir.BzrDir.open_containing(self.get_readonly_url(''))
467
self.assertEqual('', relpath)
468
branch, relpath = bzrdir.BzrDir.open_containing(self.get_readonly_url('g/p/q'))
469
self.assertEqual('g/p/q', relpath)
471
def test_open_containing_from_transport(self):
472
self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing_from_transport,
473
get_transport(self.get_readonly_url('')))
474
self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing_from_transport,
475
get_transport(self.get_readonly_url('g/p/q')))
476
control = bzrdir.BzrDir.create(self.get_url())
477
branch, relpath = bzrdir.BzrDir.open_containing_from_transport(
478
get_transport(self.get_readonly_url('')))
479
self.assertEqual('', relpath)
480
branch, relpath = bzrdir.BzrDir.open_containing_from_transport(
481
get_transport(self.get_readonly_url('g/p/q')))
482
self.assertEqual('g/p/q', relpath)
484
def test_open_containing_tree_or_branch(self):
485
def local_branch_path(branch):
486
return os.path.realpath(
487
urlutils.local_path_from_url(branch.base))
489
self.make_branch_and_tree('topdir')
490
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
492
self.assertEqual(os.path.realpath('topdir'),
493
os.path.realpath(tree.basedir))
494
self.assertEqual(os.path.realpath('topdir'),
495
local_branch_path(branch))
496
self.assertIs(tree.bzrdir, branch.bzrdir)
497
self.assertEqual('foo', relpath)
498
# opening from non-local should not return the tree
499
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
500
self.get_readonly_url('topdir/foo'))
501
self.assertEqual(None, tree)
502
self.assertEqual('foo', relpath)
504
self.make_branch('topdir/foo')
505
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
507
self.assertIs(tree, None)
508
self.assertEqual(os.path.realpath('topdir/foo'),
509
local_branch_path(branch))
510
self.assertEqual('', relpath)
512
def test_open_tree_or_branch(self):
513
def local_branch_path(branch):
514
return os.path.realpath(
515
urlutils.local_path_from_url(branch.base))
517
self.make_branch_and_tree('topdir')
518
tree, branch = bzrdir.BzrDir.open_tree_or_branch('topdir')
519
self.assertEqual(os.path.realpath('topdir'),
520
os.path.realpath(tree.basedir))
521
self.assertEqual(os.path.realpath('topdir'),
522
local_branch_path(branch))
523
self.assertIs(tree.bzrdir, branch.bzrdir)
524
# opening from non-local should not return the tree
525
tree, branch = bzrdir.BzrDir.open_tree_or_branch(
526
self.get_readonly_url('topdir'))
527
self.assertEqual(None, tree)
529
self.make_branch('topdir/foo')
530
tree, branch = bzrdir.BzrDir.open_tree_or_branch('topdir/foo')
531
self.assertIs(tree, None)
532
self.assertEqual(os.path.realpath('topdir/foo'),
533
local_branch_path(branch))
535
def test_open_from_transport(self):
536
# transport pointing at bzrdir should give a bzrdir with root transport
537
# set to the given transport
538
control = bzrdir.BzrDir.create(self.get_url())
539
transport = get_transport(self.get_url())
540
opened_bzrdir = bzrdir.BzrDir.open_from_transport(transport)
541
self.assertEqual(transport.base, opened_bzrdir.root_transport.base)
542
self.assertIsInstance(opened_bzrdir, bzrdir.BzrDir)
544
def test_open_from_transport_no_bzrdir(self):
545
transport = get_transport(self.get_url())
546
self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport,
549
def test_open_from_transport_bzrdir_in_parent(self):
550
control = bzrdir.BzrDir.create(self.get_url())
551
transport = get_transport(self.get_url())
552
transport.mkdir('subdir')
553
transport = transport.clone('subdir')
554
self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport,
557
def test_sprout_recursive(self):
558
tree = self.make_branch_and_tree('tree1', format='dirstate-with-subtree')
559
sub_tree = self.make_branch_and_tree('tree1/subtree',
560
format='dirstate-with-subtree')
561
tree.add_reference(sub_tree)
562
self.build_tree(['tree1/subtree/file'])
564
tree.commit('Initial commit')
565
tree.bzrdir.sprout('tree2')
566
self.failUnlessExists('tree2/subtree/file')
568
def test_cloning_metadir(self):
569
"""Ensure that cloning metadir is suitable"""
570
bzrdir = self.make_bzrdir('bzrdir')
571
bzrdir.cloning_metadir()
572
branch = self.make_branch('branch', format='knit')
573
format = branch.bzrdir.cloning_metadir()
574
self.assertIsInstance(format.workingtree_format,
575
workingtree.WorkingTreeFormat3)
577
def test_sprout_recursive_treeless(self):
578
tree = self.make_branch_and_tree('tree1',
579
format='dirstate-with-subtree')
580
sub_tree = self.make_branch_and_tree('tree1/subtree',
581
format='dirstate-with-subtree')
582
tree.add_reference(sub_tree)
583
self.build_tree(['tree1/subtree/file'])
585
tree.commit('Initial commit')
586
tree.bzrdir.destroy_workingtree()
587
repo = self.make_repository('repo', shared=True,
588
format='dirstate-with-subtree')
589
repo.set_make_working_trees(False)
590
tree.bzrdir.sprout('repo/tree2')
591
self.failUnlessExists('repo/tree2/subtree')
592
self.failIfExists('repo/tree2/subtree/file')
594
def make_foo_bar_baz(self):
595
foo = bzrdir.BzrDir.create_branch_convenience('foo').bzrdir
596
bar = self.make_branch('foo/bar').bzrdir
597
baz = self.make_branch('baz').bzrdir
600
def test_find_bzrdirs(self):
601
foo, bar, baz = self.make_foo_bar_baz()
602
transport = get_transport(self.get_url())
603
self.assertEqualBzrdirs([baz, foo, bar],
604
bzrdir.BzrDir.find_bzrdirs(transport))
606
def test_find_bzrdirs_list_current(self):
607
def list_current(transport):
608
return [s for s in transport.list_dir('') if s != 'baz']
610
foo, bar, baz = self.make_foo_bar_baz()
611
transport = get_transport(self.get_url())
612
self.assertEqualBzrdirs([foo, bar],
613
bzrdir.BzrDir.find_bzrdirs(transport,
614
list_current=list_current))
617
def test_find_bzrdirs_evaluate(self):
618
def evaluate(bzrdir):
620
repo = bzrdir.open_repository()
621
except NoRepositoryPresent:
622
return True, bzrdir.root_transport.base
624
return False, bzrdir.root_transport.base
626
foo, bar, baz = self.make_foo_bar_baz()
627
transport = get_transport(self.get_url())
628
self.assertEqual([baz.root_transport.base, foo.root_transport.base],
629
list(bzrdir.BzrDir.find_bzrdirs(transport,
632
def assertEqualBzrdirs(self, first, second):
634
second = list(second)
635
self.assertEqual(len(first), len(second))
636
for x, y in zip(first, second):
637
self.assertEqual(x.root_transport.base, y.root_transport.base)
639
def test_find_branches(self):
640
root = self.make_repository('', shared=True)
641
foo, bar, baz = self.make_foo_bar_baz()
642
qux = self.make_bzrdir('foo/qux')
643
transport = get_transport(self.get_url())
644
branches = bzrdir.BzrDir.find_branches(transport)
645
self.assertEqual(baz.root_transport.base, branches[0].base)
646
self.assertEqual(foo.root_transport.base, branches[1].base)
647
self.assertEqual(bar.root_transport.base, branches[2].base)
649
# ensure this works without a top-level repo
650
branches = bzrdir.BzrDir.find_branches(transport.clone('foo'))
651
self.assertEqual(foo.root_transport.base, branches[0].base)
652
self.assertEqual(bar.root_transport.base, branches[1].base)
655
class TestMeta1DirFormat(TestCaseWithTransport):
656
"""Tests specific to the meta1 dir format."""
658
def test_right_base_dirs(self):
659
dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
661
branch_base = t.clone('branch').base
662
self.assertEqual(branch_base, dir.get_branch_transport(None).base)
663
self.assertEqual(branch_base,
664
dir.get_branch_transport(bzrlib.branch.BzrBranchFormat5()).base)
665
repository_base = t.clone('repository').base
666
self.assertEqual(repository_base, dir.get_repository_transport(None).base)
667
self.assertEqual(repository_base,
668
dir.get_repository_transport(weaverepo.RepositoryFormat7()).base)
669
checkout_base = t.clone('checkout').base
670
self.assertEqual(checkout_base, dir.get_workingtree_transport(None).base)
671
self.assertEqual(checkout_base,
672
dir.get_workingtree_transport(workingtree.WorkingTreeFormat3()).base)
674
def test_meta1dir_uses_lockdir(self):
675
"""Meta1 format uses a LockDir to guard the whole directory, not a file."""
676
dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
678
self.assertIsDirectory('branch-lock', t)
680
def test_comparison(self):
681
"""Equality and inequality behave properly.
683
Metadirs should compare equal iff they have the same repo, branch and
686
mydir = bzrdir.format_registry.make_bzrdir('knit')
687
self.assertEqual(mydir, mydir)
688
self.assertFalse(mydir != mydir)
689
otherdir = bzrdir.format_registry.make_bzrdir('knit')
690
self.assertEqual(otherdir, mydir)
691
self.assertFalse(otherdir != mydir)
692
otherdir2 = bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
693
self.assertNotEqual(otherdir2, mydir)
694
self.assertFalse(otherdir2 == mydir)
696
def test_needs_conversion_different_working_tree(self):
697
# meta1dirs need an conversion if any element is not the default.
698
old_format = bzrdir.BzrDirFormat.get_default_format()
700
new_default = bzrdir.format_registry.make_bzrdir('dirstate')
701
bzrdir.BzrDirFormat._set_default_format(new_default)
703
tree = self.make_branch_and_tree('tree', format='knit')
704
self.assertTrue(tree.bzrdir.needs_format_conversion())
706
bzrdir.BzrDirFormat._set_default_format(old_format)
709
class TestFormat5(TestCaseWithTransport):
710
"""Tests specific to the version 5 bzrdir format."""
712
def test_same_lockfiles_between_tree_repo_branch(self):
713
# this checks that only a single lockfiles instance is created
714
# for format 5 objects
715
dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
716
def check_dir_components_use_same_lock(dir):
717
ctrl_1 = dir.open_repository().control_files
718
ctrl_2 = dir.open_branch().control_files
719
ctrl_3 = dir.open_workingtree()._control_files
720
self.assertTrue(ctrl_1 is ctrl_2)
721
self.assertTrue(ctrl_2 is ctrl_3)
722
check_dir_components_use_same_lock(dir)
723
# and if we open it normally.
724
dir = bzrdir.BzrDir.open(self.get_url())
725
check_dir_components_use_same_lock(dir)
727
def test_can_convert(self):
728
# format 5 dirs are convertable
729
dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
730
self.assertTrue(dir.can_convert_format())
732
def test_needs_conversion(self):
733
# format 5 dirs need a conversion if they are not the default.
734
# and they start of not the default.
735
old_format = bzrdir.BzrDirFormat.get_default_format()
736
bzrdir.BzrDirFormat._set_default_format(bzrdir.BzrDirFormat5())
738
dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
739
self.assertFalse(dir.needs_format_conversion())
741
bzrdir.BzrDirFormat._set_default_format(old_format)
742
self.assertTrue(dir.needs_format_conversion())
745
class TestFormat6(TestCaseWithTransport):
746
"""Tests specific to the version 6 bzrdir format."""
748
def test_same_lockfiles_between_tree_repo_branch(self):
749
# this checks that only a single lockfiles instance is created
750
# for format 6 objects
751
dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
752
def check_dir_components_use_same_lock(dir):
753
ctrl_1 = dir.open_repository().control_files
754
ctrl_2 = dir.open_branch().control_files
755
ctrl_3 = dir.open_workingtree()._control_files
756
self.assertTrue(ctrl_1 is ctrl_2)
757
self.assertTrue(ctrl_2 is ctrl_3)
758
check_dir_components_use_same_lock(dir)
759
# and if we open it normally.
760
dir = bzrdir.BzrDir.open(self.get_url())
761
check_dir_components_use_same_lock(dir)
763
def test_can_convert(self):
764
# format 6 dirs are convertable
765
dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
766
self.assertTrue(dir.can_convert_format())
768
def test_needs_conversion(self):
769
# format 6 dirs need an conversion if they are not the default.
770
old_format = bzrdir.BzrDirFormat.get_default_format()
771
bzrdir.BzrDirFormat._set_default_format(bzrdir.BzrDirMetaFormat1())
773
dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
774
self.assertTrue(dir.needs_format_conversion())
776
bzrdir.BzrDirFormat._set_default_format(old_format)
779
class NotBzrDir(bzrlib.bzrdir.BzrDir):
780
"""A non .bzr based control directory."""
782
def __init__(self, transport, format):
783
self._format = format
784
self.root_transport = transport
785
self.transport = transport.clone('.not')
788
class NotBzrDirFormat(bzrlib.bzrdir.BzrDirFormat):
789
"""A test class representing any non-.bzr based disk format."""
791
def initialize_on_transport(self, transport):
792
"""Initialize a new .not dir in the base directory of a Transport."""
793
transport.mkdir('.not')
794
return self.open(transport)
796
def open(self, transport):
797
"""Open this directory."""
798
return NotBzrDir(transport, self)
801
def _known_formats(self):
802
return set([NotBzrDirFormat()])
805
def probe_transport(self, transport):
806
"""Our format is present if the transport ends in '.not/'."""
807
if transport.has('.not'):
808
return NotBzrDirFormat()
811
class TestNotBzrDir(TestCaseWithTransport):
812
"""Tests for using the bzrdir api with a non .bzr based disk format.
814
If/when one of these is in the core, we can let the implementation tests
818
def test_create_and_find_format(self):
819
# create a .notbzr dir
820
format = NotBzrDirFormat()
821
dir = format.initialize(self.get_url())
822
self.assertIsInstance(dir, NotBzrDir)
824
bzrlib.bzrdir.BzrDirFormat.register_control_format(format)
826
found = bzrlib.bzrdir.BzrDirFormat.find_format(
827
get_transport(self.get_url()))
828
self.assertIsInstance(found, NotBzrDirFormat)
830
bzrlib.bzrdir.BzrDirFormat.unregister_control_format(format)
832
def test_included_in_known_formats(self):
833
bzrlib.bzrdir.BzrDirFormat.register_control_format(NotBzrDirFormat)
835
formats = bzrlib.bzrdir.BzrDirFormat.known_formats()
836
for format in formats:
837
if isinstance(format, NotBzrDirFormat):
839
self.fail("No NotBzrDirFormat in %s" % formats)
841
bzrlib.bzrdir.BzrDirFormat.unregister_control_format(NotBzrDirFormat)
844
class NonLocalTests(TestCaseWithTransport):
845
"""Tests for bzrdir static behaviour on non local paths."""
848
super(NonLocalTests, self).setUp()
849
self.vfs_transport_factory = MemoryServer
851
def test_create_branch_convenience(self):
852
# outside a repo the default convenience output is a repo+branch_tree
853
format = bzrdir.format_registry.make_bzrdir('knit')
854
branch = bzrdir.BzrDir.create_branch_convenience(
855
self.get_url('foo'), format=format)
856
self.assertRaises(errors.NoWorkingTree,
857
branch.bzrdir.open_workingtree)
858
branch.bzrdir.open_repository()
860
def test_create_branch_convenience_force_tree_not_local_fails(self):
861
# outside a repo the default convenience output is a repo+branch_tree
862
format = bzrdir.format_registry.make_bzrdir('knit')
863
self.assertRaises(errors.NotLocalUrl,
864
bzrdir.BzrDir.create_branch_convenience,
868
t = get_transport(self.get_url('.'))
869
self.assertFalse(t.has('foo'))
871
def test_clone(self):
872
# clone into a nonlocal path works
873
format = bzrdir.format_registry.make_bzrdir('knit')
874
branch = bzrdir.BzrDir.create_branch_convenience('local',
876
branch.bzrdir.open_workingtree()
877
result = branch.bzrdir.clone(self.get_url('remote'))
878
self.assertRaises(errors.NoWorkingTree,
879
result.open_workingtree)
881
result.open_repository()
883
def test_checkout_metadir(self):
884
# checkout_metadir has reasonable working tree format even when no
885
# working tree is present
886
self.make_branch('branch-knit2', format='dirstate-with-subtree')
887
my_bzrdir = bzrdir.BzrDir.open(self.get_url('branch-knit2'))
888
checkout_format = my_bzrdir.checkout_metadir()
889
self.assertIsInstance(checkout_format.workingtree_format,
890
workingtree.WorkingTreeFormat3)
893
class TestHTTPRedirectionLoop(object):
894
"""Test redirection loop between two http servers.
896
This MUST be used by daughter classes that also inherit from
897
TestCaseWithTwoWebservers.
899
We can't inherit directly from TestCaseWithTwoWebservers or the
900
test framework will try to create an instance which cannot
901
run, its implementation being incomplete.
904
# Should be defined by daughter classes to ensure redirection
905
# still use the same transport implementation (not currently
906
# enforced as it's a bit tricky to get right (see the FIXME
907
# in BzrDir.open_from_transport for the unique use case so
911
def create_transport_readonly_server(self):
912
return HTTPServerRedirecting()
914
def create_transport_secondary_server(self):
915
return HTTPServerRedirecting()
918
# Both servers redirect to each server creating a loop
919
super(TestHTTPRedirectionLoop, self).setUp()
920
# The redirections will point to the new server
921
self.new_server = self.get_readonly_server()
922
# The requests to the old server will be redirected
923
self.old_server = self.get_secondary_server()
924
# Configure the redirections
925
self.old_server.redirect_to(self.new_server.host, self.new_server.port)
926
self.new_server.redirect_to(self.old_server.host, self.old_server.port)
928
def _qualified_url(self, host, port):
929
return 'http+%s://%s:%s' % (self._qualifier, host, port)
932
# Starting from either server should loop
933
old_url = self._qualified_url(self.old_server.host,
934
self.old_server.port)
935
oldt = self._transport(old_url)
936
self.assertRaises(errors.NotBranchError,
937
bzrdir.BzrDir.open_from_transport, oldt)
938
new_url = self._qualified_url(self.new_server.host,
939
self.new_server.port)
940
newt = self._transport(new_url)
941
self.assertRaises(errors.NotBranchError,
942
bzrdir.BzrDir.open_from_transport, newt)
945
class TestHTTPRedirections_urllib(TestHTTPRedirectionLoop,
946
TestCaseWithTwoWebservers):
947
"""Tests redirections for urllib implementation"""
949
_qualifier = 'urllib'
950
_transport = HttpTransport_urllib
954
class TestHTTPRedirections_pycurl(TestWithTransport_pycurl,
955
TestHTTPRedirectionLoop,
956
TestCaseWithTwoWebservers):
957
"""Tests redirections for pycurl implementation"""
959
_qualifier = 'pycurl'
962
class TestDotBzrHidden(TestCaseWithTransport):
965
if sys.platform == 'win32':
966
ls = [os.environ['COMSPEC'], '/C', 'dir', '/B']
969
f = subprocess.Popen(self.ls, stdout=subprocess.PIPE,
970
stderr=subprocess.PIPE)
971
out, err = f.communicate()
972
self.assertEqual(0, f.returncode, 'Calling %s failed: %s'
974
return out.splitlines()
976
def test_dot_bzr_hidden(self):
977
if sys.platform == 'win32' and not win32utils.has_win32file:
978
raise TestSkipped('unable to make file hidden without pywin32 library')
979
b = bzrdir.BzrDir.create('.')
980
self.build_tree(['a'])
981
self.assertEquals(['a'], self.get_ls())
983
def test_dot_bzr_hidden_with_url(self):
984
if sys.platform == 'win32' and not win32utils.has_win32file:
985
raise TestSkipped('unable to make file hidden without pywin32 library')
986
b = bzrdir.BzrDir.create(urlutils.local_path_to_url('.'))
987
self.build_tree(['a'])
988
self.assertEquals(['a'], self.get_ls())
added
removed
bzrlib/tests/test_bzrdir.py
