1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
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.
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.
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
18
from StringIO import StringIO
32
from bzrlib.conflicts import ConflictList, TextConflict
33
from bzrlib.errors import UnrelatedBranches, NoCommits
34
from bzrlib.merge import transform_tree, merge_inner, _PlanMerge
35
from bzrlib.osutils import pathjoin, file_kind
36
from bzrlib.tests import TestCaseWithTransport, TestCaseWithMemoryTransport
37
from bzrlib.workingtree import WorkingTree
39
class TestMerge(TestCaseWithTransport):
40
"""Test appending more than one revision"""
42
def test_pending(self):
43
wt = self.make_branch_and_tree('.')
44
rev_a = wt.commit("lala!")
45
self.assertEqual([rev_a], wt.get_parent_ids())
46
self.assertRaises(errors.PointlessMerge, wt.merge_from_branch,
48
self.assertEqual([rev_a], wt.get_parent_ids())
52
wt = self.make_branch_and_tree('.')
56
wt.merge_from_branch(wt.branch, wt.branch.get_rev_id(2),
57
wt.branch.get_rev_id(1))
59
def test_nocommits(self):
60
wt = self.test_pending()
61
wt2 = self.make_branch_and_tree('branch2')
62
self.assertRaises(NoCommits, wt.merge_from_branch, wt2.branch)
65
def test_unrelated(self):
66
wt, wt2 = self.test_nocommits()
68
self.assertRaises(UnrelatedBranches, wt.merge_from_branch, wt2.branch)
71
def test_merge_one_file(self):
72
"""Do a partial merge of a tree which should not affect tree parents."""
73
wt1 = self.make_branch_and_tree('branch1')
74
tip = wt1.commit('empty commit')
75
wt2 = self.make_branch_and_tree('branch2')
77
file('branch1/foo', 'wb').write('foo')
78
file('branch1/bar', 'wb').write('bar')
81
wt1.commit('add foobar')
83
self.run_bzr('merge ../branch1/baz', retcode=3)
84
self.run_bzr('merge ../branch1/foo')
85
self.failUnlessExists('foo')
86
self.failIfExists('bar')
87
wt2 = WorkingTree.open('.') # opens branch2
88
self.assertEqual([tip], wt2.get_parent_ids())
90
def test_pending_with_null(self):
91
"""When base is forced to revno 0, parent_ids are set"""
92
wt2 = self.test_unrelated()
93
wt1 = WorkingTree.open('.')
96
# merge all of branch 2 into branch 1 even though they
98
wt1.merge_from_branch(wt2.branch, wt2.last_revision(), 'null:')
99
self.assertEqual([br1.last_revision(), wt2.branch.last_revision()],
100
wt1.get_parent_ids())
101
return (wt1, wt2.branch)
103
def test_two_roots(self):
104
"""Merge base is sane when two unrelated branches are merged"""
105
wt1, br2 = self.test_pending_with_null()
109
last = wt1.branch.last_revision()
110
last2 = br2.last_revision()
111
graph = wt1.branch.repository.get_graph()
112
self.assertEqual(last2, graph.find_unique_lca(last, last2))
116
def test_create_rename(self):
117
"""Rename an inventory entry while creating the file"""
118
tree =self.make_branch_and_tree('.')
119
file('name1', 'wb').write('Hello')
121
tree.commit(message="hello")
122
tree.rename_one('name1', 'name2')
124
transform_tree(tree, tree.branch.basis_tree())
126
def test_layered_rename(self):
127
"""Rename both child and parent at same time"""
128
tree =self.make_branch_and_tree('.')
131
filename = pathjoin('dirname1', 'name1')
132
file(filename, 'wb').write('Hello')
134
tree.commit(message="hello")
135
filename2 = pathjoin('dirname1', 'name2')
136
tree.rename_one(filename, filename2)
137
tree.rename_one('dirname1', 'dirname2')
138
transform_tree(tree, tree.branch.basis_tree())
140
def test_ignore_zero_merge_inner(self):
141
# Test that merge_inner's ignore zero parameter is effective
142
tree_a =self.make_branch_and_tree('a')
143
tree_a.commit(message="hello")
144
dir_b = tree_a.bzrdir.sprout('b')
145
tree_b = dir_b.open_workingtree()
147
self.addCleanup(tree_b.unlock)
148
tree_a.commit(message="hello again")
150
merge_inner(tree_b.branch, tree_a, tree_b.basis_tree(),
151
this_tree=tree_b, ignore_zero=True)
152
log = self._get_log(keep_log_file=True)
153
self.failUnless('All changes applied successfully.\n' not in log)
155
merge_inner(tree_b.branch, tree_a, tree_b.basis_tree(),
156
this_tree=tree_b, ignore_zero=False)
157
log = self._get_log(keep_log_file=True)
158
self.failUnless('All changes applied successfully.\n' in log)
160
def test_merge_inner_conflicts(self):
161
tree_a = self.make_branch_and_tree('a')
162
tree_a.set_conflicts(ConflictList([TextConflict('patha')]))
163
merge_inner(tree_a.branch, tree_a, tree_a, this_tree=tree_a)
164
self.assertEqual(1, len(tree_a.conflicts()))
166
def test_rmdir_conflict(self):
167
tree_a = self.make_branch_and_tree('a')
168
self.build_tree(['a/b/'])
169
tree_a.add('b', 'b-id')
170
tree_a.commit('added b')
171
# basis_tree() is only guaranteed to be valid as long as it is actually
172
# the basis tree. This mutates the tree after grabbing basis, so go to
174
base_tree = tree_a.branch.repository.revision_tree(tree_a.last_revision())
175
tree_z = tree_a.bzrdir.sprout('z').open_workingtree()
176
self.build_tree(['a/b/c'])
178
tree_a.commit('added c')
180
tree_z.commit('removed b')
181
merge_inner(tree_z.branch, tree_a, base_tree, this_tree=tree_z)
183
conflicts.MissingParent('Created directory', 'b', 'b-id'),
184
conflicts.UnversionedParent('Versioned directory', 'b', 'b-id')],
186
merge_inner(tree_a.branch, tree_z.basis_tree(), base_tree,
189
conflicts.DeletingParent('Not deleting', 'b', 'b-id'),
190
conflicts.UnversionedParent('Versioned directory', 'b', 'b-id')],
193
def test_nested_merge(self):
194
tree = self.make_branch_and_tree('tree',
195
format='dirstate-with-subtree')
196
sub_tree = self.make_branch_and_tree('tree/sub-tree',
197
format='dirstate-with-subtree')
198
sub_tree.set_root_id('sub-tree-root')
199
self.build_tree_contents([('tree/sub-tree/file', 'text1')])
201
sub_tree.commit('foo')
202
tree.add_reference(sub_tree)
203
tree.commit('set text to 1')
204
tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
205
# modify the file in the subtree
206
self.build_tree_contents([('tree2/sub-tree/file', 'text2')])
207
# and merge the changes from the diverged subtree into the containing
209
tree2.commit('changed file text')
210
tree.merge_from_branch(tree2.branch)
211
self.assertFileEqual('text2', 'tree/sub-tree/file')
213
def test_merge_with_missing(self):
214
tree_a = self.make_branch_and_tree('tree_a')
215
self.build_tree_contents([('tree_a/file', 'content_1')])
217
tree_a.commit('commit base')
218
# basis_tree() is only guaranteed to be valid as long as it is actually
219
# the basis tree. This test commits to the tree after grabbing basis,
220
# so we go to the repository.
221
base_tree = tree_a.branch.repository.revision_tree(tree_a.last_revision())
222
tree_b = tree_a.bzrdir.sprout('tree_b').open_workingtree()
223
self.build_tree_contents([('tree_a/file', 'content_2')])
224
tree_a.commit('commit other')
225
other_tree = tree_a.basis_tree()
226
# 'file' is now missing but isn't altered in any commit in b so no
227
# change should be applied.
228
os.unlink('tree_b/file')
229
merge_inner(tree_b.branch, other_tree, base_tree, this_tree=tree_b)
231
def test_merge_kind_change(self):
232
tree_a = self.make_branch_and_tree('tree_a')
233
self.build_tree_contents([('tree_a/file', 'content_1')])
234
tree_a.add('file', 'file-id')
235
tree_a.commit('added file')
236
tree_b = tree_a.bzrdir.sprout('tree_b').open_workingtree()
237
os.unlink('tree_a/file')
238
self.build_tree(['tree_a/file/'])
239
tree_a.commit('changed file to directory')
240
tree_b.merge_from_branch(tree_a.branch)
241
self.assertEqual('directory', file_kind('tree_b/file'))
243
self.assertEqual('file', file_kind('tree_b/file'))
244
self.build_tree_contents([('tree_b/file', 'content_2')])
245
tree_b.commit('content change')
246
tree_b.merge_from_branch(tree_a.branch)
247
self.assertEqual(tree_b.conflicts(),
248
[conflicts.ContentsConflict('file',
251
def test_merge_type_registry(self):
252
merge_type_option = option.Option.OPTIONS['merge-type']
253
self.assertFalse('merge4' in [x[0] for x in
254
merge_type_option.iter_switches()])
255
registry = _mod_merge.get_merge_type_registry()
256
registry.register_lazy('merge4', 'bzrlib.merge', 'Merge4Merger',
257
'time-travelling merge')
258
self.assertTrue('merge4' in [x[0] for x in
259
merge_type_option.iter_switches()])
260
registry.remove('merge4')
261
self.assertFalse('merge4' in [x[0] for x in
262
merge_type_option.iter_switches()])
264
def test_merge_other_moves_we_deleted(self):
265
tree_a = self.make_branch_and_tree('A')
267
self.addCleanup(tree_a.unlock)
268
self.build_tree(['A/a'])
270
tree_a.commit('1', rev_id='rev-1')
272
tree_a.rename_one('a', 'b')
274
bzrdir_b = tree_a.bzrdir.sprout('B', revision_id='rev-1')
275
tree_b = bzrdir_b.open_workingtree()
277
self.addCleanup(tree_b.unlock)
281
tree_b.merge_from_branch(tree_a.branch)
282
except AttributeError:
283
self.fail('tried to join a path when name was None')
285
def test_merge_uncommitted_otherbasis_ancestor_of_thisbasis(self):
286
tree_a = self.make_branch_and_tree('a')
287
self.build_tree(['a/file_1', 'a/file_2'])
288
tree_a.add(['file_1'])
289
tree_a.commit('commit 1')
290
tree_a.add(['file_2'])
291
tree_a.commit('commit 2')
292
tree_b = tree_a.bzrdir.sprout('b').open_workingtree()
293
tree_b.rename_one('file_1', 'renamed')
294
merger = _mod_merge.Merger.from_uncommitted(tree_a, tree_b,
295
progress.DummyProgress())
296
merger.merge_type = _mod_merge.Merge3Merger
298
self.assertEqual(tree_a.get_parent_ids(), [tree_b.last_revision()])
300
def test_merge_uncommitted_otherbasis_ancestor_of_thisbasis_weave(self):
301
tree_a = self.make_branch_and_tree('a')
302
self.build_tree(['a/file_1', 'a/file_2'])
303
tree_a.add(['file_1'])
304
tree_a.commit('commit 1')
305
tree_a.add(['file_2'])
306
tree_a.commit('commit 2')
307
tree_b = tree_a.bzrdir.sprout('b').open_workingtree()
308
tree_b.rename_one('file_1', 'renamed')
309
merger = _mod_merge.Merger.from_uncommitted(tree_a, tree_b,
310
progress.DummyProgress())
311
merger.merge_type = _mod_merge.WeaveMerger
313
self.assertEqual(tree_a.get_parent_ids(), [tree_b.last_revision()])
315
def test_Merger_defaults_to_DummyProgress(self):
316
branch = self.make_branch('branch')
317
merger = _mod_merge.Merger(branch, pb=None)
318
self.assertIsInstance(merger._pb, progress.DummyProgress)
320
def prepare_cherrypick(self):
321
"""Prepare a pair of trees for cherrypicking tests.
323
Both trees have a file, 'file'.
324
rev1 sets content to 'a'.
327
A full merge of rev2b and rev3b into this_tree would add both 'b' and
328
'c'. A successful cherrypick of rev2b-rev3b into this_tree will add
331
this_tree = self.make_branch_and_tree('this')
332
self.build_tree_contents([('this/file', "a\n")])
333
this_tree.add('file')
334
this_tree.commit('rev1')
335
other_tree = this_tree.bzrdir.sprout('other').open_workingtree()
336
self.build_tree_contents([('other/file', "a\nb\n")])
337
other_tree.commit('rev2b', rev_id='rev2b')
338
self.build_tree_contents([('other/file', "c\na\nb\n")])
339
other_tree.commit('rev3b', rev_id='rev3b')
340
this_tree.lock_write()
341
self.addCleanup(this_tree.unlock)
342
return this_tree, other_tree
344
def test_weave_cherrypick(self):
345
this_tree, other_tree = self.prepare_cherrypick()
346
merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
347
this_tree, 'rev3b', 'rev2b', other_tree.branch)
348
merger.merge_type = _mod_merge.WeaveMerger
350
self.assertFileEqual('c\na\n', 'this/file')
352
def test_weave_cannot_reverse_cherrypick(self):
353
this_tree, other_tree = self.prepare_cherrypick()
354
merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
355
this_tree, 'rev2b', 'rev3b', other_tree.branch)
356
merger.merge_type = _mod_merge.WeaveMerger
357
self.assertRaises(errors.CannotReverseCherrypick, merger.do_merge)
359
def test_merge3_can_reverse_cherrypick(self):
360
this_tree, other_tree = self.prepare_cherrypick()
361
merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
362
this_tree, 'rev2b', 'rev3b', other_tree.branch)
363
merger.merge_type = _mod_merge.Merge3Merger
366
def test_merge3_will_detect_cherrypick(self):
367
this_tree = self.make_branch_and_tree('this')
368
self.build_tree_contents([('this/file', "a\n")])
369
this_tree.add('file')
370
this_tree.commit('rev1')
371
other_tree = this_tree.bzrdir.sprout('other').open_workingtree()
372
self.build_tree_contents([('other/file', "a\nb\n")])
373
other_tree.commit('rev2b', rev_id='rev2b')
374
self.build_tree_contents([('other/file', "a\nb\nc\n")])
375
other_tree.commit('rev3b', rev_id='rev3b')
376
this_tree.lock_write()
377
self.addCleanup(this_tree.unlock)
379
merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
380
this_tree, 'rev3b', 'rev2b', other_tree.branch)
381
merger.merge_type = _mod_merge.Merge3Merger
383
self.assertFileEqual('a\n'
387
'>>>>>>> MERGE-SOURCE\n',
390
def test_make_merger(self):
391
this_tree = self.make_branch_and_tree('this')
392
this_tree.commit('rev1', rev_id='rev1')
393
other_tree = this_tree.bzrdir.sprout('other').open_workingtree()
394
this_tree.commit('rev2', rev_id='rev2a')
395
other_tree.commit('rev2', rev_id='rev2b')
396
this_tree.lock_write()
397
self.addCleanup(this_tree.unlock)
398
merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress,
399
this_tree, 'rev2b', other_branch=other_tree.branch)
400
merger.merge_type = _mod_merge.Merge3Merger
401
tree_merger = merger.make_merger()
402
self.assertIs(_mod_merge.Merge3Merger, tree_merger.__class__)
403
self.assertEqual('rev2b', tree_merger.other_tree.get_revision_id())
404
self.assertEqual('rev1', tree_merger.base_tree.get_revision_id())
406
def test_make_preview_transform(self):
407
this_tree = self.make_branch_and_tree('this')
408
self.build_tree_contents([('this/file', '1\n')])
409
this_tree.add('file', 'file-id')
410
this_tree.commit('rev1', rev_id='rev1')
411
other_tree = this_tree.bzrdir.sprout('other').open_workingtree()
412
self.build_tree_contents([('this/file', '1\n2a\n')])
413
this_tree.commit('rev2', rev_id='rev2a')
414
self.build_tree_contents([('other/file', '2b\n1\n')])
415
other_tree.commit('rev2', rev_id='rev2b')
416
this_tree.lock_write()
417
self.addCleanup(this_tree.unlock)
418
merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
419
this_tree, 'rev2b', other_branch=other_tree.branch)
420
merger.merge_type = _mod_merge.Merge3Merger
421
tree_merger = merger.make_merger()
422
tt = tree_merger.make_preview_transform()
423
self.addCleanup(tt.finalize)
424
preview_tree = tt.get_preview_tree()
425
tree_file = this_tree.get_file('file-id')
427
self.assertEqual('1\n2a\n', tree_file.read())
430
preview_file = preview_tree.get_file('file-id')
432
self.assertEqual('2b\n1\n2a\n', preview_file.read())
436
def test_do_merge(self):
437
this_tree = self.make_branch_and_tree('this')
438
self.build_tree_contents([('this/file', '1\n')])
439
this_tree.add('file', 'file-id')
440
this_tree.commit('rev1', rev_id='rev1')
441
other_tree = this_tree.bzrdir.sprout('other').open_workingtree()
442
self.build_tree_contents([('this/file', '1\n2a\n')])
443
this_tree.commit('rev2', rev_id='rev2a')
444
self.build_tree_contents([('other/file', '2b\n1\n')])
445
other_tree.commit('rev2', rev_id='rev2b')
446
this_tree.lock_write()
447
self.addCleanup(this_tree.unlock)
448
merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
449
this_tree, 'rev2b', other_branch=other_tree.branch)
450
merger.merge_type = _mod_merge.Merge3Merger
451
tree_merger = merger.make_merger()
452
tt = tree_merger.do_merge()
453
tree_file = this_tree.get_file('file-id')
455
self.assertEqual('2b\n1\n2a\n', tree_file.read())
459
def test_merge_add_into_deleted_root(self):
460
# Yes, people actually do this. And report bugs if it breaks.
461
source = self.make_branch_and_tree('source', format='rich-root-pack')
462
self.build_tree(['source/foo/'])
463
source.add('foo', 'foo-id')
464
source.commit('Add foo')
465
target = source.bzrdir.sprout('target').open_workingtree()
466
subtree = target.extract('foo-id')
467
subtree.commit('Delete root')
468
self.build_tree(['source/bar'])
469
source.add('bar', 'bar-id')
470
source.commit('Add bar')
471
subtree.merge_from_branch(source.branch)
473
def test_merge_joined_branch(self):
474
source = self.make_branch_and_tree('source', format='rich-root-pack')
475
self.build_tree(['source/foo'])
477
source.commit('Add foo')
478
target = self.make_branch_and_tree('target', format='rich-root-pack')
479
self.build_tree(['target/bla'])
481
target.commit('Add bla')
482
nested = source.bzrdir.sprout('target/subtree').open_workingtree()
483
target.subsume(nested)
484
target.commit('Join nested')
485
self.build_tree(['source/bar'])
487
source.commit('Add bar')
488
target.merge_from_branch(source.branch)
489
target.commit('Merge source')
492
class TestPlanMerge(TestCaseWithMemoryTransport):
495
TestCaseWithMemoryTransport.setUp(self)
496
mapper = versionedfile.PrefixMapper()
497
factory = knit.make_file_factory(True, mapper)
498
self.vf = factory(self.get_transport())
499
self.plan_merge_vf = versionedfile._PlanMergeVersionedFile('root')
500
self.plan_merge_vf.fallback_versionedfiles.append(self.vf)
502
def add_version(self, key, parents, text):
503
self.vf.add_lines(key, parents, [c+'\n' for c in text])
505
def add_rev(self, prefix, revision_id, parents, text):
506
self.add_version((prefix, revision_id), [(prefix, p) for p in parents],
509
def add_uncommitted_version(self, key, parents, text):
510
self.plan_merge_vf.add_lines(key, parents,
511
[c+'\n' for c in text])
513
def setup_plan_merge(self):
514
self.add_rev('root', 'A', [], 'abc')
515
self.add_rev('root', 'B', ['A'], 'acehg')
516
self.add_rev('root', 'C', ['A'], 'fabg')
517
return _PlanMerge('B', 'C', self.plan_merge_vf, ('root',))
519
def setup_plan_merge_uncommitted(self):
520
self.add_version(('root', 'A'), [], 'abc')
521
self.add_uncommitted_version(('root', 'B:'), [('root', 'A')], 'acehg')
522
self.add_uncommitted_version(('root', 'C:'), [('root', 'A')], 'fabg')
523
return _PlanMerge('B:', 'C:', self.plan_merge_vf, ('root',))
525
def test_unique_lines(self):
526
plan = self.setup_plan_merge()
527
self.assertEqual(plan._unique_lines(
528
plan._get_matching_blocks('B', 'C')),
531
def test_plan_merge(self):
532
self.setup_plan_merge()
533
plan = self.plan_merge_vf.plan_merge('B', 'C')
536
('unchanged', 'a\n'),
545
def test_plan_merge_cherrypick(self):
546
self.add_rev('root', 'A', [], 'abc')
547
self.add_rev('root', 'B', ['A'], 'abcde')
548
self.add_rev('root', 'C', ['A'], 'abcefg')
549
self.add_rev('root', 'D', ['A', 'B', 'C'], 'abcdegh')
550
my_plan = _PlanMerge('B', 'D', self.plan_merge_vf, ('root',))
551
# We shortcut when one text supersedes the other in the per-file graph.
552
# We don't actually need to compare the texts at this point.
561
list(my_plan.plan_merge()))
563
def test_plan_merge_no_common_ancestor(self):
564
self.add_rev('root', 'A', [], 'abc')
565
self.add_rev('root', 'B', [], 'xyz')
566
my_plan = _PlanMerge('A', 'B', self.plan_merge_vf, ('root',))
574
list(my_plan.plan_merge()))
576
def test_plan_merge_tail_ancestors(self):
577
# The graph looks like this:
578
# A # Common to all ancestors
580
# B C # Ancestors of E, only common to one side
582
# D E F # D, F are unique to G, H respectively
583
# |/ \| # E is the LCA for G & H, and the unique LCA for
588
# I J # criss-cross merge of G, H
590
# In this situation, a simple pruning of ancestors of E will leave D &
591
# F "dangling", which looks like they introduce lines different from
592
# the ones in E, but in actuality C&B introduced the lines, and they
593
# are already present in E
595
# Introduce the base text
596
self.add_rev('root', 'A', [], 'abc')
597
# Introduces a new line B
598
self.add_rev('root', 'B', ['A'], 'aBbc')
599
# Introduces a new line C
600
self.add_rev('root', 'C', ['A'], 'abCc')
601
# Introduce new line D
602
self.add_rev('root', 'D', ['B'], 'DaBbc')
603
# Merges B and C by just incorporating both
604
self.add_rev('root', 'E', ['B', 'C'], 'aBbCc')
605
# Introduce new line F
606
self.add_rev('root', 'F', ['C'], 'abCcF')
607
# Merge D & E by just combining the texts
608
self.add_rev('root', 'G', ['D', 'E'], 'DaBbCc')
609
# Merge F & E by just combining the texts
610
self.add_rev('root', 'H', ['F', 'E'], 'aBbCcF')
611
# Merge G & H by just combining texts
612
self.add_rev('root', 'I', ['G', 'H'], 'DaBbCcF')
613
# Merge G & H but supersede an old line in B
614
self.add_rev('root', 'J', ['H', 'G'], 'DaJbCcF')
615
plan = self.plan_merge_vf.plan_merge('I', 'J')
617
('unchanged', 'D\n'),
618
('unchanged', 'a\n'),
621
('unchanged', 'b\n'),
622
('unchanged', 'C\n'),
623
('unchanged', 'c\n'),
624
('unchanged', 'F\n')],
627
def test_plan_merge_tail_triple_ancestors(self):
628
# The graph looks like this:
629
# A # Common to all ancestors
631
# B C # Ancestors of E, only common to one side
633
# D E F # D, F are unique to G, H respectively
634
# |/|\| # E is the LCA for G & H, and the unique LCA for
636
# |\ /| # Q is just an extra node which is merged into both
639
# I J # criss-cross merge of G, H
641
# This is the same as the test_plan_merge_tail_ancestors, except we add
642
# a third LCA that doesn't add new lines, but will trigger our more
643
# involved ancestry logic
645
self.add_rev('root', 'A', [], 'abc')
646
self.add_rev('root', 'B', ['A'], 'aBbc')
647
self.add_rev('root', 'C', ['A'], 'abCc')
648
self.add_rev('root', 'D', ['B'], 'DaBbc')
649
self.add_rev('root', 'E', ['B', 'C'], 'aBbCc')
650
self.add_rev('root', 'F', ['C'], 'abCcF')
651
self.add_rev('root', 'G', ['D', 'E'], 'DaBbCc')
652
self.add_rev('root', 'H', ['F', 'E'], 'aBbCcF')
653
self.add_rev('root', 'Q', ['E'], 'aBbCc')
654
self.add_rev('root', 'I', ['G', 'Q', 'H'], 'DaBbCcF')
655
# Merge G & H but supersede an old line in B
656
self.add_rev('root', 'J', ['H', 'Q', 'G'], 'DaJbCcF')
657
plan = self.plan_merge_vf.plan_merge('I', 'J')
659
('unchanged', 'D\n'),
660
('unchanged', 'a\n'),
663
('unchanged', 'b\n'),
664
('unchanged', 'C\n'),
665
('unchanged', 'c\n'),
666
('unchanged', 'F\n')],
669
def test_plan_merge_2_tail_triple_ancestors(self):
670
# The graph looks like this:
671
# A B # 2 tails going back to NULL
673
# D E F # D, is unique to G, F to H
674
# |/|\| # E is the LCA for G & H, and the unique LCA for
676
# |\ /| # Q is just an extra node which is merged into both
679
# I J # criss-cross merge of G, H (and Q)
682
# This is meant to test after hitting a 3-way LCA, and multiple tail
683
# ancestors (only have NULL_REVISION in common)
685
self.add_rev('root', 'A', [], 'abc')
686
self.add_rev('root', 'B', [], 'def')
687
self.add_rev('root', 'D', ['A'], 'Dabc')
688
self.add_rev('root', 'E', ['A', 'B'], 'abcdef')
689
self.add_rev('root', 'F', ['B'], 'defF')
690
self.add_rev('root', 'G', ['D', 'E'], 'Dabcdef')
691
self.add_rev('root', 'H', ['F', 'E'], 'abcdefF')
692
self.add_rev('root', 'Q', ['E'], 'abcdef')
693
self.add_rev('root', 'I', ['G', 'Q', 'H'], 'DabcdefF')
694
# Merge G & H but supersede an old line in B
695
self.add_rev('root', 'J', ['H', 'Q', 'G'], 'DabcdJfF')
696
plan = self.plan_merge_vf.plan_merge('I', 'J')
698
('unchanged', 'D\n'),
699
('unchanged', 'a\n'),
700
('unchanged', 'b\n'),
701
('unchanged', 'c\n'),
702
('unchanged', 'd\n'),
705
('unchanged', 'f\n'),
706
('unchanged', 'F\n')],
709
def test_plan_merge_uncommitted_files(self):
710
self.setup_plan_merge_uncommitted()
711
plan = self.plan_merge_vf.plan_merge('B:', 'C:')
714
('unchanged', 'a\n'),
723
def test_plan_merge_insert_order(self):
724
"""Weave merges are sensitive to the order of insertion.
726
Specifically for overlapping regions, it effects which region gets put
727
'first'. And when a user resolves an overlapping merge, if they use the
728
same ordering, then the lines match the parents, if they don't only
729
*some* of the lines match.
731
self.add_rev('root', 'A', [], 'abcdef')
732
self.add_rev('root', 'B', ['A'], 'abwxcdef')
733
self.add_rev('root', 'C', ['A'], 'abyzcdef')
734
# Merge, and resolve the conflict by adding *both* sets of lines
735
# If we get the ordering wrong, these will look like new lines in D,
736
# rather than carried over from B, C
737
self.add_rev('root', 'D', ['B', 'C'],
739
# Supersede the lines in B and delete the lines in C, which will
740
# conflict if they are treated as being in D
741
self.add_rev('root', 'E', ['C', 'B'],
743
# Same thing for the lines in C
744
self.add_rev('root', 'F', ['C'], 'abpqcdef')
745
plan = self.plan_merge_vf.plan_merge('D', 'E')
747
('unchanged', 'a\n'),
748
('unchanged', 'b\n'),
755
('unchanged', 'c\n'),
756
('unchanged', 'd\n'),
757
('unchanged', 'e\n'),
758
('unchanged', 'f\n')],
760
plan = self.plan_merge_vf.plan_merge('E', 'D')
761
# Going in the opposite direction shows the effect of the opposite plan
763
('unchanged', 'a\n'),
764
('unchanged', 'b\n'),
769
('killed-both', 'w\n'),
770
('killed-both', 'x\n'),
773
('unchanged', 'c\n'),
774
('unchanged', 'd\n'),
775
('unchanged', 'e\n'),
776
('unchanged', 'f\n')],
779
def test_plan_merge_criss_cross(self):
780
# This is specificly trying to trigger problems when using limited
781
# ancestry and weaves. The ancestry graph looks like:
782
# XX unused ancestor, should not show up in the weave
786
# B \ Introduces a line 'foo'
788
# C D E C & D both have 'foo', E has different changes
792
# F G All of C, D, E are merged into F and G, so they are
793
# all common ancestors.
795
# The specific issue with weaves:
796
# B introduced a text ('foo') that is present in both C and D.
797
# If we do not include B (because it isn't an ancestor of E), then
798
# the A=>C and A=>D look like both sides independently introduce the
799
# text ('foo'). If F does not modify the text, it would still appear
800
# to have deleted on of the versions from C or D. If G then modifies
801
# 'foo', it should appear as superseding the value in F (since it
802
# came from B), rather than conflict because of the resolution during
804
self.add_rev('root', 'XX', [], 'qrs')
805
self.add_rev('root', 'A', ['XX'], 'abcdef')
806
self.add_rev('root', 'B', ['A'], 'axcdef')
807
self.add_rev('root', 'C', ['B'], 'axcdefg')
808
self.add_rev('root', 'D', ['B'], 'haxcdef')
809
self.add_rev('root', 'E', ['A'], 'abcdyf')
810
# Simple combining of all texts
811
self.add_rev('root', 'F', ['C', 'D', 'E'], 'haxcdyfg')
812
# combine and supersede 'x'
813
self.add_rev('root', 'G', ['C', 'D', 'E'], 'hazcdyfg')
814
plan = self.plan_merge_vf.plan_merge('F', 'G')
816
('unchanged', 'h\n'),
817
('unchanged', 'a\n'),
818
('killed-base', 'b\n'),
821
('unchanged', 'c\n'),
822
('unchanged', 'd\n'),
823
('killed-base', 'e\n'),
824
('unchanged', 'y\n'),
825
('unchanged', 'f\n'),
826
('unchanged', 'g\n')],
829
def assertRemoveExternalReferences(self, filtered_parent_map,
830
child_map, tails, parent_map):
831
"""Assert results for _PlanMerge._remove_external_references."""
832
(act_filtered_parent_map, act_child_map,
833
act_tails) = _PlanMerge._remove_external_references(parent_map)
835
# The parent map *should* preserve ordering, but the ordering of
836
# children is not strictly defined
837
# child_map = dict((k, sorted(children))
838
# for k, children in child_map.iteritems())
839
# act_child_map = dict(k, sorted(children)
840
# for k, children in act_child_map.iteritems())
841
self.assertEqual(filtered_parent_map, act_filtered_parent_map)
842
self.assertEqual(child_map, act_child_map)
843
self.assertEqual(sorted(tails), sorted(act_tails))
845
def test__remove_external_references(self):
846
# First, nothing to remove
847
self.assertRemoveExternalReferences({3: [2], 2: [1], 1: []},
848
{1: [2], 2: [3], 3: []}, [1], {3: [2], 2: [1], 1: []})
849
# The reverse direction
850
self.assertRemoveExternalReferences({1: [2], 2: [3], 3: []},
851
{3: [2], 2: [1], 1: []}, [3], {1: [2], 2: [3], 3: []})
853
self.assertRemoveExternalReferences({3: [2], 2: [1], 1: []},
854
{1: [2], 2: [3], 3: []}, [1], {3: [2, 4], 2: [1, 5], 1: [6]})
856
self.assertRemoveExternalReferences(
857
{4: [2, 3], 3: [], 2: [1], 1: []},
858
{1: [2], 2: [4], 3: [4], 4: []},
860
{4: [2, 3], 3: [5], 2: [1], 1: [6]})
862
self.assertRemoveExternalReferences(
863
{1: [3], 2: [3, 4], 3: [], 4: []},
864
{1: [], 2: [], 3: [1, 2], 4: [2]},
866
{1: [3], 2: [3, 4], 3: [5], 4: []})
868
def assertPruneTails(self, pruned_map, tails, parent_map):
870
for key, parent_keys in parent_map.iteritems():
871
child_map.setdefault(key, [])
872
for pkey in parent_keys:
873
child_map.setdefault(pkey, []).append(key)
874
_PlanMerge._prune_tails(parent_map, child_map, tails)
875
self.assertEqual(pruned_map, parent_map)
877
def test__prune_tails(self):
878
# Nothing requested to prune
879
self.assertPruneTails({1: [], 2: [], 3: []}, [],
880
{1: [], 2: [], 3: []})
881
# Prune a single entry
882
self.assertPruneTails({1: [], 3: []}, [2],
883
{1: [], 2: [], 3: []})
885
self.assertPruneTails({1: []}, [3],
886
{1: [], 2: [3], 3: []})
887
# Prune a chain with a diamond
888
self.assertPruneTails({1: []}, [5],
889
{1: [], 2: [3, 4], 3: [5], 4: [5], 5: []})
890
# Prune a partial chain
891
self.assertPruneTails({1: [6], 6:[]}, [5],
892
{1: [2, 6], 2: [3, 4], 3: [5], 4: [5], 5: [],
894
# Prune a chain with multiple tips, that pulls out intermediates
895
self.assertPruneTails({1:[3], 3:[]}, [4, 5],
896
{1: [2, 3], 2: [4, 5], 3: [], 4:[], 5:[]})
897
self.assertPruneTails({1:[3], 3:[]}, [5, 4],
898
{1: [2, 3], 2: [4, 5], 3: [], 4:[], 5:[]})
900
def test_subtract_plans(self):
902
('unchanged', 'a\n'),
911
('unchanged', 'a\n'),
920
('unchanged', 'a\n'),
924
('unchanged', 'f\n'),
927
self.assertEqual(subtracted_plan,
928
list(_PlanMerge._subtract_plans(old_plan, new_plan)))
930
def setup_merge_with_base(self):
931
self.add_rev('root', 'COMMON', [], 'abc')
932
self.add_rev('root', 'THIS', ['COMMON'], 'abcd')
933
self.add_rev('root', 'BASE', ['COMMON'], 'eabc')
934
self.add_rev('root', 'OTHER', ['BASE'], 'eafb')
936
def test_plan_merge_with_base(self):
937
self.setup_merge_with_base()
938
plan = self.plan_merge_vf.plan_merge('THIS', 'OTHER', 'BASE')
939
self.assertEqual([('unchanged', 'a\n'),
941
('unchanged', 'b\n'),
946
def test_plan_lca_merge(self):
947
self.setup_plan_merge()
948
plan = self.plan_merge_vf.plan_lca_merge('B', 'C')
951
('unchanged', 'a\n'),
956
('unchanged', 'g\n')],
959
def test_plan_lca_merge_uncommitted_files(self):
960
self.setup_plan_merge_uncommitted()
961
plan = self.plan_merge_vf.plan_lca_merge('B:', 'C:')
964
('unchanged', 'a\n'),
969
('unchanged', 'g\n')],
972
def test_plan_lca_merge_with_base(self):
973
self.setup_merge_with_base()
974
plan = self.plan_merge_vf.plan_lca_merge('THIS', 'OTHER', 'BASE')
975
self.assertEqual([('unchanged', 'a\n'),
977
('unchanged', 'b\n'),
982
def test_plan_lca_merge_with_criss_cross(self):
983
self.add_version(('root', 'ROOT'), [], 'abc')
984
# each side makes a change
985
self.add_version(('root', 'REV1'), [('root', 'ROOT')], 'abcd')
986
self.add_version(('root', 'REV2'), [('root', 'ROOT')], 'abce')
987
# both sides merge, discarding others' changes
988
self.add_version(('root', 'LCA1'),
989
[('root', 'REV1'), ('root', 'REV2')], 'abcd')
990
self.add_version(('root', 'LCA2'),
991
[('root', 'REV1'), ('root', 'REV2')], 'fabce')
992
plan = self.plan_merge_vf.plan_lca_merge('LCA1', 'LCA2')
993
self.assertEqual([('new-b', 'f\n'),
994
('unchanged', 'a\n'),
995
('unchanged', 'b\n'),
996
('unchanged', 'c\n'),
997
('conflicted-a', 'd\n'),
998
('conflicted-b', 'e\n'),
1001
def test_plan_lca_merge_with_null(self):
1002
self.add_version(('root', 'A'), [], 'ab')
1003
self.add_version(('root', 'B'), [], 'bc')
1004
plan = self.plan_merge_vf.plan_lca_merge('A', 'B')
1005
self.assertEqual([('new-a', 'a\n'),
1006
('unchanged', 'b\n'),
1010
def test_plan_merge_with_delete_and_change(self):
1011
self.add_rev('root', 'C', [], 'a')
1012
self.add_rev('root', 'A', ['C'], 'b')
1013
self.add_rev('root', 'B', ['C'], '')
1014
plan = self.plan_merge_vf.plan_merge('A', 'B')
1015
self.assertEqual([('killed-both', 'a\n'),
1019
def test_plan_merge_with_move_and_change(self):
1020
self.add_rev('root', 'C', [], 'abcd')
1021
self.add_rev('root', 'A', ['C'], 'acbd')
1022
self.add_rev('root', 'B', ['C'], 'aBcd')
1023
plan = self.plan_merge_vf.plan_merge('A', 'B')
1024
self.assertEqual([('unchanged', 'a\n'),
1026
('killed-b', 'b\n'),
1028
('killed-a', 'c\n'),
1029
('unchanged', 'd\n'),
1033
class LoggingMerger(object):
1034
# These seem to be the required attributes
1035
requires_base = False
1036
supports_reprocess = False
1037
supports_show_base = False
1038
supports_cherrypick = False
1039
# We intentionally do not define supports_lca_trees
1041
def __init__(self, *args, **kwargs):
1043
self.kwargs = kwargs
1046
class TestMergerBase(TestCaseWithMemoryTransport):
1047
"""Common functionality for Merger tests that don't write to disk."""
1049
def get_builder(self):
1050
builder = self.make_branch_builder('path')
1051
builder.start_series()
1052
self.addCleanup(builder.finish_series)
1055
def setup_simple_graph(self):
1056
"""Create a simple 3-node graph.
1058
:return: A BranchBuilder
1065
builder = self.get_builder()
1066
builder.build_snapshot('A-id', None,
1067
[('add', ('', None, 'directory', None))])
1068
builder.build_snapshot('C-id', ['A-id'], [])
1069
builder.build_snapshot('B-id', ['A-id'], [])
1072
def setup_criss_cross_graph(self):
1073
"""Create a 5-node graph with a criss-cross.
1075
:return: A BranchBuilder
1082
builder = self.setup_simple_graph()
1083
builder.build_snapshot('E-id', ['C-id', 'B-id'], [])
1084
builder.build_snapshot('D-id', ['B-id', 'C-id'], [])
1087
def make_Merger(self, builder, other_revision_id,
1088
interesting_files=None, interesting_ids=None):
1089
"""Make a Merger object from a branch builder"""
1090
mem_tree = memorytree.MemoryTree.create_on_branch(builder.get_branch())
1091
mem_tree.lock_write()
1092
self.addCleanup(mem_tree.unlock)
1093
merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
1094
mem_tree, other_revision_id)
1095
merger.set_interesting_files(interesting_files)
1096
# It seems there is no matching function for set_interesting_ids
1097
merger.interesting_ids = interesting_ids
1098
merger.merge_type = _mod_merge.Merge3Merger
1102
class TestMergerInMemory(TestMergerBase):
1104
def test_cache_trees_with_revision_ids_None(self):
1105
merger = self.make_Merger(self.setup_simple_graph(), 'C-id')
1106
original_cache = dict(merger._cached_trees)
1107
merger.cache_trees_with_revision_ids([None])
1108
self.assertEqual(original_cache, merger._cached_trees)
1110
def test_cache_trees_with_revision_ids_no_revision_id(self):
1111
merger = self.make_Merger(self.setup_simple_graph(), 'C-id')
1112
original_cache = dict(merger._cached_trees)
1113
tree = self.make_branch_and_memory_tree('tree')
1114
merger.cache_trees_with_revision_ids([tree])
1115
self.assertEqual(original_cache, merger._cached_trees)
1117
def test_cache_trees_with_revision_ids_having_revision_id(self):
1118
merger = self.make_Merger(self.setup_simple_graph(), 'C-id')
1119
original_cache = dict(merger._cached_trees)
1120
tree = merger.this_branch.repository.revision_tree('B-id')
1121
original_cache['B-id'] = tree
1122
merger.cache_trees_with_revision_ids([tree])
1123
self.assertEqual(original_cache, merger._cached_trees)
1125
def test_find_base(self):
1126
merger = self.make_Merger(self.setup_simple_graph(), 'C-id')
1127
self.assertEqual('A-id', merger.base_rev_id)
1128
self.assertFalse(merger._is_criss_cross)
1129
self.assertIs(None, merger._lca_trees)
1131
def test_find_base_criss_cross(self):
1132
builder = self.setup_criss_cross_graph()
1133
merger = self.make_Merger(builder, 'E-id')
1134
self.assertEqual('A-id', merger.base_rev_id)
1135
self.assertTrue(merger._is_criss_cross)
1136
self.assertEqual(['B-id', 'C-id'], [t.get_revision_id()
1137
for t in merger._lca_trees])
1138
# If we swap the order, we should get a different lca order
1139
builder.build_snapshot('F-id', ['E-id'], [])
1140
merger = self.make_Merger(builder, 'D-id')
1141
self.assertEqual(['C-id', 'B-id'], [t.get_revision_id()
1142
for t in merger._lca_trees])
1144
def test_find_base_triple_criss_cross(self):
1147
# B C F # F is merged into both branches
1154
builder = self.setup_criss_cross_graph()
1155
builder.build_snapshot('F-id', ['A-id'], [])
1156
builder.build_snapshot('H-id', ['E-id', 'F-id'], [])
1157
builder.build_snapshot('G-id', ['D-id', 'F-id'], [])
1158
merger = self.make_Merger(builder, 'H-id')
1159
self.assertEqual(['B-id', 'C-id', 'F-id'],
1160
[t.get_revision_id() for t in merger._lca_trees])
1162
def test_no_criss_cross_passed_to_merge_type(self):
1163
class LCATreesMerger(LoggingMerger):
1164
supports_lca_trees = True
1166
merger = self.make_Merger(self.setup_simple_graph(), 'C-id')
1167
merger.merge_type = LCATreesMerger
1168
merge_obj = merger.make_merger()
1169
self.assertIsInstance(merge_obj, LCATreesMerger)
1170
self.assertFalse('lca_trees' in merge_obj.kwargs)
1172
def test_criss_cross_passed_to_merge_type(self):
1173
merger = self.make_Merger(self.setup_criss_cross_graph(), 'E-id')
1174
merger.merge_type = _mod_merge.Merge3Merger
1175
merge_obj = merger.make_merger()
1176
self.assertEqual(['B-id', 'C-id'], [t.get_revision_id()
1177
for t in merger._lca_trees])
1179
def test_criss_cross_not_supported_merge_type(self):
1180
merger = self.make_Merger(self.setup_criss_cross_graph(), 'E-id')
1181
# We explicitly do not define supports_lca_trees
1182
merger.merge_type = LoggingMerger
1183
merge_obj = merger.make_merger()
1184
self.assertIsInstance(merge_obj, LoggingMerger)
1185
self.assertFalse('lca_trees' in merge_obj.kwargs)
1187
def test_criss_cross_unsupported_merge_type(self):
1188
class UnsupportedLCATreesMerger(LoggingMerger):
1189
supports_lca_trees = False
1191
merger = self.make_Merger(self.setup_criss_cross_graph(), 'E-id')
1192
merger.merge_type = UnsupportedLCATreesMerger
1193
merge_obj = merger.make_merger()
1194
self.assertIsInstance(merge_obj, UnsupportedLCATreesMerger)
1195
self.assertFalse('lca_trees' in merge_obj.kwargs)
1198
class TestMergerEntriesLCA(TestMergerBase):
1200
def make_merge_obj(self, builder, other_revision_id,
1201
interesting_files=None, interesting_ids=None):
1202
merger = self.make_Merger(builder, other_revision_id,
1203
interesting_files=interesting_files,
1204
interesting_ids=interesting_ids)
1205
return merger.make_merger()
1207
def test_simple(self):
1208
builder = self.get_builder()
1209
builder.build_snapshot('A-id', None,
1210
[('add', (u'', 'a-root-id', 'directory', None)),
1211
('add', (u'a', 'a-id', 'file', 'a\nb\nc\n'))])
1212
builder.build_snapshot('C-id', ['A-id'],
1213
[('modify', ('a-id', 'a\nb\nC\nc\n'))])
1214
builder.build_snapshot('B-id', ['A-id'],
1215
[('modify', ('a-id', 'a\nB\nb\nc\n'))])
1216
builder.build_snapshot('E-id', ['C-id', 'B-id'],
1217
[('modify', ('a-id', 'a\nB\nb\nC\nc\nE\n'))])
1218
builder.build_snapshot('D-id', ['B-id', 'C-id'],
1219
[('modify', ('a-id', 'a\nB\nb\nC\nc\n'))])
1220
merge_obj = self.make_merge_obj(builder, 'E-id')
1222
self.assertEqual(['B-id', 'C-id'], [t.get_revision_id()
1223
for t in merge_obj._lca_trees])
1224
self.assertEqual('A-id', merge_obj.base_tree.get_revision_id())
1225
entries = list(merge_obj._entries_lca())
1227
# (file_id, changed, parents, names, executable)
1228
# BASE, lca1, lca2, OTHER, THIS
1229
root_id = 'a-root-id'
1230
self.assertEqual([('a-id', True,
1231
((root_id, [root_id, root_id]), root_id, root_id),
1232
((u'a', [u'a', u'a']), u'a', u'a'),
1233
((False, [False, False]), False, False)),
1236
def test_not_in_base(self):
1237
# LCAs all have the same last-modified revision for the file, as do
1238
# the tips, but the base has something different
1239
# A base, doesn't have the file
1241
# B C B introduces 'foo', C introduces 'bar'
1243
# D E D and E now both have 'foo' and 'bar'
1245
# F G the files are now in F, G, D and E, but not in A
1248
builder = self.get_builder()
1249
builder.build_snapshot('A-id', None,
1250
[('add', (u'', 'a-root-id', 'directory', None))])
1251
builder.build_snapshot('B-id', ['A-id'],
1252
[('add', (u'foo', 'foo-id', 'file', 'a\nb\nc\n'))])
1253
builder.build_snapshot('C-id', ['A-id'],
1254
[('add', (u'bar', 'bar-id', 'file', 'd\ne\nf\n'))])
1255
builder.build_snapshot('D-id', ['B-id', 'C-id'],
1256
[('add', (u'bar', 'bar-id', 'file', 'd\ne\nf\n'))])
1257
builder.build_snapshot('E-id', ['C-id', 'B-id'],
1258
[('add', (u'foo', 'foo-id', 'file', 'a\nb\nc\n'))])
1259
builder.build_snapshot('G-id', ['E-id', 'D-id'],
1260
[('modify', (u'bar-id', 'd\ne\nf\nG\n'))])
1261
builder.build_snapshot('F-id', ['D-id', 'E-id'], [])
1262
merge_obj = self.make_merge_obj(builder, 'G-id')
1264
self.assertEqual(['D-id', 'E-id'], [t.get_revision_id()
1265
for t in merge_obj._lca_trees])
1266
self.assertEqual('A-id', merge_obj.base_tree.get_revision_id())
1267
entries = list(merge_obj._entries_lca())
1268
root_id = 'a-root-id'
1269
self.assertEqual([('bar-id', True,
1270
((None, [root_id, root_id]), root_id, root_id),
1271
((None, [u'bar', u'bar']), u'bar', u'bar'),
1272
((None, [False, False]), False, False)),
1275
def test_not_in_this(self):
1276
builder = self.get_builder()
1277
builder.build_snapshot('A-id', None,
1278
[('add', (u'', 'a-root-id', 'directory', None)),
1279
('add', (u'a', 'a-id', 'file', 'a\nb\nc\n'))])
1280
builder.build_snapshot('B-id', ['A-id'],
1281
[('modify', ('a-id', 'a\nB\nb\nc\n'))])
1282
builder.build_snapshot('C-id', ['A-id'],
1283
[('modify', ('a-id', 'a\nb\nC\nc\n'))])
1284
builder.build_snapshot('E-id', ['C-id', 'B-id'],
1285
[('modify', ('a-id', 'a\nB\nb\nC\nc\nE\n'))])
1286
builder.build_snapshot('D-id', ['B-id', 'C-id'],
1287
[('unversion', 'a-id')])
1288
merge_obj = self.make_merge_obj(builder, 'E-id')
1290
self.assertEqual(['B-id', 'C-id'], [t.get_revision_id()
1291
for t in merge_obj._lca_trees])
1292
self.assertEqual('A-id', merge_obj.base_tree.get_revision_id())
1294
entries = list(merge_obj._entries_lca())
1295
root_id = 'a-root-id'
1296
self.assertEqual([('a-id', True,
1297
((root_id, [root_id, root_id]), root_id, None),
1298
((u'a', [u'a', u'a']), u'a', None),
1299
((False, [False, False]), False, None)),
1302
def test_file_not_in_one_lca(self):
1305
# B C # B no file, C introduces a file
1307
# D E # D and E both have the file, unchanged from C
1308
builder = self.get_builder()
1309
builder.build_snapshot('A-id', None,
1310
[('add', (u'', 'a-root-id', 'directory', None))])
1311
builder.build_snapshot('B-id', ['A-id'], [])
1312
builder.build_snapshot('C-id', ['A-id'],
1313
[('add', (u'a', 'a-id', 'file', 'a\nb\nc\n'))])
1314
builder.build_snapshot('E-id', ['C-id', 'B-id'], []) # Inherited from C
1315
builder.build_snapshot('D-id', ['B-id', 'C-id'], # Merged from C
1316
[('add', (u'a', 'a-id', 'file', 'a\nb\nc\n'))])
1317
merge_obj = self.make_merge_obj(builder, 'E-id')
1319
self.assertEqual(['B-id', 'C-id'], [t.get_revision_id()
1320
for t in merge_obj._lca_trees])
1321
self.assertEqual('A-id', merge_obj.base_tree.get_revision_id())
1323
entries = list(merge_obj._entries_lca())
1324
self.assertEqual([], entries)
1326
def test_not_in_other(self):
1327
builder = self.get_builder()
1328
builder.build_snapshot('A-id', None,
1329
[('add', (u'', 'a-root-id', 'directory', None)),
1330
('add', (u'a', 'a-id', 'file', 'a\nb\nc\n'))])
1331
builder.build_snapshot('B-id', ['A-id'], [])
1332
builder.build_snapshot('C-id', ['A-id'], [])
1333
builder.build_snapshot('E-id', ['C-id', 'B-id'],
1334
[('unversion', 'a-id')])
1335
builder.build_snapshot('D-id', ['B-id', 'C-id'], [])
1336
merge_obj = self.make_merge_obj(builder, 'E-id')
1338
entries = list(merge_obj._entries_lca())
1339
root_id = 'a-root-id'
1340
self.assertEqual([('a-id', True,
1341
((root_id, [root_id, root_id]), None, root_id),
1342
((u'a', [u'a', u'a']), None, u'a'),
1343
((False, [False, False]), None, False)),
1346
def test_not_in_other_or_lca(self):
1347
# A base, introduces 'foo'
1349
# B C B nothing, C deletes foo
1351
# D E D restores foo (same as B), E leaves it deleted
1353
# A => B, no changes
1354
# A => C, delete foo (C should supersede B)
1355
# C => D, restore foo
1356
# C => E, no changes
1357
# D would then win 'cleanly' and no record would be given
1358
builder = self.get_builder()
1359
builder.build_snapshot('A-id', None,
1360
[('add', (u'', 'a-root-id', 'directory', None)),
1361
('add', (u'foo', 'foo-id', 'file', 'content\n'))])
1362
builder.build_snapshot('B-id', ['A-id'], [])
1363
builder.build_snapshot('C-id', ['A-id'],
1364
[('unversion', 'foo-id')])
1365
builder.build_snapshot('E-id', ['C-id', 'B-id'], [])
1366
builder.build_snapshot('D-id', ['B-id', 'C-id'], [])
1367
merge_obj = self.make_merge_obj(builder, 'E-id')
1369
entries = list(merge_obj._entries_lca())
1370
self.assertEqual([], entries)
1372
def test_not_in_other_mod_in_lca1_not_in_lca2(self):
1373
# A base, introduces 'foo'
1375
# B C B changes 'foo', C deletes foo
1377
# D E D restores foo (same as B), E leaves it deleted (as C)
1379
# A => B, modified foo
1380
# A => C, delete foo, C does not supersede B
1381
# B => D, no changes
1382
# C => D, resolve in favor of B
1383
# B => E, resolve in favor of E
1384
# C => E, no changes
1385
# In this case, we have a conflict of how the changes were resolved. E
1386
# picked C and D picked B, so we should issue a conflict
1387
builder = self.get_builder()
1388
builder.build_snapshot('A-id', None,
1389
[('add', (u'', 'a-root-id', 'directory', None)),
1390
('add', (u'foo', 'foo-id', 'file', 'content\n'))])
1391
builder.build_snapshot('B-id', ['A-id'], [
1392
('modify', ('foo-id', 'new-content\n'))])
1393
builder.build_snapshot('C-id', ['A-id'],
1394
[('unversion', 'foo-id')])
1395
builder.build_snapshot('E-id', ['C-id', 'B-id'], [])
1396
builder.build_snapshot('D-id', ['B-id', 'C-id'], [])
1397
merge_obj = self.make_merge_obj(builder, 'E-id')
1399
entries = list(merge_obj._entries_lca())
1400
root_id = 'a-root-id'
1401
self.assertEqual([('foo-id', True,
1402
((root_id, [root_id, None]), None, root_id),
1403
((u'foo', [u'foo', None]), None, 'foo'),
1404
((False, [False, None]), None, False)),
1407
def test_only_in_one_lca(self):
1410
# B C B nothing, C add file
1412
# D E D still has nothing, E removes file
1415
# C => D, removed the file
1417
# C => E, removed the file
1418
# Thus D & E have identical changes, and this is a no-op
1421
# A => C, add file, thus C supersedes B
1422
# w/ C=BASE, D=THIS, E=OTHER we have 'happy convergence'
1423
builder = self.get_builder()
1424
builder.build_snapshot('A-id', None,
1425
[('add', (u'', 'a-root-id', 'directory', None))])
1426
builder.build_snapshot('B-id', ['A-id'], [])
1427
builder.build_snapshot('C-id', ['A-id'],
1428
[('add', (u'a', 'a-id', 'file', 'a\nb\nc\n'))])
1429
builder.build_snapshot('E-id', ['C-id', 'B-id'],
1430
[('unversion', 'a-id')])
1431
builder.build_snapshot('D-id', ['B-id', 'C-id'], [])
1432
merge_obj = self.make_merge_obj(builder, 'E-id')
1434
entries = list(merge_obj._entries_lca())
1435
self.assertEqual([], entries)
1437
def test_only_in_other(self):
1438
builder = self.get_builder()
1439
builder.build_snapshot('A-id', None,
1440
[('add', (u'', 'a-root-id', 'directory', None))])
1441
builder.build_snapshot('B-id', ['A-id'], [])
1442
builder.build_snapshot('C-id', ['A-id'], [])
1443
builder.build_snapshot('E-id', ['C-id', 'B-id'],
1444
[('add', (u'a', 'a-id', 'file', 'a\nb\nc\n'))])
1445
builder.build_snapshot('D-id', ['B-id', 'C-id'], [])
1446
merge_obj = self.make_merge_obj(builder, 'E-id')
1448
entries = list(merge_obj._entries_lca())
1449
root_id = 'a-root-id'
1450
self.assertEqual([('a-id', True,
1451
((None, [None, None]), root_id, None),
1452
((None, [None, None]), u'a', None),
1453
((None, [None, None]), False, None)),
1456
def test_one_lca_supersedes(self):
1457
# One LCA supersedes the other LCAs last modified value, but the
1458
# value is not the same as BASE.
1459
# A base, introduces 'foo', last mod A
1461
# B C B modifies 'foo' (mod B), C does nothing (mod A)
1463
# D E D does nothing (mod B), E updates 'foo' (mod E)
1465
# F G F updates 'foo' (mod F). G does nothing (mod E)
1467
# At this point, G should not be considered to modify 'foo', even
1468
# though its LCAs disagree. This is because the modification in E
1469
# completely supersedes the value in D.
1470
builder = self.get_builder()
1471
builder.build_snapshot('A-id', None,
1472
[('add', (u'', 'a-root-id', 'directory', None)),
1473
('add', (u'foo', 'foo-id', 'file', 'A content\n'))])
1474
builder.build_snapshot('C-id', ['A-id'], [])
1475
builder.build_snapshot('B-id', ['A-id'],
1476
[('modify', ('foo-id', 'B content\n'))])
1477
builder.build_snapshot('D-id', ['B-id', 'C-id'], [])
1478
builder.build_snapshot('E-id', ['C-id', 'B-id'],
1479
[('modify', ('foo-id', 'E content\n'))])
1480
builder.build_snapshot('G-id', ['E-id', 'D-id'], [])
1481
builder.build_snapshot('F-id', ['D-id', 'E-id'],
1482
[('modify', ('foo-id', 'F content\n'))])
1483
merge_obj = self.make_merge_obj(builder, 'G-id')
1485
self.assertEqual([], list(merge_obj._entries_lca()))
1487
def test_one_lca_supersedes_path(self):
1488
# Double-criss-cross merge, the ultimate base value is different from
1492
# B C B value 'bar', C = 'foo'
1494
# D E D = 'bar', E supersedes to 'bing'
1496
# F G F = 'bing', G supersedes to 'barry'
1498
# In this case, we technically should not care about the value 'bar' for
1499
# D, because it was clearly superseded by E's 'bing'. The
1500
# per-file/attribute graph would actually look like:
1509
# Because the other side of the merge never modifies the value, it just
1510
# takes the value from the merge.
1512
# ATM this fails because we will prune 'foo' from the LCAs, but we
1513
# won't prune 'bar'. This is getting far off into edge-case land, so we
1514
# aren't supporting it yet.
1516
builder = self.get_builder()
1517
builder.build_snapshot('A-id', None,
1518
[('add', (u'', 'a-root-id', 'directory', None)),
1519
('add', (u'foo', 'foo-id', 'file', 'A content\n'))])
1520
builder.build_snapshot('C-id', ['A-id'], [])
1521
builder.build_snapshot('B-id', ['A-id'],
1522
[('rename', ('foo', 'bar'))])
1523
builder.build_snapshot('D-id', ['B-id', 'C-id'], [])
1524
builder.build_snapshot('E-id', ['C-id', 'B-id'],
1525
[('rename', ('foo', 'bing'))]) # override to bing
1526
builder.build_snapshot('G-id', ['E-id', 'D-id'],
1527
[('rename', ('bing', 'barry'))]) # override to barry
1528
builder.build_snapshot('F-id', ['D-id', 'E-id'],
1529
[('rename', ('bar', 'bing'))]) # Merge in E's change
1530
merge_obj = self.make_merge_obj(builder, 'G-id')
1532
self.expectFailure("We don't do an actual heads() check on lca values,"
1533
" or use the per-attribute graph",
1534
self.assertEqual, [], list(merge_obj._entries_lca()))
1536
def test_one_lca_accidentally_pruned(self):
1537
# Another incorrect resolution from the same basic flaw:
1540
# B C B value 'bar', C = 'foo'
1542
# D E D = 'bar', E reverts to 'foo'
1544
# F G F = 'bing', G switches to 'bar'
1546
# 'bar' will not be seen as an interesting change, because 'foo' will
1547
# be pruned from the LCAs, even though it was newly introduced by E
1549
builder = self.get_builder()
1550
builder.build_snapshot('A-id', None,
1551
[('add', (u'', 'a-root-id', 'directory', None)),
1552
('add', (u'foo', 'foo-id', 'file', 'A content\n'))])
1553
builder.build_snapshot('C-id', ['A-id'], [])
1554
builder.build_snapshot('B-id', ['A-id'],
1555
[('rename', ('foo', 'bar'))])
1556
builder.build_snapshot('D-id', ['B-id', 'C-id'], [])
1557
builder.build_snapshot('E-id', ['C-id', 'B-id'], [])
1558
builder.build_snapshot('G-id', ['E-id', 'D-id'],
1559
[('rename', ('foo', 'bar'))])
1560
builder.build_snapshot('F-id', ['D-id', 'E-id'],
1561
[('rename', ('bar', 'bing'))]) # should end up conflicting
1562
merge_obj = self.make_merge_obj(builder, 'G-id')
1564
entries = list(merge_obj._entries_lca())
1565
root_id = 'a-root-id'
1566
self.expectFailure("We prune values from BASE even when relevant.",
1569
((root_id, [root_id, root_id]), root_id, root_id),
1570
((u'foo', [u'bar', u'foo']), u'bar', u'bing'),
1571
((False, [False, False]), False, False)),
1574
def test_both_sides_revert(self):
1575
# Both sides of a criss-cross revert the text to the lca
1576
# A base, introduces 'foo'
1578
# B C B modifies 'foo', C modifies 'foo'
1580
# D E D reverts to B, E reverts to C
1581
# This should conflict
1582
builder = self.get_builder()
1583
builder.build_snapshot('A-id', None,
1584
[('add', (u'', 'a-root-id', 'directory', None)),
1585
('add', (u'foo', 'foo-id', 'file', 'A content\n'))])
1586
builder.build_snapshot('B-id', ['A-id'],
1587
[('modify', ('foo-id', 'B content\n'))])
1588
builder.build_snapshot('C-id', ['A-id'],
1589
[('modify', ('foo-id', 'C content\n'))])
1590
builder.build_snapshot('E-id', ['C-id', 'B-id'], [])
1591
builder.build_snapshot('D-id', ['B-id', 'C-id'], [])
1592
merge_obj = self.make_merge_obj(builder, 'E-id')
1594
entries = list(merge_obj._entries_lca())
1595
root_id = 'a-root-id'
1596
self.assertEqual([('foo-id', True,
1597
((root_id, [root_id, root_id]), root_id, root_id),
1598
((u'foo', [u'foo', u'foo']), u'foo', u'foo'),
1599
((False, [False, False]), False, False)),
1602
def test_different_lca_resolve_one_side_updates_content(self):
1603
# Both sides converge, but then one side updates the text.
1604
# A base, introduces 'foo'
1606
# B C B modifies 'foo', C modifies 'foo'
1608
# D E D reverts to B, E reverts to C
1610
# F F updates to a new value
1611
# We need to emit an entry for 'foo', because D & E differed on the
1613
builder = self.get_builder()
1614
builder.build_snapshot('A-id', None,
1615
[('add', (u'', 'a-root-id', 'directory', None)),
1616
('add', (u'foo', 'foo-id', 'file', 'A content\n'))])
1617
builder.build_snapshot('B-id', ['A-id'],
1618
[('modify', ('foo-id', 'B content\n'))])
1619
builder.build_snapshot('C-id', ['A-id'],
1620
[('modify', ('foo-id', 'C content\n'))])
1621
builder.build_snapshot('E-id', ['C-id', 'B-id'], [])
1622
builder.build_snapshot('D-id', ['B-id', 'C-id'], [])
1623
builder.build_snapshot('F-id', ['D-id'],
1624
[('modify', ('foo-id', 'F content\n'))])
1625
merge_obj = self.make_merge_obj(builder, 'E-id')
1627
entries = list(merge_obj._entries_lca())
1628
root_id = 'a-root-id'
1629
self.assertEqual([('foo-id', True,
1630
((root_id, [root_id, root_id]), root_id, root_id),
1631
((u'foo', [u'foo', u'foo']), u'foo', u'foo'),
1632
((False, [False, False]), False, False)),
1635
def test_same_lca_resolution_one_side_updates_content(self):
1636
# Both sides converge, but then one side updates the text.
1637
# A base, introduces 'foo'
1639
# B C B modifies 'foo', C modifies 'foo'
1641
# D E D and E use C's value
1643
# F F updates to a new value
1644
# I think it is a bug that this conflicts, but we don't have a way to
1645
# detect otherwise. And because of:
1646
# test_different_lca_resolve_one_side_updates_content
1647
# We need to conflict.
1649
builder = self.get_builder()
1650
builder.build_snapshot('A-id', None,
1651
[('add', (u'', 'a-root-id', 'directory', None)),
1652
('add', (u'foo', 'foo-id', 'file', 'A content\n'))])
1653
builder.build_snapshot('B-id', ['A-id'],
1654
[('modify', ('foo-id', 'B content\n'))])
1655
builder.build_snapshot('C-id', ['A-id'],
1656
[('modify', ('foo-id', 'C content\n'))])
1657
builder.build_snapshot('E-id', ['C-id', 'B-id'], [])
1658
builder.build_snapshot('D-id', ['B-id', 'C-id'],
1659
[('modify', ('foo-id', 'C content\n'))]) # Same as E
1660
builder.build_snapshot('F-id', ['D-id'],
1661
[('modify', ('foo-id', 'F content\n'))])
1662
merge_obj = self.make_merge_obj(builder, 'E-id')
1664
entries = list(merge_obj._entries_lca())
1665
self.expectFailure("We don't detect that LCA resolution was the"
1666
" same on both sides",
1667
self.assertEqual, [], entries)
1669
def test_only_path_changed(self):
1670
builder = self.get_builder()
1671
builder.build_snapshot('A-id', None,
1672
[('add', (u'', 'a-root-id', 'directory', None)),
1673
('add', (u'a', 'a-id', 'file', 'content\n'))])
1674
builder.build_snapshot('B-id', ['A-id'], [])
1675
builder.build_snapshot('C-id', ['A-id'], [])
1676
builder.build_snapshot('E-id', ['C-id', 'B-id'],
1677
[('rename', (u'a', u'b'))])
1678
builder.build_snapshot('D-id', ['B-id', 'C-id'], [])
1679
merge_obj = self.make_merge_obj(builder, 'E-id')
1680
entries = list(merge_obj._entries_lca())
1681
root_id = 'a-root-id'
1682
# The content was not changed, only the path
1683
self.assertEqual([('a-id', False,
1684
((root_id, [root_id, root_id]), root_id, root_id),
1685
((u'a', [u'a', u'a']), u'b', u'a'),
1686
((False, [False, False]), False, False)),
1689
def test_kind_changed(self):
1690
# Identical content, except 'D' changes a-id into a directory
1691
builder = self.get_builder()
1692
builder.build_snapshot('A-id', None,
1693
[('add', (u'', 'a-root-id', 'directory', None)),
1694
('add', (u'a', 'a-id', 'file', 'content\n'))])
1695
builder.build_snapshot('B-id', ['A-id'], [])
1696
builder.build_snapshot('C-id', ['A-id'], [])
1697
builder.build_snapshot('E-id', ['C-id', 'B-id'],
1698
[('unversion', 'a-id'),
1699
('add', (u'a', 'a-id', 'directory', None))])
1700
builder.build_snapshot('D-id', ['B-id', 'C-id'], [])
1701
merge_obj = self.make_merge_obj(builder, 'E-id')
1702
entries = list(merge_obj._entries_lca())
1703
root_id = 'a-root-id'
1704
# Only the kind was changed (content)
1705
self.assertEqual([('a-id', True,
1706
((root_id, [root_id, root_id]), root_id, root_id),
1707
((u'a', [u'a', u'a']), u'a', u'a'),
1708
((False, [False, False]), False, False)),
1711
def test_this_changed_kind(self):
1712
# Identical content, but THIS changes a file to a directory
1713
builder = self.get_builder()
1714
builder.build_snapshot('A-id', None,
1715
[('add', (u'', 'a-root-id', 'directory', None)),
1716
('add', (u'a', 'a-id', 'file', 'content\n'))])
1717
builder.build_snapshot('B-id', ['A-id'], [])
1718
builder.build_snapshot('C-id', ['A-id'], [])
1719
builder.build_snapshot('E-id', ['C-id', 'B-id'], [])
1720
builder.build_snapshot('D-id', ['B-id', 'C-id'],
1721
[('unversion', 'a-id'),
1722
('add', (u'a', 'a-id', 'directory', None))])
1723
merge_obj = self.make_merge_obj(builder, 'E-id')
1724
entries = list(merge_obj._entries_lca())
1725
# Only the kind was changed (content)
1726
self.assertEqual([], entries)
1728
def test_interesting_files(self):
1729
# Two files modified, but we should filter one of them
1730
builder = self.get_builder()
1731
builder.build_snapshot('A-id', None,
1732
[('add', (u'', 'a-root-id', 'directory', None)),
1733
('add', (u'a', 'a-id', 'file', 'content\n')),
1734
('add', (u'b', 'b-id', 'file', 'content\n'))])
1735
builder.build_snapshot('B-id', ['A-id'], [])
1736
builder.build_snapshot('C-id', ['A-id'], [])
1737
builder.build_snapshot('E-id', ['C-id', 'B-id'],
1738
[('modify', ('a-id', 'new-content\n')),
1739
('modify', ('b-id', 'new-content\n'))])
1740
builder.build_snapshot('D-id', ['B-id', 'C-id'], [])
1741
merge_obj = self.make_merge_obj(builder, 'E-id',
1742
interesting_files=['b'])
1743
entries = list(merge_obj._entries_lca())
1744
root_id = 'a-root-id'
1745
self.assertEqual([('b-id', True,
1746
((root_id, [root_id, root_id]), root_id, root_id),
1747
((u'b', [u'b', u'b']), u'b', u'b'),
1748
((False, [False, False]), False, False)),
1751
def test_interesting_file_in_this(self):
1752
# This renamed the file, but it should still match the entry in other
1753
builder = self.get_builder()
1754
builder.build_snapshot('A-id', None,
1755
[('add', (u'', 'a-root-id', 'directory', None)),
1756
('add', (u'a', 'a-id', 'file', 'content\n')),
1757
('add', (u'b', 'b-id', 'file', 'content\n'))])
1758
builder.build_snapshot('B-id', ['A-id'], [])
1759
builder.build_snapshot('C-id', ['A-id'], [])
1760
builder.build_snapshot('E-id', ['C-id', 'B-id'],
1761
[('modify', ('a-id', 'new-content\n')),
1762
('modify', ('b-id', 'new-content\n'))])
1763
builder.build_snapshot('D-id', ['B-id', 'C-id'],
1764
[('rename', ('b', 'c'))])
1765
merge_obj = self.make_merge_obj(builder, 'E-id',
1766
interesting_files=['c'])
1767
entries = list(merge_obj._entries_lca())
1768
root_id = 'a-root-id'
1769
self.assertEqual([('b-id', True,
1770
((root_id, [root_id, root_id]), root_id, root_id),
1771
((u'b', [u'b', u'b']), u'b', u'c'),
1772
((False, [False, False]), False, False)),
1775
def test_interesting_file_in_base(self):
1776
# This renamed the file, but it should still match the entry in BASE
1777
builder = self.get_builder()
1778
builder.build_snapshot('A-id', None,
1779
[('add', (u'', 'a-root-id', 'directory', None)),
1780
('add', (u'a', 'a-id', 'file', 'content\n')),
1781
('add', (u'c', 'c-id', 'file', 'content\n'))])
1782
builder.build_snapshot('B-id', ['A-id'],
1783
[('rename', ('c', 'b'))])
1784
builder.build_snapshot('C-id', ['A-id'],
1785
[('rename', ('c', 'b'))])
1786
builder.build_snapshot('E-id', ['C-id', 'B-id'],
1787
[('modify', ('a-id', 'new-content\n')),
1788
('modify', ('c-id', 'new-content\n'))])
1789
builder.build_snapshot('D-id', ['B-id', 'C-id'], [])
1790
merge_obj = self.make_merge_obj(builder, 'E-id',
1791
interesting_files=['c'])
1792
entries = list(merge_obj._entries_lca())
1793
root_id = 'a-root-id'
1794
self.assertEqual([('c-id', True,
1795
((root_id, [root_id, root_id]), root_id, root_id),
1796
((u'c', [u'b', u'b']), u'b', u'b'),
1797
((False, [False, False]), False, False)),
1800
def test_interesting_file_in_lca(self):
1801
# This renamed the file, but it should still match the entry in LCA
1802
builder = self.get_builder()
1803
builder.build_snapshot('A-id', None,
1804
[('add', (u'', 'a-root-id', 'directory', None)),
1805
('add', (u'a', 'a-id', 'file', 'content\n')),
1806
('add', (u'b', 'b-id', 'file', 'content\n'))])
1807
builder.build_snapshot('B-id', ['A-id'],
1808
[('rename', ('b', 'c'))])
1809
builder.build_snapshot('C-id', ['A-id'], [])
1810
builder.build_snapshot('E-id', ['C-id', 'B-id'],
1811
[('modify', ('a-id', 'new-content\n')),
1812
('modify', ('b-id', 'new-content\n'))])
1813
builder.build_snapshot('D-id', ['B-id', 'C-id'],
1814
[('rename', ('c', 'b'))])
1815
merge_obj = self.make_merge_obj(builder, 'E-id',
1816
interesting_files=['c'])
1817
entries = list(merge_obj._entries_lca())
1818
root_id = 'a-root-id'
1819
self.assertEqual([('b-id', True,
1820
((root_id, [root_id, root_id]), root_id, root_id),
1821
((u'b', [u'c', u'b']), u'b', u'b'),
1822
((False, [False, False]), False, False)),
1825
def test_interesting_ids(self):
1826
# Two files modified, but we should filter one of them
1827
builder = self.get_builder()
1828
builder.build_snapshot('A-id', None,
1829
[('add', (u'', 'a-root-id', 'directory', None)),
1830
('add', (u'a', 'a-id', 'file', 'content\n')),
1831
('add', (u'b', 'b-id', 'file', 'content\n'))])
1832
builder.build_snapshot('B-id', ['A-id'], [])
1833
builder.build_snapshot('C-id', ['A-id'], [])
1834
builder.build_snapshot('E-id', ['C-id', 'B-id'],
1835
[('modify', ('a-id', 'new-content\n')),
1836
('modify', ('b-id', 'new-content\n'))])
1837
builder.build_snapshot('D-id', ['B-id', 'C-id'], [])
1838
merge_obj = self.make_merge_obj(builder, 'E-id',
1839
interesting_ids=['b-id'])
1840
entries = list(merge_obj._entries_lca())
1841
root_id = 'a-root-id'
1842
self.assertEqual([('b-id', True,
1843
((root_id, [root_id, root_id]), root_id, root_id),
1844
((u'b', [u'b', u'b']), u'b', u'b'),
1845
((False, [False, False]), False, False)),
1850
class TestMergerEntriesLCAOnDisk(tests.TestCaseWithTransport):
1852
def get_builder(self):
1853
builder = self.make_branch_builder('path')
1854
builder.start_series()
1855
self.addCleanup(builder.finish_series)
1858
def get_wt_from_builder(self, builder):
1859
"""Get a real WorkingTree from the builder."""
1860
the_branch = builder.get_branch()
1861
wt = the_branch.bzrdir.create_workingtree()
1862
# Note: This is a little bit ugly, but we are holding the branch
1863
# write-locked as part of the build process, and we would like to
1864
# maintain that. So we just force the WT to re-use the same
1866
wt._branch = the_branch
1868
self.addCleanup(wt.unlock)
1871
def do_merge(self, builder, other_revision_id):
1872
wt = self.get_wt_from_builder(builder)
1873
merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
1874
wt, other_revision_id)
1875
merger.merge_type = _mod_merge.Merge3Merger
1876
return wt, merger.do_merge()
1878
def test_simple_lca(self):
1879
builder = self.get_builder()
1880
builder.build_snapshot('A-id', None,
1881
[('add', (u'', 'a-root-id', 'directory', None)),
1882
('add', (u'a', 'a-id', 'file', 'a\nb\nc\n'))])
1883
builder.build_snapshot('C-id', ['A-id'], [])
1884
builder.build_snapshot('B-id', ['A-id'], [])
1885
builder.build_snapshot('E-id', ['C-id', 'B-id'], [])
1886
builder.build_snapshot('D-id', ['B-id', 'C-id'],
1887
[('modify', ('a-id', 'a\nb\nc\nd\ne\nf\n'))])
1888
wt, conflicts = self.do_merge(builder, 'E-id')
1889
self.assertEqual(0, conflicts)
1890
# The merge should have simply update the contents of 'a'
1891
self.assertEqual('a\nb\nc\nd\ne\nf\n', wt.get_file_text('a-id'))
1893
def test_conflict_without_lca(self):
1894
# This test would cause a merge conflict, unless we use the lca trees
1895
# to determine the real ancestry
1898
# B C Path renamed to 'bar' in B
1902
# D E Path at 'bar' in D and E
1904
# F Path at 'baz' in F, which supersedes 'bar' and 'foo'
1905
builder = self.get_builder()
1906
builder.build_snapshot('A-id', None,
1907
[('add', (u'', 'a-root-id', 'directory', None)),
1908
('add', (u'foo', 'foo-id', 'file', 'a\nb\nc\n'))])
1909
builder.build_snapshot('C-id', ['A-id'], [])
1910
builder.build_snapshot('B-id', ['A-id'],
1911
[('rename', ('foo', 'bar'))])
1912
builder.build_snapshot('E-id', ['C-id', 'B-id'], # merge the rename
1913
[('rename', ('foo', 'bar'))])
1914
builder.build_snapshot('F-id', ['E-id'],
1915
[('rename', ('bar', 'baz'))])
1916
builder.build_snapshot('D-id', ['B-id', 'C-id'], [])
1917
wt, conflicts = self.do_merge(builder, 'F-id')
1918
self.assertEqual(0, conflicts)
1919
# The merge should simply recognize that the final rename takes
1921
self.assertEqual('baz', wt.id2path('foo-id'))
1923
def test_other_deletes_lca_renames(self):
1924
# This test would cause a merge conflict, unless we use the lca trees
1925
# to determine the real ancestry
1928
# B C Path renamed to 'bar' in B
1932
# D E Path at 'bar' in D and E
1935
builder = self.get_builder()
1936
builder.build_snapshot('A-id', None,
1937
[('add', (u'', 'a-root-id', 'directory', None)),
1938
('add', (u'foo', 'foo-id', 'file', 'a\nb\nc\n'))])
1939
builder.build_snapshot('C-id', ['A-id'], [])
1940
builder.build_snapshot('B-id', ['A-id'],
1941
[('rename', ('foo', 'bar'))])
1942
builder.build_snapshot('E-id', ['C-id', 'B-id'], # merge the rename
1943
[('rename', ('foo', 'bar'))])
1944
builder.build_snapshot('F-id', ['E-id'],
1945
[('unversion', 'foo-id')])
1946
builder.build_snapshot('D-id', ['B-id', 'C-id'], [])
1947
wt, conflicts = self.do_merge(builder, 'F-id')
1948
self.assertEqual(0, conflicts)
1949
self.assertRaises(errors.NoSuchId, wt.id2path, 'foo-id')
1951
def test_executable_changes(self):
1960
# F Executable bit changed
1961
builder = self.get_builder()
1962
builder.build_snapshot('A-id', None,
1963
[('add', (u'', 'a-root-id', 'directory', None)),
1964
('add', (u'foo', 'foo-id', 'file', 'a\nb\nc\n'))])
1965
builder.build_snapshot('C-id', ['A-id'], [])
1966
builder.build_snapshot('B-id', ['A-id'], [])
1967
builder.build_snapshot('D-id', ['B-id', 'C-id'], [])
1968
builder.build_snapshot('E-id', ['C-id', 'B-id'], [])
1969
# Have to use a real WT, because BranchBuilder doesn't support exec bit
1970
wt = self.get_wt_from_builder(builder)
1971
tt = transform.TreeTransform(wt)
1973
tt.set_executability(True, tt.trans_id_tree_file_id('foo-id'))
1978
self.assertTrue(wt.is_executable('foo-id'))
1979
wt.commit('F-id', rev_id='F-id')
1980
# Reset to D, so that we can merge F
1981
wt.set_parent_ids(['D-id'])
1982
wt.branch.set_last_revision_info(3, 'D-id')
1984
self.assertFalse(wt.is_executable('foo-id'))
1985
conflicts = wt.merge_from_branch(wt.branch, to_revision='F-id')
1986
self.assertEqual(0, conflicts)
1987
self.assertTrue(wt.is_executable('foo-id'))
1989
def test_create_symlink(self):
1990
self.requireFeature(tests.SymlinkFeature)
1999
# F Add a symlink 'foo' => 'bar'
2000
# Have to use a real WT, because BranchBuilder and MemoryTree don't
2001
# have symlink support
2002
builder = self.get_builder()
2003
builder.build_snapshot('A-id', None,
2004
[('add', (u'', 'a-root-id', 'directory', None))])
2005
builder.build_snapshot('C-id', ['A-id'], [])
2006
builder.build_snapshot('B-id', ['A-id'], [])
2007
builder.build_snapshot('D-id', ['B-id', 'C-id'], [])
2008
builder.build_snapshot('E-id', ['C-id', 'B-id'], [])
2009
# Have to use a real WT, because BranchBuilder doesn't support exec bit
2010
wt = self.get_wt_from_builder(builder)
2011
os.symlink('bar', 'path/foo')
2012
wt.add(['foo'], ['foo-id'])
2013
self.assertEqual('bar', wt.get_symlink_target('foo-id'))
2014
wt.commit('add symlink', rev_id='F-id')
2015
# Reset to D, so that we can merge F
2016
wt.set_parent_ids(['D-id'])
2017
wt.branch.set_last_revision_info(3, 'D-id')
2019
self.assertIs(None, wt.path2id('foo'))
2020
conflicts = wt.merge_from_branch(wt.branch, to_revision='F-id')
2021
self.assertEqual(0, conflicts)
2022
self.assertEqual('foo-id', wt.path2id('foo'))
2023
self.assertEqual('bar', wt.get_symlink_target('foo-id'))
2025
def test_both_sides_revert(self):
2026
# Both sides of a criss-cross revert the text to the lca
2027
# A base, introduces 'foo'
2029
# B C B modifies 'foo', C modifies 'foo'
2031
# D E D reverts to B, E reverts to C
2032
# This should conflict
2033
# This must be done with a real WorkingTree, because normally their
2034
# inventory contains "None" rather than a real sha1
2035
builder = self.get_builder()
2036
builder.build_snapshot('A-id', None,
2037
[('add', (u'', 'a-root-id', 'directory', None)),
2038
('add', (u'foo', 'foo-id', 'file', 'A content\n'))])
2039
builder.build_snapshot('B-id', ['A-id'],
2040
[('modify', ('foo-id', 'B content\n'))])
2041
builder.build_snapshot('C-id', ['A-id'],
2042
[('modify', ('foo-id', 'C content\n'))])
2043
builder.build_snapshot('E-id', ['C-id', 'B-id'], [])
2044
builder.build_snapshot('D-id', ['B-id', 'C-id'], [])
2045
wt, conflicts = self.do_merge(builder, 'E-id')
2046
self.assertEqual(1, conflicts)
2047
self.assertEqualDiff('<<<<<<< TREE\n'
2051
'>>>>>>> MERGE-SOURCE\n',
2052
wt.get_file_text('foo-id'))
2054
def test_modified_symlink(self):
2055
self.requireFeature(tests.SymlinkFeature)
2056
# A Create symlink foo => bar
2058
# B C B relinks foo => baz
2062
# D E D & E have foo => baz
2064
# F F changes it to bing
2066
# Merging D & F should result in F cleanly overriding D, because D's
2067
# value actually comes from B
2069
# Have to use a real WT, because BranchBuilder and MemoryTree don't
2070
# have symlink support
2071
wt = self.make_branch_and_tree('path')
2073
self.addCleanup(wt.unlock)
2074
os.symlink('bar', 'path/foo')
2075
wt.add(['foo'], ['foo-id'])
2076
wt.commit('add symlink', rev_id='A-id')
2077
os.remove('path/foo')
2078
os.symlink('baz', 'path/foo')
2079
wt.commit('foo => baz', rev_id='B-id')
2080
wt.set_last_revision('A-id')
2081
wt.branch.set_last_revision_info(1, 'A-id')
2083
wt.commit('C', rev_id='C-id')
2084
wt.merge_from_branch(wt.branch, 'B-id')
2085
self.assertEqual('baz', wt.get_symlink_target('foo-id'))
2086
wt.commit('E merges C & B', rev_id='E-id')
2087
os.remove('path/foo')
2088
os.symlink('bing', 'path/foo')
2089
wt.commit('F foo => bing', rev_id='F-id')
2090
wt.set_last_revision('B-id')
2091
wt.branch.set_last_revision_info(2, 'B-id')
2093
wt.merge_from_branch(wt.branch, 'C-id')
2094
wt.commit('D merges B & C', rev_id='D-id')
2095
conflicts = wt.merge_from_branch(wt.branch, to_revision='F-id')
2096
self.assertEqual(0, conflicts)
2097
self.assertEqual('bing', wt.get_symlink_target('foo-id'))
2099
def test_renamed_symlink(self):
2100
self.requireFeature(tests.SymlinkFeature)
2101
# A Create symlink foo => bar
2103
# B C B renames foo => barry
2107
# D E D & E have barry
2109
# F F renames barry to blah
2111
# Merging D & F should result in F cleanly overriding D, because D's
2112
# value actually comes from B
2114
wt = self.make_branch_and_tree('path')
2116
self.addCleanup(wt.unlock)
2117
os.symlink('bar', 'path/foo')
2118
wt.add(['foo'], ['foo-id'])
2119
wt.commit('A add symlink', rev_id='A-id')
2120
wt.rename_one('foo', 'barry')
2121
wt.commit('B foo => barry', rev_id='B-id')
2122
wt.set_last_revision('A-id')
2123
wt.branch.set_last_revision_info(1, 'A-id')
2125
wt.commit('C', rev_id='C-id')
2126
wt.merge_from_branch(wt.branch, 'B-id')
2127
self.assertEqual('barry', wt.id2path('foo-id'))
2128
self.assertEqual('bar', wt.get_symlink_target('foo-id'))
2129
wt.commit('E merges C & B', rev_id='E-id')
2130
wt.rename_one('barry', 'blah')
2131
wt.commit('F barry => blah', rev_id='F-id')
2132
wt.set_last_revision('B-id')
2133
wt.branch.set_last_revision_info(2, 'B-id')
2135
wt.merge_from_branch(wt.branch, 'C-id')
2136
wt.commit('D merges B & C', rev_id='D-id')
2137
self.assertEqual('barry', wt.id2path('foo-id'))
2138
# Check the output of the Merger object directly
2139
merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
2141
merger.merge_type = _mod_merge.Merge3Merger
2142
merge_obj = merger.make_merger()
2143
root_id = wt.path2id('')
2144
entries = list(merge_obj._entries_lca())
2145
# No content change, just a path change
2146
self.assertEqual([('foo-id', False,
2147
((root_id, [root_id, root_id]), root_id, root_id),
2148
((u'foo', [u'barry', u'foo']), u'blah', u'barry'),
2149
((False, [False, False]), False, False)),
2151
conflicts = wt.merge_from_branch(wt.branch, to_revision='F-id')
2152
self.assertEqual(0, conflicts)
2153
self.assertEqual('blah', wt.id2path('foo-id'))
2155
def test_symlink_no_content_change(self):
2156
self.requireFeature(tests.SymlinkFeature)
2157
# A Create symlink foo => bar
2159
# B C B relinks foo => baz
2163
# D E D & E have foo => baz
2165
# F F has foo => bing
2167
# Merging E into F should not cause a conflict, because E doesn't have
2168
# a content change relative to the LCAs (it does relative to A)
2169
wt = self.make_branch_and_tree('path')
2171
self.addCleanup(wt.unlock)
2172
os.symlink('bar', 'path/foo')
2173
wt.add(['foo'], ['foo-id'])
2174
wt.commit('add symlink', rev_id='A-id')
2175
os.remove('path/foo')
2176
os.symlink('baz', 'path/foo')
2177
wt.commit('foo => baz', rev_id='B-id')
2178
wt.set_last_revision('A-id')
2179
wt.branch.set_last_revision_info(1, 'A-id')
2181
wt.commit('C', rev_id='C-id')
2182
wt.merge_from_branch(wt.branch, 'B-id')
2183
self.assertEqual('baz', wt.get_symlink_target('foo-id'))
2184
wt.commit('E merges C & B', rev_id='E-id')
2185
wt.set_last_revision('B-id')
2186
wt.branch.set_last_revision_info(2, 'B-id')
2188
wt.merge_from_branch(wt.branch, 'C-id')
2189
wt.commit('D merges B & C', rev_id='D-id')
2190
os.remove('path/foo')
2191
os.symlink('bing', 'path/foo')
2192
wt.commit('F foo => bing', rev_id='F-id')
2194
# Check the output of the Merger object directly
2195
merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
2197
merger.merge_type = _mod_merge.Merge3Merger
2198
merge_obj = merger.make_merger()
2199
# Nothing interesting happened in OTHER relative to BASE
2200
self.assertEqual([], list(merge_obj._entries_lca()))
2201
# Now do a real merge, just to test the rest of the stack
2202
conflicts = wt.merge_from_branch(wt.branch, to_revision='E-id')
2203
self.assertEqual(0, conflicts)
2204
self.assertEqual('bing', wt.get_symlink_target('foo-id'))
2206
def test_symlink_this_changed_kind(self):
2207
self.requireFeature(tests.SymlinkFeature)
2210
# B C B creates symlink foo => bar
2214
# D E D changes foo into a file, E has foo => bing
2216
# Mostly, this is trying to test that we don't try to os.readlink() on
2217
# a file, or when there is nothing there
2218
wt = self.make_branch_and_tree('path')
2220
self.addCleanup(wt.unlock)
2221
wt.commit('base', rev_id='A-id')
2222
os.symlink('bar', 'path/foo')
2223
wt.add(['foo'], ['foo-id'])
2224
wt.commit('add symlink foo => bar', rev_id='B-id')
2225
wt.set_last_revision('A-id')
2226
wt.branch.set_last_revision_info(1, 'A-id')
2228
wt.commit('C', rev_id='C-id')
2229
wt.merge_from_branch(wt.branch, 'B-id')
2230
self.assertEqual('bar', wt.get_symlink_target('foo-id'))
2231
os.remove('path/foo')
2232
# We have to change the link in E, or it won't try to do a comparison
2233
os.symlink('bing', 'path/foo')
2234
wt.commit('E merges C & B, overrides to bing', rev_id='E-id')
2235
wt.set_last_revision('B-id')
2236
wt.branch.set_last_revision_info(2, 'B-id')
2238
wt.merge_from_branch(wt.branch, 'C-id')
2239
os.remove('path/foo')
2240
self.build_tree_contents([('path/foo', 'file content\n')])
2241
# XXX: workaround, WT doesn't detect kind changes unless you do
2243
list(wt.iter_changes(wt.basis_tree()))
2244
wt.commit('D merges B & C, makes it a file', rev_id='D-id')
2246
merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
2248
merger.merge_type = _mod_merge.Merge3Merger
2249
merge_obj = merger.make_merger()
2250
entries = list(merge_obj._entries_lca())
2251
root_id = wt.path2id('')
2252
self.assertEqual([('foo-id', True,
2253
((None, [root_id, None]), root_id, root_id),
2254
((None, [u'foo', None]), u'foo', u'foo'),
2255
((None, [False, None]), False, False)),
2258
def test_symlink_all_wt(self):
2259
"""Check behavior if all trees are Working Trees."""
2260
self.requireFeature(tests.SymlinkFeature)
2261
# The big issue is that entry.symlink_target is None for WorkingTrees.
2262
# So we need to make sure we handle that case correctly.
2265
# B C B relinks foo => baz
2267
# D E D & E have foo => baz
2269
# F F changes it to bing
2270
# Merging D & F should result in F cleanly overriding D, because D's
2271
# value actually comes from B
2273
wt = self.make_branch_and_tree('path')
2275
self.addCleanup(wt.unlock)
2276
os.symlink('bar', 'path/foo')
2277
wt.add(['foo'], ['foo-id'])
2278
wt.commit('add symlink', rev_id='A-id')
2279
os.remove('path/foo')
2280
os.symlink('baz', 'path/foo')
2281
wt.commit('foo => baz', rev_id='B-id')
2282
wt.set_last_revision('A-id')
2283
wt.branch.set_last_revision_info(1, 'A-id')
2285
wt.commit('C', rev_id='C-id')
2286
wt.merge_from_branch(wt.branch, 'B-id')
2287
self.assertEqual('baz', wt.get_symlink_target('foo-id'))
2288
wt.commit('E merges C & B', rev_id='E-id')
2289
os.remove('path/foo')
2290
os.symlink('bing', 'path/foo')
2291
wt.commit('F foo => bing', rev_id='F-id')
2292
wt.set_last_revision('B-id')
2293
wt.branch.set_last_revision_info(2, 'B-id')
2295
wt.merge_from_branch(wt.branch, 'C-id')
2296
wt.commit('D merges B & C', rev_id='D-id')
2297
wt_base = wt.bzrdir.sprout('base', 'A-id').open_workingtree()
2299
self.addCleanup(wt_base.unlock)
2300
wt_lca1 = wt.bzrdir.sprout('b-tree', 'B-id').open_workingtree()
2302
self.addCleanup(wt_lca1.unlock)
2303
wt_lca2 = wt.bzrdir.sprout('c-tree', 'C-id').open_workingtree()
2305
self.addCleanup(wt_lca2.unlock)
2306
wt_other = wt.bzrdir.sprout('other', 'F-id').open_workingtree()
2307
wt_other.lock_read()
2308
self.addCleanup(wt_other.unlock)
2309
merge_obj = _mod_merge.Merge3Merger(wt, wt, wt_base,
2310
wt_other, lca_trees=[wt_lca1, wt_lca2], do_merge=False)
2311
entries = list(merge_obj._entries_lca())
2312
root_id = wt.path2id('')
2313
self.assertEqual([('foo-id', True,
2314
((root_id, [root_id, root_id]), root_id, root_id),
2315
((u'foo', [u'foo', u'foo']), u'foo', u'foo'),
2316
((False, [False, False]), False, False)),
2319
def test_other_reverted_path_to_base(self):
2322
# B C Path at 'bar' in B
2329
builder = self.get_builder()
2330
builder.build_snapshot('A-id', None,
2331
[('add', (u'', 'a-root-id', 'directory', None)),
2332
('add', (u'foo', 'foo-id', 'file', 'a\nb\nc\n'))])
2333
builder.build_snapshot('C-id', ['A-id'], [])
2334
builder.build_snapshot('B-id', ['A-id'],
2335
[('rename', ('foo', 'bar'))])
2336
builder.build_snapshot('E-id', ['C-id', 'B-id'],
2337
[('rename', ('foo', 'bar'))]) # merge the rename
2338
builder.build_snapshot('F-id', ['E-id'],
2339
[('rename', ('bar', 'foo'))]) # Rename back to BASE
2340
builder.build_snapshot('D-id', ['B-id', 'C-id'], [])
2341
wt, conflicts = self.do_merge(builder, 'F-id')
2342
self.assertEqual(0, conflicts)
2343
self.assertEqual('foo', wt.id2path('foo-id'))
2345
def test_other_reverted_content_to_base(self):
2346
builder = self.get_builder()
2347
builder.build_snapshot('A-id', None,
2348
[('add', (u'', 'a-root-id', 'directory', None)),
2349
('add', (u'foo', 'foo-id', 'file', 'base content\n'))])
2350
builder.build_snapshot('C-id', ['A-id'], [])
2351
builder.build_snapshot('B-id', ['A-id'],
2352
[('modify', ('foo-id', 'B content\n'))])
2353
builder.build_snapshot('E-id', ['C-id', 'B-id'],
2354
[('modify', ('foo-id', 'B content\n'))]) # merge the content
2355
builder.build_snapshot('F-id', ['E-id'],
2356
[('modify', ('foo-id', 'base content\n'))]) # Revert back to BASE
2357
builder.build_snapshot('D-id', ['B-id', 'C-id'], [])
2358
wt, conflicts = self.do_merge(builder, 'F-id')
2359
self.assertEqual(0, conflicts)
2360
# TODO: We need to use the per-file graph to properly select a BASE
2361
# before this will work. Or at least use the LCA trees to find
2362
# the appropriate content base. (which is B, not A).
2363
self.assertEqual('base content\n', wt.get_file_text('foo-id'))
2365
def test_other_modified_content(self):
2366
builder = self.get_builder()
2367
builder.build_snapshot('A-id', None,
2368
[('add', (u'', 'a-root-id', 'directory', None)),
2369
('add', (u'foo', 'foo-id', 'file', 'base content\n'))])
2370
builder.build_snapshot('C-id', ['A-id'], [])
2371
builder.build_snapshot('B-id', ['A-id'],
2372
[('modify', ('foo-id', 'B content\n'))])
2373
builder.build_snapshot('E-id', ['C-id', 'B-id'],
2374
[('modify', ('foo-id', 'B content\n'))]) # merge the content
2375
builder.build_snapshot('F-id', ['E-id'],
2376
[('modify', ('foo-id', 'F content\n'))]) # Override B content
2377
builder.build_snapshot('D-id', ['B-id', 'C-id'], [])
2378
wt, conflicts = self.do_merge(builder, 'F-id')
2379
self.assertEqual(0, conflicts)
2380
self.assertEqual('F content\n', wt.get_file_text('foo-id'))
2382
def test_all_wt(self):
2383
"""Check behavior if all trees are Working Trees."""
2384
# The big issue is that entry.revision is None for WorkingTrees. (as is
2385
# entry.text_sha1, etc. So we need to make sure we handle that case
2387
# A Content of 'foo', path of 'a'
2389
# B C B modifies content, C renames 'a' => 'b'
2391
# D E E updates content, renames 'b' => 'c'
2392
builder = self.get_builder()
2393
builder.build_snapshot('A-id', None,
2394
[('add', (u'', 'a-root-id', 'directory', None)),
2395
('add', (u'a', 'a-id', 'file', 'base content\n')),
2396
('add', (u'foo', 'foo-id', 'file', 'base content\n'))])
2397
builder.build_snapshot('B-id', ['A-id'],
2398
[('modify', ('foo-id', 'B content\n'))])
2399
builder.build_snapshot('C-id', ['A-id'],
2400
[('rename', ('a', 'b'))])
2401
builder.build_snapshot('E-id', ['C-id', 'B-id'],
2402
[('rename', ('b', 'c')),
2403
('modify', ('foo-id', 'E content\n'))])
2404
builder.build_snapshot('D-id', ['B-id', 'C-id'],
2405
[('rename', ('a', 'b'))]) # merged change
2406
wt_this = self.get_wt_from_builder(builder)
2407
wt_base = wt_this.bzrdir.sprout('base', 'A-id').open_workingtree()
2409
self.addCleanup(wt_base.unlock)
2410
wt_lca1 = wt_this.bzrdir.sprout('b-tree', 'B-id').open_workingtree()
2412
self.addCleanup(wt_lca1.unlock)
2413
wt_lca2 = wt_this.bzrdir.sprout('c-tree', 'C-id').open_workingtree()
2415
self.addCleanup(wt_lca2.unlock)
2416
wt_other = wt_this.bzrdir.sprout('other', 'E-id').open_workingtree()
2417
wt_other.lock_read()
2418
self.addCleanup(wt_other.unlock)
2419
merge_obj = _mod_merge.Merge3Merger(wt_this, wt_this, wt_base,
2420
wt_other, lca_trees=[wt_lca1, wt_lca2], do_merge=False)
2421
entries = list(merge_obj._entries_lca())
2422
root_id = 'a-root-id'
2423
self.assertEqual([('a-id', False,
2424
((root_id, [root_id, root_id]), root_id, root_id),
2425
((u'a', [u'a', u'b']), u'c', u'b'),
2426
((False, [False, False]), False, False)),
2428
((root_id, [root_id, root_id]), root_id, root_id),
2429
((u'foo', [u'foo', u'foo']), u'foo', u'foo'),
2430
((False, [False, False]), False, False)),
2433
def test_nested_tree_unmodified(self):
2434
# Tested with a real WT, because BranchBuilder/MemoryTree don't handle
2436
wt = self.make_branch_and_tree('tree',
2437
format='dirstate-with-subtree')
2439
self.addCleanup(wt.unlock)
2440
sub_tree = self.make_branch_and_tree('tree/sub-tree',
2441
format='dirstate-with-subtree')
2442
wt.set_root_id('a-root-id')
2443
sub_tree.set_root_id('sub-tree-root')
2444
self.build_tree_contents([('tree/sub-tree/file', 'text1')])
2445
sub_tree.add('file')
2446
sub_tree.commit('foo', rev_id='sub-A-id')
2447
wt.add_reference(sub_tree)
2448
wt.commit('set text to 1', rev_id='A-id', recursive=None)
2449
# Now create a criss-cross merge in the parent, without modifying the
2451
wt.commit('B', rev_id='B-id', recursive=None)
2452
wt.set_last_revision('A-id')
2453
wt.branch.set_last_revision_info(1, 'A-id')
2454
wt.commit('C', rev_id='C-id', recursive=None)
2455
wt.merge_from_branch(wt.branch, to_revision='B-id')
2456
wt.commit('E', rev_id='E-id', recursive=None)
2457
wt.set_parent_ids(['B-id', 'C-id'])
2458
wt.branch.set_last_revision_info(2, 'B-id')
2459
wt.commit('D', rev_id='D-id', recursive=None)
2461
merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
2463
merger.merge_type = _mod_merge.Merge3Merger
2464
merge_obj = merger.make_merger()
2465
entries = list(merge_obj._entries_lca())
2466
self.assertEqual([], entries)
2468
def test_nested_tree_subtree_modified(self):
2469
# Tested with a real WT, because BranchBuilder/MemoryTree don't handle
2471
wt = self.make_branch_and_tree('tree',
2472
format='dirstate-with-subtree')
2474
self.addCleanup(wt.unlock)
2475
sub_tree = self.make_branch_and_tree('tree/sub',
2476
format='dirstate-with-subtree')
2477
wt.set_root_id('a-root-id')
2478
sub_tree.set_root_id('sub-tree-root')
2479
self.build_tree_contents([('tree/sub/file', 'text1')])
2480
sub_tree.add('file')
2481
sub_tree.commit('foo', rev_id='sub-A-id')
2482
wt.add_reference(sub_tree)
2483
wt.commit('set text to 1', rev_id='A-id', recursive=None)
2484
# Now create a criss-cross merge in the parent, without modifying the
2486
wt.commit('B', rev_id='B-id', recursive=None)
2487
wt.set_last_revision('A-id')
2488
wt.branch.set_last_revision_info(1, 'A-id')
2489
wt.commit('C', rev_id='C-id', recursive=None)
2490
wt.merge_from_branch(wt.branch, to_revision='B-id')
2491
self.build_tree_contents([('tree/sub/file', 'text2')])
2492
sub_tree.commit('modify contents', rev_id='sub-B-id')
2493
wt.commit('E', rev_id='E-id', recursive=None)
2494
wt.set_parent_ids(['B-id', 'C-id'])
2495
wt.branch.set_last_revision_info(2, 'B-id')
2496
wt.commit('D', rev_id='D-id', recursive=None)
2498
merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
2500
merger.merge_type = _mod_merge.Merge3Merger
2501
merge_obj = merger.make_merger()
2502
entries = list(merge_obj._entries_lca())
2503
# Nothing interesting about this sub-tree, because content changes are
2504
# computed at a higher level
2505
self.assertEqual([], entries)
2507
def test_nested_tree_subtree_renamed(self):
2508
# Tested with a real WT, because BranchBuilder/MemoryTree don't handle
2510
wt = self.make_branch_and_tree('tree',
2511
format='dirstate-with-subtree')
2513
self.addCleanup(wt.unlock)
2514
sub_tree = self.make_branch_and_tree('tree/sub',
2515
format='dirstate-with-subtree')
2516
wt.set_root_id('a-root-id')
2517
sub_tree.set_root_id('sub-tree-root')
2518
self.build_tree_contents([('tree/sub/file', 'text1')])
2519
sub_tree.add('file')
2520
sub_tree.commit('foo', rev_id='sub-A-id')
2521
wt.add_reference(sub_tree)
2522
wt.commit('set text to 1', rev_id='A-id', recursive=None)
2523
# Now create a criss-cross merge in the parent, without modifying the
2525
wt.commit('B', rev_id='B-id', recursive=None)
2526
wt.set_last_revision('A-id')
2527
wt.branch.set_last_revision_info(1, 'A-id')
2528
wt.commit('C', rev_id='C-id', recursive=None)
2529
wt.merge_from_branch(wt.branch, to_revision='B-id')
2530
wt.rename_one('sub', 'alt_sub')
2531
wt.commit('E', rev_id='E-id', recursive=None)
2532
wt.set_last_revision('B-id')
2534
wt.set_parent_ids(['B-id', 'C-id'])
2535
wt.branch.set_last_revision_info(2, 'B-id')
2536
wt.commit('D', rev_id='D-id', recursive=None)
2538
merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
2540
merger.merge_type = _mod_merge.Merge3Merger
2541
merge_obj = merger.make_merger()
2542
entries = list(merge_obj._entries_lca())
2543
root_id = 'a-root-id'
2544
self.assertEqual([('sub-tree-root', False,
2545
((root_id, [root_id, root_id]), root_id, root_id),
2546
((u'sub', [u'sub', u'sub']), u'alt_sub', u'sub'),
2547
((False, [False, False]), False, False)),
2550
def test_nested_tree_subtree_renamed_and_modified(self):
2551
# Tested with a real WT, because BranchBuilder/MemoryTree don't handle
2553
wt = self.make_branch_and_tree('tree',
2554
format='dirstate-with-subtree')
2556
self.addCleanup(wt.unlock)
2557
sub_tree = self.make_branch_and_tree('tree/sub',
2558
format='dirstate-with-subtree')
2559
wt.set_root_id('a-root-id')
2560
sub_tree.set_root_id('sub-tree-root')
2561
self.build_tree_contents([('tree/sub/file', 'text1')])
2562
sub_tree.add('file')
2563
sub_tree.commit('foo', rev_id='sub-A-id')
2564
wt.add_reference(sub_tree)
2565
wt.commit('set text to 1', rev_id='A-id', recursive=None)
2566
# Now create a criss-cross merge in the parent, without modifying the
2568
wt.commit('B', rev_id='B-id', recursive=None)
2569
wt.set_last_revision('A-id')
2570
wt.branch.set_last_revision_info(1, 'A-id')
2571
wt.commit('C', rev_id='C-id', recursive=None)
2572
wt.merge_from_branch(wt.branch, to_revision='B-id')
2573
self.build_tree_contents([('tree/sub/file', 'text2')])
2574
sub_tree.commit('modify contents', rev_id='sub-B-id')
2575
wt.rename_one('sub', 'alt_sub')
2576
wt.commit('E', rev_id='E-id', recursive=None)
2577
wt.set_last_revision('B-id')
2579
wt.set_parent_ids(['B-id', 'C-id'])
2580
wt.branch.set_last_revision_info(2, 'B-id')
2581
wt.commit('D', rev_id='D-id', recursive=None)
2583
merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
2585
merger.merge_type = _mod_merge.Merge3Merger
2586
merge_obj = merger.make_merger()
2587
entries = list(merge_obj._entries_lca())
2588
root_id = 'a-root-id'
2589
self.assertEqual([('sub-tree-root', False,
2590
((root_id, [root_id, root_id]), root_id, root_id),
2591
((u'sub', [u'sub', u'sub']), u'alt_sub', u'sub'),
2592
((False, [False, False]), False, False)),
2596
class TestLCAMultiWay(tests.TestCase):
2598
def assertLCAMultiWay(self, expected, base, lcas, other, this,
2599
allow_overriding_lca=True):
2600
self.assertEqual(expected, _mod_merge.Merge3Merger._lca_multi_way(
2601
(base, lcas), other, this,
2602
allow_overriding_lca=allow_overriding_lca))
2604
def test_other_equal_equal_lcas(self):
2605
"""Test when OTHER=LCA and all LCAs are identical."""
2606
self.assertLCAMultiWay('this',
2607
'bval', ['bval', 'bval'], 'bval', 'bval')
2608
self.assertLCAMultiWay('this',
2609
'bval', ['lcaval', 'lcaval'], 'lcaval', 'bval')
2610
self.assertLCAMultiWay('this',
2611
'bval', ['lcaval', 'lcaval', 'lcaval'], 'lcaval', 'bval')
2612
self.assertLCAMultiWay('this',
2613
'bval', ['lcaval', 'lcaval', 'lcaval'], 'lcaval', 'tval')
2614
self.assertLCAMultiWay('this',
2615
'bval', ['lcaval', 'lcaval', 'lcaval'], 'lcaval', None)
2617
def test_other_equal_this(self):
2618
"""Test when other and this are identical."""
2619
self.assertLCAMultiWay('this',
2620
'bval', ['bval', 'bval'], 'oval', 'oval')
2621
self.assertLCAMultiWay('this',
2622
'bval', ['lcaval', 'lcaval'], 'oval', 'oval')
2623
self.assertLCAMultiWay('this',
2624
'bval', ['cval', 'dval'], 'oval', 'oval')
2625
self.assertLCAMultiWay('this',
2626
'bval', [None, 'lcaval'], 'oval', 'oval')
2627
self.assertLCAMultiWay('this',
2628
None, [None, 'lcaval'], 'oval', 'oval')
2629
self.assertLCAMultiWay('this',
2630
None, ['lcaval', 'lcaval'], 'oval', 'oval')
2631
self.assertLCAMultiWay('this',
2632
None, ['cval', 'dval'], 'oval', 'oval')
2633
self.assertLCAMultiWay('this',
2634
None, ['cval', 'dval'], None, None)
2635
self.assertLCAMultiWay('this',
2636
None, ['cval', 'dval', 'eval', 'fval'], 'oval', 'oval')
2638
def test_no_lcas(self):
2639
self.assertLCAMultiWay('this',
2640
'bval', [], 'bval', 'tval')
2641
self.assertLCAMultiWay('other',
2642
'bval', [], 'oval', 'bval')
2643
self.assertLCAMultiWay('conflict',
2644
'bval', [], 'oval', 'tval')
2645
self.assertLCAMultiWay('this',
2646
'bval', [], 'oval', 'oval')
2648
def test_lca_supersedes_other_lca(self):
2649
"""If one lca == base, the other lca takes precedence"""
2650
self.assertLCAMultiWay('this',
2651
'bval', ['bval', 'lcaval'], 'lcaval', 'tval')
2652
self.assertLCAMultiWay('this',
2653
'bval', ['bval', 'lcaval'], 'lcaval', 'bval')
2654
# This is actually considered a 'revert' because the 'lcaval' in LCAS
2655
# supersedes the BASE val (in the other LCA) but then OTHER reverts it
2657
self.assertLCAMultiWay('other',
2658
'bval', ['bval', 'lcaval'], 'bval', 'lcaval')
2659
self.assertLCAMultiWay('conflict',
2660
'bval', ['bval', 'lcaval'], 'bval', 'tval')
2662
def test_other_and_this_pick_different_lca(self):
2663
# OTHER and THIS resolve the lca conflict in different ways
2664
self.assertLCAMultiWay('conflict',
2665
'bval', ['lca1val', 'lca2val'], 'lca1val', 'lca2val')
2666
self.assertLCAMultiWay('conflict',
2667
'bval', ['lca1val', 'lca2val', 'lca3val'], 'lca1val', 'lca2val')
2668
self.assertLCAMultiWay('conflict',
2669
'bval', ['lca1val', 'lca2val', 'bval'], 'lca1val', 'lca2val')
2671
def test_other_in_lca(self):
2672
# OTHER takes a value of one of the LCAs, THIS takes a new value, which
2673
# theoretically supersedes both LCA values and 'wins'
2674
self.assertLCAMultiWay('this',
2675
'bval', ['lca1val', 'lca2val'], 'lca1val', 'newval')
2676
self.assertLCAMultiWay('this',
2677
'bval', ['lca1val', 'lca2val', 'lca3val'], 'lca1val', 'newval')
2678
self.assertLCAMultiWay('conflict',
2679
'bval', ['lca1val', 'lca2val'], 'lca1val', 'newval',
2680
allow_overriding_lca=False)
2681
self.assertLCAMultiWay('conflict',
2682
'bval', ['lca1val', 'lca2val', 'lca3val'], 'lca1val', 'newval',
2683
allow_overriding_lca=False)
2684
# THIS reverted back to BASE, but that is an explicit supersede of all
2686
self.assertLCAMultiWay('this',
2687
'bval', ['lca1val', 'lca2val', 'lca3val'], 'lca1val', 'bval')
2688
self.assertLCAMultiWay('this',
2689
'bval', ['lca1val', 'lca2val', 'bval'], 'lca1val', 'bval')
2690
self.assertLCAMultiWay('conflict',
2691
'bval', ['lca1val', 'lca2val', 'lca3val'], 'lca1val', 'bval',
2692
allow_overriding_lca=False)
2693
self.assertLCAMultiWay('conflict',
2694
'bval', ['lca1val', 'lca2val', 'bval'], 'lca1val', 'bval',
2695
allow_overriding_lca=False)
2697
def test_this_in_lca(self):
2698
# THIS takes a value of one of the LCAs, OTHER takes a new value, which
2699
# theoretically supersedes both LCA values and 'wins'
2700
self.assertLCAMultiWay('other',
2701
'bval', ['lca1val', 'lca2val'], 'oval', 'lca1val')
2702
self.assertLCAMultiWay('other',
2703
'bval', ['lca1val', 'lca2val'], 'oval', 'lca2val')
2704
self.assertLCAMultiWay('conflict',
2705
'bval', ['lca1val', 'lca2val'], 'oval', 'lca1val',
2706
allow_overriding_lca=False)
2707
self.assertLCAMultiWay('conflict',
2708
'bval', ['lca1val', 'lca2val'], 'oval', 'lca2val',
2709
allow_overriding_lca=False)
2710
# OTHER reverted back to BASE, but that is an explicit supersede of all
2712
self.assertLCAMultiWay('other',
2713
'bval', ['lca1val', 'lca2val', 'lca3val'], 'bval', 'lca3val')
2714
self.assertLCAMultiWay('conflict',
2715
'bval', ['lca1val', 'lca2val', 'lca3val'], 'bval', 'lca3val',
2716
allow_overriding_lca=False)
2718
def test_all_differ(self):
2719
self.assertLCAMultiWay('conflict',
2720
'bval', ['lca1val', 'lca2val'], 'oval', 'tval')
2721
self.assertLCAMultiWay('conflict',
2722
'bval', ['lca1val', 'lca2val', 'lca2val'], 'oval', 'tval')
2723
self.assertLCAMultiWay('conflict',
2724
'bval', ['lca1val', 'lca2val', 'lca3val'], 'oval', 'tval')
added
removed
bzrlib/tests/test_merge.py
