/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_reconfigure.py

  • Committer: Vincent Ladeuil
  • Date: 2012-01-18 14:09:19 UTC
  • mto: This revision was merged to the branch mainline in revision 6468.
  • Revision ID: v.ladeuil+lp@free.fr-20120118140919-rlvdrhpc0nq1lbwi
Change set/remove to require a lock for the branch config files.

This means that tests (or any plugin for that matter) do not requires an
explicit lock on the branch anymore to change a single option. This also
means the optimisation becomes "opt-in" and as such won't be as
spectacular as it may be and/or harder to get right (nothing fails
anymore).

This reduces the diff by ~300 lines.

Code/tests that were updating more than one config option is still taking
a lock to at least avoid some IOs and demonstrate the benefits through
the decreased number of hpss calls.

The duplication between BranchStack and BranchOnlyStack will be removed
once the same sharing is in place for local config files, at which point
the Stack class itself may be able to host the changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_reconfigure.py
 
1
# Copyright (C) 2007, 2008, 2009, 2011, 2012 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
from bzrlib import (
 
18
    branch as _mod_branch,
 
19
    bzrdir,
 
20
    errors,
 
21
    reconfigure,
 
22
    repository,
 
23
    tests,
 
24
    vf_repository,
 
25
    workingtree,
 
26
    )
 
27
 
 
28
 
 
29
class TestReconfigure(tests.TestCaseWithTransport):
 
30
 
 
31
    def test_tree_to_branch(self):
 
32
        tree = self.make_branch_and_tree('tree')
 
33
        reconfiguration = reconfigure.Reconfigure.to_branch(tree.bzrdir)
 
34
        reconfiguration.apply()
 
35
        self.assertRaises(errors.NoWorkingTree, workingtree.WorkingTree.open,
 
36
                          'tree')
 
37
 
 
38
    def test_modified_tree_to_branch(self):
 
39
        tree = self.make_branch_and_tree('tree')
 
40
        self.build_tree(['tree/file'])
 
41
        tree.add('file')
 
42
        reconfiguration = reconfigure.Reconfigure.to_branch(tree.bzrdir)
 
43
        self.assertRaises(errors.UncommittedChanges, reconfiguration.apply)
 
44
        reconfiguration.apply(force=True)
 
45
        self.assertRaises(errors.NoWorkingTree, workingtree.WorkingTree.open,
 
46
                          'tree')
 
47
 
 
48
    def test_tree_with_pending_merge_to_branch(self):
 
49
        tree = self.make_branch_and_tree('tree')
 
50
        tree.commit('unchanged')
 
51
        other_tree = tree.bzrdir.sprout('other').open_workingtree()
 
52
        other_tree.commit('mergeable commit')
 
53
        tree.merge_from_branch(other_tree.branch)
 
54
        reconfiguration = reconfigure.Reconfigure.to_branch(tree.bzrdir)
 
55
        self.assertRaises(errors.UncommittedChanges, reconfiguration.apply)
 
56
        reconfiguration.apply(force=True)
 
57
        self.assertRaises(errors.NoWorkingTree, workingtree.WorkingTree.open,
 
58
                          'tree')
 
59
 
 
60
    def test_branch_to_branch(self):
 
61
        branch = self.make_branch('branch')
 
62
        self.assertRaises(errors.AlreadyBranch,
 
63
                          reconfigure.Reconfigure.to_branch, branch.bzrdir)
 
64
 
 
65
    def test_repo_to_branch(self):
 
66
        repo = self.make_repository('repo')
 
67
        reconfiguration = reconfigure.Reconfigure.to_branch(repo.bzrdir)
 
68
        reconfiguration.apply()
 
69
 
 
70
    def test_checkout_to_branch(self):
 
71
        branch = self.make_branch('branch')
 
72
        checkout = branch.create_checkout('checkout')
 
73
        reconfiguration = reconfigure.Reconfigure.to_branch(checkout.bzrdir)
 
74
        reconfiguration.apply()
 
75
        reconfigured = bzrdir.BzrDir.open('checkout').open_branch()
 
76
        self.assertIs(None, reconfigured.get_bound_location())
 
77
 
 
78
    def prepare_lightweight_checkout_to_branch(self):
 
79
        branch = self.make_branch('branch')
 
80
        checkout = branch.create_checkout('checkout', lightweight=True)
 
81
        checkout.commit('first commit', rev_id='rev1')
 
82
        reconfiguration = reconfigure.Reconfigure.to_branch(checkout.bzrdir)
 
83
        return reconfiguration, checkout
 
84
 
 
85
    def test_lightweight_checkout_to_branch(self):
 
86
        reconfiguration, checkout = \
 
87
            self.prepare_lightweight_checkout_to_branch()
 
88
        reconfiguration.apply()
 
89
        checkout_branch = checkout.bzrdir.open_branch()
 
90
        self.assertEqual(checkout_branch.bzrdir.root_transport.base,
 
91
                         checkout.bzrdir.root_transport.base)
 
92
        self.assertEqual('rev1', checkout_branch.last_revision())
 
93
        repo = checkout.bzrdir.open_repository()
 
94
        repo.get_revision('rev1')
 
95
 
 
96
    def test_lightweight_checkout_to_branch_tags(self):
 
97
        reconfiguration, checkout = \
 
98
            self.prepare_lightweight_checkout_to_branch()
 
99
        checkout.branch.tags.set_tag('foo', 'bar')
 
100
        reconfiguration.apply()
 
101
        checkout_branch = checkout.bzrdir.open_branch()
 
102
        self.assertEqual('bar', checkout_branch.tags.lookup_tag('foo'))
 
103
 
 
104
    def prepare_lightweight_checkout_to_checkout(self):
 
105
        branch = self.make_branch('branch')
 
106
        checkout = branch.create_checkout('checkout', lightweight=True)
 
107
        reconfiguration = reconfigure.Reconfigure.to_checkout(checkout.bzrdir)
 
108
        return reconfiguration, checkout
 
109
 
 
110
    def test_lightweight_checkout_to_checkout(self):
 
111
        reconfiguration, checkout = \
 
112
            self.prepare_lightweight_checkout_to_checkout()
 
113
        reconfiguration.apply()
 
114
        checkout_branch = checkout.bzrdir.open_branch()
 
115
        self.assertIsNot(checkout_branch.get_bound_location(), None)
 
116
 
 
117
    def test_lightweight_checkout_to_checkout_tags(self):
 
118
        reconfiguration, checkout = \
 
119
            self.prepare_lightweight_checkout_to_checkout()
 
120
        checkout.branch.tags.set_tag('foo', 'bar')
 
121
        reconfiguration.apply()
 
122
        checkout_branch = checkout.bzrdir.open_branch()
 
123
        self.assertEqual('bar', checkout_branch.tags.lookup_tag('foo'))
 
124
 
 
125
    def test_lightweight_conversion_uses_shared_repo(self):
 
126
        parent = self.make_branch('parent')
 
127
        shared_repo = self.make_repository('repo', shared=True)
 
128
        checkout = parent.create_checkout('repo/checkout', lightweight=True)
 
129
        reconfigure.Reconfigure.to_tree(checkout.bzrdir).apply()
 
130
        checkout_repo = checkout.bzrdir.open_branch().repository
 
131
        self.assertEqual(shared_repo.bzrdir.root_transport.base,
 
132
                         checkout_repo.bzrdir.root_transport.base)
 
133
 
 
134
    def test_branch_to_tree(self):
 
135
        branch = self.make_branch('branch')
 
136
        reconfiguration=reconfigure.Reconfigure.to_tree(branch.bzrdir)
 
137
        reconfiguration.apply()
 
138
        branch.bzrdir.open_workingtree()
 
139
 
 
140
    def test_tree_to_tree(self):
 
141
        tree = self.make_branch_and_tree('tree')
 
142
        self.assertRaises(errors.AlreadyTree, reconfigure.Reconfigure.to_tree,
 
143
                          tree.bzrdir)
 
144
 
 
145
    def test_select_bind_location(self):
 
146
        branch = self.make_branch('branch')
 
147
        reconfiguration = reconfigure.Reconfigure(branch.bzrdir)
 
148
        self.assertRaises(errors.NoBindLocation,
 
149
                          reconfiguration._select_bind_location)
 
150
        branch.set_parent('http://parent')
 
151
        reconfiguration = reconfigure.Reconfigure(branch.bzrdir)
 
152
        self.assertEqual('http://parent',
 
153
                         reconfiguration._select_bind_location())
 
154
        branch.set_push_location('sftp://push')
 
155
        reconfiguration = reconfigure.Reconfigure(branch.bzrdir)
 
156
        self.assertEqual('sftp://push',
 
157
                         reconfiguration._select_bind_location())
 
158
        branch.lock_write()
 
159
        try:
 
160
            branch.set_bound_location('bzr://foo/old-bound')
 
161
            branch.set_bound_location(None)
 
162
        finally:
 
163
            branch.unlock()
 
164
        reconfiguration = reconfigure.Reconfigure(branch.bzrdir)
 
165
        self.assertEqual('bzr://foo/old-bound',
 
166
                         reconfiguration._select_bind_location())
 
167
        branch.set_bound_location('bzr://foo/cur-bound')
 
168
        reconfiguration = reconfigure.Reconfigure(branch.bzrdir)
 
169
        self.assertEqual('bzr://foo/cur-bound',
 
170
                         reconfiguration._select_bind_location())
 
171
        reconfiguration.new_bound_location = 'ftp://user-specified'
 
172
        self.assertEqual('ftp://user-specified',
 
173
                         reconfiguration._select_bind_location())
 
174
 
 
175
    def test_select_reference_bind_location(self):
 
176
        branch = self.make_branch('branch')
 
177
        checkout = branch.create_checkout('checkout', lightweight=True)
 
178
        reconfiguration = reconfigure.Reconfigure(checkout.bzrdir)
 
179
        self.assertEqual(branch.base,
 
180
                         reconfiguration._select_bind_location())
 
181
 
 
182
    def test_tree_to_checkout(self):
 
183
        # A tree with no related branches and no supplied bind location cannot
 
184
        # become a checkout
 
185
        parent = self.make_branch('parent')
 
186
 
 
187
        tree = self.make_branch_and_tree('tree')
 
188
        reconfiguration = reconfigure.Reconfigure.to_checkout(tree.bzrdir)
 
189
        self.assertRaises(errors.NoBindLocation, reconfiguration.apply)
 
190
        # setting a parent allows it to become a checkout
 
191
        tree.branch.set_parent(parent.base)
 
192
        reconfiguration = reconfigure.Reconfigure.to_checkout(tree.bzrdir)
 
193
        reconfiguration.apply()
 
194
        # supplying a location allows it to become a checkout
 
195
        tree2 = self.make_branch_and_tree('tree2')
 
196
        reconfiguration = reconfigure.Reconfigure.to_checkout(tree2.bzrdir,
 
197
                                                              parent.base)
 
198
        reconfiguration.apply()
 
199
 
 
200
    def test_tree_to_lightweight_checkout(self):
 
201
        # A tree with no related branches and no supplied bind location cannot
 
202
        # become a checkout
 
203
        parent = self.make_branch('parent')
 
204
 
 
205
        tree = self.make_branch_and_tree('tree')
 
206
        reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
 
207
            tree.bzrdir)
 
208
        self.assertRaises(errors.NoBindLocation, reconfiguration.apply)
 
209
        # setting a parent allows it to become a checkout
 
210
        tree.branch.set_parent(parent.base)
 
211
        reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
 
212
            tree.bzrdir)
 
213
        reconfiguration.apply()
 
214
        # supplying a location allows it to become a checkout
 
215
        tree2 = self.make_branch_and_tree('tree2')
 
216
        reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
 
217
            tree2.bzrdir, parent.base)
 
218
        reconfiguration.apply()
 
219
 
 
220
    def test_checkout_to_checkout(self):
 
221
        parent = self.make_branch('parent')
 
222
        checkout = parent.create_checkout('checkout')
 
223
        self.assertRaises(errors.AlreadyCheckout,
 
224
                          reconfigure.Reconfigure.to_checkout, checkout.bzrdir)
 
225
 
 
226
    def make_unsynced_checkout(self):
 
227
        parent = self.make_branch('parent')
 
228
        checkout = parent.create_checkout('checkout')
 
229
        checkout.commit('test', rev_id='new-commit', local=True)
 
230
        reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
 
231
            checkout.bzrdir)
 
232
        return checkout, parent, reconfiguration
 
233
 
 
234
    def test_unsynced_checkout_to_lightweight(self):
 
235
        checkout, parent, reconfiguration = self.make_unsynced_checkout()
 
236
        self.assertRaises(errors.UnsyncedBranches, reconfiguration.apply)
 
237
 
 
238
    def test_synced_checkout_to_lightweight(self):
 
239
        checkout, parent, reconfiguration = self.make_unsynced_checkout()
 
240
        parent.pull(checkout.branch)
 
241
        reconfiguration.apply()
 
242
        wt = checkout.bzrdir.open_workingtree()
 
243
        self.assertTrue(parent.repository.has_same_location(
 
244
            wt.branch.repository))
 
245
        parent.repository.get_revision('new-commit')
 
246
        self.assertRaises(errors.NoRepositoryPresent,
 
247
                          checkout.bzrdir.open_repository)
 
248
 
 
249
    def prepare_branch_to_lightweight_checkout(self):
 
250
        parent = self.make_branch('parent')
 
251
        child = parent.bzrdir.sprout('child').open_workingtree()
 
252
        child.commit('test', rev_id='new-commit')
 
253
        parent.pull(child.branch)
 
254
        child.bzrdir.destroy_workingtree()
 
255
        reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
 
256
            child.bzrdir)
 
257
        return parent, child, reconfiguration
 
258
 
 
259
    def test_branch_to_lightweight_checkout(self):
 
260
        parent, child, reconfiguration = \
 
261
            self.prepare_branch_to_lightweight_checkout()
 
262
        reconfiguration.apply()
 
263
        self.assertTrue(reconfiguration._destroy_branch)
 
264
        wt = child.bzrdir.open_workingtree()
 
265
        self.assertTrue(parent.repository.has_same_location(
 
266
            wt.branch.repository))
 
267
        parent.repository.get_revision('new-commit')
 
268
        self.assertRaises(errors.NoRepositoryPresent,
 
269
                          child.bzrdir.open_repository)
 
270
 
 
271
    def test_branch_to_lightweight_checkout_failure(self):
 
272
        parent, child, reconfiguration = \
 
273
            self.prepare_branch_to_lightweight_checkout()
 
274
        old_Repository_fetch = vf_repository.VersionedFileRepository.fetch
 
275
        vf_repository.VersionedFileRepository.fetch = None
 
276
        try:
 
277
            self.assertRaises(TypeError, reconfiguration.apply)
 
278
        finally:
 
279
            vf_repository.VersionedFileRepository.fetch = old_Repository_fetch
 
280
        child = _mod_branch.Branch.open('child')
 
281
        self.assertContainsRe(child.base, 'child/$')
 
282
 
 
283
    def test_branch_to_lightweight_checkout_fetch_tags(self):
 
284
        parent, child, reconfiguration = \
 
285
            self.prepare_branch_to_lightweight_checkout()
 
286
        child.branch.tags.set_tag('foo', 'bar')
 
287
        reconfiguration.apply()
 
288
        child = _mod_branch.Branch.open('child')
 
289
        self.assertEqual('bar', parent.tags.lookup_tag('foo'))
 
290
 
 
291
    def test_lightweight_checkout_to_lightweight_checkout(self):
 
292
        parent = self.make_branch('parent')
 
293
        checkout = parent.create_checkout('checkout', lightweight=True)
 
294
        self.assertRaises(errors.AlreadyLightweightCheckout,
 
295
                          reconfigure.Reconfigure.to_lightweight_checkout,
 
296
                          checkout.bzrdir)
 
297
 
 
298
    def test_repo_to_tree(self):
 
299
        repo = self.make_repository('repo')
 
300
        reconfiguration = reconfigure.Reconfigure.to_tree(repo.bzrdir)
 
301
        reconfiguration.apply()
 
302
        workingtree.WorkingTree.open('repo')
 
303
 
 
304
    def test_shared_repo_to_lightweight_checkout(self):
 
305
        repo = self.make_repository('repo', shared=True)
 
306
        reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
 
307
            repo.bzrdir)
 
308
        self.assertRaises(errors.NoBindLocation, reconfiguration.apply)
 
309
        branch = self.make_branch('branch')
 
310
        reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
 
311
            repo.bzrdir, 'branch')
 
312
        reconfiguration.apply()
 
313
        workingtree.WorkingTree.open('repo')
 
314
        repository.Repository.open('repo')
 
315
 
 
316
    def test_unshared_repo_to_lightweight_checkout(self):
 
317
        repo = self.make_repository('repo', shared=False)
 
318
        branch = self.make_branch('branch')
 
319
        reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
 
320
            repo.bzrdir, 'branch')
 
321
        reconfiguration.apply()
 
322
        workingtree.WorkingTree.open('repo')
 
323
        self.assertRaises(errors.NoRepositoryPresent,
 
324
                          repository.Repository.open, 'repo')
 
325
 
 
326
    def test_standalone_to_use_shared(self):
 
327
        self.build_tree(['root/'])
 
328
        tree = self.make_branch_and_tree('root/tree')
 
329
        tree.commit('Hello', rev_id='hello-id')
 
330
        repo = self.make_repository('root', shared=True)
 
331
        reconfiguration = reconfigure.Reconfigure.to_use_shared(tree.bzrdir)
 
332
        reconfiguration.apply()
 
333
        tree = workingtree.WorkingTree.open('root/tree')
 
334
        self.assertTrue(repo.has_same_location(tree.branch.repository))
 
335
        self.assertEqual('Hello', repo.get_revision('hello-id').message)
 
336
 
 
337
    def add_dead_head(self, tree):
 
338
        revno, revision_id = tree.branch.last_revision_info()
 
339
        tree.commit('Dead head', rev_id='dead-head-id')
 
340
        tree.branch.set_last_revision_info(revno, revision_id)
 
341
        tree.set_last_revision(revision_id)
 
342
 
 
343
    def test_standalone_to_use_shared_preserves_dead_heads(self):
 
344
        self.build_tree(['root/'])
 
345
        tree = self.make_branch_and_tree('root/tree')
 
346
        self.add_dead_head(tree)
 
347
        tree.commit('Hello', rev_id='hello-id')
 
348
        repo = self.make_repository('root', shared=True)
 
349
        reconfiguration = reconfigure.Reconfigure.to_use_shared(tree.bzrdir)
 
350
        reconfiguration.apply()
 
351
        tree = workingtree.WorkingTree.open('root/tree')
 
352
        message = repo.get_revision('dead-head-id').message
 
353
        self.assertEqual('Dead head', message)
 
354
 
 
355
    def make_repository_tree(self):
 
356
        self.build_tree(['root/'])
 
357
        repo = self.make_repository('root', shared=True)
 
358
        tree = self.make_branch_and_tree('root/tree')
 
359
        reconfigure.Reconfigure.to_use_shared(tree.bzrdir).apply()
 
360
        return workingtree.WorkingTree.open('root/tree')
 
361
 
 
362
    def test_use_shared_to_use_shared(self):
 
363
        tree = self.make_repository_tree()
 
364
        self.assertRaises(errors.AlreadyUsingShared,
 
365
                          reconfigure.Reconfigure.to_use_shared, tree.bzrdir)
 
366
 
 
367
    def test_use_shared_to_standalone(self):
 
368
        tree = self.make_repository_tree()
 
369
        tree.commit('Hello', rev_id='hello-id')
 
370
        reconfigure.Reconfigure.to_standalone(tree.bzrdir).apply()
 
371
        tree = workingtree.WorkingTree.open('root/tree')
 
372
        repo = tree.branch.repository
 
373
        self.assertEqual(repo.bzrdir.root_transport.base,
 
374
                         tree.bzrdir.root_transport.base)
 
375
        self.assertEqual('Hello', repo.get_revision('hello-id').message)
 
376
 
 
377
    def test_use_shared_to_standalone_preserves_dead_heads(self):
 
378
        tree = self.make_repository_tree()
 
379
        self.add_dead_head(tree)
 
380
        tree.commit('Hello', rev_id='hello-id')
 
381
        reconfigure.Reconfigure.to_standalone(tree.bzrdir).apply()
 
382
        tree = workingtree.WorkingTree.open('root/tree')
 
383
        repo = tree.branch.repository
 
384
        self.assertRaises(errors.NoSuchRevision, repo.get_revision,
 
385
                          'dead-head-id')
 
386
 
 
387
    def test_standalone_to_standalone(self):
 
388
        tree = self.make_branch_and_tree('tree')
 
389
        self.assertRaises(errors.AlreadyStandalone,
 
390
                          reconfigure.Reconfigure.to_standalone, tree.bzrdir)
 
391
 
 
392
    def make_unsynced_branch_reconfiguration(self):
 
393
        parent = self.make_branch_and_tree('parent')
 
394
        parent.commit('commit 1')
 
395
        child = parent.bzrdir.sprout('child').open_workingtree()
 
396
        child.commit('commit 2')
 
397
        return reconfigure.Reconfigure.to_lightweight_checkout(child.bzrdir)
 
398
 
 
399
    def test_unsynced_branch_to_lightweight_checkout_unforced(self):
 
400
        reconfiguration = self.make_unsynced_branch_reconfiguration()
 
401
        self.assertRaises(errors.UnsyncedBranches, reconfiguration.apply)
 
402
 
 
403
    def test_unsynced_branch_to_lightweight_checkout_forced(self):
 
404
        reconfiguration = self.make_unsynced_branch_reconfiguration()
 
405
        reconfiguration.apply(force=True)
 
406
 
 
407
    def make_repository_with_without_trees(self, with_trees):
 
408
        repo = self.make_repository('repo', shared=True)
 
409
        repo.set_make_working_trees(with_trees)
 
410
        return repo
 
411
 
 
412
    def test_make_with_trees(self):
 
413
        repo = self.make_repository_with_without_trees(False)
 
414
        reconfiguration = reconfigure.Reconfigure.set_repository_trees(
 
415
            repo.bzrdir, True)
 
416
        reconfiguration.apply()
 
417
        self.assertIs(True, repo.make_working_trees())
 
418
 
 
419
    def test_make_without_trees(self):
 
420
        repo = self.make_repository_with_without_trees(True)
 
421
        reconfiguration = reconfigure.Reconfigure.set_repository_trees(
 
422
            repo.bzrdir, False)
 
423
        reconfiguration.apply()
 
424
        self.assertIs(False, repo.make_working_trees())
 
425
 
 
426
    def test_make_with_trees_already_with_trees(self):
 
427
        repo = self.make_repository_with_without_trees(True)
 
428
        e = self.assertRaises(errors.AlreadyWithTrees,
 
429
           reconfigure.Reconfigure.set_repository_trees, repo.bzrdir, True)
 
430
        self.assertContainsRe(str(e),
 
431
            r"Shared repository '.*' already creates working trees.")
 
432
 
 
433
    def test_make_without_trees_already_no_trees(self):
 
434
        repo = self.make_repository_with_without_trees(False)
 
435
        e = self.assertRaises(errors.AlreadyWithNoTrees,
 
436
            reconfigure.Reconfigure.set_repository_trees, repo.bzrdir, False)
 
437
        self.assertContainsRe(str(e),
 
438
            r"Shared repository '.*' already doesn't create working trees.")
 
439
 
 
440
    def test_repository_tree_reconfiguration_not_supported(self):
 
441
        tree = self.make_branch_and_tree('tree')
 
442
        e = self.assertRaises(errors.ReconfigurationNotSupported,
 
443
            reconfigure.Reconfigure.set_repository_trees, tree.bzrdir, None)
 
444
        self.assertContainsRe(str(e),
 
445
            r"Requested reconfiguration of '.*' is not supported.")
 
446
 
 
447
    def test_lightweight_checkout_to_tree_preserves_reference_locations(self):
 
448
        format = bzrdir.format_registry.make_bzrdir('1.9')
 
449
        format.set_branch_format(_mod_branch.BzrBranchFormat8())
 
450
        tree = self.make_branch_and_tree('tree', format=format)
 
451
        tree.branch.set_reference_info('file_id', 'path', '../location')
 
452
        checkout = tree.branch.create_checkout('checkout', lightweight=True)
 
453
        reconfiguration = reconfigure.Reconfigure.to_tree(checkout.bzrdir)
 
454
        reconfiguration.apply()
 
455
        checkout_branch = checkout.bzrdir.open_branch()
 
456
        self.assertEqual(('path', '../location'),
 
457
                         checkout_branch.get_reference_info('file_id'))