235
222
control.create_repository()
236
223
control.create_branch()
237
224
tree = workingtree.WorkingTreeFormat3().initialize(control)
238
tree._transport.delete("pending-merges")
225
tree._control_files._transport.delete("pending-merges")
239
226
self.assertEqual([], tree.get_parent_ids())
229
class TestWorkingTreeFormat4(TestCaseWithTransport):
230
"""Tests specific to WorkingTreeFormat4."""
232
def test_disk_layout(self):
233
control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
234
control.create_repository()
235
control.create_branch()
236
tree = workingtree.WorkingTreeFormat4().initialize(control)
238
# format 'Bazaar Working Tree format 4'
240
t = control.get_workingtree_transport(None)
241
self.assertEqualDiff('Bazaar Working Tree format 4\n',
242
t.get('format').read())
243
self.assertEqualDiff('### bzr hashcache v5\n',
244
t.get('stat-cache').read())
245
self.assertFalse(t.has('inventory.basis'))
246
# no last-revision file means 'None' or 'NULLREVISION'
247
self.assertFalse(t.has('last-revision'))
248
# TODO RBC 20060210 do a commit, check the inventory.basis is created
249
# correctly and last-revision file becomes present.
250
# manually make a dirstate toc check the format is as desired.
251
state = dirstate.DirState.on_file(t.local_abspath('dirstate'))
252
self.assertEqual([], state.get_parent_ids())
254
def test_uses_lockdir(self):
255
"""WorkingTreeFormat4 uses its own LockDir:
257
- lock is a directory
258
- when the WorkingTree is locked, LockDir can see that
260
# this test could be factored into a subclass of tests common to both
261
# format 3 and 4, but for now its not much of an issue as there is only one in common.
262
t = self.get_transport()
263
tree = self.make_workingtree()
264
self.assertIsDirectory('.bzr', t)
265
self.assertIsDirectory('.bzr/checkout', t)
266
self.assertIsDirectory('.bzr/checkout/lock', t)
267
our_lock = LockDir(t, '.bzr/checkout/lock')
268
self.assertEquals(our_lock.peek(), None)
270
self.assertTrue(our_lock.peek())
272
self.assertEquals(our_lock.peek(), None)
274
def make_workingtree(self):
276
dir = bzrdir.BzrDirMetaFormat1().initialize(url)
277
repo = dir.create_repository()
278
branch = dir.create_branch()
280
return workingtree.WorkingTreeFormat4().initialize(dir)
281
except errors.NotLocalUrl:
282
raise TestSkipped('Not a local URL')
284
# TODO: test that dirstate also stores & retrieves the parent list of
285
# workingtree-parent revisions, including when they have multiple parents.
286
# (in other words, the case when we're constructing a merge of
287
# revisions which are themselves merges.)
289
# The simplest case is that the the workingtree's primary
290
# parent tree can be retrieved. This is required for all WorkingTrees,
291
# and covered by the generic tests.
293
def test_dirstate_stores_all_parent_inventories(self):
294
tree = self.make_workingtree()
296
# We're going to build in tree a working tree
297
# with three parent trees, with some files in common.
299
# We really don't want to do commit or merge in the new dirstate-based
300
# tree, because that might not work yet. So instead we build
301
# revisions elsewhere and pull them across, doing by hand part of the
302
# work that merge would do.
304
subtree = self.make_branch_and_tree('subdir')
305
self.build_tree(['subdir/file-a',])
306
subtree.add(['file-a'], ['id-a'])
307
rev1 = subtree.commit('commit in subdir')
308
rev1_tree = subtree.basis_tree()
310
subtree2 = subtree.bzrdir.sprout('subdir2').open_workingtree()
311
self.build_tree(['subdir2/file-b'])
312
subtree2.add(['file-b'], ['id-b'])
313
rev2 = subtree2.commit('commit in subdir2')
314
rev2_tree = subtree2.basis_tree()
316
subtree.merge_from_branch(subtree2.branch)
317
rev3 = subtree.commit('merge from subdir2')
318
rev3_tree = subtree.basis_tree()
320
repo = tree.branch.repository
321
repo.fetch(subtree.branch.repository, rev3)
322
# will also pull the others...
324
# tree doesn't contain a text merge yet but we'll just
325
# set the parents as if a merge had taken place.
326
# this should cause the tree data to be folded into the
328
tree.set_parent_trees([
331
(rev3, rev3_tree), ])
333
# now we should be able to get them back out
334
self.assertTreesEqual(tree.revision_tree(rev1), rev1_tree)
335
self.assertTreesEqual(tree.revision_tree(rev2), rev2_tree)
336
self.assertTreesEqual(tree.revision_tree(rev3), rev3_tree)
338
def test_dirstate_doesnt_read_parents_from_repo_when_setting(self):
339
"""Setting parent trees on a dirstate working tree takes
340
the trees it's given and doesn't need to read them from the
343
tree = self.make_workingtree()
345
subtree = self.make_branch_and_tree('subdir')
346
rev1 = subtree.commit('commit in subdir')
347
rev1_tree = subtree.basis_tree()
349
tree.branch.pull(subtree.branch)
351
# break the repository's legs to make sure it only uses the trees
352
# it's given; any calls to forbidden methods will raise an
354
repo = tree.branch.repository
355
repo.get_revision = self.fail
356
repo.get_inventory = self.fail
357
repo.get_inventory_xml = self.fail
358
# try to set the parent trees.
359
tree.set_parent_trees([(rev1, rev1_tree)])
361
def test_dirstate_doesnt_read_from_repo_when_returning_cache_tree(self):
362
"""Getting parent trees from a dirstate tree does not read from the
363
repos inventory store. This is an important part of the dirstate
364
performance optimisation work.
366
tree = self.make_workingtree()
368
subtree = self.make_branch_and_tree('subdir')
369
rev1 = subtree.commit('commit in subdir')
370
rev1_tree = subtree.basis_tree()
371
rev2 = subtree.commit('second commit in subdir', allow_pointless=True)
372
rev2_tree = subtree.basis_tree()
374
tree.branch.pull(subtree.branch)
376
# break the repository's legs to make sure it only uses the trees
377
# it's given; any calls to forbidden methods will raise an
379
repo = tree.branch.repository
380
# dont uncomment this: the revision object must be accessed to
381
# answer 'get_parent_ids' for the revision tree- dirstate does not
382
# cache the parents of a parent tree at this point.
383
#repo.get_revision = self.fail
384
repo.get_inventory = self.fail
385
repo.get_inventory_xml = self.fail
386
# set the parent trees.
387
tree.set_parent_trees([(rev1, rev1_tree), (rev2, rev2_tree)])
388
# read the first tree
389
result_rev1_tree = tree.revision_tree(rev1)
391
result_rev2_tree = tree.revision_tree(rev2)
392
# compare - there should be no differences between the handed and
394
self.assertTreesEqual(rev1_tree, result_rev1_tree)
395
self.assertTreesEqual(rev2_tree, result_rev2_tree)
397
def test_dirstate_doesnt_cache_non_parent_trees(self):
398
"""Getting parent trees from a dirstate tree does not read from the
399
repos inventory store. This is an important part of the dirstate
400
performance optimisation work.
402
tree = self.make_workingtree()
404
# make a tree that we can try for, which is able to be returned but
406
subtree = self.make_branch_and_tree('subdir')
407
rev1 = subtree.commit('commit in subdir')
408
tree.branch.pull(subtree.branch)
410
self.assertRaises(errors.NoSuchRevision, tree.revision_tree, rev1)
412
def test_no_dirstate_outside_lock(self):
413
# temporary test until the code is mature enough to test from outside.
414
"""Getting a dirstate object fails if there is no lock."""
415
def lock_and_call_current_dirstate(tree, lock_method):
416
getattr(tree, lock_method)()
417
tree.current_dirstate()
419
tree = self.make_workingtree()
420
self.assertRaises(errors.ObjectNotLocked, tree.current_dirstate)
421
lock_and_call_current_dirstate(tree, 'lock_read')
422
self.assertRaises(errors.ObjectNotLocked, tree.current_dirstate)
423
lock_and_call_current_dirstate(tree, 'lock_write')
424
self.assertRaises(errors.ObjectNotLocked, tree.current_dirstate)
425
lock_and_call_current_dirstate(tree, 'lock_tree_write')
426
self.assertRaises(errors.ObjectNotLocked, tree.current_dirstate)
428
def test_new_dirstate_on_new_lock(self):
429
# until we have detection for when a dirstate can be reused, we
430
# want to reparse dirstate on every new lock.
431
known_dirstates = set()
432
def lock_and_compare_all_current_dirstate(tree, lock_method):
433
getattr(tree, lock_method)()
434
state = tree.current_dirstate()
435
self.assertFalse(state in known_dirstates)
436
known_dirstates.add(state)
438
tree = self.make_workingtree()
439
# lock twice with each type to prevent silly per-lock-type bugs.
440
# each lock and compare looks for a unique state object.
441
lock_and_compare_all_current_dirstate(tree, 'lock_read')
442
lock_and_compare_all_current_dirstate(tree, 'lock_read')
443
lock_and_compare_all_current_dirstate(tree, 'lock_tree_write')
444
lock_and_compare_all_current_dirstate(tree, 'lock_tree_write')
445
lock_and_compare_all_current_dirstate(tree, 'lock_write')
446
lock_and_compare_all_current_dirstate(tree, 'lock_write')
242
449
class TestFormat2WorkingTree(TestCaseWithTransport):
243
450
"""Tests that are specific to format 2 trees."""
245
452
def create_format2_tree(self, url):
246
453
return self.make_branch_and_tree(
247
url, format=bzrdir.BzrDirFormat6())
454
url, format=bzrlib.bzrdir.BzrDirFormat6())
249
456
def test_conflicts(self):
250
457
# test backwards compatability
313
533
self.assertEqual(['t', 'u'], tree._locks)
314
534
self.assertRaises(TypeError, tree.method_that_raises, 'foo')
315
535
self.assertEqual(['t', 'u', 't', 'u'], tree._locks)
318
class TestRevert(TestCaseWithTransport):
320
def test_revert_conflicts_recursive(self):
321
this_tree = self.make_branch_and_tree('this-tree')
322
self.build_tree_contents([('this-tree/foo/',),
323
('this-tree/foo/bar', 'bar')])
324
this_tree.add(['foo', 'foo/bar'])
325
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')])
328
other_tree.commit('changed bar')
329
self.build_tree_contents([('this-tree/foo/bar', 'qux')])
330
this_tree.commit('changed qux')
331
this_tree.merge_from_branch(other_tree.branch)
332
self.assertEqual(1, len(this_tree.conflicts()))
333
this_tree.revert(['foo'])
334
self.assertEqual(0, len(this_tree.conflicts()))
337
class TestAutoResolve(TestCaseWithTransport):
339
def test_auto_resolve(self):
340
base = self.make_branch_and_tree('base')
341
self.build_tree_contents([('base/hello', 'Hello')])
342
base.add('hello', 'hello_id')
344
other = base.bzrdir.sprout('other').open_workingtree()
345
self.build_tree_contents([('other/hello', 'hELLO')])
346
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')])
350
this.commit('Add World')
351
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>>>>>>>')])
366
remaining, resolved = this.auto_resolve()
367
self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
369
self.assertEqual([], resolved)
370
self.build_tree_contents([('this/hello', 'hELLO wORLD')])
371
remaining, resolved = this.auto_resolve()
372
self.assertEqual([], this.conflicts())
373
self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
375
self.failIfExists('this/hello.BASE')
377
def test_auto_resolve_dir(self):
378
tree = self.make_branch_and_tree('tree')
379
self.build_tree(['tree/hello/'])
380
tree.add('hello', 'hello-id')
381
file_conflict = conflicts.TextConflict('file', None, 'hello-id')
382
tree.set_conflicts(conflicts.ConflictList([file_conflict]))
386
class TestFindTrees(TestCaseWithTransport):
388
def test_find_trees(self):
389
self.make_branch_and_tree('foo')
390
self.make_branch_and_tree('foo/bar')
391
# Sticking a tree inside a control dir is heinous, so let's skip it
392
self.make_branch_and_tree('foo/.bzr/baz')
393
self.make_branch('qux')
394
trees = workingtree.WorkingTree.find_trees('.')
395
self.assertEqual(2, len(list(trees)))
added
removed
bzrlib/tests/test_workingtree.py
