/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_bzrdir.py

  • Committer: Robert Collins
  • Date: 2008-08-20 02:07:36 UTC
  • mfrom: (3640 +trunk)
  • mto: This revision was merged to the branch mainline in revision 3682.
  • Revision ID: robertc@robertcollins.net-20080820020736-g2xe4921zzxtymle
Merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_bzrdir.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
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
6
6
# (at your option) any later version.
7
 
# 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
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
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
19
For interface contract tests, see tests/bzr_dir_implementations.
20
20
"""
21
21
 
 
22
import os
 
23
import os.path
22
24
from StringIO import StringIO
 
25
import subprocess
 
26
import sys
23
27
 
 
28
from bzrlib import (
 
29
    bzrdir,
 
30
    errors,
 
31
    help_topics,
 
32
    repository,
 
33
    osutils,
 
34
    symbol_versioning,
 
35
    urlutils,
 
36
    win32utils,
 
37
    workingtree,
 
38
    )
24
39
import bzrlib.branch
25
 
import bzrlib.bzrdir as bzrdir
26
 
import bzrlib.errors as errors
27
40
from bzrlib.errors import (NotBranchError,
28
41
                           UnknownFormatError,
29
42
                           UnsupportedFormatError,
30
43
                           )
31
 
import bzrlib.repository as repository
32
 
from bzrlib.tests import TestCase, TestCaseWithTransport
 
44
from bzrlib.tests import (
 
45
    TestCase,
 
46
    TestCaseWithMemoryTransport,
 
47
    TestCaseWithTransport,
 
48
    TestSkipped,
 
49
    test_sftp_transport
 
50
    )
 
51
from bzrlib.tests.http_server import HttpServer
 
52
from bzrlib.tests.http_utils import (
 
53
    TestCaseWithTwoWebservers,
 
54
    HTTPServerRedirecting,
 
55
    )
 
56
from bzrlib.tests.test_http import TestWithTransport_pycurl
33
57
from bzrlib.transport import get_transport
34
 
from bzrlib.transport.http import HttpServer
 
58
from bzrlib.transport.http._urllib import HttpTransport_urllib
35
59
from bzrlib.transport.memory import MemoryServer
36
 
import bzrlib.workingtree as workingtree
 
60
from bzrlib.repofmt import knitrepo, weaverepo
37
61
 
38
62
 
39
63
class TestDefaultFormat(TestCase):
42
66
        old_format = bzrdir.BzrDirFormat.get_default_format()
43
67
        # default is BzrDirFormat6
44
68
        self.failUnless(isinstance(old_format, bzrdir.BzrDirMetaFormat1))
45
 
        bzrdir.BzrDirFormat.set_default_format(SampleBzrDirFormat())
 
69
        bzrdir.BzrDirFormat._set_default_format(SampleBzrDirFormat())
46
70
        # creating a bzr dir should now create an instrumented dir.
47
71
        try:
48
72
            result = bzrdir.BzrDir.create('memory:///')
49
73
            self.failUnless(isinstance(result, SampleBzrDir))
50
74
        finally:
51
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
75
            bzrdir.BzrDirFormat._set_default_format(old_format)
52
76
        self.assertEqual(old_format, bzrdir.BzrDirFormat.get_default_format())
53
77
 
54
78
 
 
79
class TestFormatRegistry(TestCase):
 
80
 
 
81
    def make_format_registry(self):
 
82
        my_format_registry = bzrdir.BzrDirFormatRegistry()
 
83
        my_format_registry.register('weave', bzrdir.BzrDirFormat6,
 
84
            'Pre-0.8 format.  Slower and does not support checkouts or shared'
 
85
            ' repositories', deprecated=True)
 
86
        my_format_registry.register_lazy('lazy', 'bzrlib.bzrdir', 
 
87
            'BzrDirFormat6', 'Format registered lazily', deprecated=True)
 
88
        my_format_registry.register_metadir('knit',
 
89
            'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
 
90
            'Format using knits',
 
91
            )
 
92
        my_format_registry.set_default('knit')
 
93
        my_format_registry.register_metadir(
 
94
            'branch6',
 
95
            'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
 
96
            'Experimental successor to knit.  Use at your own risk.',
 
97
            branch_format='bzrlib.branch.BzrBranchFormat6',
 
98
            experimental=True)
 
99
        my_format_registry.register_metadir(
 
100
            'hidden format',
 
101
            'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
 
102
            'Experimental successor to knit.  Use at your own risk.',
 
103
            branch_format='bzrlib.branch.BzrBranchFormat6', hidden=True)
 
104
        my_format_registry.register('hiddenweave', bzrdir.BzrDirFormat6,
 
105
            'Pre-0.8 format.  Slower and does not support checkouts or shared'
 
106
            ' repositories', hidden=True)
 
107
        my_format_registry.register_lazy('hiddenlazy', 'bzrlib.bzrdir',
 
108
            'BzrDirFormat6', 'Format registered lazily', deprecated=True,
 
109
            hidden=True)
 
110
        return my_format_registry
 
111
 
 
112
    def test_format_registry(self):
 
113
        my_format_registry = self.make_format_registry()
 
114
        my_bzrdir = my_format_registry.make_bzrdir('lazy')
 
115
        self.assertIsInstance(my_bzrdir, bzrdir.BzrDirFormat6)
 
116
        my_bzrdir = my_format_registry.make_bzrdir('weave')
 
117
        self.assertIsInstance(my_bzrdir, bzrdir.BzrDirFormat6)
 
118
        my_bzrdir = my_format_registry.make_bzrdir('default')
 
119
        self.assertIsInstance(my_bzrdir.repository_format, 
 
120
            knitrepo.RepositoryFormatKnit1)
 
121
        my_bzrdir = my_format_registry.make_bzrdir('knit')
 
122
        self.assertIsInstance(my_bzrdir.repository_format, 
 
123
            knitrepo.RepositoryFormatKnit1)
 
124
        my_bzrdir = my_format_registry.make_bzrdir('branch6')
 
125
        self.assertIsInstance(my_bzrdir.get_branch_format(),
 
126
                              bzrlib.branch.BzrBranchFormat6)
 
127
 
 
128
    def test_get_help(self):
 
129
        my_format_registry = self.make_format_registry()
 
130
        self.assertEqual('Format registered lazily',
 
131
                         my_format_registry.get_help('lazy'))
 
132
        self.assertEqual('Format using knits', 
 
133
                         my_format_registry.get_help('knit'))
 
134
        self.assertEqual('Format using knits', 
 
135
                         my_format_registry.get_help('default'))
 
136
        self.assertEqual('Pre-0.8 format.  Slower and does not support'
 
137
                         ' checkouts or shared repositories', 
 
138
                         my_format_registry.get_help('weave'))
 
139
        
 
140
    def test_help_topic(self):
 
141
        topics = help_topics.HelpTopicRegistry()
 
142
        topics.register('formats', self.make_format_registry().help_topic, 
 
143
                        'Directory formats')
 
144
        topic = topics.get_detail('formats')
 
145
        new, rest = topic.split('Experimental formats')
 
146
        experimental, deprecated = rest.split('Deprecated formats')
 
147
        self.assertContainsRe(new, 'These formats can be used')
 
148
        self.assertContainsRe(new, 
 
149
                ':knit:\n    \(native\) \(default\) Format using knits\n')
 
150
        self.assertContainsRe(experimental, 
 
151
                ':branch6:\n    \(native\) Experimental successor to knit')
 
152
        self.assertContainsRe(deprecated, 
 
153
                ':lazy:\n    \(native\) Format registered lazily\n')
 
154
        self.assertNotContainsRe(new, 'hidden')
 
155
 
 
156
    def test_set_default_repository(self):
 
157
        default_factory = bzrdir.format_registry.get('default')
 
158
        old_default = [k for k, v in bzrdir.format_registry.iteritems()
 
159
                       if v == default_factory and k != 'default'][0]
 
160
        bzrdir.format_registry.set_default_repository('dirstate-with-subtree')
 
161
        try:
 
162
            self.assertIs(bzrdir.format_registry.get('dirstate-with-subtree'),
 
163
                          bzrdir.format_registry.get('default'))
 
164
            self.assertIs(
 
165
                repository.RepositoryFormat.get_default_format().__class__,
 
166
                knitrepo.RepositoryFormatKnit3)
 
167
        finally:
 
168
            bzrdir.format_registry.set_default_repository(old_default)
 
169
 
 
170
    def test_aliases(self):
 
171
        a_registry = bzrdir.BzrDirFormatRegistry()
 
172
        a_registry.register('weave', bzrdir.BzrDirFormat6,
 
173
            'Pre-0.8 format.  Slower and does not support checkouts or shared'
 
174
            ' repositories', deprecated=True)
 
175
        a_registry.register('weavealias', bzrdir.BzrDirFormat6,
 
176
            'Pre-0.8 format.  Slower and does not support checkouts or shared'
 
177
            ' repositories', deprecated=True, alias=True)
 
178
        self.assertEqual(frozenset(['weavealias']), a_registry.aliases())
 
179
    
 
180
 
55
181
class SampleBranch(bzrlib.branch.Branch):
56
182
    """A dummy branch for guess what, dummy use."""
57
183
 
62
188
class SampleBzrDir(bzrdir.BzrDir):
63
189
    """A sample BzrDir implementation to allow testing static methods."""
64
190
 
65
 
    def create_repository(self):
 
191
    def create_repository(self, shared=False):
66
192
        """See BzrDir.create_repository."""
67
193
        return "A repository"
68
194
 
90
216
        """See BzrDirFormat.get_format_string()."""
91
217
        return "Sample .bzr dir format."
92
218
 
93
 
    def initialize(self, url):
 
219
    def initialize_on_transport(self, t):
94
220
        """Create a bzr dir."""
95
 
        t = get_transport(url)
96
221
        t.mkdir('.bzr')
97
 
        t.put('.bzr/branch-format', StringIO(self.get_format_string()))
 
222
        t.put_bytes('.bzr/branch-format', self.get_format_string())
98
223
        return SampleBzrDir(t, self)
99
224
 
100
225
    def is_supported(self):
129
254
    def test_find_format_unknown_format(self):
130
255
        t = get_transport(self.get_url())
131
256
        t.mkdir('.bzr')
132
 
        t.put('.bzr/branch-format', StringIO())
 
257
        t.put_bytes('.bzr/branch-format', '')
133
258
        self.assertRaises(UnknownFormatError,
134
259
                          bzrdir.BzrDirFormat.find_format,
135
260
                          get_transport('.'))
153
278
        # now open_downlevel should fail too.
154
279
        self.assertRaises(UnknownFormatError, bzrdir.BzrDir.open_unsupported, url)
155
280
 
156
 
    def test_create_repository(self):
157
 
        format = SampleBzrDirFormat()
158
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
159
 
        bzrdir.BzrDirFormat.set_default_format(format)
160
 
        try:
161
 
            repo = bzrdir.BzrDir.create_repository(self.get_url())
162
 
            self.assertEqual('A repository', repo)
163
 
        finally:
164
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
165
 
 
166
 
    def test_create_repository_under_shared(self):
167
 
        # an explicit create_repository always does so.
168
 
        # we trust the format is right from the 'create_repository test'
169
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
170
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
171
 
        try:
172
 
            self.make_repository('.', shared=True)
173
 
            repo = bzrdir.BzrDir.create_repository(self.get_url('child'))
174
 
            self.assertTrue(isinstance(repo, repository.Repository))
175
 
            self.assertTrue(repo.bzrdir.root_transport.base.endswith('child/'))
176
 
        finally:
177
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
178
 
 
179
281
    def test_create_branch_and_repo_uses_default(self):
180
282
        format = SampleBzrDirFormat()
181
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
182
 
        bzrdir.BzrDirFormat.set_default_format(format)
183
 
        try:
184
 
            branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url())
185
 
            self.assertTrue(isinstance(branch, SampleBranch))
186
 
        finally:
187
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
283
        branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url(),
 
284
                                                      format=format)
 
285
        self.assertTrue(isinstance(branch, SampleBranch))
188
286
 
189
287
    def test_create_branch_and_repo_under_shared(self):
190
288
        # creating a branch and repo in a shared repo uses the
191
289
        # shared repository
192
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
193
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
194
 
        try:
195
 
            self.make_repository('.', shared=True)
196
 
            branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url('child'))
197
 
            self.assertRaises(errors.NoRepositoryPresent,
198
 
                              branch.bzrdir.open_repository)
199
 
        finally:
200
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
290
        format = bzrdir.format_registry.make_bzrdir('knit')
 
291
        self.make_repository('.', shared=True, format=format)
 
292
        branch = bzrdir.BzrDir.create_branch_and_repo(
 
293
            self.get_url('child'), format=format)
 
294
        self.assertRaises(errors.NoRepositoryPresent,
 
295
                          branch.bzrdir.open_repository)
201
296
 
202
297
    def test_create_branch_and_repo_under_shared_force_new(self):
203
298
        # creating a branch and repo in a shared repo can be forced to 
204
299
        # make a new repo
205
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
206
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
207
 
        try:
208
 
            self.make_repository('.', shared=True)
209
 
            branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url('child'),
210
 
                                                          force_new_repo=True)
211
 
            branch.bzrdir.open_repository()
212
 
        finally:
213
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
300
        format = bzrdir.format_registry.make_bzrdir('knit')
 
301
        self.make_repository('.', shared=True, format=format)
 
302
        branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url('child'),
 
303
                                                      force_new_repo=True,
 
304
                                                      format=format)
 
305
        branch.bzrdir.open_repository()
214
306
 
215
307
    def test_create_standalone_working_tree(self):
216
308
        format = SampleBzrDirFormat()
217
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
218
 
        bzrdir.BzrDirFormat.set_default_format(format)
219
 
        try:
220
 
            # note this is deliberately readonly, as this failure should 
221
 
            # occur before any writes.
222
 
            self.assertRaises(errors.NotLocalUrl,
223
 
                              bzrdir.BzrDir.create_standalone_workingtree,
224
 
                              self.get_readonly_url())
225
 
            tree = bzrdir.BzrDir.create_standalone_workingtree('.')
226
 
            self.assertEqual('A tree', tree)
227
 
        finally:
228
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
309
        # note this is deliberately readonly, as this failure should 
 
310
        # occur before any writes.
 
311
        self.assertRaises(errors.NotLocalUrl,
 
312
                          bzrdir.BzrDir.create_standalone_workingtree,
 
313
                          self.get_readonly_url(), format=format)
 
314
        tree = bzrdir.BzrDir.create_standalone_workingtree('.', 
 
315
                                                           format=format)
 
316
        self.assertEqual('A tree', tree)
229
317
 
230
318
    def test_create_standalone_working_tree_under_shared_repo(self):
231
319
        # create standalone working tree always makes a repo.
232
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
233
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
234
 
        try:
235
 
            self.make_repository('.', shared=True)
236
 
            # note this is deliberately readonly, as this failure should 
237
 
            # occur before any writes.
238
 
            self.assertRaises(errors.NotLocalUrl,
239
 
                              bzrdir.BzrDir.create_standalone_workingtree,
240
 
                              self.get_readonly_url('child'))
241
 
            tree = bzrdir.BzrDir.create_standalone_workingtree('child')
242
 
            tree.bzrdir.open_repository()
243
 
        finally:
244
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
320
        format = bzrdir.format_registry.make_bzrdir('knit')
 
321
        self.make_repository('.', shared=True, format=format)
 
322
        # note this is deliberately readonly, as this failure should 
 
323
        # occur before any writes.
 
324
        self.assertRaises(errors.NotLocalUrl,
 
325
                          bzrdir.BzrDir.create_standalone_workingtree,
 
326
                          self.get_readonly_url('child'), format=format)
 
327
        tree = bzrdir.BzrDir.create_standalone_workingtree('child', 
 
328
            format=format)
 
329
        tree.bzrdir.open_repository()
245
330
 
246
331
    def test_create_branch_convenience(self):
247
332
        # outside a repo the default convenience output is a repo+branch_tree
248
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
249
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
250
 
        try:
251
 
            branch = bzrdir.BzrDir.create_branch_convenience('.')
252
 
            branch.bzrdir.open_workingtree()
253
 
            branch.bzrdir.open_repository()
254
 
        finally:
255
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
333
        format = bzrdir.format_registry.make_bzrdir('knit')
 
334
        branch = bzrdir.BzrDir.create_branch_convenience('.', format=format)
 
335
        branch.bzrdir.open_workingtree()
 
336
        branch.bzrdir.open_repository()
 
337
 
 
338
    def test_create_branch_convenience_possible_transports(self):
 
339
        """Check that the optional 'possible_transports' is recognized"""
 
340
        format = bzrdir.format_registry.make_bzrdir('knit')
 
341
        t = self.get_transport()
 
342
        branch = bzrdir.BzrDir.create_branch_convenience(
 
343
            '.', format=format, possible_transports=[t])
 
344
        branch.bzrdir.open_workingtree()
 
345
        branch.bzrdir.open_repository()
256
346
 
257
347
    def test_create_branch_convenience_root(self):
258
348
        """Creating a branch at the root of a fs should work."""
259
 
        self.transport_server = MemoryServer
 
349
        self.vfs_transport_factory = MemoryServer
260
350
        # outside a repo the default convenience output is a repo+branch_tree
261
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
262
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
263
 
        try:
264
 
            branch = bzrdir.BzrDir.create_branch_convenience(self.get_url())
265
 
            self.assertRaises(errors.NoWorkingTree,
266
 
                              branch.bzrdir.open_workingtree)
267
 
            branch.bzrdir.open_repository()
268
 
        finally:
269
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
351
        format = bzrdir.format_registry.make_bzrdir('knit')
 
352
        branch = bzrdir.BzrDir.create_branch_convenience(self.get_url(), 
 
353
                                                         format=format)
 
354
        self.assertRaises(errors.NoWorkingTree,
 
355
                          branch.bzrdir.open_workingtree)
 
356
        branch.bzrdir.open_repository()
270
357
 
271
358
    def test_create_branch_convenience_under_shared_repo(self):
272
359
        # inside a repo the default convenience output is a branch+ follow the
273
360
        # repo tree policy
274
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
275
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
276
 
        try:
277
 
            self.make_repository('.', shared=True)
278
 
            branch = bzrdir.BzrDir.create_branch_convenience('child')
279
 
            branch.bzrdir.open_workingtree()
280
 
            self.assertRaises(errors.NoRepositoryPresent,
281
 
                              branch.bzrdir.open_repository)
282
 
        finally:
283
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
361
        format = bzrdir.format_registry.make_bzrdir('knit')
 
362
        self.make_repository('.', shared=True, format=format)
 
363
        branch = bzrdir.BzrDir.create_branch_convenience('child',
 
364
            format=format)
 
365
        branch.bzrdir.open_workingtree()
 
366
        self.assertRaises(errors.NoRepositoryPresent,
 
367
                          branch.bzrdir.open_repository)
284
368
            
285
369
    def test_create_branch_convenience_under_shared_repo_force_no_tree(self):
286
370
        # inside a repo the default convenience output is a branch+ follow the
287
371
        # repo tree policy but we can override that
288
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
289
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
290
 
        try:
291
 
            self.make_repository('.', shared=True)
292
 
            branch = bzrdir.BzrDir.create_branch_convenience('child',
293
 
                force_new_tree=False)
294
 
            self.assertRaises(errors.NoWorkingTree,
295
 
                              branch.bzrdir.open_workingtree)
296
 
            self.assertRaises(errors.NoRepositoryPresent,
297
 
                              branch.bzrdir.open_repository)
298
 
        finally:
299
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
372
        format = bzrdir.format_registry.make_bzrdir('knit')
 
373
        self.make_repository('.', shared=True, format=format)
 
374
        branch = bzrdir.BzrDir.create_branch_convenience('child',
 
375
            force_new_tree=False, format=format)
 
376
        self.assertRaises(errors.NoWorkingTree,
 
377
                          branch.bzrdir.open_workingtree)
 
378
        self.assertRaises(errors.NoRepositoryPresent,
 
379
                          branch.bzrdir.open_repository)
300
380
            
301
381
    def test_create_branch_convenience_under_shared_repo_no_tree_policy(self):
302
382
        # inside a repo the default convenience output is a branch+ follow the
303
383
        # repo tree policy
304
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
305
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
306
 
        try:
307
 
            repo = self.make_repository('.', shared=True)
308
 
            repo.set_make_working_trees(False)
309
 
            branch = bzrdir.BzrDir.create_branch_convenience('child')
310
 
            self.assertRaises(errors.NoWorkingTree,
311
 
                              branch.bzrdir.open_workingtree)
312
 
            self.assertRaises(errors.NoRepositoryPresent,
313
 
                              branch.bzrdir.open_repository)
314
 
        finally:
315
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
384
        format = bzrdir.format_registry.make_bzrdir('knit')
 
385
        repo = self.make_repository('.', shared=True, format=format)
 
386
        repo.set_make_working_trees(False)
 
387
        branch = bzrdir.BzrDir.create_branch_convenience('child', 
 
388
                                                         format=format)
 
389
        self.assertRaises(errors.NoWorkingTree,
 
390
                          branch.bzrdir.open_workingtree)
 
391
        self.assertRaises(errors.NoRepositoryPresent,
 
392
                          branch.bzrdir.open_repository)
316
393
 
317
394
    def test_create_branch_convenience_under_shared_repo_no_tree_policy_force_tree(self):
318
395
        # inside a repo the default convenience output is a branch+ follow the
319
396
        # repo tree policy but we can override that
320
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
321
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
322
 
        try:
323
 
            repo = self.make_repository('.', shared=True)
324
 
            repo.set_make_working_trees(False)
325
 
            branch = bzrdir.BzrDir.create_branch_convenience('child',
326
 
                force_new_tree=True)
327
 
            branch.bzrdir.open_workingtree()
328
 
            self.assertRaises(errors.NoRepositoryPresent,
329
 
                              branch.bzrdir.open_repository)
330
 
        finally:
331
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
397
        format = bzrdir.format_registry.make_bzrdir('knit')
 
398
        repo = self.make_repository('.', shared=True, format=format)
 
399
        repo.set_make_working_trees(False)
 
400
        branch = bzrdir.BzrDir.create_branch_convenience('child',
 
401
            force_new_tree=True, format=format)
 
402
        branch.bzrdir.open_workingtree()
 
403
        self.assertRaises(errors.NoRepositoryPresent,
 
404
                          branch.bzrdir.open_repository)
332
405
 
333
406
    def test_create_branch_convenience_under_shared_repo_force_new_repo(self):
334
407
        # inside a repo the default convenience output is overridable to give
335
408
        # repo+branch+tree
336
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
337
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
338
 
        try:
339
 
            self.make_repository('.', shared=True)
340
 
            branch = bzrdir.BzrDir.create_branch_convenience('child',
341
 
                force_new_repo=True)
342
 
            branch.bzrdir.open_repository()
343
 
            branch.bzrdir.open_workingtree()
344
 
        finally:
345
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
409
        format = bzrdir.format_registry.make_bzrdir('knit')
 
410
        self.make_repository('.', shared=True, format=format)
 
411
        branch = bzrdir.BzrDir.create_branch_convenience('child',
 
412
            force_new_repo=True, format=format)
 
413
        branch.bzrdir.open_repository()
 
414
        branch.bzrdir.open_workingtree()
 
415
 
 
416
 
 
417
class TestRepositoryAcquisitionPolicy(TestCaseWithTransport):
 
418
 
 
419
    def test_acquire_repository_standalone(self):
 
420
        """The default acquisition policy should create a standalone branch."""
 
421
        my_bzrdir = self.make_bzrdir('.')
 
422
        repo_policy = my_bzrdir.determine_repository_policy()
 
423
        repo = repo_policy.acquire_repository()
 
424
        self.assertEqual(repo.bzrdir.root_transport.base,
 
425
                         my_bzrdir.root_transport.base)
 
426
        self.assertFalse(repo.is_shared())
 
427
 
 
428
 
 
429
    def test_determine_stacking_policy(self):
 
430
        parent_bzrdir = self.make_bzrdir('.')
 
431
        child_bzrdir = self.make_bzrdir('child')
 
432
        parent_bzrdir.get_config().set_default_stack_on('http://example.org')
 
433
        repo_policy = child_bzrdir.determine_repository_policy()
 
434
        self.assertEqual('http://example.org', repo_policy._stack_on)
 
435
 
 
436
    def test_determine_stacking_policy_relative(self):
 
437
        parent_bzrdir = self.make_bzrdir('.')
 
438
        child_bzrdir = self.make_bzrdir('child')
 
439
        parent_bzrdir.get_config().set_default_stack_on('child2')
 
440
        repo_policy = child_bzrdir.determine_repository_policy()
 
441
        self.assertEqual('child2', repo_policy._stack_on)
 
442
        self.assertEqual(parent_bzrdir.root_transport.base,
 
443
                         repo_policy._stack_on_pwd)
 
444
 
 
445
    def prepare_default_stacking(self):
 
446
        parent_bzrdir = self.make_bzrdir('.')
 
447
        child_branch = self.make_branch('child', format='development1')
 
448
        parent_bzrdir.get_config().set_default_stack_on(child_branch.base)
 
449
        new_child_transport = parent_bzrdir.transport.clone('child2')
 
450
        return child_branch, new_child_transport
 
451
 
 
452
    def test_clone_on_transport_obeys_stacking_policy(self):
 
453
        child_branch, new_child_transport = self.prepare_default_stacking()
 
454
        new_child = child_branch.bzrdir.clone_on_transport(new_child_transport)
 
455
        self.assertEqual(child_branch.base,
 
456
                         new_child.open_branch().get_stacked_on_url())
 
457
 
 
458
    def test_sprout_obeys_stacking_policy(self):
 
459
        child_branch, new_child_transport = self.prepare_default_stacking()
 
460
        new_child = child_branch.bzrdir.sprout(new_child_transport.base)
 
461
        self.assertEqual(child_branch.base,
 
462
                         new_child.open_branch().get_stacked_on_url())
 
463
 
 
464
    def test_add_fallback_repo_handles_absolute_urls(self):
 
465
        stack_on = self.make_branch('stack_on', format='development1')
 
466
        repo = self.make_repository('repo', format='development1')
 
467
        policy = bzrdir.UseExistingRepository(repo, stack_on.base)
 
468
        policy._add_fallback(repo)
 
469
 
 
470
    def test_add_fallback_repo_handles_relative_urls(self):
 
471
        stack_on = self.make_branch('stack_on', format='development1')
 
472
        repo = self.make_repository('repo', format='development1')
 
473
        policy = bzrdir.UseExistingRepository(repo, '.', stack_on.base)
 
474
        policy._add_fallback(repo)
 
475
 
 
476
    def test_configure_relative_branch_stacking_url(self):
 
477
        stack_on = self.make_branch('stack_on', format='development1')
 
478
        stacked = self.make_branch('stack_on/stacked', format='development1')
 
479
        policy = bzrdir.UseExistingRepository(stacked.repository,
 
480
            '.', stack_on.base)
 
481
        policy.configure_branch(stacked)
 
482
        self.assertEqual('..', stacked.get_stacked_on_url())
 
483
 
 
484
    def test_relative_branch_stacking_to_absolute(self):
 
485
        stack_on = self.make_branch('stack_on', format='development1')
 
486
        stacked = self.make_branch('stack_on/stacked', format='development1')
 
487
        policy = bzrdir.UseExistingRepository(stacked.repository,
 
488
            '.', self.get_readonly_url('stack_on'))
 
489
        policy.configure_branch(stacked)
 
490
        self.assertEqual(self.get_readonly_url('stack_on'),
 
491
                         stacked.get_stacked_on_url())
346
492
 
347
493
 
348
494
class ChrootedTests(TestCaseWithTransport):
355
501
 
356
502
    def setUp(self):
357
503
        super(ChrootedTests, self).setUp()
358
 
        if not self.transport_server == MemoryServer:
 
504
        if not self.vfs_transport_factory == MemoryServer:
359
505
            self.transport_readonly_server = HttpServer
360
506
 
 
507
    def local_branch_path(self, branch):
 
508
         return os.path.realpath(urlutils.local_path_from_url(branch.base))
 
509
 
361
510
    def test_open_containing(self):
362
511
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing,
363
512
                          self.get_readonly_url(''))
369
518
        branch, relpath = bzrdir.BzrDir.open_containing(self.get_readonly_url('g/p/q'))
370
519
        self.assertEqual('g/p/q', relpath)
371
520
 
 
521
    def test_open_containing_tree_branch_or_repository_empty(self):
 
522
        self.assertRaises(errors.NotBranchError,
 
523
            bzrdir.BzrDir.open_containing_tree_branch_or_repository,
 
524
            self.get_readonly_url(''))
 
525
 
 
526
    def test_open_containing_tree_branch_or_repository_all(self):
 
527
        self.make_branch_and_tree('topdir')
 
528
        tree, branch, repo, relpath = \
 
529
            bzrdir.BzrDir.open_containing_tree_branch_or_repository(
 
530
                'topdir/foo')
 
531
        self.assertEqual(os.path.realpath('topdir'),
 
532
                         os.path.realpath(tree.basedir))
 
533
        self.assertEqual(os.path.realpath('topdir'),
 
534
                         self.local_branch_path(branch))
 
535
        self.assertEqual(
 
536
            osutils.realpath(os.path.join('topdir', '.bzr', 'repository')),
 
537
            repo.bzrdir.transport.local_abspath('repository'))
 
538
        self.assertEqual(relpath, 'foo')
 
539
 
 
540
    def test_open_containing_tree_branch_or_repository_no_tree(self):
 
541
        self.make_branch('branch')
 
542
        tree, branch, repo, relpath = \
 
543
            bzrdir.BzrDir.open_containing_tree_branch_or_repository(
 
544
                'branch/foo')
 
545
        self.assertEqual(tree, None)
 
546
        self.assertEqual(os.path.realpath('branch'),
 
547
                         self.local_branch_path(branch))
 
548
        self.assertEqual(
 
549
            osutils.realpath(os.path.join('branch', '.bzr', 'repository')),
 
550
            repo.bzrdir.transport.local_abspath('repository'))
 
551
        self.assertEqual(relpath, 'foo')
 
552
 
 
553
    def test_open_containing_tree_branch_or_repository_repo(self):
 
554
        self.make_repository('repo')
 
555
        tree, branch, repo, relpath = \
 
556
            bzrdir.BzrDir.open_containing_tree_branch_or_repository(
 
557
                'repo')
 
558
        self.assertEqual(tree, None)
 
559
        self.assertEqual(branch, None)
 
560
        self.assertEqual(
 
561
            osutils.realpath(os.path.join('repo', '.bzr', 'repository')),
 
562
            repo.bzrdir.transport.local_abspath('repository'))
 
563
        self.assertEqual(relpath, '')
 
564
 
 
565
    def test_open_containing_tree_branch_or_repository_shared_repo(self):
 
566
        self.make_repository('shared', shared=True)
 
567
        bzrdir.BzrDir.create_branch_convenience('shared/branch',
 
568
                                                force_new_tree=False)
 
569
        tree, branch, repo, relpath = \
 
570
            bzrdir.BzrDir.open_containing_tree_branch_or_repository(
 
571
                'shared/branch')
 
572
        self.assertEqual(tree, None)
 
573
        self.assertEqual(os.path.realpath('shared/branch'),
 
574
                         self.local_branch_path(branch))
 
575
        self.assertEqual(
 
576
            osutils.realpath(os.path.join('shared', '.bzr', 'repository')),
 
577
            repo.bzrdir.transport.local_abspath('repository'))
 
578
        self.assertEqual(relpath, '')
 
579
 
 
580
    def test_open_containing_tree_branch_or_repository_branch_subdir(self):
 
581
        self.make_branch_and_tree('foo')
 
582
        self.build_tree(['foo/bar/'])
 
583
        tree, branch, repo, relpath = \
 
584
            bzrdir.BzrDir.open_containing_tree_branch_or_repository(
 
585
                'foo/bar')
 
586
        self.assertEqual(os.path.realpath('foo'),
 
587
                         os.path.realpath(tree.basedir))
 
588
        self.assertEqual(os.path.realpath('foo'),
 
589
                         self.local_branch_path(branch))
 
590
        self.assertEqual(
 
591
            osutils.realpath(os.path.join('foo', '.bzr', 'repository')),
 
592
            repo.bzrdir.transport.local_abspath('repository'))
 
593
        self.assertEqual(relpath, 'bar')
 
594
 
 
595
    def test_open_containing_tree_branch_or_repository_repo_subdir(self):
 
596
        self.make_repository('bar')
 
597
        self.build_tree(['bar/baz/'])
 
598
        tree, branch, repo, relpath = \
 
599
            bzrdir.BzrDir.open_containing_tree_branch_or_repository(
 
600
                'bar/baz')
 
601
        self.assertEqual(tree, None)
 
602
        self.assertEqual(branch, None)
 
603
        self.assertEqual(
 
604
            osutils.realpath(os.path.join('bar', '.bzr', 'repository')),
 
605
            repo.bzrdir.transport.local_abspath('repository'))
 
606
        self.assertEqual(relpath, 'baz')
 
607
 
372
608
    def test_open_containing_from_transport(self):
373
609
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing_from_transport,
374
610
                          get_transport(self.get_readonly_url('')))
382
618
            get_transport(self.get_readonly_url('g/p/q')))
383
619
        self.assertEqual('g/p/q', relpath)
384
620
 
 
621
    def test_open_containing_tree_or_branch(self):
 
622
        self.make_branch_and_tree('topdir')
 
623
        tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
 
624
            'topdir/foo')
 
625
        self.assertEqual(os.path.realpath('topdir'),
 
626
                         os.path.realpath(tree.basedir))
 
627
        self.assertEqual(os.path.realpath('topdir'),
 
628
                         self.local_branch_path(branch))
 
629
        self.assertIs(tree.bzrdir, branch.bzrdir)
 
630
        self.assertEqual('foo', relpath)
 
631
        # opening from non-local should not return the tree
 
632
        tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
 
633
            self.get_readonly_url('topdir/foo'))
 
634
        self.assertEqual(None, tree)
 
635
        self.assertEqual('foo', relpath)
 
636
        # without a tree:
 
637
        self.make_branch('topdir/foo')
 
638
        tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
 
639
            'topdir/foo')
 
640
        self.assertIs(tree, None)
 
641
        self.assertEqual(os.path.realpath('topdir/foo'),
 
642
                         self.local_branch_path(branch))
 
643
        self.assertEqual('', relpath)
 
644
 
 
645
    def test_open_tree_or_branch(self):
 
646
        self.make_branch_and_tree('topdir')
 
647
        tree, branch = bzrdir.BzrDir.open_tree_or_branch('topdir')
 
648
        self.assertEqual(os.path.realpath('topdir'),
 
649
                         os.path.realpath(tree.basedir))
 
650
        self.assertEqual(os.path.realpath('topdir'),
 
651
                         self.local_branch_path(branch))
 
652
        self.assertIs(tree.bzrdir, branch.bzrdir)
 
653
        # opening from non-local should not return the tree
 
654
        tree, branch = bzrdir.BzrDir.open_tree_or_branch(
 
655
            self.get_readonly_url('topdir'))
 
656
        self.assertEqual(None, tree)
 
657
        # without a tree:
 
658
        self.make_branch('topdir/foo')
 
659
        tree, branch = bzrdir.BzrDir.open_tree_or_branch('topdir/foo')
 
660
        self.assertIs(tree, None)
 
661
        self.assertEqual(os.path.realpath('topdir/foo'),
 
662
                         self.local_branch_path(branch))
 
663
 
 
664
    def test_open_from_transport(self):
 
665
        # transport pointing at bzrdir should give a bzrdir with root transport
 
666
        # set to the given transport
 
667
        control = bzrdir.BzrDir.create(self.get_url())
 
668
        transport = get_transport(self.get_url())
 
669
        opened_bzrdir = bzrdir.BzrDir.open_from_transport(transport)
 
670
        self.assertEqual(transport.base, opened_bzrdir.root_transport.base)
 
671
        self.assertIsInstance(opened_bzrdir, bzrdir.BzrDir)
 
672
        
 
673
    def test_open_from_transport_no_bzrdir(self):
 
674
        transport = get_transport(self.get_url())
 
675
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport,
 
676
                          transport)
 
677
 
 
678
    def test_open_from_transport_bzrdir_in_parent(self):
 
679
        control = bzrdir.BzrDir.create(self.get_url())
 
680
        transport = get_transport(self.get_url())
 
681
        transport.mkdir('subdir')
 
682
        transport = transport.clone('subdir')
 
683
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport,
 
684
                          transport)
 
685
 
 
686
    def test_sprout_recursive(self):
 
687
        tree = self.make_branch_and_tree('tree1', format='dirstate-with-subtree')
 
688
        sub_tree = self.make_branch_and_tree('tree1/subtree',
 
689
            format='dirstate-with-subtree')
 
690
        tree.add_reference(sub_tree)
 
691
        self.build_tree(['tree1/subtree/file'])
 
692
        sub_tree.add('file')
 
693
        tree.commit('Initial commit')
 
694
        tree.bzrdir.sprout('tree2')
 
695
        self.failUnlessExists('tree2/subtree/file')
 
696
 
 
697
    def test_cloning_metadir(self):
 
698
        """Ensure that cloning metadir is suitable"""
 
699
        bzrdir = self.make_bzrdir('bzrdir')
 
700
        bzrdir.cloning_metadir()
 
701
        branch = self.make_branch('branch', format='knit')
 
702
        format = branch.bzrdir.cloning_metadir()
 
703
        self.assertIsInstance(format.workingtree_format,
 
704
            workingtree.WorkingTreeFormat3)
 
705
 
 
706
    def test_sprout_recursive_treeless(self):
 
707
        tree = self.make_branch_and_tree('tree1',
 
708
            format='dirstate-with-subtree')
 
709
        sub_tree = self.make_branch_and_tree('tree1/subtree',
 
710
            format='dirstate-with-subtree')
 
711
        tree.add_reference(sub_tree)
 
712
        self.build_tree(['tree1/subtree/file'])
 
713
        sub_tree.add('file')
 
714
        tree.commit('Initial commit')
 
715
        tree.bzrdir.destroy_workingtree()
 
716
        repo = self.make_repository('repo', shared=True,
 
717
            format='dirstate-with-subtree')
 
718
        repo.set_make_working_trees(False)
 
719
        tree.bzrdir.sprout('repo/tree2')
 
720
        self.failUnlessExists('repo/tree2/subtree')
 
721
        self.failIfExists('repo/tree2/subtree/file')
 
722
 
 
723
    def make_foo_bar_baz(self):
 
724
        foo = bzrdir.BzrDir.create_branch_convenience('foo').bzrdir
 
725
        bar = self.make_branch('foo/bar').bzrdir
 
726
        baz = self.make_branch('baz').bzrdir
 
727
        return foo, bar, baz
 
728
 
 
729
    def test_find_bzrdirs(self):
 
730
        foo, bar, baz = self.make_foo_bar_baz()
 
731
        transport = get_transport(self.get_url())
 
732
        self.assertEqualBzrdirs([baz, foo, bar],
 
733
                                bzrdir.BzrDir.find_bzrdirs(transport))
 
734
 
 
735
    def test_find_bzrdirs_list_current(self):
 
736
        def list_current(transport):
 
737
            return [s for s in transport.list_dir('') if s != 'baz']
 
738
 
 
739
        foo, bar, baz = self.make_foo_bar_baz()
 
740
        transport = get_transport(self.get_url())
 
741
        self.assertEqualBzrdirs([foo, bar],
 
742
                                bzrdir.BzrDir.find_bzrdirs(transport,
 
743
                                    list_current=list_current))
 
744
 
 
745
 
 
746
    def test_find_bzrdirs_evaluate(self):
 
747
        def evaluate(bzrdir):
 
748
            try:
 
749
                repo = bzrdir.open_repository()
 
750
            except NoRepositoryPresent:
 
751
                return True, bzrdir.root_transport.base
 
752
            else:
 
753
                return False, bzrdir.root_transport.base
 
754
 
 
755
        foo, bar, baz = self.make_foo_bar_baz()
 
756
        transport = get_transport(self.get_url())
 
757
        self.assertEqual([baz.root_transport.base, foo.root_transport.base],
 
758
                         list(bzrdir.BzrDir.find_bzrdirs(transport,
 
759
                                                         evaluate=evaluate)))
 
760
 
 
761
    def assertEqualBzrdirs(self, first, second):
 
762
        first = list(first)
 
763
        second = list(second)
 
764
        self.assertEqual(len(first), len(second))
 
765
        for x, y in zip(first, second):
 
766
            self.assertEqual(x.root_transport.base, y.root_transport.base)
 
767
 
 
768
    def test_find_branches(self):
 
769
        root = self.make_repository('', shared=True)
 
770
        foo, bar, baz = self.make_foo_bar_baz()
 
771
        qux = self.make_bzrdir('foo/qux')
 
772
        transport = get_transport(self.get_url())
 
773
        branches = bzrdir.BzrDir.find_branches(transport)
 
774
        self.assertEqual(baz.root_transport.base, branches[0].base)
 
775
        self.assertEqual(foo.root_transport.base, branches[1].base)
 
776
        self.assertEqual(bar.root_transport.base, branches[2].base)
 
777
 
 
778
        # ensure this works without a top-level repo
 
779
        branches = bzrdir.BzrDir.find_branches(transport.clone('foo'))
 
780
        self.assertEqual(foo.root_transport.base, branches[0].base)
 
781
        self.assertEqual(bar.root_transport.base, branches[1].base)
 
782
 
385
783
 
386
784
class TestMeta1DirFormat(TestCaseWithTransport):
387
785
    """Tests specific to the meta1 dir format."""
396
794
        repository_base = t.clone('repository').base
397
795
        self.assertEqual(repository_base, dir.get_repository_transport(None).base)
398
796
        self.assertEqual(repository_base,
399
 
                         dir.get_repository_transport(repository.RepositoryFormat7()).base)
 
797
                         dir.get_repository_transport(weaverepo.RepositoryFormat7()).base)
400
798
        checkout_base = t.clone('checkout').base
401
799
        self.assertEqual(checkout_base, dir.get_workingtree_transport(None).base)
402
800
        self.assertEqual(checkout_base,
408
806
        t = dir.transport
409
807
        self.assertIsDirectory('branch-lock', t)
410
808
 
411
 
        
 
809
    def test_comparison(self):
 
810
        """Equality and inequality behave properly.
 
811
 
 
812
        Metadirs should compare equal iff they have the same repo, branch and
 
813
        tree formats.
 
814
        """
 
815
        mydir = bzrdir.format_registry.make_bzrdir('knit')
 
816
        self.assertEqual(mydir, mydir)
 
817
        self.assertFalse(mydir != mydir)
 
818
        otherdir = bzrdir.format_registry.make_bzrdir('knit')
 
819
        self.assertEqual(otherdir, mydir)
 
820
        self.assertFalse(otherdir != mydir)
 
821
        otherdir2 = bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
 
822
        self.assertNotEqual(otherdir2, mydir)
 
823
        self.assertFalse(otherdir2 == mydir)
 
824
 
 
825
    def test_needs_conversion_different_working_tree(self):
 
826
        # meta1dirs need an conversion if any element is not the default.
 
827
        old_format = bzrdir.BzrDirFormat.get_default_format()
 
828
        # test with 
 
829
        new_default = bzrdir.format_registry.make_bzrdir('dirstate')
 
830
        bzrdir.BzrDirFormat._set_default_format(new_default)
 
831
        try:
 
832
            tree = self.make_branch_and_tree('tree', format='knit')
 
833
            self.assertTrue(tree.bzrdir.needs_format_conversion())
 
834
        finally:
 
835
            bzrdir.BzrDirFormat._set_default_format(old_format)
 
836
 
 
837
 
412
838
class TestFormat5(TestCaseWithTransport):
413
839
    """Tests specific to the version 5 bzrdir format."""
414
840
 
436
862
        # format 5 dirs need a conversion if they are not the default.
437
863
        # and they start of not the default.
438
864
        old_format = bzrdir.BzrDirFormat.get_default_format()
439
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirFormat5())
 
865
        bzrdir.BzrDirFormat._set_default_format(bzrdir.BzrDirFormat5())
440
866
        try:
441
867
            dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
442
868
            self.assertFalse(dir.needs_format_conversion())
443
869
        finally:
444
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
870
            bzrdir.BzrDirFormat._set_default_format(old_format)
445
871
        self.assertTrue(dir.needs_format_conversion())
446
872
 
447
873
 
471
897
    def test_needs_conversion(self):
472
898
        # format 6 dirs need an conversion if they are not the default.
473
899
        old_format = bzrdir.BzrDirFormat.get_default_format()
474
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
 
900
        bzrdir.BzrDirFormat._set_default_format(bzrdir.BzrDirMetaFormat1())
475
901
        try:
476
902
            dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
477
903
            self.assertTrue(dir.needs_format_conversion())
478
904
        finally:
479
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
905
            bzrdir.BzrDirFormat._set_default_format(old_format)
 
906
 
 
907
 
 
908
class NotBzrDir(bzrlib.bzrdir.BzrDir):
 
909
    """A non .bzr based control directory."""
 
910
 
 
911
    def __init__(self, transport, format):
 
912
        self._format = format
 
913
        self.root_transport = transport
 
914
        self.transport = transport.clone('.not')
 
915
 
 
916
 
 
917
class NotBzrDirFormat(bzrlib.bzrdir.BzrDirFormat):
 
918
    """A test class representing any non-.bzr based disk format."""
 
919
 
 
920
    def initialize_on_transport(self, transport):
 
921
        """Initialize a new .not dir in the base directory of a Transport."""
 
922
        transport.mkdir('.not')
 
923
        return self.open(transport)
 
924
 
 
925
    def open(self, transport):
 
926
        """Open this directory."""
 
927
        return NotBzrDir(transport, self)
 
928
 
 
929
    @classmethod
 
930
    def _known_formats(self):
 
931
        return set([NotBzrDirFormat()])
 
932
 
 
933
    @classmethod
 
934
    def probe_transport(self, transport):
 
935
        """Our format is present if the transport ends in '.not/'."""
 
936
        if transport.has('.not'):
 
937
            return NotBzrDirFormat()
 
938
 
 
939
 
 
940
class TestNotBzrDir(TestCaseWithTransport):
 
941
    """Tests for using the bzrdir api with a non .bzr based disk format.
 
942
    
 
943
    If/when one of these is in the core, we can let the implementation tests
 
944
    verify this works.
 
945
    """
 
946
 
 
947
    def test_create_and_find_format(self):
 
948
        # create a .notbzr dir 
 
949
        format = NotBzrDirFormat()
 
950
        dir = format.initialize(self.get_url())
 
951
        self.assertIsInstance(dir, NotBzrDir)
 
952
        # now probe for it.
 
953
        bzrlib.bzrdir.BzrDirFormat.register_control_format(format)
 
954
        try:
 
955
            found = bzrlib.bzrdir.BzrDirFormat.find_format(
 
956
                get_transport(self.get_url()))
 
957
            self.assertIsInstance(found, NotBzrDirFormat)
 
958
        finally:
 
959
            bzrlib.bzrdir.BzrDirFormat.unregister_control_format(format)
 
960
 
 
961
    def test_included_in_known_formats(self):
 
962
        bzrlib.bzrdir.BzrDirFormat.register_control_format(NotBzrDirFormat)
 
963
        try:
 
964
            formats = bzrlib.bzrdir.BzrDirFormat.known_formats()
 
965
            for format in formats:
 
966
                if isinstance(format, NotBzrDirFormat):
 
967
                    return
 
968
            self.fail("No NotBzrDirFormat in %s" % formats)
 
969
        finally:
 
970
            bzrlib.bzrdir.BzrDirFormat.unregister_control_format(NotBzrDirFormat)
480
971
 
481
972
 
482
973
class NonLocalTests(TestCaseWithTransport):
484
975
 
485
976
    def setUp(self):
486
977
        super(NonLocalTests, self).setUp()
487
 
        self.transport_server = MemoryServer
 
978
        self.vfs_transport_factory = MemoryServer
488
979
    
489
980
    def test_create_branch_convenience(self):
490
981
        # outside a repo the default convenience output is a repo+branch_tree
491
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
492
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
493
 
        try:
494
 
            branch = bzrdir.BzrDir.create_branch_convenience(self.get_url('foo'))
495
 
            self.assertRaises(errors.NoWorkingTree,
496
 
                              branch.bzrdir.open_workingtree)
497
 
            branch.bzrdir.open_repository()
498
 
        finally:
499
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
982
        format = bzrdir.format_registry.make_bzrdir('knit')
 
983
        branch = bzrdir.BzrDir.create_branch_convenience(
 
984
            self.get_url('foo'), format=format)
 
985
        self.assertRaises(errors.NoWorkingTree,
 
986
                          branch.bzrdir.open_workingtree)
 
987
        branch.bzrdir.open_repository()
500
988
 
501
989
    def test_create_branch_convenience_force_tree_not_local_fails(self):
502
990
        # outside a repo the default convenience output is a repo+branch_tree
503
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
504
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
505
 
        try:
506
 
            self.assertRaises(errors.NotLocalUrl,
507
 
                bzrdir.BzrDir.create_branch_convenience,
508
 
                self.get_url('foo'),
509
 
                force_new_tree=True)
510
 
            t = get_transport(self.get_url('.'))
511
 
            self.assertFalse(t.has('foo'))
512
 
        finally:
513
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
991
        format = bzrdir.format_registry.make_bzrdir('knit')
 
992
        self.assertRaises(errors.NotLocalUrl,
 
993
            bzrdir.BzrDir.create_branch_convenience,
 
994
            self.get_url('foo'),
 
995
            force_new_tree=True,
 
996
            format=format)
 
997
        t = get_transport(self.get_url('.'))
 
998
        self.assertFalse(t.has('foo'))
514
999
 
515
1000
    def test_clone(self):
516
1001
        # clone into a nonlocal path works
517
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
518
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
519
 
        try:
520
 
            branch = bzrdir.BzrDir.create_branch_convenience('local')
521
 
        finally:
522
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
1002
        format = bzrdir.format_registry.make_bzrdir('knit')
 
1003
        branch = bzrdir.BzrDir.create_branch_convenience('local',
 
1004
                                                         format=format)
523
1005
        branch.bzrdir.open_workingtree()
524
1006
        result = branch.bzrdir.clone(self.get_url('remote'))
525
1007
        self.assertRaises(errors.NoWorkingTree,
527
1009
        result.open_branch()
528
1010
        result.open_repository()
529
1011
 
 
1012
    def test_checkout_metadir(self):
 
1013
        # checkout_metadir has reasonable working tree format even when no
 
1014
        # working tree is present
 
1015
        self.make_branch('branch-knit2', format='dirstate-with-subtree')
 
1016
        my_bzrdir = bzrdir.BzrDir.open(self.get_url('branch-knit2'))
 
1017
        checkout_format = my_bzrdir.checkout_metadir()
 
1018
        self.assertIsInstance(checkout_format.workingtree_format,
 
1019
                              workingtree.WorkingTreeFormat3)
 
1020
 
 
1021
 
 
1022
class TestHTTPRedirectionLoop(object):
 
1023
    """Test redirection loop between two http servers.
 
1024
 
 
1025
    This MUST be used by daughter classes that also inherit from
 
1026
    TestCaseWithTwoWebservers.
 
1027
 
 
1028
    We can't inherit directly from TestCaseWithTwoWebservers or the
 
1029
    test framework will try to create an instance which cannot
 
1030
    run, its implementation being incomplete. 
 
1031
    """
 
1032
 
 
1033
    # Should be defined by daughter classes to ensure redirection
 
1034
    # still use the same transport implementation (not currently
 
1035
    # enforced as it's a bit tricky to get right (see the FIXME
 
1036
    # in BzrDir.open_from_transport for the unique use case so
 
1037
    # far)
 
1038
    _qualifier = None
 
1039
 
 
1040
    def create_transport_readonly_server(self):
 
1041
        return HTTPServerRedirecting()
 
1042
 
 
1043
    def create_transport_secondary_server(self):
 
1044
        return HTTPServerRedirecting()
 
1045
 
 
1046
    def setUp(self):
 
1047
        # Both servers redirect to each server creating a loop
 
1048
        super(TestHTTPRedirectionLoop, self).setUp()
 
1049
        # The redirections will point to the new server
 
1050
        self.new_server = self.get_readonly_server()
 
1051
        # The requests to the old server will be redirected
 
1052
        self.old_server = self.get_secondary_server()
 
1053
        # Configure the redirections
 
1054
        self.old_server.redirect_to(self.new_server.host, self.new_server.port)
 
1055
        self.new_server.redirect_to(self.old_server.host, self.old_server.port)
 
1056
 
 
1057
    def _qualified_url(self, host, port):
 
1058
        return 'http+%s://%s:%s' % (self._qualifier, host, port)
 
1059
 
 
1060
    def test_loop(self):
 
1061
        # Starting from either server should loop
 
1062
        old_url = self._qualified_url(self.old_server.host, 
 
1063
                                      self.old_server.port)
 
1064
        oldt = self._transport(old_url)
 
1065
        self.assertRaises(errors.NotBranchError,
 
1066
                          bzrdir.BzrDir.open_from_transport, oldt)
 
1067
        new_url = self._qualified_url(self.new_server.host, 
 
1068
                                      self.new_server.port)
 
1069
        newt = self._transport(new_url)
 
1070
        self.assertRaises(errors.NotBranchError,
 
1071
                          bzrdir.BzrDir.open_from_transport, newt)
 
1072
 
 
1073
 
 
1074
class TestHTTPRedirections_urllib(TestHTTPRedirectionLoop,
 
1075
                                  TestCaseWithTwoWebservers):
 
1076
    """Tests redirections for urllib implementation"""
 
1077
 
 
1078
    _qualifier = 'urllib'
 
1079
    _transport = HttpTransport_urllib
 
1080
 
 
1081
 
 
1082
 
 
1083
class TestHTTPRedirections_pycurl(TestWithTransport_pycurl,
 
1084
                                  TestHTTPRedirectionLoop,
 
1085
                                  TestCaseWithTwoWebservers):
 
1086
    """Tests redirections for pycurl implementation"""
 
1087
 
 
1088
    _qualifier = 'pycurl'
 
1089
 
 
1090
 
 
1091
class TestDotBzrHidden(TestCaseWithTransport):
 
1092
 
 
1093
    ls = ['ls']
 
1094
    if sys.platform == 'win32':
 
1095
        ls = [os.environ['COMSPEC'], '/C', 'dir', '/B']
 
1096
 
 
1097
    def get_ls(self):
 
1098
        f = subprocess.Popen(self.ls, stdout=subprocess.PIPE,
 
1099
            stderr=subprocess.PIPE)
 
1100
        out, err = f.communicate()
 
1101
        self.assertEqual(0, f.returncode, 'Calling %s failed: %s'
 
1102
                         % (self.ls, err))
 
1103
        return out.splitlines()
 
1104
 
 
1105
    def test_dot_bzr_hidden(self):
 
1106
        if sys.platform == 'win32' and not win32utils.has_win32file:
 
1107
            raise TestSkipped('unable to make file hidden without pywin32 library')
 
1108
        b = bzrdir.BzrDir.create('.')
 
1109
        self.build_tree(['a'])
 
1110
        self.assertEquals(['a'], self.get_ls())
 
1111
 
 
1112
    def test_dot_bzr_hidden_with_url(self):
 
1113
        if sys.platform == 'win32' and not win32utils.has_win32file:
 
1114
            raise TestSkipped('unable to make file hidden without pywin32 library')
 
1115
        b = bzrdir.BzrDir.create(urlutils.local_path_to_url('.'))
 
1116
        self.build_tree(['a'])
 
1117
        self.assertEquals(['a'], self.get_ls())
 
1118
 
 
1119
 
 
1120
class _TestBzrDirFormat(bzrdir.BzrDirMetaFormat1):
 
1121
    """Test BzrDirFormat implementation for TestBzrDirSprout."""
 
1122
 
 
1123
    def _open(self, transport):
 
1124
        return _TestBzrDir(transport, self)
 
1125
 
 
1126
 
 
1127
class _TestBzrDir(bzrdir.BzrDirMeta1):
 
1128
    """Test BzrDir implementation for TestBzrDirSprout.
 
1129
    
 
1130
    When created a _TestBzrDir already has repository and a branch.  The branch
 
1131
    is a test double as well.
 
1132
    """
 
1133
 
 
1134
    def __init__(self, *args, **kwargs):
 
1135
        super(_TestBzrDir, self).__init__(*args, **kwargs)
 
1136
        self.test_branch = _TestBranch()
 
1137
        self.test_branch.repository = self.create_repository()
 
1138
 
 
1139
    def open_branch(self, unsupported=False):
 
1140
        return self.test_branch
 
1141
 
 
1142
    def cloning_metadir(self):
 
1143
        return _TestBzrDirFormat()
 
1144
 
 
1145
 
 
1146
class _TestBranch(bzrlib.branch.Branch):
 
1147
    """Test Branch implementation for TestBzrDirSprout."""
 
1148
 
 
1149
    def __init__(self, *args, **kwargs):
 
1150
        super(_TestBranch, self).__init__(*args, **kwargs)
 
1151
        self.calls = []
 
1152
    
 
1153
    def sprout(self, *args, **kwargs):
 
1154
        self.calls.append('sprout')
 
1155
 
 
1156
 
 
1157
class TestBzrDirSprout(TestCaseWithMemoryTransport):
 
1158
 
 
1159
    def test_sprout_uses_branch_sprout(self):
 
1160
        """BzrDir.sprout calls Branch.sprout.
 
1161
 
 
1162
        Usually, BzrDir.sprout should delegate to the branch's sprout method
 
1163
        for part of the work.  This allows the source branch to control the
 
1164
        choice of format for the new branch.
 
1165
        
 
1166
        There are exceptions, but this tests avoids them:
 
1167
          - if there's no branch in the source bzrdir,
 
1168
          - or if the stacking has been requested and the format needs to be
 
1169
            overridden to satisfy that.
 
1170
        """
 
1171
        # Make an instrumented bzrdir.
 
1172
        t = self.get_transport('source')
 
1173
        t.ensure_base()
 
1174
        source_bzrdir = _TestBzrDirFormat().initialize_on_transport(t)
 
1175
        # The instrumented bzrdir has a test_branch attribute that logs calls
 
1176
        # made to the branch contained in that bzrdir.  Initially the test
 
1177
        # branch exists but no calls have been made to it.
 
1178
        self.assertEqual([], source_bzrdir.test_branch.calls)
 
1179
 
 
1180
        # Sprout the bzrdir
 
1181
        target_url = self.get_url('target')
 
1182
        result = source_bzrdir.sprout(target_url, recurse='no')
 
1183
 
 
1184
        # The bzrdir called the branch's sprout method.
 
1185
        self.assertEqual(['sprout'], source_bzrdir.test_branch.calls)
 
1186