/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

First attempt to merge .dev and resolve the conflicts (but tests are 
failing)

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
 
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
222
        t.put_bytes('.bzr/branch-format', self.get_format_string())
98
223
        return SampleBzrDir(t, self)
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_shared(self):
167
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
168
 
        repo = bzrdir.BzrDir.create_repository('.', shared=True)
169
 
        self.assertTrue(repo.is_shared())
170
 
 
171
 
    def test_create_repository_nonshared(self):
172
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
173
 
        repo = bzrdir.BzrDir.create_repository('.')
174
 
        self.assertFalse(repo.is_shared())
175
 
 
176
 
    def test_create_repository_under_shared(self):
177
 
        # an explicit create_repository always does so.
178
 
        # we trust the format is right from the 'create_repository test'
179
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
180
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
181
 
        try:
182
 
            self.make_repository('.', shared=True)
183
 
            repo = bzrdir.BzrDir.create_repository(self.get_url('child'))
184
 
            self.assertTrue(isinstance(repo, repository.Repository))
185
 
            self.assertTrue(repo.bzrdir.root_transport.base.endswith('child/'))
186
 
        finally:
187
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
188
 
 
189
281
    def test_create_branch_and_repo_uses_default(self):
190
282
        format = SampleBzrDirFormat()
191
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
192
 
        bzrdir.BzrDirFormat.set_default_format(format)
193
 
        try:
194
 
            branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url())
195
 
            self.assertTrue(isinstance(branch, SampleBranch))
196
 
        finally:
197
 
            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))
198
286
 
199
287
    def test_create_branch_and_repo_under_shared(self):
200
288
        # creating a branch and repo in a shared repo uses the
201
289
        # shared repository
202
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
203
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
204
 
        try:
205
 
            self.make_repository('.', shared=True)
206
 
            branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url('child'))
207
 
            self.assertRaises(errors.NoRepositoryPresent,
208
 
                              branch.bzrdir.open_repository)
209
 
        finally:
210
 
            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)
211
296
 
212
297
    def test_create_branch_and_repo_under_shared_force_new(self):
213
298
        # creating a branch and repo in a shared repo can be forced to 
214
299
        # make a new repo
215
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
216
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
217
 
        try:
218
 
            self.make_repository('.', shared=True)
219
 
            branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url('child'),
220
 
                                                          force_new_repo=True)
221
 
            branch.bzrdir.open_repository()
222
 
        finally:
223
 
            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()
224
306
 
225
307
    def test_create_standalone_working_tree(self):
226
308
        format = SampleBzrDirFormat()
227
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
228
 
        bzrdir.BzrDirFormat.set_default_format(format)
229
 
        try:
230
 
            # note this is deliberately readonly, as this failure should 
231
 
            # occur before any writes.
232
 
            self.assertRaises(errors.NotLocalUrl,
233
 
                              bzrdir.BzrDir.create_standalone_workingtree,
234
 
                              self.get_readonly_url())
235
 
            tree = bzrdir.BzrDir.create_standalone_workingtree('.')
236
 
            self.assertEqual('A tree', tree)
237
 
        finally:
238
 
            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)
239
317
 
240
318
    def test_create_standalone_working_tree_under_shared_repo(self):
241
319
        # create standalone working tree always makes a repo.
242
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
243
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
244
 
        try:
245
 
            self.make_repository('.', shared=True)
246
 
            # note this is deliberately readonly, as this failure should 
247
 
            # occur before any writes.
248
 
            self.assertRaises(errors.NotLocalUrl,
249
 
                              bzrdir.BzrDir.create_standalone_workingtree,
250
 
                              self.get_readonly_url('child'))
251
 
            tree = bzrdir.BzrDir.create_standalone_workingtree('child')
252
 
            tree.bzrdir.open_repository()
253
 
        finally:
254
 
            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()
255
330
 
256
331
    def test_create_branch_convenience(self):
257
332
        # outside a repo the default convenience output is a repo+branch_tree
258
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
259
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
260
 
        try:
261
 
            branch = bzrdir.BzrDir.create_branch_convenience('.')
262
 
            branch.bzrdir.open_workingtree()
263
 
            branch.bzrdir.open_repository()
264
 
        finally:
265
 
            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()
266
346
 
267
347
    def test_create_branch_convenience_root(self):
268
348
        """Creating a branch at the root of a fs should work."""
269
 
        self.transport_server = MemoryServer
 
349
        self.vfs_transport_factory = MemoryServer
270
350
        # outside a repo the default convenience output is a repo+branch_tree
271
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
272
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
273
 
        try:
274
 
            branch = bzrdir.BzrDir.create_branch_convenience(self.get_url())
275
 
            self.assertRaises(errors.NoWorkingTree,
276
 
                              branch.bzrdir.open_workingtree)
277
 
            branch.bzrdir.open_repository()
278
 
        finally:
279
 
            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()
280
357
 
281
358
    def test_create_branch_convenience_under_shared_repo(self):
282
359
        # inside a repo the default convenience output is a branch+ follow the
283
360
        # repo tree policy
284
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
285
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
286
 
        try:
287
 
            self.make_repository('.', shared=True)
288
 
            branch = bzrdir.BzrDir.create_branch_convenience('child')
289
 
            branch.bzrdir.open_workingtree()
290
 
            self.assertRaises(errors.NoRepositoryPresent,
291
 
                              branch.bzrdir.open_repository)
292
 
        finally:
293
 
            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)
294
368
            
295
369
    def test_create_branch_convenience_under_shared_repo_force_no_tree(self):
296
370
        # inside a repo the default convenience output is a branch+ follow the
297
371
        # repo tree policy but we can override that
298
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
299
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
300
 
        try:
301
 
            self.make_repository('.', shared=True)
302
 
            branch = bzrdir.BzrDir.create_branch_convenience('child',
303
 
                force_new_tree=False)
304
 
            self.assertRaises(errors.NoWorkingTree,
305
 
                              branch.bzrdir.open_workingtree)
306
 
            self.assertRaises(errors.NoRepositoryPresent,
307
 
                              branch.bzrdir.open_repository)
308
 
        finally:
309
 
            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)
310
380
            
311
381
    def test_create_branch_convenience_under_shared_repo_no_tree_policy(self):
312
382
        # inside a repo the default convenience output is a branch+ follow the
313
383
        # repo tree policy
314
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
315
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
316
 
        try:
317
 
            repo = self.make_repository('.', shared=True)
318
 
            repo.set_make_working_trees(False)
319
 
            branch = bzrdir.BzrDir.create_branch_convenience('child')
320
 
            self.assertRaises(errors.NoWorkingTree,
321
 
                              branch.bzrdir.open_workingtree)
322
 
            self.assertRaises(errors.NoRepositoryPresent,
323
 
                              branch.bzrdir.open_repository)
324
 
        finally:
325
 
            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)
326
393
 
327
394
    def test_create_branch_convenience_under_shared_repo_no_tree_policy_force_tree(self):
328
395
        # inside a repo the default convenience output is a branch+ follow the
329
396
        # repo tree policy but we can override that
330
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
331
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
332
 
        try:
333
 
            repo = self.make_repository('.', shared=True)
334
 
            repo.set_make_working_trees(False)
335
 
            branch = bzrdir.BzrDir.create_branch_convenience('child',
336
 
                force_new_tree=True)
337
 
            branch.bzrdir.open_workingtree()
338
 
            self.assertRaises(errors.NoRepositoryPresent,
339
 
                              branch.bzrdir.open_repository)
340
 
        finally:
341
 
            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)
342
405
 
343
406
    def test_create_branch_convenience_under_shared_repo_force_new_repo(self):
344
407
        # inside a repo the default convenience output is overridable to give
345
408
        # repo+branch+tree
346
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
347
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
348
 
        try:
349
 
            self.make_repository('.', shared=True)
350
 
            branch = bzrdir.BzrDir.create_branch_convenience('child',
351
 
                force_new_repo=True)
352
 
            branch.bzrdir.open_repository()
353
 
            branch.bzrdir.open_workingtree()
354
 
        finally:
355
 
            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())
356
492
 
357
493
 
358
494
class ChrootedTests(TestCaseWithTransport):
365
501
 
366
502
    def setUp(self):
367
503
        super(ChrootedTests, self).setUp()
368
 
        if not self.transport_server == MemoryServer:
 
504
        if not self.vfs_transport_factory == MemoryServer:
369
505
            self.transport_readonly_server = HttpServer
370
506
 
 
507
    def local_branch_path(self, branch):
 
508
         return os.path.realpath(urlutils.local_path_from_url(branch.base))
 
509
 
371
510
    def test_open_containing(self):
372
511
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing,
373
512
                          self.get_readonly_url(''))
379
518
        branch, relpath = bzrdir.BzrDir.open_containing(self.get_readonly_url('g/p/q'))
380
519
        self.assertEqual('g/p/q', relpath)
381
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
 
382
608
    def test_open_containing_from_transport(self):
383
609
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing_from_transport,
384
610
                          get_transport(self.get_readonly_url('')))
392
618
            get_transport(self.get_readonly_url('g/p/q')))
393
619
        self.assertEqual('g/p/q', relpath)
394
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
 
395
664
    def test_open_from_transport(self):
396
665
        # transport pointing at bzrdir should give a bzrdir with root transport
397
666
        # set to the given transport
414
683
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport,
415
684
                          transport)
416
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
 
417
783
 
418
784
class TestMeta1DirFormat(TestCaseWithTransport):
419
785
    """Tests specific to the meta1 dir format."""
428
794
        repository_base = t.clone('repository').base
429
795
        self.assertEqual(repository_base, dir.get_repository_transport(None).base)
430
796
        self.assertEqual(repository_base,
431
 
                         dir.get_repository_transport(repository.RepositoryFormat7()).base)
 
797
                         dir.get_repository_transport(weaverepo.RepositoryFormat7()).base)
432
798
        checkout_base = t.clone('checkout').base
433
799
        self.assertEqual(checkout_base, dir.get_workingtree_transport(None).base)
434
800
        self.assertEqual(checkout_base,
440
806
        t = dir.transport
441
807
        self.assertIsDirectory('branch-lock', t)
442
808
 
443
 
        
 
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
 
444
838
class TestFormat5(TestCaseWithTransport):
445
839
    """Tests specific to the version 5 bzrdir format."""
446
840
 
468
862
        # format 5 dirs need a conversion if they are not the default.
469
863
        # and they start of not the default.
470
864
        old_format = bzrdir.BzrDirFormat.get_default_format()
471
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirFormat5())
 
865
        bzrdir.BzrDirFormat._set_default_format(bzrdir.BzrDirFormat5())
472
866
        try:
473
867
            dir = bzrdir.BzrDirFormat5().initialize(self.get_url())
474
868
            self.assertFalse(dir.needs_format_conversion())
475
869
        finally:
476
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
870
            bzrdir.BzrDirFormat._set_default_format(old_format)
477
871
        self.assertTrue(dir.needs_format_conversion())
478
872
 
479
873
 
503
897
    def test_needs_conversion(self):
504
898
        # format 6 dirs need an conversion if they are not the default.
505
899
        old_format = bzrdir.BzrDirFormat.get_default_format()
506
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
 
900
        bzrdir.BzrDirFormat._set_default_format(bzrdir.BzrDirMetaFormat1())
507
901
        try:
508
902
            dir = bzrdir.BzrDirFormat6().initialize(self.get_url())
509
903
            self.assertTrue(dir.needs_format_conversion())
510
904
        finally:
511
 
            bzrdir.BzrDirFormat.set_default_format(old_format)
 
905
            bzrdir.BzrDirFormat._set_default_format(old_format)
512
906
 
513
907
 
514
908
class NotBzrDir(bzrlib.bzrdir.BzrDir):
581
975
 
582
976
    def setUp(self):
583
977
        super(NonLocalTests, self).setUp()
584
 
        self.transport_server = MemoryServer
 
978
        self.vfs_transport_factory = MemoryServer
585
979
    
586
980
    def test_create_branch_convenience(self):
587
981
        # outside a repo the default convenience output is a repo+branch_tree
588
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
589
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
590
 
        try:
591
 
            branch = bzrdir.BzrDir.create_branch_convenience(self.get_url('foo'))
592
 
            self.assertRaises(errors.NoWorkingTree,
593
 
                              branch.bzrdir.open_workingtree)
594
 
            branch.bzrdir.open_repository()
595
 
        finally:
596
 
            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()
597
988
 
598
989
    def test_create_branch_convenience_force_tree_not_local_fails(self):
599
990
        # outside a repo the default convenience output is a repo+branch_tree
600
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
601
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
602
 
        try:
603
 
            self.assertRaises(errors.NotLocalUrl,
604
 
                bzrdir.BzrDir.create_branch_convenience,
605
 
                self.get_url('foo'),
606
 
                force_new_tree=True)
607
 
            t = get_transport(self.get_url('.'))
608
 
            self.assertFalse(t.has('foo'))
609
 
        finally:
610
 
            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'))
611
999
 
612
1000
    def test_clone(self):
613
1001
        # clone into a nonlocal path works
614
 
        old_format = bzrdir.BzrDirFormat.get_default_format()
615
 
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
616
 
        try:
617
 
            branch = bzrdir.BzrDir.create_branch_convenience('local')
618
 
        finally:
619
 
            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)
620
1005
        branch.bzrdir.open_workingtree()
621
1006
        result = branch.bzrdir.clone(self.get_url('remote'))
622
1007
        self.assertRaises(errors.NoWorkingTree,
624
1009
        result.open_branch()
625
1010
        result.open_repository()
626
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