← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_bzrdir.py

  • Committer: Robert Collins
  • Date: 2009-07-07 04:32:13 UTC
  • mto: This revision was merged to the branch mainline in revision 4524.
  • Revision ID: robertc@robertcollins.net-20090707043213-4hjjhgr40iq7gk2d
More informative assertions in xml serialisation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_bzrdir.py
1
 
    # Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
 
# 
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
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
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Tests for the BzrDir facility and any format specific tests.
18
18
 
19
19
For interface contract tests, see tests/bzr_dir_implementations.
20
20
"""
21
21
 
22
 
import os.path
23
 
from StringIO import StringIO
 
22
import os
 
23
import subprocess
 
24
import sys
24
25
 
25
26
from bzrlib import (
26
27
    bzrdir,
27
28
    errors,
28
29
    help_topics,
29
30
    repository,
30
 
    symbol_versioning,
 
31
    osutils,
 
32
    remote,
31
33
    urlutils,
 
34
    win32utils,
32
35
    workingtree,
33
36
    )
34
37
import bzrlib.branch
38
41
                           )
39
42
from bzrlib.tests import (
40
43
    TestCase,
 
44
    TestCaseWithMemoryTransport,
41
45
    TestCaseWithTransport,
42
 
    test_sftp_transport
 
46
    TestSkipped,
43
47
    )
44
 
from bzrlib.tests.HttpServer import HttpServer
45
 
from bzrlib.tests.HTTPTestUtil import (
46
 
    TestCaseWithTwoWebservers,
47
 
    HTTPServerRedirecting,
 
48
from bzrlib.tests import(
 
49
    http_server,
 
50
    http_utils,
48
51
    )
49
52
from bzrlib.tests.test_http import TestWithTransport_pycurl
50
53
from bzrlib.transport import get_transport
51
54
from bzrlib.transport.http._urllib import HttpTransport_urllib
52
55
from bzrlib.transport.memory import MemoryServer
53
 
from bzrlib.repofmt import knitrepo, weaverepo
 
56
from bzrlib.transport.nosmart import NoSmartTransportDecorator
 
57
from bzrlib.transport.readonly import ReadonlyTransportDecorator
 
58
from bzrlib.repofmt import knitrepo, weaverepo, pack_repo
54
59
 
55
60
 
56
61
class TestDefaultFormat(TestCase):
59
64
        old_format = bzrdir.BzrDirFormat.get_default_format()
60
65
        # default is BzrDirFormat6
61
66
        self.failUnless(isinstance(old_format, bzrdir.BzrDirMetaFormat1))
62
 
        self.applyDeprecated(symbol_versioning.zero_fourteen, 
63
 
                             bzrdir.BzrDirFormat.set_default_format, 
64
 
                             SampleBzrDirFormat())
 
67
        bzrdir.BzrDirFormat._set_default_format(SampleBzrDirFormat())
65
68
        # creating a bzr dir should now create an instrumented dir.
66
69
        try:
67
70
            result = bzrdir.BzrDir.create('memory:///')
68
71
            self.failUnless(isinstance(result, SampleBzrDir))
69
72
        finally:
70
 
            self.applyDeprecated(symbol_versioning.zero_fourteen,
71
 
                bzrdir.BzrDirFormat.set_default_format, old_format)
 
73
            bzrdir.BzrDirFormat._set_default_format(old_format)
72
74
        self.assertEqual(old_format, bzrdir.BzrDirFormat.get_default_format())
73
75
 
74
76
 
79
81
        my_format_registry.register('weave', bzrdir.BzrDirFormat6,
80
82
            'Pre-0.8 format.  Slower and does not support checkouts or shared'
81
83
            ' repositories', deprecated=True)
82
 
        my_format_registry.register_lazy('lazy', 'bzrlib.bzrdir', 
 
84
        my_format_registry.register_lazy('lazy', 'bzrlib.bzrdir',
83
85
            'BzrDirFormat6', 'Format registered lazily', deprecated=True)
84
86
        my_format_registry.register_metadir('knit',
85
87
            'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
90
92
            'branch6',
91
93
            'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
92
94
            'Experimental successor to knit.  Use at your own risk.',
93
 
            branch_format='bzrlib.branch.BzrBranchFormat6')
 
95
            branch_format='bzrlib.branch.BzrBranchFormat6',
 
96
            experimental=True)
94
97
        my_format_registry.register_metadir(
95
98
            'hidden format',
96
99
            'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
111
114
        my_bzrdir = my_format_registry.make_bzrdir('weave')
112
115
        self.assertIsInstance(my_bzrdir, bzrdir.BzrDirFormat6)
113
116
        my_bzrdir = my_format_registry.make_bzrdir('default')
114
 
        self.assertIsInstance(my_bzrdir.repository_format, 
 
117
        self.assertIsInstance(my_bzrdir.repository_format,
115
118
            knitrepo.RepositoryFormatKnit1)
116
119
        my_bzrdir = my_format_registry.make_bzrdir('knit')
117
 
        self.assertIsInstance(my_bzrdir.repository_format, 
 
120
        self.assertIsInstance(my_bzrdir.repository_format,
118
121
            knitrepo.RepositoryFormatKnit1)
119
122
        my_bzrdir = my_format_registry.make_bzrdir('branch6')
120
123
        self.assertIsInstance(my_bzrdir.get_branch_format(),
124
127
        my_format_registry = self.make_format_registry()
125
128
        self.assertEqual('Format registered lazily',
126
129
                         my_format_registry.get_help('lazy'))
127
 
        self.assertEqual('Format using knits', 
 
130
        self.assertEqual('Format using knits',
128
131
                         my_format_registry.get_help('knit'))
129
 
        self.assertEqual('Format using knits', 
 
132
        self.assertEqual('Format using knits',
130
133
                         my_format_registry.get_help('default'))
131
134
        self.assertEqual('Pre-0.8 format.  Slower and does not support'
132
 
                         ' checkouts or shared repositories', 
 
135
                         ' checkouts or shared repositories',
133
136
                         my_format_registry.get_help('weave'))
134
 
        
 
137
 
135
138
    def test_help_topic(self):
136
139
        topics = help_topics.HelpTopicRegistry()
137
 
        topics.register('formats', self.make_format_registry().help_topic, 
138
 
                        'Directory formats')
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')
 
140
        registry = self.make_format_registry()
 
141
        topics.register('current-formats', registry.help_topic,
 
142
                        'Current formats')
 
143
        topics.register('other-formats', registry.help_topic,
 
144
                        'Other formats')
 
145
        new = topics.get_detail('current-formats')
 
146
        rest = topics.get_detail('other-formats')
 
147
        experimental, deprecated = rest.split('Deprecated formats')
 
148
        self.assertContainsRe(new, 'bzr help formats')
 
149
        self.assertContainsRe(new,
 
150
                ':knit:\n    \(native\) \(default\) Format using knits\n')
 
151
        self.assertContainsRe(experimental,
 
152
                ':branch6:\n    \(native\) Experimental successor to knit')
 
153
        self.assertContainsRe(deprecated,
 
154
                ':lazy:\n    \(native\) Format registered lazily\n')
146
155
        self.assertNotContainsRe(new, 'hidden')
147
156
 
148
157
    def test_set_default_repository(self):
159
168
        finally:
160
169
            bzrdir.format_registry.set_default_repository(old_default)
161
170
 
 
171
    def test_aliases(self):
 
172
        a_registry = bzrdir.BzrDirFormatRegistry()
 
173
        a_registry.register('weave', bzrdir.BzrDirFormat6,
 
174
            'Pre-0.8 format.  Slower and does not support checkouts or shared'
 
175
            ' repositories', deprecated=True)
 
176
        a_registry.register('weavealias', bzrdir.BzrDirFormat6,
 
177
            'Pre-0.8 format.  Slower and does not support checkouts or shared'
 
178
            ' repositories', deprecated=True, alias=True)
 
179
        self.assertEqual(frozenset(['weavealias']), a_registry.aliases())
 
180
 
162
181
 
163
182
class SampleBranch(bzrlib.branch.Branch):
164
183
    """A dummy branch for guess what, dummy use."""
167
186
        self.bzrdir = dir
168
187
 
169
188
 
 
189
class SampleRepository(bzrlib.repository.Repository):
 
190
    """A dummy repo."""
 
191
 
 
192
    def __init__(self, dir):
 
193
        self.bzrdir = dir
 
194
 
 
195
 
170
196
class SampleBzrDir(bzrdir.BzrDir):
171
197
    """A sample BzrDir implementation to allow testing static methods."""
172
198
 
176
202
 
177
203
    def open_repository(self):
178
204
        """See BzrDir.open_repository."""
179
 
        return "A repository"
 
205
        return SampleRepository(self)
180
206
 
181
207
    def create_branch(self):
182
208
        """See BzrDir.create_branch."""
190
216
class SampleBzrDirFormat(bzrdir.BzrDirFormat):
191
217
    """A sample format
192
218
 
193
 
    this format is initializable, unsupported to aid in testing the 
 
219
    this format is initializable, unsupported to aid in testing the
194
220
    open and open_downlevel routines.
195
221
    """
196
222
 
198
224
        """See BzrDirFormat.get_format_string()."""
199
225
        return "Sample .bzr dir format."
200
226
 
201
 
    def initialize(self, url):
 
227
    def initialize_on_transport(self, t):
202
228
        """Create a bzr dir."""
203
 
        t = get_transport(url)
204
229
        t.mkdir('.bzr')
205
230
        t.put_bytes('.bzr/branch-format', self.get_format_string())
206
231
        return SampleBzrDir(t, self)
218
243
    def test_find_format(self):
219
244
        # is the right format object found for a branch?
220
245
        # create a branch with a few known format objects.
221
 
        # this is not quite the same as 
 
246
        # this is not quite the same as
222
247
        t = get_transport(self.get_url())
223
248
        self.build_tree(["foo/", "bar/"], transport=t)
224
249
        def check_format(format, url):
228
253
            self.failUnless(isinstance(found_format, format.__class__))
229
254
        check_format(bzrdir.BzrDirFormat5(), "foo")
230
255
        check_format(bzrdir.BzrDirFormat6(), "bar")
231
 
        
 
256
 
232
257
    def test_find_format_nothing_there(self):
233
258
        self.assertRaises(NotBranchError,
234
259
                          bzrdir.BzrDirFormat.find_format,
261
286
        # now open_downlevel should fail too.
262
287
        self.assertRaises(UnknownFormatError, bzrdir.BzrDir.open_unsupported, url)
263
288
 
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)
268
 
 
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())
273
 
 
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())
278
 
 
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'),
285
 
                                               format=format)
286
 
        self.assertTrue(isinstance(repo, repository.Repository))
287
 
        self.assertTrue(repo.bzrdir.root_transport.base.endswith('child/'))
288
 
 
289
289
    def test_create_branch_and_repo_uses_default(self):
290
290
        format = SampleBzrDirFormat()
291
 
        branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url(), 
 
291
        branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url(),
292
292
                                                      format=format)
293
293
        self.assertTrue(isinstance(branch, SampleBranch))
294
294
 
303
303
                          branch.bzrdir.open_repository)
304
304
 
305
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 
 
306
        # creating a branch and repo in a shared repo can be forced to
307
307
        # make a new repo
308
308
        format = bzrdir.format_registry.make_bzrdir('knit')
309
309
        self.make_repository('.', shared=True, format=format)
314
314
 
315
315
    def test_create_standalone_working_tree(self):
316
316
        format = SampleBzrDirFormat()
317
 
        # note this is deliberately readonly, as this failure should 
 
317
        # note this is deliberately readonly, as this failure should
318
318
        # occur before any writes.
319
319
        self.assertRaises(errors.NotLocalUrl,
320
320
                          bzrdir.BzrDir.create_standalone_workingtree,
321
321
                          self.get_readonly_url(), format=format)
322
 
        tree = bzrdir.BzrDir.create_standalone_workingtree('.', 
 
322
        tree = bzrdir.BzrDir.create_standalone_workingtree('.',
323
323
                                                           format=format)
324
324
        self.assertEqual('A tree', tree)
325
325
 
327
327
        # create standalone working tree always makes a repo.
328
328
        format = bzrdir.format_registry.make_bzrdir('knit')
329
329
        self.make_repository('.', shared=True, format=format)
330
 
        # note this is deliberately readonly, as this failure should 
 
330
        # note this is deliberately readonly, as this failure should
331
331
        # occur before any writes.
332
332
        self.assertRaises(errors.NotLocalUrl,
333
333
                          bzrdir.BzrDir.create_standalone_workingtree,
334
334
                          self.get_readonly_url('child'), format=format)
335
 
        tree = bzrdir.BzrDir.create_standalone_workingtree('child', 
 
335
        tree = bzrdir.BzrDir.create_standalone_workingtree('child',
336
336
            format=format)
337
337
        tree.bzrdir.open_repository()
338
338
 
343
343
        branch.bzrdir.open_workingtree()
344
344
        branch.bzrdir.open_repository()
345
345
 
 
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()
 
354
 
346
355
    def test_create_branch_convenience_root(self):
347
356
        """Creating a branch at the root of a fs should work."""
348
357
        self.vfs_transport_factory = MemoryServer
349
358
        # outside a repo the default convenience output is a repo+branch_tree
350
359
        format = bzrdir.format_registry.make_bzrdir('knit')
351
 
        branch = bzrdir.BzrDir.create_branch_convenience(self.get_url(), 
 
360
        branch = bzrdir.BzrDir.create_branch_convenience(self.get_url(),
352
361
                                                         format=format)
353
362
        self.assertRaises(errors.NoWorkingTree,
354
363
                          branch.bzrdir.open_workingtree)
364
373
        branch.bzrdir.open_workingtree()
365
374
        self.assertRaises(errors.NoRepositoryPresent,
366
375
                          branch.bzrdir.open_repository)
367
 
            
 
376
 
368
377
    def test_create_branch_convenience_under_shared_repo_force_no_tree(self):
369
378
        # inside a repo the default convenience output is a branch+ follow the
370
379
        # repo tree policy but we can override that
376
385
                          branch.bzrdir.open_workingtree)
377
386
        self.assertRaises(errors.NoRepositoryPresent,
378
387
                          branch.bzrdir.open_repository)
379
 
            
 
388
 
380
389
    def test_create_branch_convenience_under_shared_repo_no_tree_policy(self):
381
390
        # inside a repo the default convenience output is a branch+ follow the
382
391
        # repo tree policy
383
392
        format = bzrdir.format_registry.make_bzrdir('knit')
384
393
        repo = self.make_repository('.', shared=True, format=format)
385
394
        repo.set_make_working_trees(False)
386
 
        branch = bzrdir.BzrDir.create_branch_convenience('child', 
 
395
        branch = bzrdir.BzrDir.create_branch_convenience('child',
387
396
                                                         format=format)
388
397
        self.assertRaises(errors.NoWorkingTree,
389
398
                          branch.bzrdir.open_workingtree)
413
422
        branch.bzrdir.open_workingtree()
414
423
 
415
424
 
 
425
class TestRepositoryAcquisitionPolicy(TestCaseWithTransport):
 
426
 
 
427
    def test_acquire_repository_standalone(self):
 
428
        """The default acquisition policy should create a standalone branch."""
 
429
        my_bzrdir = self.make_bzrdir('.')
 
430
        repo_policy = my_bzrdir.determine_repository_policy()
 
431
        repo, is_new = repo_policy.acquire_repository()
 
432
        self.assertEqual(repo.bzrdir.root_transport.base,
 
433
                         my_bzrdir.root_transport.base)
 
434
        self.assertFalse(repo.is_shared())
 
435
 
 
436
    def test_determine_stacking_policy(self):
 
437
        parent_bzrdir = self.make_bzrdir('.')
 
438
        child_bzrdir = self.make_bzrdir('child')
 
439
        parent_bzrdir.get_config().set_default_stack_on('http://example.org')
 
440
        repo_policy = child_bzrdir.determine_repository_policy()
 
441
        self.assertEqual('http://example.org', repo_policy._stack_on)
 
442
 
 
443
    def test_determine_stacking_policy_relative(self):
 
444
        parent_bzrdir = self.make_bzrdir('.')
 
445
        child_bzrdir = self.make_bzrdir('child')
 
446
        parent_bzrdir.get_config().set_default_stack_on('child2')
 
447
        repo_policy = child_bzrdir.determine_repository_policy()
 
448
        self.assertEqual('child2', repo_policy._stack_on)
 
449
        self.assertEqual(parent_bzrdir.root_transport.base,
 
450
                         repo_policy._stack_on_pwd)
 
451
 
 
452
    def prepare_default_stacking(self, child_format='1.6'):
 
453
        parent_bzrdir = self.make_bzrdir('.')
 
454
        child_branch = self.make_branch('child', format=child_format)
 
455
        parent_bzrdir.get_config().set_default_stack_on(child_branch.base)
 
456
        new_child_transport = parent_bzrdir.transport.clone('child2')
 
457
        return child_branch, new_child_transport
 
458
 
 
459
    def test_clone_on_transport_obeys_stacking_policy(self):
 
460
        child_branch, new_child_transport = self.prepare_default_stacking()
 
461
        new_child = child_branch.bzrdir.clone_on_transport(new_child_transport)
 
462
        self.assertEqual(child_branch.base,
 
463
                         new_child.open_branch().get_stacked_on_url())
 
464
 
 
465
    def test_default_stacking_with_stackable_branch_unstackable_repo(self):
 
466
        # Make stackable source branch with an unstackable repo format.
 
467
        source_bzrdir = self.make_bzrdir('source')
 
468
        pack_repo.RepositoryFormatKnitPack1().initialize(source_bzrdir)
 
469
        source_branch = bzrlib.branch.BzrBranchFormat7().initialize(source_bzrdir)
 
470
        # Make a directory with a default stacking policy
 
471
        parent_bzrdir = self.make_bzrdir('parent')
 
472
        stacked_on = self.make_branch('parent/stacked-on', format='pack-0.92')
 
473
        parent_bzrdir.get_config().set_default_stack_on(stacked_on.base)
 
474
        # Clone source into directory
 
475
        target = source_bzrdir.clone(self.get_url('parent/target'))
 
476
 
 
477
    def test_sprout_obeys_stacking_policy(self):
 
478
        child_branch, new_child_transport = self.prepare_default_stacking()
 
479
        new_child = child_branch.bzrdir.sprout(new_child_transport.base)
 
480
        self.assertEqual(child_branch.base,
 
481
                         new_child.open_branch().get_stacked_on_url())
 
482
 
 
483
    def test_clone_ignores_policy_for_unsupported_formats(self):
 
484
        child_branch, new_child_transport = self.prepare_default_stacking(
 
485
            child_format='pack-0.92')
 
486
        new_child = child_branch.bzrdir.clone_on_transport(new_child_transport)
 
487
        self.assertRaises(errors.UnstackableBranchFormat,
 
488
                          new_child.open_branch().get_stacked_on_url)
 
489
 
 
490
    def test_sprout_ignores_policy_for_unsupported_formats(self):
 
491
        child_branch, new_child_transport = self.prepare_default_stacking(
 
492
            child_format='pack-0.92')
 
493
        new_child = child_branch.bzrdir.sprout(new_child_transport.base)
 
494
        self.assertRaises(errors.UnstackableBranchFormat,
 
495
                          new_child.open_branch().get_stacked_on_url)
 
496
 
 
497
    def test_sprout_upgrades_format_if_stacked_specified(self):
 
498
        child_branch, new_child_transport = self.prepare_default_stacking(
 
499
            child_format='pack-0.92')
 
500
        new_child = child_branch.bzrdir.sprout(new_child_transport.base,
 
501
                                               stacked=True)
 
502
        self.assertEqual(child_branch.bzrdir.root_transport.base,
 
503
                         new_child.open_branch().get_stacked_on_url())
 
504
        repo = new_child.open_repository()
 
505
        self.assertTrue(repo._format.supports_external_lookups)
 
506
        self.assertFalse(repo.supports_rich_root())
 
507
 
 
508
    def test_clone_on_transport_upgrades_format_if_stacked_on_specified(self):
 
509
        child_branch, new_child_transport = self.prepare_default_stacking(
 
510
            child_format='pack-0.92')
 
511
        new_child = child_branch.bzrdir.clone_on_transport(new_child_transport,
 
512
            stacked_on=child_branch.bzrdir.root_transport.base)
 
513
        self.assertEqual(child_branch.bzrdir.root_transport.base,
 
514
                         new_child.open_branch().get_stacked_on_url())
 
515
        repo = new_child.open_repository()
 
516
        self.assertTrue(repo._format.supports_external_lookups)
 
517
        self.assertFalse(repo.supports_rich_root())
 
518
 
 
519
    def test_sprout_upgrades_to_rich_root_format_if_needed(self):
 
520
        child_branch, new_child_transport = self.prepare_default_stacking(
 
521
            child_format='rich-root-pack')
 
522
        new_child = child_branch.bzrdir.sprout(new_child_transport.base,
 
523
                                               stacked=True)
 
524
        repo = new_child.open_repository()
 
525
        self.assertTrue(repo._format.supports_external_lookups)
 
526
        self.assertTrue(repo.supports_rich_root())
 
527
 
 
528
    def test_add_fallback_repo_handles_absolute_urls(self):
 
529
        stack_on = self.make_branch('stack_on', format='1.6')
 
530
        repo = self.make_repository('repo', format='1.6')
 
531
        policy = bzrdir.UseExistingRepository(repo, stack_on.base)
 
532
        policy._add_fallback(repo)
 
533
 
 
534
    def test_add_fallback_repo_handles_relative_urls(self):
 
535
        stack_on = self.make_branch('stack_on', format='1.6')
 
536
        repo = self.make_repository('repo', format='1.6')
 
537
        policy = bzrdir.UseExistingRepository(repo, '.', stack_on.base)
 
538
        policy._add_fallback(repo)
 
539
 
 
540
    def test_configure_relative_branch_stacking_url(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
            '.', stack_on.base)
 
545
        policy.configure_branch(stacked)
 
546
        self.assertEqual('..', stacked.get_stacked_on_url())
 
547
 
 
548
    def test_relative_branch_stacking_to_absolute(self):
 
549
        stack_on = self.make_branch('stack_on', format='1.6')
 
550
        stacked = self.make_branch('stack_on/stacked', format='1.6')
 
551
        policy = bzrdir.UseExistingRepository(stacked.repository,
 
552
            '.', self.get_readonly_url('stack_on'))
 
553
        policy.configure_branch(stacked)
 
554
        self.assertEqual(self.get_readonly_url('stack_on'),
 
555
                         stacked.get_stacked_on_url())
 
556
 
 
557
 
416
558
class ChrootedTests(TestCaseWithTransport):
417
559
    """A support class that provides readonly urls outside the local namespace.
418
560
 
424
566
    def setUp(self):
425
567
        super(ChrootedTests, self).setUp()
426
568
        if not self.vfs_transport_factory == MemoryServer:
427
 
            self.transport_readonly_server = HttpServer
 
569
            self.transport_readonly_server = http_server.HttpServer
 
570
 
 
571
    def local_branch_path(self, branch):
 
572
         return os.path.realpath(urlutils.local_path_from_url(branch.base))
428
573
 
429
574
    def test_open_containing(self):
430
575
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing,
437
582
        branch, relpath = bzrdir.BzrDir.open_containing(self.get_readonly_url('g/p/q'))
438
583
        self.assertEqual('g/p/q', relpath)
439
584
 
 
585
    def test_open_containing_tree_branch_or_repository_empty(self):
 
586
        self.assertRaises(errors.NotBranchError,
 
587
            bzrdir.BzrDir.open_containing_tree_branch_or_repository,
 
588
            self.get_readonly_url(''))
 
589
 
 
590
    def test_open_containing_tree_branch_or_repository_all(self):
 
591
        self.make_branch_and_tree('topdir')
 
592
        tree, branch, repo, relpath = \
 
593
            bzrdir.BzrDir.open_containing_tree_branch_or_repository(
 
594
                'topdir/foo')
 
595
        self.assertEqual(os.path.realpath('topdir'),
 
596
                         os.path.realpath(tree.basedir))
 
597
        self.assertEqual(os.path.realpath('topdir'),
 
598
                         self.local_branch_path(branch))
 
599
        self.assertEqual(
 
600
            osutils.realpath(os.path.join('topdir', '.bzr', 'repository')),
 
601
            repo.bzrdir.transport.local_abspath('repository'))
 
602
        self.assertEqual(relpath, 'foo')
 
603
 
 
604
    def test_open_containing_tree_branch_or_repository_no_tree(self):
 
605
        self.make_branch('branch')
 
606
        tree, branch, repo, relpath = \
 
607
            bzrdir.BzrDir.open_containing_tree_branch_or_repository(
 
608
                'branch/foo')
 
609
        self.assertEqual(tree, None)
 
610
        self.assertEqual(os.path.realpath('branch'),
 
611
                         self.local_branch_path(branch))
 
612
        self.assertEqual(
 
613
            osutils.realpath(os.path.join('branch', '.bzr', 'repository')),
 
614
            repo.bzrdir.transport.local_abspath('repository'))
 
615
        self.assertEqual(relpath, 'foo')
 
616
 
 
617
    def test_open_containing_tree_branch_or_repository_repo(self):
 
618
        self.make_repository('repo')
 
619
        tree, branch, repo, relpath = \
 
620
            bzrdir.BzrDir.open_containing_tree_branch_or_repository(
 
621
                'repo')
 
622
        self.assertEqual(tree, None)
 
623
        self.assertEqual(branch, None)
 
624
        self.assertEqual(
 
625
            osutils.realpath(os.path.join('repo', '.bzr', 'repository')),
 
626
            repo.bzrdir.transport.local_abspath('repository'))
 
627
        self.assertEqual(relpath, '')
 
628
 
 
629
    def test_open_containing_tree_branch_or_repository_shared_repo(self):
 
630
        self.make_repository('shared', shared=True)
 
631
        bzrdir.BzrDir.create_branch_convenience('shared/branch',
 
632
                                                force_new_tree=False)
 
633
        tree, branch, repo, relpath = \
 
634
            bzrdir.BzrDir.open_containing_tree_branch_or_repository(
 
635
                'shared/branch')
 
636
        self.assertEqual(tree, None)
 
637
        self.assertEqual(os.path.realpath('shared/branch'),
 
638
                         self.local_branch_path(branch))
 
639
        self.assertEqual(
 
640
            osutils.realpath(os.path.join('shared', '.bzr', 'repository')),
 
641
            repo.bzrdir.transport.local_abspath('repository'))
 
642
        self.assertEqual(relpath, '')
 
643
 
 
644
    def test_open_containing_tree_branch_or_repository_branch_subdir(self):
 
645
        self.make_branch_and_tree('foo')
 
646
        self.build_tree(['foo/bar/'])
 
647
        tree, branch, repo, relpath = \
 
648
            bzrdir.BzrDir.open_containing_tree_branch_or_repository(
 
649
                'foo/bar')
 
650
        self.assertEqual(os.path.realpath('foo'),
 
651
                         os.path.realpath(tree.basedir))
 
652
        self.assertEqual(os.path.realpath('foo'),
 
653
                         self.local_branch_path(branch))
 
654
        self.assertEqual(
 
655
            osutils.realpath(os.path.join('foo', '.bzr', 'repository')),
 
656
            repo.bzrdir.transport.local_abspath('repository'))
 
657
        self.assertEqual(relpath, 'bar')
 
658
 
 
659
    def test_open_containing_tree_branch_or_repository_repo_subdir(self):
 
660
        self.make_repository('bar')
 
661
        self.build_tree(['bar/baz/'])
 
662
        tree, branch, repo, relpath = \
 
663
            bzrdir.BzrDir.open_containing_tree_branch_or_repository(
 
664
                'bar/baz')
 
665
        self.assertEqual(tree, None)
 
666
        self.assertEqual(branch, None)
 
667
        self.assertEqual(
 
668
            osutils.realpath(os.path.join('bar', '.bzr', 'repository')),
 
669
            repo.bzrdir.transport.local_abspath('repository'))
 
670
        self.assertEqual(relpath, 'baz')
 
671
 
440
672
    def test_open_containing_from_transport(self):
441
673
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing_from_transport,
442
674
                          get_transport(self.get_readonly_url('')))
451
683
        self.assertEqual('g/p/q', relpath)
452
684
 
453
685
    def test_open_containing_tree_or_branch(self):
454
 
        def local_branch_path(branch):
455
 
             return os.path.realpath(
456
 
                urlutils.local_path_from_url(branch.base))
457
 
 
458
686
        self.make_branch_and_tree('topdir')
459
687
        tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
460
688
            'topdir/foo')
461
689
        self.assertEqual(os.path.realpath('topdir'),
462
690
                         os.path.realpath(tree.basedir))
463
691
        self.assertEqual(os.path.realpath('topdir'),
464
 
                         local_branch_path(branch))
 
692
                         self.local_branch_path(branch))
465
693
        self.assertIs(tree.bzrdir, branch.bzrdir)
466
694
        self.assertEqual('foo', relpath)
467
695
        # opening from non-local should not return the tree
475
703
            'topdir/foo')
476
704
        self.assertIs(tree, None)
477
705
        self.assertEqual(os.path.realpath('topdir/foo'),
478
 
                         local_branch_path(branch))
 
706
                         self.local_branch_path(branch))
479
707
        self.assertEqual('', relpath)
480
708
 
 
709
    def test_open_tree_or_branch(self):
 
710
        self.make_branch_and_tree('topdir')
 
711
        tree, branch = bzrdir.BzrDir.open_tree_or_branch('topdir')
 
712
        self.assertEqual(os.path.realpath('topdir'),
 
713
                         os.path.realpath(tree.basedir))
 
714
        self.assertEqual(os.path.realpath('topdir'),
 
715
                         self.local_branch_path(branch))
 
716
        self.assertIs(tree.bzrdir, branch.bzrdir)
 
717
        # opening from non-local should not return the tree
 
718
        tree, branch = bzrdir.BzrDir.open_tree_or_branch(
 
719
            self.get_readonly_url('topdir'))
 
720
        self.assertEqual(None, tree)
 
721
        # without a tree:
 
722
        self.make_branch('topdir/foo')
 
723
        tree, branch = bzrdir.BzrDir.open_tree_or_branch('topdir/foo')
 
724
        self.assertIs(tree, None)
 
725
        self.assertEqual(os.path.realpath('topdir/foo'),
 
726
                         self.local_branch_path(branch))
 
727
 
481
728
    def test_open_from_transport(self):
482
729
        # transport pointing at bzrdir should give a bzrdir with root transport
483
730
        # set to the given transport
486
733
        opened_bzrdir = bzrdir.BzrDir.open_from_transport(transport)
487
734
        self.assertEqual(transport.base, opened_bzrdir.root_transport.base)
488
735
        self.assertIsInstance(opened_bzrdir, bzrdir.BzrDir)
489
 
        
 
736
 
490
737
    def test_open_from_transport_no_bzrdir(self):
491
738
        transport = get_transport(self.get_url())
492
739
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport,
501
748
                          transport)
502
749
 
503
750
    def test_sprout_recursive(self):
504
 
        tree = self.make_branch_and_tree('tree1', format='dirstate-with-subtree')
 
751
        tree = self.make_branch_and_tree('tree1',
 
752
                                         format='dirstate-with-subtree')
505
753
        sub_tree = self.make_branch_and_tree('tree1/subtree',
506
754
            format='dirstate-with-subtree')
 
755
        sub_tree.set_root_id('subtree-root')
507
756
        tree.add_reference(sub_tree)
508
757
        self.build_tree(['tree1/subtree/file'])
509
758
        sub_tree.add('file')
510
759
        tree.commit('Initial commit')
511
 
        tree.bzrdir.sprout('tree2')
 
760
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
 
761
        tree2.lock_read()
 
762
        self.addCleanup(tree2.unlock)
512
763
        self.failUnlessExists('tree2/subtree/file')
 
764
        self.assertEqual('tree-reference', tree2.kind('subtree-root'))
513
765
 
514
766
    def test_cloning_metadir(self):
515
767
        """Ensure that cloning metadir is suitable"""
537
789
        self.failUnlessExists('repo/tree2/subtree')
538
790
        self.failIfExists('repo/tree2/subtree/file')
539
791
 
 
792
    def make_foo_bar_baz(self):
 
793
        foo = bzrdir.BzrDir.create_branch_convenience('foo').bzrdir
 
794
        bar = self.make_branch('foo/bar').bzrdir
 
795
        baz = self.make_branch('baz').bzrdir
 
796
        return foo, bar, baz
 
797
 
 
798
    def test_find_bzrdirs(self):
 
799
        foo, bar, baz = self.make_foo_bar_baz()
 
800
        transport = get_transport(self.get_url())
 
801
        self.assertEqualBzrdirs([baz, foo, bar],
 
802
                                bzrdir.BzrDir.find_bzrdirs(transport))
 
803
 
 
804
    def test_find_bzrdirs_list_current(self):
 
805
        def list_current(transport):
 
806
            return [s for s in transport.list_dir('') if s != 'baz']
 
807
 
 
808
        foo, bar, baz = self.make_foo_bar_baz()
 
809
        transport = get_transport(self.get_url())
 
810
        self.assertEqualBzrdirs([foo, bar],
 
811
                                bzrdir.BzrDir.find_bzrdirs(transport,
 
812
                                    list_current=list_current))
 
813
 
 
814
 
 
815
    def test_find_bzrdirs_evaluate(self):
 
816
        def evaluate(bzrdir):
 
817
            try:
 
818
                repo = bzrdir.open_repository()
 
819
            except NoRepositoryPresent:
 
820
                return True, bzrdir.root_transport.base
 
821
            else:
 
822
                return False, bzrdir.root_transport.base
 
823
 
 
824
        foo, bar, baz = self.make_foo_bar_baz()
 
825
        transport = get_transport(self.get_url())
 
826
        self.assertEqual([baz.root_transport.base, foo.root_transport.base],
 
827
                         list(bzrdir.BzrDir.find_bzrdirs(transport,
 
828
                                                         evaluate=evaluate)))
 
829
 
 
830
    def assertEqualBzrdirs(self, first, second):
 
831
        first = list(first)
 
832
        second = list(second)
 
833
        self.assertEqual(len(first), len(second))
 
834
        for x, y in zip(first, second):
 
835
            self.assertEqual(x.root_transport.base, y.root_transport.base)
 
836
 
 
837
    def test_find_branches(self):
 
838
        root = self.make_repository('', shared=True)
 
839
        foo, bar, baz = self.make_foo_bar_baz()
 
840
        qux = self.make_bzrdir('foo/qux')
 
841
        transport = get_transport(self.get_url())
 
842
        branches = bzrdir.BzrDir.find_branches(transport)
 
843
        self.assertEqual(baz.root_transport.base, branches[0].base)
 
844
        self.assertEqual(foo.root_transport.base, branches[1].base)
 
845
        self.assertEqual(bar.root_transport.base, branches[2].base)
 
846
 
 
847
        # ensure this works without a top-level repo
 
848
        branches = bzrdir.BzrDir.find_branches(transport.clone('foo'))
 
849
        self.assertEqual(foo.root_transport.base, branches[0].base)
 
850
        self.assertEqual(bar.root_transport.base, branches[1].base)
 
851
 
540
852
 
541
853
class TestMeta1DirFormat(TestCaseWithTransport):
542
854
    """Tests specific to the meta1 dir format."""
581
893
 
582
894
    def test_needs_conversion_different_working_tree(self):
583
895
        # meta1dirs need an conversion if any element is not the default.
584
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
585
 
        # test with 
586
 
        new_default = bzrdir.format_registry.make_bzrdir('dirstate')
587
 
        bzrdir.BzrDirFormat._set_default_format(new_default)
588
 
        try:
589
 
            tree = self.make_branch_and_tree('tree', format='knit')
590
 
            self.assertTrue(tree.bzrdir.needs_format_conversion())
591
 
        finally:
592
 
            bzrdir.BzrDirFormat._set_default_format(old_format)
 
896
        new_format = bzrdir.format_registry.make_bzrdir('dirstate')
 
897
        tree = self.make_branch_and_tree('tree', format='knit')
 
898
        self.assertTrue(tree.bzrdir.needs_format_conversion(
 
899
            new_format))
 
900
 
 
901
    def test_initialize_on_format_uses_smart_transport(self):
 
902
        self.setup_smart_server_with_call_log()
 
903
        new_format = bzrdir.format_registry.make_bzrdir('dirstate')
 
904
        transport = self.get_transport('target')
 
905
        transport.ensure_base()
 
906
        self.reset_smart_call_log()
 
907
        instance = new_format.initialize_on_transport(transport)
 
908
        self.assertIsInstance(instance, remote.RemoteBzrDir)
 
909
        rpc_count = len(self.hpss_calls)
 
910
        # This figure represent the amount of work to perform this use case. It
 
911
        # is entirely ok to reduce this number if a test fails due to rpc_count
 
912
        # being too low. If rpc_count increases, more network roundtrips have
 
913
        # become necessary for this use case. Please do not adjust this number
 
914
        # upwards without agreement from bzr's network support maintainers.
 
915
        self.assertEqual(2, rpc_count)
593
916
 
594
917
 
595
918
class TestFormat5(TestCaseWithTransport):
596
919
    """Tests specific to the version 5 bzrdir format."""
597
920
 
598
921
    def test_same_lockfiles_between_tree_repo_branch(self):
599
 
        # this checks that only a single lockfiles instance is created 
 
922
        # this checks that only a single lockfiles instance is created
600
923
        # for format 5 objects
601
924
        dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
602
925
        def check_dir_components_use_same_lock(dir):
609
932
        # and if we open it normally.
610
933
        dir = bzrdir.BzrDir.open(self.get_url())
611
934
        check_dir_components_use_same_lock(dir)
612
 
    
 
935
 
613
936
    def test_can_convert(self):
614
937
        # format 5 dirs are convertable
615
938
        dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
616
939
        self.assertTrue(dir.can_convert_format())
617
 
    
 
940
 
618
941
    def test_needs_conversion(self):
619
 
        # format 5 dirs need a conversion if they are not the default.
620
 
        # and they start of not the default.
621
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
622
 
        bzrdir.BzrDirFormat._set_default_format(bzrdir.BzrDirFormat5())
623
 
        try:
624
 
            dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
625
 
            self.assertFalse(dir.needs_format_conversion())
626
 
        finally:
627
 
            bzrdir.BzrDirFormat._set_default_format(old_format)
628
 
        self.assertTrue(dir.needs_format_conversion())
 
942
        # format 5 dirs need a conversion if they are not the default,
 
943
        # and they aren't
 
944
        dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
 
945
        # don't need to convert it to itself
 
946
        self.assertFalse(dir.needs_format_conversion(bzrdir.BzrDirFormat5()))
 
947
        # do need to convert it to the current default
 
948
        self.assertTrue(dir.needs_format_conversion(
 
949
            bzrdir.BzrDirFormat.get_default_format()))
629
950
 
630
951
 
631
952
class TestFormat6(TestCaseWithTransport):
632
953
    """Tests specific to the version 6 bzrdir format."""
633
954
 
634
955
    def test_same_lockfiles_between_tree_repo_branch(self):
635
 
        # this checks that only a single lockfiles instance is created 
 
956
        # this checks that only a single lockfiles instance is created
636
957
        # for format 6 objects
637
958
        dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
638
959
        def check_dir_components_use_same_lock(dir):
645
966
        # and if we open it normally.
646
967
        dir = bzrdir.BzrDir.open(self.get_url())
647
968
        check_dir_components_use_same_lock(dir)
648
 
    
 
969
 
649
970
    def test_can_convert(self):
650
971
        # format 6 dirs are convertable
651
972
        dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
652
973
        self.assertTrue(dir.can_convert_format())
653
 
    
 
974
 
654
975
    def test_needs_conversion(self):
655
976
        # format 6 dirs need an conversion if they are not the default.
656
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
657
 
        bzrdir.BzrDirFormat._set_default_format(bzrdir.BzrDirMetaFormat1())
658
 
        try:
659
 
            dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
660
 
            self.assertTrue(dir.needs_format_conversion())
661
 
        finally:
662
 
            bzrdir.BzrDirFormat._set_default_format(old_format)
 
977
        dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
 
978
        self.assertTrue(dir.needs_format_conversion(
 
979
            bzrdir.BzrDirFormat.get_default_format()))
663
980
 
664
981
 
665
982
class NotBzrDir(bzrlib.bzrdir.BzrDir):
696
1013
 
697
1014
class TestNotBzrDir(TestCaseWithTransport):
698
1015
    """Tests for using the bzrdir api with a non .bzr based disk format.
699
 
    
 
1016
 
700
1017
    If/when one of these is in the core, we can let the implementation tests
701
1018
    verify this works.
702
1019
    """
703
1020
 
704
1021
    def test_create_and_find_format(self):
705
 
        # create a .notbzr dir 
 
1022
        # create a .notbzr dir
706
1023
        format = NotBzrDirFormat()
707
1024
        dir = format.initialize(self.get_url())
708
1025
        self.assertIsInstance(dir, NotBzrDir)
733
1050
    def setUp(self):
734
1051
        super(NonLocalTests, self).setUp()
735
1052
        self.vfs_transport_factory = MemoryServer
736
 
    
 
1053
 
737
1054
    def test_create_branch_convenience(self):
738
1055
        # outside a repo the default convenience output is a repo+branch_tree
739
1056
        format = bzrdir.format_registry.make_bzrdir('knit')
776
1093
                              workingtree.WorkingTreeFormat3)
777
1094
 
778
1095
 
779
 
class TestHTTPRedirectionLoop(object):
780
 
    """Test redirection loop between two http servers.
 
1096
class TestHTTPRedirections(object):
 
1097
    """Test redirection between two http servers.
781
1098
 
782
1099
    This MUST be used by daughter classes that also inherit from
783
1100
    TestCaseWithTwoWebservers.
784
1101
 
785
1102
    We can't inherit directly from TestCaseWithTwoWebservers or the
786
1103
    test framework will try to create an instance which cannot
787
 
    run, its implementation being incomplete. 
 
1104
    run, its implementation being incomplete.
788
1105
    """
789
1106
 
790
 
    # Should be defined by daughter classes to ensure redirection
791
 
    # still use the same transport implementation (not currently
792
 
    # enforced as it's a bit tricky to get right (see the FIXME
793
 
    # in BzrDir.open_from_transport for the unique use case so
794
 
    # far)
795
 
    _qualifier = None
796
 
 
797
1107
    def create_transport_readonly_server(self):
798
 
        return HTTPServerRedirecting()
 
1108
        return http_utils.HTTPServerRedirecting()
799
1109
 
800
1110
    def create_transport_secondary_server(self):
801
 
        return HTTPServerRedirecting()
 
1111
        return http_utils.HTTPServerRedirecting()
802
1112
 
803
1113
    def setUp(self):
804
 
        # Both servers redirect to each server creating a loop
805
 
        super(TestHTTPRedirectionLoop, self).setUp()
 
1114
        super(TestHTTPRedirections, self).setUp()
806
1115
        # The redirections will point to the new server
807
1116
        self.new_server = self.get_readonly_server()
808
1117
        # The requests to the old server will be redirected
809
1118
        self.old_server = self.get_secondary_server()
810
1119
        # Configure the redirections
811
1120
        self.old_server.redirect_to(self.new_server.host, self.new_server.port)
 
1121
 
 
1122
    def test_loop(self):
 
1123
        # Both servers redirect to each other creating a loop
812
1124
        self.new_server.redirect_to(self.old_server.host, self.old_server.port)
813
 
 
814
 
    def _qualified_url(self, host, port):
815
 
        return 'http+%s://%s:%s' % (self._qualifier, host, port)
816
 
 
817
 
    def test_loop(self):
818
1125
        # Starting from either server should loop
819
 
        old_url = self._qualified_url(self.old_server.host, 
 
1126
        old_url = self._qualified_url(self.old_server.host,
820
1127
                                      self.old_server.port)
821
1128
        oldt = self._transport(old_url)
822
1129
        self.assertRaises(errors.NotBranchError,
823
1130
                          bzrdir.BzrDir.open_from_transport, oldt)
824
 
        new_url = self._qualified_url(self.new_server.host, 
 
1131
        new_url = self._qualified_url(self.new_server.host,
825
1132
                                      self.new_server.port)
826
1133
        newt = self._transport(new_url)
827
1134
        self.assertRaises(errors.NotBranchError,
828
1135
                          bzrdir.BzrDir.open_from_transport, newt)
829
1136
 
830
 
 
831
 
class TestHTTPRedirections_urllib(TestHTTPRedirectionLoop,
832
 
                                  TestCaseWithTwoWebservers):
 
1137
    def test_qualifier_preserved(self):
 
1138
        wt = self.make_branch_and_tree('branch')
 
1139
        old_url = self._qualified_url(self.old_server.host,
 
1140
                                      self.old_server.port)
 
1141
        start = self._transport(old_url).clone('branch')
 
1142
        bdir = bzrdir.BzrDir.open_from_transport(start)
 
1143
        # Redirection should preserve the qualifier, hence the transport class
 
1144
        # itself.
 
1145
        self.assertIsInstance(bdir.root_transport, type(start))
 
1146
 
 
1147
 
 
1148
class TestHTTPRedirections_urllib(TestHTTPRedirections,
 
1149
                                  http_utils.TestCaseWithTwoWebservers):
833
1150
    """Tests redirections for urllib implementation"""
834
1151
 
835
 
    _qualifier = 'urllib'
836
1152
    _transport = HttpTransport_urllib
837
1153
 
 
1154
    def _qualified_url(self, host, port):
 
1155
        return 'http+urllib://%s:%s' % (host, port)
 
1156
 
838
1157
 
839
1158
 
840
1159
class TestHTTPRedirections_pycurl(TestWithTransport_pycurl,
841
 
                                  TestHTTPRedirectionLoop,
842
 
                                  TestCaseWithTwoWebservers):
 
1160
                                  TestHTTPRedirections,
 
1161
                                  http_utils.TestCaseWithTwoWebservers):
843
1162
    """Tests redirections for pycurl implementation"""
844
1163
 
845
 
    _qualifier = 'pycurl'
 
1164
    def _qualified_url(self, host, port):
 
1165
        return 'http+pycurl://%s:%s' % (host, port)
 
1166
 
 
1167
 
 
1168
class TestHTTPRedirections_nosmart(TestHTTPRedirections,
 
1169
                                  http_utils.TestCaseWithTwoWebservers):
 
1170
    """Tests redirections for the nosmart decorator"""
 
1171
 
 
1172
    _transport = NoSmartTransportDecorator
 
1173
 
 
1174
    def _qualified_url(self, host, port):
 
1175
        return 'nosmart+http://%s:%s' % (host, port)
 
1176
 
 
1177
 
 
1178
class TestHTTPRedirections_readonly(TestHTTPRedirections,
 
1179
                                    http_utils.TestCaseWithTwoWebservers):
 
1180
    """Tests redirections for readonly decoratror"""
 
1181
 
 
1182
    _transport = ReadonlyTransportDecorator
 
1183
 
 
1184
    def _qualified_url(self, host, port):
 
1185
        return 'readonly+http://%s:%s' % (host, port)
 
1186
 
 
1187
 
 
1188
class TestDotBzrHidden(TestCaseWithTransport):
 
1189
 
 
1190
    ls = ['ls']
 
1191
    if sys.platform == 'win32':
 
1192
        ls = [os.environ['COMSPEC'], '/C', 'dir', '/B']
 
1193
 
 
1194
    def get_ls(self):
 
1195
        f = subprocess.Popen(self.ls, stdout=subprocess.PIPE,
 
1196
            stderr=subprocess.PIPE)
 
1197
        out, err = f.communicate()
 
1198
        self.assertEqual(0, f.returncode, 'Calling %s failed: %s'
 
1199
                         % (self.ls, err))
 
1200
        return out.splitlines()
 
1201
 
 
1202
    def test_dot_bzr_hidden(self):
 
1203
        if sys.platform == 'win32' and not win32utils.has_win32file:
 
1204
            raise TestSkipped('unable to make file hidden without pywin32 library')
 
1205
        b = bzrdir.BzrDir.create('.')
 
1206
        self.build_tree(['a'])
 
1207
        self.assertEquals(['a'], self.get_ls())
 
1208
 
 
1209
    def test_dot_bzr_hidden_with_url(self):
 
1210
        if sys.platform == 'win32' and not win32utils.has_win32file:
 
1211
            raise TestSkipped('unable to make file hidden without pywin32 library')
 
1212
        b = bzrdir.BzrDir.create(urlutils.local_path_to_url('.'))
 
1213
        self.build_tree(['a'])
 
1214
        self.assertEquals(['a'], self.get_ls())
 
1215
 
 
1216
 
 
1217
class _TestBzrDirFormat(bzrdir.BzrDirMetaFormat1):
 
1218
    """Test BzrDirFormat implementation for TestBzrDirSprout."""
 
1219
 
 
1220
    def _open(self, transport):
 
1221
        return _TestBzrDir(transport, self)
 
1222
 
 
1223
 
 
1224
class _TestBzrDir(bzrdir.BzrDirMeta1):
 
1225
    """Test BzrDir implementation for TestBzrDirSprout.
 
1226
 
 
1227
    When created a _TestBzrDir already has repository and a branch.  The branch
 
1228
    is a test double as well.
 
1229
    """
 
1230
 
 
1231
    def __init__(self, *args, **kwargs):
 
1232
        super(_TestBzrDir, self).__init__(*args, **kwargs)
 
1233
        self.test_branch = _TestBranch()
 
1234
        self.test_branch.repository = self.create_repository()
 
1235
 
 
1236
    def open_branch(self, unsupported=False):
 
1237
        return self.test_branch
 
1238
 
 
1239
    def cloning_metadir(self, require_stacking=False):
 
1240
        return _TestBzrDirFormat()
 
1241
 
 
1242
 
 
1243
class _TestBranchFormat(bzrlib.branch.BranchFormat):
 
1244
    """Test Branch format for TestBzrDirSprout."""
 
1245
 
 
1246
 
 
1247
class _TestBranch(bzrlib.branch.Branch):
 
1248
    """Test Branch implementation for TestBzrDirSprout."""
 
1249
 
 
1250
    def __init__(self, *args, **kwargs):
 
1251
        self._format = _TestBranchFormat()
 
1252
        super(_TestBranch, self).__init__(*args, **kwargs)
 
1253
        self.calls = []
 
1254
        self._parent = None
 
1255
 
 
1256
    def sprout(self, *args, **kwargs):
 
1257
        self.calls.append('sprout')
 
1258
        return _TestBranch()
 
1259
 
 
1260
    def copy_content_into(self, destination, revision_id=None):
 
1261
        self.calls.append('copy_content_into')
 
1262
 
 
1263
    def get_parent(self):
 
1264
        return self._parent
 
1265
 
 
1266
    def set_parent(self, parent):
 
1267
        self._parent = parent
 
1268
 
 
1269
 
 
1270
class TestBzrDirSprout(TestCaseWithMemoryTransport):
 
1271
 
 
1272
    def test_sprout_uses_branch_sprout(self):
 
1273
        """BzrDir.sprout calls Branch.sprout.
 
1274
 
 
1275
        Usually, BzrDir.sprout should delegate to the branch's sprout method
 
1276
        for part of the work.  This allows the source branch to control the
 
1277
        choice of format for the new branch.
 
1278
 
 
1279
        There are exceptions, but this tests avoids them:
 
1280
          - if there's no branch in the source bzrdir,
 
1281
          - or if the stacking has been requested and the format needs to be
 
1282
            overridden to satisfy that.
 
1283
        """
 
1284
        # Make an instrumented bzrdir.
 
1285
        t = self.get_transport('source')
 
1286
        t.ensure_base()
 
1287
        source_bzrdir = _TestBzrDirFormat().initialize_on_transport(t)
 
1288
        # The instrumented bzrdir has a test_branch attribute that logs calls
 
1289
        # made to the branch contained in that bzrdir.  Initially the test
 
1290
        # branch exists but no calls have been made to it.
 
1291
        self.assertEqual([], source_bzrdir.test_branch.calls)
 
1292
 
 
1293
        # Sprout the bzrdir
 
1294
        target_url = self.get_url('target')
 
1295
        result = source_bzrdir.sprout(target_url, recurse='no')
 
1296
 
 
1297
        # The bzrdir called the branch's sprout method.
 
1298
        self.assertSubset(['sprout'], source_bzrdir.test_branch.calls)
 
1299
 
 
1300
    def test_sprout_parent(self):
 
1301
        grandparent_tree = self.make_branch('grandparent')
 
1302
        parent = grandparent_tree.bzrdir.sprout('parent').open_branch()
 
1303
        branch_tree = parent.bzrdir.sprout('branch').open_branch()
 
1304
        self.assertContainsRe(branch_tree.get_parent(), '/parent/$')
 
1305
 
 
1306
 
 
1307
class TestBzrDirHooks(TestCaseWithMemoryTransport):
 
1308
 
 
1309
    def test_pre_open_called(self):
 
1310
        calls = []
 
1311
        bzrdir.BzrDir.hooks.install_named_hook('pre_open', calls.append, None)
 
1312
        transport = self.get_transport('foo')
 
1313
        url = transport.base
 
1314
        self.assertRaises(errors.NotBranchError, bzrdir.BzrDir.open, url)
 
1315
        self.assertEqual([transport.base], [t.base for t in calls])
 
1316
 
 
1317
    def test_pre_open_actual_exceptions_raised(self):
 
1318
        count = [0]
 
1319
        def fail_once(transport):
 
1320
            count[0] += 1
 
1321
            if count[0] == 1:
 
1322
                raise errors.BzrError("fail")
 
1323
        bzrdir.BzrDir.hooks.install_named_hook('pre_open', fail_once, None)
 
1324
        transport = self.get_transport('foo')
 
1325
        url = transport.base
 
1326
        err = self.assertRaises(errors.BzrError, bzrdir.BzrDir.open, url)
 
1327
        self.assertEqual('fail', err._preformatted_string)