63
65
class TestDefaultFormat(TestCaseWithTransport):
65
67
def test_get_set_default_format(self):
66
old_format = workingtree.format_registry.get_default()
68
self.assertTrue(isinstance(old_format, workingtree_4.WorkingTreeFormat6))
69
workingtree.format_registry.set_default(SampleTreeFormat())
71
# the default branch format is used by the meta dir format
72
# which is not the default bzrdir format at this point
73
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
74
dir.create_repository()
76
result = dir.create_workingtree()
77
self.assertEqual(result, 'A tree')
79
workingtree.format_registry.set_default(old_format)
80
self.assertEqual(old_format, workingtree.format_registry.get_default())
82
def test_from_string(self):
83
self.assertIsInstance(
84
SampleTreeFormat.from_string("Sample tree format."),
86
self.assertRaises(AssertionError,
87
SampleTreeFormat.from_string, "Different format string.")
89
def test_get_set_default_format_by_key(self):
90
old_format = workingtree.format_registry.get_default()
92
format = SampleTreeFormat()
93
workingtree.format_registry.register(format)
94
self.addCleanup(workingtree.format_registry.remove, format)
95
self.assertTrue(isinstance(old_format, workingtree_4.WorkingTreeFormat6))
96
workingtree.format_registry.set_default_key(format.get_format_string())
98
# the default branch format is used by the meta dir format
99
# which is not the default bzrdir format at this point
100
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
101
dir.create_repository()
103
result = dir.create_workingtree()
104
self.assertEqual(result, 'A tree')
106
workingtree.format_registry.set_default_key(
107
old_format.get_format_string())
108
self.assertEqual(old_format, workingtree.format_registry.get_default())
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())
110
84
def test_open(self):
111
85
tree = self.make_branch_and_tree('.')
153
126
return "opened tree."
156
class SampleExtraTreeFormat(workingtree.WorkingTreeFormat):
157
"""A sample format that does not support use in a metadir.
161
def get_format_string(self):
162
# Not usable in a metadir, so no format string
165
def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
166
accelerator_tree=None, hardlink=False):
167
raise NotImplementedError(self.initialize)
169
def is_supported(self):
172
def open(self, transport, _found=False):
173
raise NotImplementedError(self.open)
176
129
class TestWorkingTreeFormat(TestCaseWithTransport):
177
130
"""Tests for the WorkingTreeFormat facility."""
179
def test_find_format_string(self):
180
# is the right format object found for a working tree?
181
branch = self.make_branch('branch')
182
self.assertRaises(errors.NoWorkingTree,
183
workingtree.WorkingTreeFormatMetaDir.find_format_string, branch.bzrdir)
184
transport = branch.bzrdir.get_workingtree_transport(None)
186
transport.put_bytes("format", "some format name")
187
# The format does not have to be known by Bazaar,
188
# find_format_string just retrieves the name
189
self.assertEqual("some format name",
190
workingtree.WorkingTreeFormatMetaDir.find_format_string(branch.bzrdir))
192
132
def test_find_format(self):
193
133
# is the right format object found for a working tree?
194
134
# create a branch with a few known format objects.
199
139
dir.create_branch()
200
140
format.initialize(dir)
201
141
t = transport.get_transport(url)
202
found_format = workingtree.WorkingTreeFormatMetaDir.find_format(dir)
203
self.assertIsInstance(found_format, format.__class__)
204
check_format(workingtree_3.WorkingTreeFormat3(), "bar")
142
found_format = workingtree.WorkingTreeFormat.find_format(dir)
143
self.failUnless(isinstance(found_format, format.__class__))
144
check_format(workingtree.WorkingTreeFormat3(), "bar")
206
146
def test_find_format_no_tree(self):
207
147
dir = bzrdir.BzrDirMetaFormat1().initialize('.')
208
148
self.assertRaises(errors.NoWorkingTree,
209
workingtree.WorkingTreeFormatMetaDir.find_format,
149
workingtree.WorkingTreeFormat.find_format,
212
152
def test_find_format_unknown_format(self):
215
155
dir.create_branch()
216
156
SampleTreeFormat().initialize(dir)
217
157
self.assertRaises(errors.UnknownFormatError,
218
workingtree.WorkingTreeFormatMetaDir.find_format,
158
workingtree.WorkingTreeFormat.find_format,
221
def test_find_format_with_features(self):
222
tree = self.make_branch_and_tree('.', format='2a')
223
tree.update_feature_flags({"name": "necessity"})
224
found_format = workingtree.WorkingTreeFormatMetaDir.find_format(
226
self.assertIsInstance(found_format, workingtree.WorkingTreeFormat)
227
self.assertEqual(found_format.features.get("name"), "necessity")
228
self.assertRaises(errors.MissingFeature, found_format.check_support_status,
230
self.addCleanup(workingtree.WorkingTreeFormatMetaDir.unregister_feature,
232
workingtree.WorkingTreeFormatMetaDir.register_feature("name")
233
found_format.check_support_status(True)
236
class TestWorkingTreeIterEntriesByDir_wSubtrees(TestCaseWithTransport):
238
def make_simple_tree(self):
239
tree = self.make_branch_and_tree('tree', format='development-subtree')
240
self.build_tree(['tree/a/', 'tree/a/b/', 'tree/a/b/c'])
241
tree.set_root_id('root-id')
242
tree.add(['a', 'a/b', 'a/b/c'], ['a-id', 'b-id', 'c-id'])
243
tree.commit('initial')
246
def test_just_directory(self):
247
tree = self.make_simple_tree()
248
self.assertEqual([('directory', 'root-id'),
249
('directory', 'a-id'),
250
('directory', 'b-id'),
252
[(ie.kind, ie.file_id)
253
for path, ie in tree.iter_entries_by_dir()])
254
subtree = self.make_branch_and_tree('tree/a/b')
255
self.assertEqual([('tree-reference', 'b-id')],
256
[(ie.kind, ie.file_id)
257
for path, ie in tree.iter_entries_by_dir(['b-id'])])
259
def test_direct_subtree(self):
260
tree = self.make_simple_tree()
261
subtree = self.make_branch_and_tree('tree/a/b')
262
self.assertEqual([('directory', 'root-id'),
263
('directory', 'a-id'),
264
('tree-reference', 'b-id')],
265
[(ie.kind, ie.file_id)
266
for path, ie in tree.iter_entries_by_dir()])
268
def test_indirect_subtree(self):
269
tree = self.make_simple_tree()
270
subtree = self.make_branch_and_tree('tree/a')
271
self.assertEqual([('directory', 'root-id'),
272
('tree-reference', 'a-id')],
273
[(ie.kind, ie.file_id)
274
for path, ie in tree.iter_entries_by_dir()])
277
class TestWorkingTreeFormatRegistry(TestCase):
280
super(TestWorkingTreeFormatRegistry, self).setUp()
281
self.registry = workingtree.WorkingTreeFormatRegistry()
283
161
def test_register_unregister_format(self):
284
162
format = SampleTreeFormat()
285
self.registry.register(format)
286
self.assertEqual(format, self.registry.get("Sample tree format."))
287
self.registry.remove(format)
288
self.assertRaises(KeyError, self.registry.get, "Sample tree format.")
290
def test_get_all(self):
291
format = SampleTreeFormat()
292
self.assertEqual([], self.registry._get_all())
293
self.registry.register(format)
294
self.assertEqual([format], self.registry._get_all())
296
def test_register_extra(self):
297
format = SampleExtraTreeFormat()
298
self.assertEqual([], self.registry._get_all())
299
self.registry.register_extra(format)
300
self.assertEqual([format], self.registry._get_all())
302
def test_register_extra_lazy(self):
303
self.assertEqual([], self.registry._get_all())
304
self.registry.register_extra_lazy("bzrlib.tests.test_workingtree",
305
"SampleExtraTreeFormat")
306
formats = self.registry._get_all()
307
self.assertEqual(1, len(formats))
308
self.assertIsInstance(formats[0], SampleExtraTreeFormat)
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)
311
179
class TestWorkingTreeFormat3(TestCaseWithTransport):
349
217
repo = dir.create_repository()
350
218
branch = dir.create_branch()
352
tree = workingtree_3.WorkingTreeFormat3().initialize(dir)
220
tree = workingtree.WorkingTreeFormat3().initialize(dir)
353
221
except errors.NotLocalUrl:
354
222
raise TestSkipped('Not a local URL')
355
223
self.assertIsDirectory('.bzr', t)
356
224
self.assertIsDirectory('.bzr/checkout', t)
357
225
self.assertIsDirectory('.bzr/checkout/lock', t)
358
226
our_lock = LockDir(t, '.bzr/checkout/lock')
359
self.assertEqual(our_lock.peek(), None)
227
self.assertEquals(our_lock.peek(), None)
360
228
tree.lock_write()
361
229
self.assertTrue(our_lock.peek())
363
self.assertEqual(our_lock.peek(), None)
231
self.assertEquals(our_lock.peek(), None)
365
233
def test_missing_pending_merges(self):
366
234
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
367
235
control.create_repository()
368
236
control.create_branch()
369
tree = workingtree_3.WorkingTreeFormat3().initialize(control)
237
tree = workingtree.WorkingTreeFormat3().initialize(control)
370
238
tree._transport.delete("pending-merges")
371
239
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])
374
272
class InstrumentedTree(object):
375
273
"""A instrumented tree to check the needs_tree_write_lock decorator."""
447
345
self.build_tree_contents([('other/hello', 'hELLO')])
448
346
other.commit('Case switch')
449
347
this = base.bzrdir.sprout('this').open_workingtree()
450
self.assertPathExists('this/hello')
348
self.failUnlessExists('this/hello')
451
349
self.build_tree_contents([('this/hello', 'Hello World')])
452
350
this.commit('Add World')
453
351
this.merge_from_branch(other.branch)
454
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
352
self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
455
353
this.conflicts())
456
354
this.auto_resolve()
457
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
355
self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
458
356
this.conflicts())
459
357
self.build_tree_contents([('this/hello', '<<<<<<<')])
460
358
this.auto_resolve()
461
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
359
self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
462
360
this.conflicts())
463
361
self.build_tree_contents([('this/hello', '=======')])
464
362
this.auto_resolve()
465
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
363
self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
466
364
this.conflicts())
467
365
self.build_tree_contents([('this/hello', '\n>>>>>>>')])
468
366
remaining, resolved = this.auto_resolve()
469
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
367
self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
470
368
this.conflicts())
471
369
self.assertEqual([], resolved)
472
370
self.build_tree_contents([('this/hello', 'hELLO wORLD')])
473
371
remaining, resolved = this.auto_resolve()
474
372
self.assertEqual([], this.conflicts())
475
self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
373
self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
477
self.assertPathDoesNotExist('this/hello.BASE')
375
self.failIfExists('this/hello.BASE')
479
377
def test_auto_resolve_dir(self):
480
378
tree = self.make_branch_and_tree('tree')
481
379
self.build_tree(['tree/hello/'])
482
380
tree.add('hello', 'hello-id')
483
file_conflict = conflicts.TextConflict('file', 'hello-id')
381
file_conflict = conflicts.TextConflict('file', None, 'hello-id')
484
382
tree.set_conflicts(conflicts.ConflictList([file_conflict]))
485
383
tree.auto_resolve()
495
393
self.make_branch('qux')
496
394
trees = workingtree.WorkingTree.find_trees('.')
497
395
self.assertEqual(2, len(list(trees)))
500
class TestStoredUncommitted(TestCaseWithTransport):
502
def store_uncommitted(self):
503
tree = self.make_branch_and_tree('tree')
504
tree.commit('get root in there')
505
self.build_tree_contents([('tree/file', 'content')])
506
tree.add('file', 'file-id')
507
tree.store_uncommitted()
510
def test_store_uncommitted(self):
511
self.store_uncommitted()
512
self.assertPathDoesNotExist('tree/file')
514
def test_store_uncommitted_no_change(self):
515
tree = self.make_branch_and_tree('tree')
516
tree.commit('get root in there')
517
tree.store_uncommitted()
518
self.assertIs(None, tree.branch.get_unshelver(tree))
520
def test_restore_uncommitted(self):
521
with write_locked(self.store_uncommitted()) as tree:
522
tree.restore_uncommitted()
523
self.assertPathExists('tree/file')
524
self.assertIs(None, tree.branch.get_unshelver(tree))
526
def test_restore_uncommitted_none(self):
527
tree = self.make_branch_and_tree('tree')
528
tree.restore_uncommitted()