15
15
# along with this program; if not, write to the Free Software
16
16
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
from cStringIO import StringIO
27
from bzrlib.branch import Branch
28
from bzrlib.bzrdir import BzrDir
29
from bzrlib.lockdir import LockDir
30
from bzrlib.mutabletree import needs_tree_write_lock
31
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
32
from bzrlib.transport import get_transport
33
from bzrlib.workingtree import (
27
workingtree as bzrworkingtree,
31
from ..lock import write_locked
32
from ..lockdir import LockDir
33
from . import TestCase, TestCaseWithTransport, TestSkipped
65
66
class TestDefaultFormat(TestCaseWithTransport):
67
68
def test_get_set_default_format(self):
68
old_format = workingtree.WorkingTreeFormat.get_default_format()
70
self.assertTrue(isinstance(old_format, workingtree.WorkingTreeFormat3))
71
workingtree.WorkingTreeFormat.set_default_format(SampleTreeFormat())
73
# the default branch format is used by the meta dir format
74
# which is not the default bzrdir format at this point
75
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
76
dir.create_repository()
78
result = dir.create_workingtree()
79
self.assertEqual(result, 'A tree')
81
workingtree.WorkingTreeFormat.set_default_format(old_format)
82
self.assertEqual(old_format, workingtree.WorkingTreeFormat.get_default_format())
69
old_format = workingtree.format_registry.get_default()
71
self.assertTrue(isinstance(old_format, workingtree_4.WorkingTreeFormat6))
72
workingtree.format_registry.set_default(SampleTreeFormat())
74
# the default branch format is used by the meta dir format
75
# which is not the default bzrdir format at this point
76
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
77
dir.create_repository()
79
result = dir.create_workingtree()
80
self.assertEqual(result, 'A tree')
82
workingtree.format_registry.set_default(old_format)
83
self.assertEqual(old_format, workingtree.format_registry.get_default())
85
def test_from_string(self):
86
self.assertIsInstance(
87
SampleTreeFormat.from_string(b"Sample tree format."),
89
self.assertRaises(AssertionError,
90
SampleTreeFormat.from_string, b"Different format string.")
92
def test_get_set_default_format_by_key(self):
93
old_format = workingtree.format_registry.get_default()
95
format = SampleTreeFormat()
96
workingtree.format_registry.register(format)
97
self.addCleanup(workingtree.format_registry.remove, format)
98
self.assertTrue(isinstance(old_format, workingtree_4.WorkingTreeFormat6))
99
workingtree.format_registry.set_default_key(format.get_format_string())
101
# the default branch format is used by the meta dir format
102
# which is not the default bzrdir format at this point
103
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
104
dir.create_repository()
106
result = dir.create_workingtree()
107
self.assertEqual(result, 'A tree')
109
workingtree.format_registry.set_default_key(
110
old_format.get_format_string())
111
self.assertEqual(old_format, workingtree.format_registry.get_default())
84
113
def test_open(self):
85
114
tree = self.make_branch_and_tree('.')
101
130
self.assertEqual('subdir', relpath)
104
class SampleTreeFormat(workingtree.WorkingTreeFormat):
133
class SampleTreeFormat(bzrworkingtree.WorkingTreeFormatMetaDir):
105
134
"""A sample format
107
136
this format is initializable, unsupported to aid in testing the
108
137
open and open_downlevel routines.
111
def get_format_string(self):
141
def get_format_string(cls):
112
142
"""See WorkingTreeFormat.get_format_string()."""
113
return "Sample tree format."
143
return b"Sample tree format."
115
def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
145
def initialize(self, a_controldir, revision_id=None, from_branch=None,
116
146
accelerator_tree=None, hardlink=False):
117
147
"""Sample branches cannot be created."""
118
t = a_bzrdir.get_workingtree_transport(self)
148
t = a_controldir.get_workingtree_transport(self)
119
149
t.put_bytes('format', self.get_format_string())
126
156
return "opened tree."
159
class SampleExtraTreeFormat(workingtree.WorkingTreeFormat):
160
"""A sample format that does not support use in a metadir.
164
def get_format_string(self):
165
# Not usable in a metadir, so no format string
168
def initialize(self, a_controldir, revision_id=None, from_branch=None,
169
accelerator_tree=None, hardlink=False):
170
raise NotImplementedError(self.initialize)
172
def is_supported(self):
175
def open(self, transport, _found=False):
176
raise NotImplementedError(self.open)
129
179
class TestWorkingTreeFormat(TestCaseWithTransport):
130
180
"""Tests for the WorkingTreeFormat facility."""
182
def test_find_format_string(self):
183
# is the right format object found for a working tree?
184
branch = self.make_branch('branch')
185
self.assertRaises(errors.NoWorkingTree,
186
bzrworkingtree.WorkingTreeFormatMetaDir.find_format_string, branch.controldir)
187
transport = branch.controldir.get_workingtree_transport(None)
189
transport.put_bytes("format", "some format name")
190
# The format does not have to be known by Bazaar,
191
# find_format_string just retrieves the name
192
self.assertEqual("some format name",
193
bzrworkingtree.WorkingTreeFormatMetaDir.find_format_string(branch.controldir))
132
195
def test_find_format(self):
133
196
# is the right format object found for a working tree?
134
197
# create a branch with a few known format objects.
135
198
self.build_tree(["foo/", "bar/"])
136
199
def check_format(format, url):
137
dir = format._matchingbzrdir.initialize(url)
200
dir = format._matchingcontroldir.initialize(url)
138
201
dir.create_repository()
139
202
dir.create_branch()
140
203
format.initialize(dir)
141
t = get_transport(url)
142
found_format = workingtree.WorkingTreeFormat.find_format(dir)
143
self.failUnless(isinstance(found_format, format.__class__))
144
check_format(workingtree.WorkingTreeFormat3(), "bar")
204
t = transport.get_transport(url)
205
found_format = bzrworkingtree.WorkingTreeFormatMetaDir.find_format(dir)
206
self.assertIsInstance(found_format, format.__class__)
207
check_format(workingtree_3.WorkingTreeFormat3(), "bar")
146
209
def test_find_format_no_tree(self):
147
210
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
148
211
self.assertRaises(errors.NoWorkingTree,
149
workingtree.WorkingTreeFormat.find_format,
212
bzrworkingtree.WorkingTreeFormatMetaDir.find_format,
152
215
def test_find_format_unknown_format(self):
155
218
dir.create_branch()
156
219
SampleTreeFormat().initialize(dir)
157
220
self.assertRaises(errors.UnknownFormatError,
158
workingtree.WorkingTreeFormat.find_format,
221
bzrworkingtree.WorkingTreeFormatMetaDir.find_format,
224
def test_find_format_with_features(self):
225
tree = self.make_branch_and_tree('.', format='2a')
226
tree.update_feature_flags({b"name": b"necessity"})
227
found_format = bzrworkingtree.WorkingTreeFormatMetaDir.find_format(
229
self.assertIsInstance(found_format, workingtree.WorkingTreeFormat)
230
self.assertEqual(found_format.features.get(b"name"), b"necessity")
231
self.assertRaises(bzrdir.MissingFeature, found_format.check_support_status,
233
self.addCleanup(bzrworkingtree.WorkingTreeFormatMetaDir.unregister_feature,
235
bzrworkingtree.WorkingTreeFormatMetaDir.register_feature(b"name")
236
found_format.check_support_status(True)
239
class TestWorkingTreeIterEntriesByDir_wSubtrees(TestCaseWithTransport):
241
def make_simple_tree(self):
242
tree = self.make_branch_and_tree('tree', format='development-subtree')
243
self.build_tree(['tree/a/', 'tree/a/b/', 'tree/a/b/c'])
244
tree.set_root_id(b'root-id')
245
tree.add(['a', 'a/b', 'a/b/c'], [b'a-id', b'b-id', b'c-id'])
246
tree.commit('initial')
249
def test_just_directory(self):
250
tree = self.make_simple_tree()
251
self.assertEqual([('directory', b'root-id'),
252
('directory', b'a-id'),
253
('directory', b'b-id'),
255
[(ie.kind, ie.file_id)
256
for path, ie in tree.iter_entries_by_dir()])
257
subtree = self.make_branch_and_tree('tree/a/b')
258
self.assertEqual([('tree-reference', b'b-id')],
259
[(ie.kind, ie.file_id)
260
for path, ie in tree.iter_entries_by_dir(
261
specific_files=['a/b'])])
263
def test_direct_subtree(self):
264
tree = self.make_simple_tree()
265
subtree = self.make_branch_and_tree('tree/a/b')
266
self.assertEqual([('directory', b'root-id'),
267
('directory', b'a-id'),
268
('tree-reference', b'b-id')],
269
[(ie.kind, ie.file_id)
270
for path, ie in tree.iter_entries_by_dir()])
272
def test_indirect_subtree(self):
273
tree = self.make_simple_tree()
274
subtree = self.make_branch_and_tree('tree/a')
275
self.assertEqual([('directory', b'root-id'),
276
('tree-reference', b'a-id')],
277
[(ie.kind, ie.file_id)
278
for path, ie in tree.iter_entries_by_dir()])
281
class TestWorkingTreeFormatRegistry(TestCase):
284
super(TestWorkingTreeFormatRegistry, self).setUp()
285
self.registry = workingtree.WorkingTreeFormatRegistry()
161
287
def test_register_unregister_format(self):
162
288
format = SampleTreeFormat()
164
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
165
dir.create_repository()
168
format.initialize(dir)
169
# register a format for it.
170
workingtree.WorkingTreeFormat.register_format(format)
171
# which branch.Open will refuse (not supported)
172
self.assertRaises(errors.UnsupportedFormatError, workingtree.WorkingTree.open, '.')
173
# but open_downlevel will work
174
self.assertEqual(format.open(dir), workingtree.WorkingTree.open_downlevel('.'))
175
# unregister the format
176
workingtree.WorkingTreeFormat.unregister_format(format)
289
self.registry.register(format)
290
self.assertEqual(format, self.registry.get(b"Sample tree format."))
291
self.registry.remove(format)
292
self.assertRaises(KeyError, self.registry.get, b"Sample tree format.")
294
def test_get_all(self):
295
format = SampleTreeFormat()
296
self.assertEqual([], self.registry._get_all())
297
self.registry.register(format)
298
self.assertEqual([format], self.registry._get_all())
300
def test_register_extra(self):
301
format = SampleExtraTreeFormat()
302
self.assertEqual([], self.registry._get_all())
303
self.registry.register_extra(format)
304
self.assertEqual([format], self.registry._get_all())
306
def test_register_extra_lazy(self):
307
self.assertEqual([], self.registry._get_all())
308
self.registry.register_extra_lazy("breezy.tests.test_workingtree",
309
"SampleExtraTreeFormat")
310
formats = self.registry._get_all()
311
self.assertEqual(1, len(formats))
312
self.assertIsInstance(formats[0], SampleExtraTreeFormat)
179
315
class TestWorkingTreeFormat3(TestCaseWithTransport):
217
353
repo = dir.create_repository()
218
354
branch = dir.create_branch()
220
tree = workingtree.WorkingTreeFormat3().initialize(dir)
356
tree = workingtree_3.WorkingTreeFormat3().initialize(dir)
221
357
except errors.NotLocalUrl:
222
358
raise TestSkipped('Not a local URL')
223
359
self.assertIsDirectory('.bzr', t)
224
360
self.assertIsDirectory('.bzr/checkout', t)
225
361
self.assertIsDirectory('.bzr/checkout/lock', t)
226
362
our_lock = LockDir(t, '.bzr/checkout/lock')
227
self.assertEquals(our_lock.peek(), None)
229
self.assertTrue(our_lock.peek())
231
self.assertEquals(our_lock.peek(), None)
363
self.assertEqual(our_lock.peek(), None)
364
with tree.lock_write():
365
self.assertTrue(our_lock.peek())
366
self.assertEqual(our_lock.peek(), None)
233
368
def test_missing_pending_merges(self):
234
369
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
235
370
control.create_repository()
236
371
control.create_branch()
237
tree = workingtree.WorkingTreeFormat3().initialize(control)
372
tree = workingtree_3.WorkingTreeFormat3().initialize(control)
238
373
tree._transport.delete("pending-merges")
239
374
self.assertEqual([], tree.get_parent_ids())
242
class TestFormat2WorkingTree(TestCaseWithTransport):
243
"""Tests that are specific to format 2 trees."""
245
def create_format2_tree(self, url):
246
return self.make_branch_and_tree(
247
url, format=bzrdir.BzrDirFormat6())
249
def test_conflicts(self):
250
# test backwards compatability
251
tree = self.create_format2_tree('.')
252
self.assertRaises(errors.UnsupportedOperation, tree.set_conflicts,
254
file('lala.BASE', 'wb').write('labase')
255
expected = conflicts.ContentsConflict('lala')
256
self.assertEqual(list(tree.conflicts()), [expected])
257
file('lala', 'wb').write('la')
258
tree.add('lala', 'lala-id')
259
expected = conflicts.ContentsConflict('lala', file_id='lala-id')
260
self.assertEqual(list(tree.conflicts()), [expected])
261
file('lala.THIS', 'wb').write('lathis')
262
file('lala.OTHER', 'wb').write('laother')
263
# When "text conflict"s happen, stem, THIS and OTHER are text
264
expected = conflicts.TextConflict('lala', file_id='lala-id')
265
self.assertEqual(list(tree.conflicts()), [expected])
266
os.unlink('lala.OTHER')
267
os.mkdir('lala.OTHER')
268
expected = conflicts.ContentsConflict('lala', file_id='lala-id')
269
self.assertEqual(list(tree.conflicts()), [expected])
272
class InstrumentedTree(object):
273
"""A instrumented tree to check the needs_tree_write_lock decorator."""
278
def lock_tree_write(self):
279
self._locks.append('t')
281
@needs_tree_write_lock
282
def method_with_tree_write_lock(self, *args, **kwargs):
283
"""A lock_tree_write decorated method that returns its arguments."""
286
@needs_tree_write_lock
287
def method_that_raises(self):
288
"""This method causes an exception when called with parameters.
290
This allows the decorator code to be checked - it should still call
295
self._locks.append('u')
298
class TestInstrumentedTree(TestCase):
300
def test_needs_tree_write_lock(self):
301
"""@needs_tree_write_lock should be semantically transparent."""
302
tree = InstrumentedTree()
304
'method_with_tree_write_lock',
305
tree.method_with_tree_write_lock.__name__)
306
self.assertDocstring(
307
"A lock_tree_write decorated method that returns its arguments.",
308
tree.method_with_tree_write_lock)
311
result = tree.method_with_tree_write_lock(1,2,3, a='b')
312
self.assertEqual((args, kwargs), result)
313
self.assertEqual(['t', 'u'], tree._locks)
314
self.assertRaises(TypeError, tree.method_that_raises, 'foo')
315
self.assertEqual(['t', 'u', 't', 'u'], tree._locks)
318
377
class TestRevert(TestCaseWithTransport):
320
379
def test_revert_conflicts_recursive(self):
321
380
this_tree = self.make_branch_and_tree('this-tree')
322
381
self.build_tree_contents([('this-tree/foo/',),
323
('this-tree/foo/bar', 'bar')])
382
('this-tree/foo/bar', b'bar')])
324
383
this_tree.add(['foo', 'foo/bar'])
325
384
this_tree.commit('created foo/bar')
326
other_tree = this_tree.bzrdir.sprout('other-tree').open_workingtree()
327
self.build_tree_contents([('other-tree/foo/bar', 'baz')])
385
other_tree = this_tree.controldir.sprout('other-tree').open_workingtree()
386
self.build_tree_contents([('other-tree/foo/bar', b'baz')])
328
387
other_tree.commit('changed bar')
329
self.build_tree_contents([('this-tree/foo/bar', 'qux')])
388
self.build_tree_contents([('this-tree/foo/bar', b'qux')])
330
389
this_tree.commit('changed qux')
331
390
this_tree.merge_from_branch(other_tree.branch)
332
391
self.assertEqual(1, len(this_tree.conflicts()))
339
398
def test_auto_resolve(self):
340
399
base = self.make_branch_and_tree('base')
341
self.build_tree_contents([('base/hello', 'Hello')])
342
base.add('hello', 'hello_id')
400
self.build_tree_contents([('base/hello', b'Hello')])
401
base.add('hello', b'hello_id')
343
402
base.commit('Hello')
344
other = base.bzrdir.sprout('other').open_workingtree()
345
self.build_tree_contents([('other/hello', 'hELLO')])
403
other = base.controldir.sprout('other').open_workingtree()
404
self.build_tree_contents([('other/hello', b'hELLO')])
346
405
other.commit('Case switch')
347
this = base.bzrdir.sprout('this').open_workingtree()
348
self.failUnlessExists('this/hello')
349
self.build_tree_contents([('this/hello', 'Hello World')])
406
this = base.controldir.sprout('this').open_workingtree()
407
self.assertPathExists('this/hello')
408
self.build_tree_contents([('this/hello', b'Hello World')])
350
409
this.commit('Add World')
351
410
this.merge_from_branch(other.branch)
352
self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
355
self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
357
self.build_tree_contents([('this/hello', '<<<<<<<')])
359
self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
361
self.build_tree_contents([('this/hello', '=======')])
363
self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
365
self.build_tree_contents([('this/hello', '\n>>>>>>>')])
411
self.assertEqual([conflicts.TextConflict('hello', b'hello_id')],
414
self.assertEqual([conflicts.TextConflict('hello', b'hello_id')],
416
self.build_tree_contents([('this/hello', b'<<<<<<<')])
418
self.assertEqual([conflicts.TextConflict('hello', b'hello_id')],
420
self.build_tree_contents([('this/hello', b'=======')])
422
self.assertEqual([conflicts.TextConflict('hello', b'hello_id')],
424
self.build_tree_contents([('this/hello', b'\n>>>>>>>')])
366
425
remaining, resolved = this.auto_resolve()
367
self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
426
self.assertEqual([conflicts.TextConflict('hello', b'hello_id')],
368
427
this.conflicts())
369
428
self.assertEqual([], resolved)
370
self.build_tree_contents([('this/hello', 'hELLO wORLD')])
429
self.build_tree_contents([('this/hello', b'hELLO wORLD')])
371
430
remaining, resolved = this.auto_resolve()
372
431
self.assertEqual([], this.conflicts())
373
self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
432
self.assertEqual([conflicts.TextConflict('hello', b'hello_id')],
375
self.failIfExists('this/hello.BASE')
434
self.assertPathDoesNotExist('this/hello.BASE')
377
436
def test_auto_resolve_dir(self):
378
437
tree = self.make_branch_and_tree('tree')
379
438
self.build_tree(['tree/hello/'])
380
tree.add('hello', 'hello-id')
381
file_conflict = conflicts.TextConflict('file', None, 'hello-id')
439
tree.add('hello', b'hello-id')
440
file_conflict = conflicts.TextConflict('file', b'hello-id')
382
441
tree.set_conflicts(conflicts.ConflictList([file_conflict]))
383
442
tree.auto_resolve()
393
452
self.make_branch('qux')
394
453
trees = workingtree.WorkingTree.find_trees('.')
395
454
self.assertEqual(2, len(list(trees)))
457
class TestStoredUncommitted(TestCaseWithTransport):
459
def store_uncommitted(self):
460
tree = self.make_branch_and_tree('tree')
461
tree.commit('get root in there')
462
self.build_tree_contents([('tree/file', b'content')])
463
tree.add('file', b'file-id')
464
tree.store_uncommitted()
467
def test_store_uncommitted(self):
468
self.store_uncommitted()
469
self.assertPathDoesNotExist('tree/file')
471
def test_store_uncommitted_no_change(self):
472
tree = self.make_branch_and_tree('tree')
473
tree.commit('get root in there')
474
tree.store_uncommitted()
475
self.assertIs(None, tree.branch.get_unshelver(tree))
477
def test_restore_uncommitted(self):
478
with write_locked(self.store_uncommitted()) as tree:
479
tree.restore_uncommitted()
480
self.assertPathExists('tree/file')
481
self.assertIs(None, tree.branch.get_unshelver(tree))
483
def test_restore_uncommitted_none(self):
484
tree = self.make_branch_and_tree('tree')
485
tree.restore_uncommitted()
added
removed
breezy/tests/test_workingtree.py
