← 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: Ian Clatworthy
  • Date: 2009-09-09 11:43:10 UTC
  • mto: (4634.37.2 prepare-2.0)
  • mto: This revision was merged to the branch mainline in revision 4689.
  • Revision ID: ian.clatworthy@canonical.com-20090909114310-glw7tv76i5gnx9pt
put rules back in Makefile supporting plain-style docs

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_bzrdir.py
1
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
 
# 
 
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
 
For interface contract tests, see tests/bzr_dir_implementations.
 
19
For interface contract tests, see tests/per_bzr_dir.
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
36
39
                           UnknownFormatError,
37
40
                           UnsupportedFormatError,
38
41
                           )
39
 
from bzrlib.symbol_versioning import (
40
 
    zero_ninetyone,
41
 
    )
42
42
from bzrlib.tests import (
43
43
    TestCase,
 
44
    TestCaseWithMemoryTransport,
44
45
    TestCaseWithTransport,
45
 
    test_sftp_transport
 
46
    TestSkipped,
46
47
    )
47
 
from bzrlib.tests.HttpServer import HttpServer
48
 
from bzrlib.tests.HTTPTestUtil import (
49
 
    TestCaseWithTwoWebservers,
50
 
    HTTPServerRedirecting,
 
48
from bzrlib.tests import(
 
49
    http_server,
 
50
    http_utils,
51
51
    )
52
52
from bzrlib.tests.test_http import TestWithTransport_pycurl
53
53
from bzrlib.transport import get_transport
54
54
from bzrlib.transport.http._urllib import HttpTransport_urllib
55
55
from bzrlib.transport.memory import MemoryServer
56
 
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
57
59
 
58
60
 
59
61
class TestDefaultFormat(TestCase):
62
64
        old_format = bzrdir.BzrDirFormat.get_default_format()
63
65
        # default is BzrDirFormat6
64
66
        self.failUnless(isinstance(old_format, bzrdir.BzrDirMetaFormat1))
65
 
        self.applyDeprecated(symbol_versioning.zero_fourteen, 
66
 
                             bzrdir.BzrDirFormat.set_default_format, 
67
 
                             SampleBzrDirFormat())
 
67
        bzrdir.BzrDirFormat._set_default_format(SampleBzrDirFormat())
68
68
        # creating a bzr dir should now create an instrumented dir.
69
69
        try:
70
70
            result = bzrdir.BzrDir.create('memory:///')
71
71
            self.failUnless(isinstance(result, SampleBzrDir))
72
72
        finally:
73
 
            self.applyDeprecated(symbol_versioning.zero_fourteen,
74
 
                bzrdir.BzrDirFormat.set_default_format, old_format)
 
73
            bzrdir.BzrDirFormat._set_default_format(old_format)
75
74
        self.assertEqual(old_format, bzrdir.BzrDirFormat.get_default_format())
76
75
 
77
76
 
82
81
        my_format_registry.register('weave', bzrdir.BzrDirFormat6,
83
82
            'Pre-0.8 format.  Slower and does not support checkouts or shared'
84
83
            ' repositories', deprecated=True)
85
 
        my_format_registry.register_lazy('lazy', 'bzrlib.bzrdir', 
 
84
        my_format_registry.register_lazy('lazy', 'bzrlib.bzrdir',
86
85
            'BzrDirFormat6', 'Format registered lazily', deprecated=True)
87
86
        my_format_registry.register_metadir('knit',
88
87
            'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
93
92
            'branch6',
94
93
            'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
95
94
            'Experimental successor to knit.  Use at your own risk.',
96
 
            branch_format='bzrlib.branch.BzrBranchFormat6')
 
95
            branch_format='bzrlib.branch.BzrBranchFormat6',
 
96
            experimental=True)
97
97
        my_format_registry.register_metadir(
98
98
            'hidden format',
99
99
            'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
114
114
        my_bzrdir = my_format_registry.make_bzrdir('weave')
115
115
        self.assertIsInstance(my_bzrdir, bzrdir.BzrDirFormat6)
116
116
        my_bzrdir = my_format_registry.make_bzrdir('default')
117
 
        self.assertIsInstance(my_bzrdir.repository_format, 
 
117
        self.assertIsInstance(my_bzrdir.repository_format,
118
118
            knitrepo.RepositoryFormatKnit1)
119
119
        my_bzrdir = my_format_registry.make_bzrdir('knit')
120
 
        self.assertIsInstance(my_bzrdir.repository_format, 
 
120
        self.assertIsInstance(my_bzrdir.repository_format,
121
121
            knitrepo.RepositoryFormatKnit1)
122
122
        my_bzrdir = my_format_registry.make_bzrdir('branch6')
123
123
        self.assertIsInstance(my_bzrdir.get_branch_format(),
127
127
        my_format_registry = self.make_format_registry()
128
128
        self.assertEqual('Format registered lazily',
129
129
                         my_format_registry.get_help('lazy'))
130
 
        self.assertEqual('Format using knits', 
 
130
        self.assertEqual('Format using knits',
131
131
                         my_format_registry.get_help('knit'))
132
 
        self.assertEqual('Format using knits', 
 
132
        self.assertEqual('Format using knits',
133
133
                         my_format_registry.get_help('default'))
134
134
        self.assertEqual('Pre-0.8 format.  Slower and does not support'
135
 
                         ' checkouts or shared repositories', 
 
135
                         ' checkouts or shared repositories',
136
136
                         my_format_registry.get_help('weave'))
137
 
        
 
137
 
138
138
    def test_help_topic(self):
139
139
        topics = help_topics.HelpTopicRegistry()
140
 
        topics.register('formats', self.make_format_registry().help_topic, 
141
 
                        'Directory formats')
142
 
        topic = topics.get_detail('formats')
143
 
        new, deprecated = topic.split('Deprecated formats')
144
 
        self.assertContainsRe(new, 'These formats can be used')
145
 
        self.assertContainsRe(new, 
 
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,
146
150
                ':knit:\n    \(native\) \(default\) Format using knits\n')
147
 
        self.assertContainsRe(deprecated, 
 
151
        self.assertContainsRe(experimental,
 
152
                ':branch6:\n    \(native\) Experimental successor to knit')
 
153
        self.assertContainsRe(deprecated,
148
154
                ':lazy:\n    \(native\) Format registered lazily\n')
149
155
        self.assertNotContainsRe(new, 'hidden')
150
156
 
162
168
        finally:
163
169
            bzrdir.format_registry.set_default_repository(old_default)
164
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
 
165
181
 
166
182
class SampleBranch(bzrlib.branch.Branch):
167
183
    """A dummy branch for guess what, dummy use."""
170
186
        self.bzrdir = dir
171
187
 
172
188
 
 
189
class SampleRepository(bzrlib.repository.Repository):
 
190
    """A dummy repo."""
 
191
 
 
192
    def __init__(self, dir):
 
193
        self.bzrdir = dir
 
194
 
 
195
 
173
196
class SampleBzrDir(bzrdir.BzrDir):
174
197
    """A sample BzrDir implementation to allow testing static methods."""
175
198
 
179
202
 
180
203
    def open_repository(self):
181
204
        """See BzrDir.open_repository."""
182
 
        return "A repository"
 
205
        return SampleRepository(self)
183
206
 
184
207
    def create_branch(self):
185
208
        """See BzrDir.create_branch."""
193
216
class SampleBzrDirFormat(bzrdir.BzrDirFormat):
194
217
    """A sample format
195
218
 
196
 
    this format is initializable, unsupported to aid in testing the 
 
219
    this format is initializable, unsupported to aid in testing the
197
220
    open and open_downlevel routines.
198
221
    """
199
222
 
201
224
        """See BzrDirFormat.get_format_string()."""
202
225
        return "Sample .bzr dir format."
203
226
 
204
 
    def initialize(self, url, possible_transports=None):
 
227
    def initialize_on_transport(self, t):
205
228
        """Create a bzr dir."""
206
 
        t = get_transport(url, possible_transports)
207
229
        t.mkdir('.bzr')
208
230
        t.put_bytes('.bzr/branch-format', self.get_format_string())
209
231
        return SampleBzrDir(t, self)
221
243
    def test_find_format(self):
222
244
        # is the right format object found for a branch?
223
245
        # create a branch with a few known format objects.
224
 
        # this is not quite the same as 
 
246
        # this is not quite the same as
225
247
        t = get_transport(self.get_url())
226
248
        self.build_tree(["foo/", "bar/"], transport=t)
227
249
        def check_format(format, url):
231
253
            self.failUnless(isinstance(found_format, format.__class__))
232
254
        check_format(bzrdir.BzrDirFormat5(), "foo")
233
255
        check_format(bzrdir.BzrDirFormat6(), "bar")
234
 
        
 
256
 
235
257
    def test_find_format_nothing_there(self):
236
258
        self.assertRaises(NotBranchError,
237
259
                          bzrdir.BzrDirFormat.find_format,
264
286
        # now open_downlevel should fail too.
265
287
        self.assertRaises(UnknownFormatError, bzrdir.BzrDir.open_unsupported, url)
266
288
 
267
 
    def test_create_repository_deprecated(self):
268
 
        # new interface is to make the bzrdir, then a repository within that.
269
 
        format = SampleBzrDirFormat()
270
 
        repo = self.applyDeprecated(zero_ninetyone,
271
 
                bzrdir.BzrDir.create_repository,
272
 
                self.get_url(), format=format)
273
 
        self.assertEqual('A repository', repo)
274
 
 
275
 
    def test_create_repository_shared(self):
276
 
        # new interface is to make the bzrdir, then a repository within that.
277
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
278
 
        repo = self.applyDeprecated(zero_ninetyone,
279
 
                bzrdir.BzrDir.create_repository,
280
 
                '.', shared=True)
281
 
        self.assertTrue(repo.is_shared())
282
 
 
283
 
    def test_create_repository_nonshared(self):
284
 
        # new interface is to make the bzrdir, then a repository within that.
285
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
286
 
        repo = self.applyDeprecated(zero_ninetyone,
287
 
                bzrdir.BzrDir.create_repository,
288
 
                '.')
289
 
        self.assertFalse(repo.is_shared())
290
 
 
291
 
    def test_create_repository_under_shared(self):
292
 
        # an explicit create_repository always does so.
293
 
        # we trust the format is right from the 'create_repository test'
294
 
        # new interface is to make the bzrdir, then a repository within that.
295
 
        format = bzrdir.format_registry.make_bzrdir('knit')
296
 
        self.make_repository('.', shared=True, format=format)
297
 
        repo = self.applyDeprecated(zero_ninetyone,
298
 
                bzrdir.BzrDir.create_repository,
299
 
                self.get_url('child'),
300
 
                format=format)
301
 
        self.assertTrue(isinstance(repo, repository.Repository))
302
 
        self.assertTrue(repo.bzrdir.root_transport.base.endswith('child/'))
303
 
 
304
289
    def test_create_branch_and_repo_uses_default(self):
305
290
        format = SampleBzrDirFormat()
306
291
        branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url(),
318
303
                          branch.bzrdir.open_repository)
319
304
 
320
305
    def test_create_branch_and_repo_under_shared_force_new(self):
321
 
        # 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
322
307
        # make a new repo
323
308
        format = bzrdir.format_registry.make_bzrdir('knit')
324
309
        self.make_repository('.', shared=True, format=format)
329
314
 
330
315
    def test_create_standalone_working_tree(self):
331
316
        format = SampleBzrDirFormat()
332
 
        # note this is deliberately readonly, as this failure should 
 
317
        # note this is deliberately readonly, as this failure should
333
318
        # occur before any writes.
334
319
        self.assertRaises(errors.NotLocalUrl,
335
320
                          bzrdir.BzrDir.create_standalone_workingtree,
336
321
                          self.get_readonly_url(), format=format)
337
 
        tree = bzrdir.BzrDir.create_standalone_workingtree('.', 
 
322
        tree = bzrdir.BzrDir.create_standalone_workingtree('.',
338
323
                                                           format=format)
339
324
        self.assertEqual('A tree', tree)
340
325
 
342
327
        # create standalone working tree always makes a repo.
343
328
        format = bzrdir.format_registry.make_bzrdir('knit')
344
329
        self.make_repository('.', shared=True, format=format)
345
 
        # note this is deliberately readonly, as this failure should 
 
330
        # note this is deliberately readonly, as this failure should
346
331
        # occur before any writes.
347
332
        self.assertRaises(errors.NotLocalUrl,
348
333
                          bzrdir.BzrDir.create_standalone_workingtree,
349
334
                          self.get_readonly_url('child'), format=format)
350
 
        tree = bzrdir.BzrDir.create_standalone_workingtree('child', 
 
335
        tree = bzrdir.BzrDir.create_standalone_workingtree('child',
351
336
            format=format)
352
337
        tree.bzrdir.open_repository()
353
338
 
372
357
        self.vfs_transport_factory = MemoryServer
373
358
        # outside a repo the default convenience output is a repo+branch_tree
374
359
        format = bzrdir.format_registry.make_bzrdir('knit')
375
 
        branch = bzrdir.BzrDir.create_branch_convenience(self.get_url(), 
 
360
        branch = bzrdir.BzrDir.create_branch_convenience(self.get_url(),
376
361
                                                         format=format)
377
362
        self.assertRaises(errors.NoWorkingTree,
378
363
                          branch.bzrdir.open_workingtree)
388
373
        branch.bzrdir.open_workingtree()
389
374
        self.assertRaises(errors.NoRepositoryPresent,
390
375
                          branch.bzrdir.open_repository)
391
 
            
 
376
 
392
377
    def test_create_branch_convenience_under_shared_repo_force_no_tree(self):
393
378
        # inside a repo the default convenience output is a branch+ follow the
394
379
        # repo tree policy but we can override that
400
385
                          branch.bzrdir.open_workingtree)
401
386
        self.assertRaises(errors.NoRepositoryPresent,
402
387
                          branch.bzrdir.open_repository)
403
 
            
 
388
 
404
389
    def test_create_branch_convenience_under_shared_repo_no_tree_policy(self):
405
390
        # inside a repo the default convenience output is a branch+ follow the
406
391
        # repo tree policy
407
392
        format = bzrdir.format_registry.make_bzrdir('knit')
408
393
        repo = self.make_repository('.', shared=True, format=format)
409
394
        repo.set_make_working_trees(False)
410
 
        branch = bzrdir.BzrDir.create_branch_convenience('child', 
 
395
        branch = bzrdir.BzrDir.create_branch_convenience('child',
411
396
                                                         format=format)
412
397
        self.assertRaises(errors.NoWorkingTree,
413
398
                          branch.bzrdir.open_workingtree)
437
422
        branch.bzrdir.open_workingtree()
438
423
 
439
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
 
440
558
class ChrootedTests(TestCaseWithTransport):
441
559
    """A support class that provides readonly urls outside the local namespace.
442
560
 
448
566
    def setUp(self):
449
567
        super(ChrootedTests, self).setUp()
450
568
        if not self.vfs_transport_factory == MemoryServer:
451
 
            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))
452
573
 
453
574
    def test_open_containing(self):
454
575
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing,
461
582
        branch, relpath = bzrdir.BzrDir.open_containing(self.get_readonly_url('g/p/q'))
462
583
        self.assertEqual('g/p/q', relpath)
463
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
 
464
672
    def test_open_containing_from_transport(self):
465
673
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing_from_transport,
466
674
                          get_transport(self.get_readonly_url('')))
475
683
        self.assertEqual('g/p/q', relpath)
476
684
 
477
685
    def test_open_containing_tree_or_branch(self):
478
 
        def local_branch_path(branch):
479
 
             return os.path.realpath(
480
 
                urlutils.local_path_from_url(branch.base))
481
 
 
482
686
        self.make_branch_and_tree('topdir')
483
687
        tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
484
688
            'topdir/foo')
485
689
        self.assertEqual(os.path.realpath('topdir'),
486
690
                         os.path.realpath(tree.basedir))
487
691
        self.assertEqual(os.path.realpath('topdir'),
488
 
                         local_branch_path(branch))
 
692
                         self.local_branch_path(branch))
489
693
        self.assertIs(tree.bzrdir, branch.bzrdir)
490
694
        self.assertEqual('foo', relpath)
491
695
        # opening from non-local should not return the tree
499
703
            'topdir/foo')
500
704
        self.assertIs(tree, None)
501
705
        self.assertEqual(os.path.realpath('topdir/foo'),
502
 
                         local_branch_path(branch))
 
706
                         self.local_branch_path(branch))
503
707
        self.assertEqual('', relpath)
504
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
 
505
728
    def test_open_from_transport(self):
506
729
        # transport pointing at bzrdir should give a bzrdir with root transport
507
730
        # set to the given transport
510
733
        opened_bzrdir = bzrdir.BzrDir.open_from_transport(transport)
511
734
        self.assertEqual(transport.base, opened_bzrdir.root_transport.base)
512
735
        self.assertIsInstance(opened_bzrdir, bzrdir.BzrDir)
513
 
        
 
736
 
514
737
    def test_open_from_transport_no_bzrdir(self):
515
738
        transport = get_transport(self.get_url())
516
739
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport,
525
748
                          transport)
526
749
 
527
750
    def test_sprout_recursive(self):
528
 
        tree = self.make_branch_and_tree('tree1', format='dirstate-with-subtree')
 
751
        tree = self.make_branch_and_tree('tree1',
 
752
                                         format='dirstate-with-subtree')
529
753
        sub_tree = self.make_branch_and_tree('tree1/subtree',
530
754
            format='dirstate-with-subtree')
 
755
        sub_tree.set_root_id('subtree-root')
531
756
        tree.add_reference(sub_tree)
532
757
        self.build_tree(['tree1/subtree/file'])
533
758
        sub_tree.add('file')
534
759
        tree.commit('Initial commit')
535
 
        tree.bzrdir.sprout('tree2')
 
760
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
 
761
        tree2.lock_read()
 
762
        self.addCleanup(tree2.unlock)
536
763
        self.failUnlessExists('tree2/subtree/file')
 
764
        self.assertEqual('tree-reference', tree2.kind('subtree-root'))
537
765
 
538
766
    def test_cloning_metadir(self):
539
767
        """Ensure that cloning metadir is suitable"""
561
789
        self.failUnlessExists('repo/tree2/subtree')
562
790
        self.failIfExists('repo/tree2/subtree/file')
563
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
 
564
852
 
565
853
class TestMeta1DirFormat(TestCaseWithTransport):
566
854
    """Tests specific to the meta1 dir format."""
605
893
 
606
894
    def test_needs_conversion_different_working_tree(self):
607
895
        # meta1dirs need an conversion if any element is not the default.
608
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
609
 
        # test with 
610
 
        new_default = bzrdir.format_registry.make_bzrdir('dirstate')
611
 
        bzrdir.BzrDirFormat._set_default_format(new_default)
612
 
        try:
613
 
            tree = self.make_branch_and_tree('tree', format='knit')
614
 
            self.assertTrue(tree.bzrdir.needs_format_conversion())
615
 
        finally:
616
 
            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)
617
916
 
618
917
 
619
918
class TestFormat5(TestCaseWithTransport):
620
919
    """Tests specific to the version 5 bzrdir format."""
621
920
 
622
921
    def test_same_lockfiles_between_tree_repo_branch(self):
623
 
        # this checks that only a single lockfiles instance is created 
 
922
        # this checks that only a single lockfiles instance is created
624
923
        # for format 5 objects
625
924
        dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
626
925
        def check_dir_components_use_same_lock(dir):
633
932
        # and if we open it normally.
634
933
        dir = bzrdir.BzrDir.open(self.get_url())
635
934
        check_dir_components_use_same_lock(dir)
636
 
    
 
935
 
637
936
    def test_can_convert(self):
638
937
        # format 5 dirs are convertable
639
938
        dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
640
939
        self.assertTrue(dir.can_convert_format())
641
 
    
 
940
 
642
941
    def test_needs_conversion(self):
643
 
        # format 5 dirs need a conversion if they are not the default.
644
 
        # and they start of not the default.
645
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
646
 
        bzrdir.BzrDirFormat._set_default_format(bzrdir.BzrDirFormat5())
647
 
        try:
648
 
            dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
649
 
            self.assertFalse(dir.needs_format_conversion())
650
 
        finally:
651
 
            bzrdir.BzrDirFormat._set_default_format(old_format)
652
 
        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()))
653
950
 
654
951
 
655
952
class TestFormat6(TestCaseWithTransport):
656
953
    """Tests specific to the version 6 bzrdir format."""
657
954
 
658
955
    def test_same_lockfiles_between_tree_repo_branch(self):
659
 
        # this checks that only a single lockfiles instance is created 
 
956
        # this checks that only a single lockfiles instance is created
660
957
        # for format 6 objects
661
958
        dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
662
959
        def check_dir_components_use_same_lock(dir):
669
966
        # and if we open it normally.
670
967
        dir = bzrdir.BzrDir.open(self.get_url())
671
968
        check_dir_components_use_same_lock(dir)
672
 
    
 
969
 
673
970
    def test_can_convert(self):
674
971
        # format 6 dirs are convertable
675
972
        dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
676
973
        self.assertTrue(dir.can_convert_format())
677
 
    
 
974
 
678
975
    def test_needs_conversion(self):
679
976
        # format 6 dirs need an conversion if they are not the default.
680
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
681
 
        bzrdir.BzrDirFormat._set_default_format(bzrdir.BzrDirMetaFormat1())
682
 
        try:
683
 
            dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
684
 
            self.assertTrue(dir.needs_format_conversion())
685
 
        finally:
686
 
            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()))
687
980
 
688
981
 
689
982
class NotBzrDir(bzrlib.bzrdir.BzrDir):
720
1013
 
721
1014
class TestNotBzrDir(TestCaseWithTransport):
722
1015
    """Tests for using the bzrdir api with a non .bzr based disk format.
723
 
    
 
1016
 
724
1017
    If/when one of these is in the core, we can let the implementation tests
725
1018
    verify this works.
726
1019
    """
727
1020
 
728
1021
    def test_create_and_find_format(self):
729
 
        # create a .notbzr dir 
 
1022
        # create a .notbzr dir
730
1023
        format = NotBzrDirFormat()
731
1024
        dir = format.initialize(self.get_url())
732
1025
        self.assertIsInstance(dir, NotBzrDir)
757
1050
    def setUp(self):
758
1051
        super(NonLocalTests, self).setUp()
759
1052
        self.vfs_transport_factory = MemoryServer
760
 
    
 
1053
 
761
1054
    def test_create_branch_convenience(self):
762
1055
        # outside a repo the default convenience output is a repo+branch_tree
763
1056
        format = bzrdir.format_registry.make_bzrdir('knit')
800
1093
                              workingtree.WorkingTreeFormat3)
801
1094
 
802
1095
 
803
 
class TestHTTPRedirectionLoop(object):
804
 
    """Test redirection loop between two http servers.
 
1096
class TestHTTPRedirections(object):
 
1097
    """Test redirection between two http servers.
805
1098
 
806
1099
    This MUST be used by daughter classes that also inherit from
807
1100
    TestCaseWithTwoWebservers.
808
1101
 
809
1102
    We can't inherit directly from TestCaseWithTwoWebservers or the
810
1103
    test framework will try to create an instance which cannot
811
 
    run, its implementation being incomplete. 
 
1104
    run, its implementation being incomplete.
812
1105
    """
813
1106
 
814
 
    # Should be defined by daughter classes to ensure redirection
815
 
    # still use the same transport implementation (not currently
816
 
    # enforced as it's a bit tricky to get right (see the FIXME
817
 
    # in BzrDir.open_from_transport for the unique use case so
818
 
    # far)
819
 
    _qualifier = None
820
 
 
821
1107
    def create_transport_readonly_server(self):
822
 
        return HTTPServerRedirecting()
 
1108
        return http_utils.HTTPServerRedirecting()
823
1109
 
824
1110
    def create_transport_secondary_server(self):
825
 
        return HTTPServerRedirecting()
 
1111
        return http_utils.HTTPServerRedirecting()
826
1112
 
827
1113
    def setUp(self):
828
 
        # Both servers redirect to each server creating a loop
829
 
        super(TestHTTPRedirectionLoop, self).setUp()
 
1114
        super(TestHTTPRedirections, self).setUp()
830
1115
        # The redirections will point to the new server
831
1116
        self.new_server = self.get_readonly_server()
832
1117
        # The requests to the old server will be redirected
833
1118
        self.old_server = self.get_secondary_server()
834
1119
        # Configure the redirections
835
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
836
1124
        self.new_server.redirect_to(self.old_server.host, self.old_server.port)
837
 
 
838
 
    def _qualified_url(self, host, port):
839
 
        return 'http+%s://%s:%s' % (self._qualifier, host, port)
840
 
 
841
 
    def test_loop(self):
842
1125
        # Starting from either server should loop
843
 
        old_url = self._qualified_url(self.old_server.host, 
 
1126
        old_url = self._qualified_url(self.old_server.host,
844
1127
                                      self.old_server.port)
845
1128
        oldt = self._transport(old_url)
846
1129
        self.assertRaises(errors.NotBranchError,
847
1130
                          bzrdir.BzrDir.open_from_transport, oldt)
848
 
        new_url = self._qualified_url(self.new_server.host, 
 
1131
        new_url = self._qualified_url(self.new_server.host,
849
1132
                                      self.new_server.port)
850
1133
        newt = self._transport(new_url)
851
1134
        self.assertRaises(errors.NotBranchError,
852
1135
                          bzrdir.BzrDir.open_from_transport, newt)
853
1136
 
854
 
 
855
 
class TestHTTPRedirections_urllib(TestHTTPRedirectionLoop,
856
 
                                  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):
857
1150
    """Tests redirections for urllib implementation"""
858
1151
 
859
 
    _qualifier = 'urllib'
860
1152
    _transport = HttpTransport_urllib
861
1153
 
 
1154
    def _qualified_url(self, host, port):
 
1155
        return 'http+urllib://%s:%s' % (host, port)
 
1156
 
862
1157
 
863
1158
 
864
1159
class TestHTTPRedirections_pycurl(TestWithTransport_pycurl,
865
 
                                  TestHTTPRedirectionLoop,
866
 
                                  TestCaseWithTwoWebservers):
 
1160
                                  TestHTTPRedirections,
 
1161
                                  http_utils.TestCaseWithTwoWebservers):
867
1162
    """Tests redirections for pycurl implementation"""
868
1163
 
869
 
    _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)