← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_merge.py

  • Committer: John Arbash Meinel
  • Date: 2009-11-18 15:47:16 UTC
  • mto: This revision was merged to the branch mainline in revision 4810.
  • Revision ID: john@arbash-meinel.com-20091118154716-meiszr5ej7ohas3v
Move all the stat comparison and platform checkning code to assertEqualStat.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_merge.py
1
 
# Copyright (C) 2005-2012, 2016 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
18
18
from StringIO import StringIO
19
19
 
20
20
from bzrlib import (
21
 
    branch as _mod_branch,
22
 
    cleanup,
23
21
    conflicts,
24
22
    errors,
25
 
    inventory,
26
23
    knit,
27
24
    memorytree,
28
25
    merge as _mod_merge,
29
26
    option,
30
 
    revision as _mod_revision,
 
27
    progress,
31
28
    tests,
32
29
    transform,
33
30
    versionedfile,
34
31
    )
 
32
from bzrlib.branch import Branch
35
33
from bzrlib.conflicts import ConflictList, TextConflict
36
 
from bzrlib.errors import UnrelatedBranches, NoCommits
 
34
from bzrlib.errors import UnrelatedBranches, NoCommits, BzrCommandError
37
35
from bzrlib.merge import transform_tree, merge_inner, _PlanMerge
38
 
from bzrlib.osutils import basename, pathjoin, file_kind
39
 
from bzrlib.tests import (
40
 
    features,
41
 
    TestCaseWithMemoryTransport,
42
 
    TestCaseWithTransport,
43
 
    test_merge_core,
44
 
    )
 
36
from bzrlib.osutils import pathjoin, file_kind
 
37
from bzrlib.tests import TestCaseWithTransport, TestCaseWithMemoryTransport
45
38
from bzrlib.workingtree import WorkingTree
46
 
 
 
39
from bzrlib.transform import TreeTransform
47
40
 
48
41
class TestMerge(TestCaseWithTransport):
49
42
    """Test appending more than one revision"""
83
76
        tip = wt1.commit('empty commit')
84
77
        wt2 = self.make_branch_and_tree('branch2')
85
78
        wt2.pull(wt1.branch)
86
 
        with file('branch1/foo', 'wb') as f:
87
 
            f.write('foo')
88
 
        with file('branch1/bar', 'wb') as f:
89
 
            f.write('bar')
 
79
        file('branch1/foo', 'wb').write('foo')
 
80
        file('branch1/bar', 'wb').write('bar')
90
81
        wt1.add('foo')
91
82
        wt1.add('bar')
92
83
        wt1.commit('add foobar')
93
 
        self.run_bzr('merge ../branch1/baz', retcode=3, working_dir='branch2')
94
 
        self.run_bzr('merge ../branch1/foo', working_dir='branch2')
95
 
        self.assertPathExists('branch2/foo')
96
 
        self.assertPathDoesNotExist('branch2/bar')
97
 
        wt2 = WorkingTree.open('branch2')
 
84
        os.chdir('branch2')
 
85
        self.run_bzr('merge ../branch1/baz', retcode=3)
 
86
        self.run_bzr('merge ../branch1/foo')
 
87
        self.failUnlessExists('foo')
 
88
        self.failIfExists('bar')
 
89
        wt2 = WorkingTree.open('.') # opens branch2
98
90
        self.assertEqual([tip], wt2.get_parent_ids())
99
91
 
100
92
    def test_pending_with_null(self):
123
115
        finally:
124
116
            wt1.unlock()
125
117
 
126
 
    def test_merge_into_null_tree(self):
127
 
        wt = self.make_branch_and_tree('tree')
128
 
        null_tree = wt.basis_tree()
129
 
        self.build_tree(['tree/file'])
130
 
        wt.add('file')
131
 
        wt.commit('tree with root')
132
 
        merger = _mod_merge.Merge3Merger(null_tree, null_tree, null_tree, wt,
133
 
                                         this_branch=wt.branch,
134
 
                                         do_merge=False)
135
 
        with merger.make_preview_transform() as tt:
136
 
            self.assertEqual([], tt.find_conflicts())
137
 
            preview = tt.get_preview_tree()
138
 
            self.assertEqual(wt.get_root_id(), preview.get_root_id())
139
 
 
140
 
    def test_merge_unrelated_retains_root(self):
141
 
        wt = self.make_branch_and_tree('tree')
142
 
        other_tree = self.make_branch_and_tree('other')
143
 
        self.addCleanup(other_tree.lock_read().unlock)
144
 
        merger = _mod_merge.Merge3Merger(wt, wt, wt.basis_tree(), other_tree,
145
 
                                         this_branch=wt.branch,
146
 
                                         do_merge=False)
147
 
        with transform.TransformPreview(wt) as merger.tt:
148
 
            merger._compute_transform()
149
 
            new_root_id = merger.tt.final_file_id(merger.tt.root)
150
 
            self.assertEqual(wt.get_root_id(), new_root_id)
151
 
 
152
118
    def test_create_rename(self):
153
119
        """Rename an inventory entry while creating the file"""
154
120
        tree =self.make_branch_and_tree('.')
155
 
        with file('name1', 'wb') as f: f.write('Hello')
 
121
        file('name1', 'wb').write('Hello')
156
122
        tree.add('name1')
157
123
        tree.commit(message="hello")
158
124
        tree.rename_one('name1', 'name2')
165
131
        os.mkdir('dirname1')
166
132
        tree.add('dirname1')
167
133
        filename = pathjoin('dirname1', 'name1')
168
 
        with file(filename, 'wb') as f: f.write('Hello')
 
134
        file(filename, 'wb').write('Hello')
169
135
        tree.add(filename)
170
136
        tree.commit(message="hello")
171
137
        filename2 = pathjoin('dirname1', 'name2')
185
151
        log = StringIO()
186
152
        merge_inner(tree_b.branch, tree_a, tree_b.basis_tree(),
187
153
                    this_tree=tree_b, ignore_zero=True)
188
 
        self.assertTrue('All changes applied successfully.\n' not in
189
 
            self.get_log())
 
154
        log = self._get_log(keep_log_file=True)
 
155
        self.failUnless('All changes applied successfully.\n' not in log)
190
156
        tree_b.revert()
191
157
        merge_inner(tree_b.branch, tree_a, tree_b.basis_tree(),
192
158
                    this_tree=tree_b, ignore_zero=False)
193
 
        self.assertTrue('All changes applied successfully.\n' in self.get_log())
 
159
        log = self._get_log(keep_log_file=True)
 
160
        self.failUnless('All changes applied successfully.\n' in log)
194
161
 
195
162
    def test_merge_inner_conflicts(self):
196
163
        tree_a = self.make_branch_and_tree('a')
227
194
 
228
195
    def test_nested_merge(self):
229
196
        tree = self.make_branch_and_tree('tree',
230
 
            format='development-subtree')
 
197
            format='dirstate-with-subtree')
231
198
        sub_tree = self.make_branch_and_tree('tree/sub-tree',
232
 
            format='development-subtree')
 
199
            format='dirstate-with-subtree')
233
200
        sub_tree.set_root_id('sub-tree-root')
234
201
        self.build_tree_contents([('tree/sub-tree/file', 'text1')])
235
202
        sub_tree.add('file')
326
293
        tree_a.commit('commit 2')
327
294
        tree_b = tree_a.bzrdir.sprout('b').open_workingtree()
328
295
        tree_b.rename_one('file_1', 'renamed')
329
 
        merger = _mod_merge.Merger.from_uncommitted(tree_a, tree_b)
 
296
        merger = _mod_merge.Merger.from_uncommitted(tree_a, tree_b,
 
297
                                                    progress.DummyProgress())
330
298
        merger.merge_type = _mod_merge.Merge3Merger
331
299
        merger.do_merge()
332
300
        self.assertEqual(tree_a.get_parent_ids(), [tree_b.last_revision()])
340
308
        tree_a.commit('commit 2')
341
309
        tree_b = tree_a.bzrdir.sprout('b').open_workingtree()
342
310
        tree_b.rename_one('file_1', 'renamed')
343
 
        merger = _mod_merge.Merger.from_uncommitted(tree_a, tree_b)
 
311
        merger = _mod_merge.Merger.from_uncommitted(tree_a, tree_b,
 
312
                                                    progress.DummyProgress())
344
313
        merger.merge_type = _mod_merge.WeaveMerger
345
314
        merger.do_merge()
346
315
        self.assertEqual(tree_a.get_parent_ids(), [tree_b.last_revision()])
347
316
 
 
317
    def test_Merger_defaults_to_DummyProgress(self):
 
318
        branch = self.make_branch('branch')
 
319
        merger = _mod_merge.Merger(branch, pb=None)
 
320
        self.assertIsInstance(merger._pb, progress.DummyProgress)
 
321
 
348
322
    def prepare_cherrypick(self):
349
323
        """Prepare a pair of trees for cherrypicking tests.
350
324
 
371
345
 
372
346
    def test_weave_cherrypick(self):
373
347
        this_tree, other_tree = self.prepare_cherrypick()
374
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
348
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
375
349
            this_tree, 'rev3b', 'rev2b', other_tree.branch)
376
350
        merger.merge_type = _mod_merge.WeaveMerger
377
351
        merger.do_merge()
379
353
 
380
354
    def test_weave_cannot_reverse_cherrypick(self):
381
355
        this_tree, other_tree = self.prepare_cherrypick()
382
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
356
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
383
357
            this_tree, 'rev2b', 'rev3b', other_tree.branch)
384
358
        merger.merge_type = _mod_merge.WeaveMerger
385
359
        self.assertRaises(errors.CannotReverseCherrypick, merger.do_merge)
386
360
 
387
361
    def test_merge3_can_reverse_cherrypick(self):
388
362
        this_tree, other_tree = self.prepare_cherrypick()
389
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
363
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
390
364
            this_tree, 'rev2b', 'rev3b', other_tree.branch)
391
365
        merger.merge_type = _mod_merge.Merge3Merger
392
366
        merger.do_merge()
404
378
        this_tree.lock_write()
405
379
        self.addCleanup(this_tree.unlock)
406
380
 
407
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
381
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
408
382
            this_tree, 'rev3b', 'rev2b', other_tree.branch)
409
383
        merger.merge_type = _mod_merge.Merge3Merger
410
384
        merger.do_merge()
415
389
                             '>>>>>>> MERGE-SOURCE\n',
416
390
                             'this/file')
417
391
 
418
 
    def test_merge_reverse_revision_range(self):
419
 
        tree = self.make_branch_and_tree(".")
420
 
        tree.lock_write()
421
 
        self.addCleanup(tree.unlock)
422
 
        self.build_tree(['a'])
423
 
        tree.add('a')
424
 
        first_rev = tree.commit("added a")
425
 
        merger = _mod_merge.Merger.from_revision_ids(None, tree,
426
 
                                          _mod_revision.NULL_REVISION,
427
 
                                          first_rev)
428
 
        merger.merge_type = _mod_merge.Merge3Merger
429
 
        merger.interesting_files = 'a'
430
 
        conflict_count = merger.do_merge()
431
 
        self.assertEqual(0, conflict_count)
432
 
 
433
 
        self.assertPathDoesNotExist("a")
434
 
        tree.revert()
435
 
        self.assertPathExists("a")
436
 
 
437
392
    def test_make_merger(self):
438
393
        this_tree = self.make_branch_and_tree('this')
439
394
        this_tree.commit('rev1', rev_id='rev1')
442
397
        other_tree.commit('rev2', rev_id='rev2b')
443
398
        this_tree.lock_write()
444
399
        self.addCleanup(this_tree.unlock)
445
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
400
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress,
446
401
            this_tree, 'rev2b', other_branch=other_tree.branch)
447
402
        merger.merge_type = _mod_merge.Merge3Merger
448
403
        tree_merger = merger.make_merger()
449
404
        self.assertIs(_mod_merge.Merge3Merger, tree_merger.__class__)
450
 
        self.assertEqual('rev2b',
451
 
            tree_merger.other_tree.get_revision_id())
452
 
        self.assertEqual('rev1',
453
 
            tree_merger.base_tree.get_revision_id())
454
 
        self.assertEqual(other_tree.branch, tree_merger.other_branch)
 
405
        self.assertEqual('rev2b', tree_merger.other_tree.get_revision_id())
 
406
        self.assertEqual('rev1', tree_merger.base_tree.get_revision_id())
455
407
 
456
408
    def test_make_preview_transform(self):
457
409
        this_tree = self.make_branch_and_tree('this')
465
417
        other_tree.commit('rev2', rev_id='rev2b')
466
418
        this_tree.lock_write()
467
419
        self.addCleanup(this_tree.unlock)
468
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
420
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
469
421
            this_tree, 'rev2b', other_branch=other_tree.branch)
470
422
        merger.merge_type = _mod_merge.Merge3Merger
471
423
        tree_merger = merger.make_merger()
495
447
        other_tree.commit('rev2', rev_id='rev2b')
496
448
        this_tree.lock_write()
497
449
        self.addCleanup(this_tree.unlock)
498
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
450
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
499
451
            this_tree, 'rev2b', other_branch=other_tree.branch)
500
452
        merger.merge_type = _mod_merge.Merge3Merger
501
453
        tree_merger = merger.make_merger()
506
458
        finally:
507
459
            tree_file.close()
508
460
 
509
 
    def test_merge_require_tree_root(self):
510
 
        tree = self.make_branch_and_tree(".")
511
 
        tree.lock_write()
512
 
        self.addCleanup(tree.unlock)
513
 
        self.build_tree(['a'])
514
 
        tree.add('a')
515
 
        first_rev = tree.commit("added a")
516
 
        old_root_id = tree.get_root_id()
517
 
        merger = _mod_merge.Merger.from_revision_ids(None, tree,
518
 
                                          _mod_revision.NULL_REVISION,
519
 
                                          first_rev)
520
 
        merger.merge_type = _mod_merge.Merge3Merger
521
 
        conflict_count = merger.do_merge()
522
 
        self.assertEqual(0, conflict_count)
523
 
        self.assertEqual(set([old_root_id]), tree.all_file_ids())
524
 
        tree.set_parent_ids([])
525
 
 
526
461
    def test_merge_add_into_deleted_root(self):
527
462
        # Yes, people actually do this.  And report bugs if it breaks.
528
463
        source = self.make_branch_and_tree('source', format='rich-root-pack')
559
494
class TestPlanMerge(TestCaseWithMemoryTransport):
560
495
 
561
496
    def setUp(self):
562
 
        super(TestPlanMerge, self).setUp()
 
497
        TestCaseWithMemoryTransport.setUp(self)
563
498
        mapper = versionedfile.PrefixMapper()
564
499
        factory = knit.make_file_factory(True, mapper)
565
500
        self.vf = factory(self.get_transport())
589
524
        self.add_uncommitted_version(('root', 'C:'), [('root', 'A')], 'fabg')
590
525
        return _PlanMerge('B:', 'C:', self.plan_merge_vf, ('root',))
591
526
 
592
 
    def test_base_from_plan(self):
593
 
        self.setup_plan_merge()
594
 
        plan = self.plan_merge_vf.plan_merge('B', 'C')
595
 
        pwm = versionedfile.PlanWeaveMerge(plan)
596
 
        self.assertEqual(['a\n', 'b\n', 'c\n'], pwm.base_from_plan())
597
 
 
598
527
    def test_unique_lines(self):
599
528
        plan = self.setup_plan_merge()
600
529
        self.assertEqual(plan._unique_lines(
898
827
                          ('unchanged', 'f\n'),
899
828
                          ('unchanged', 'g\n')],
900
829
                         list(plan))
901
 
        plan = self.plan_merge_vf.plan_lca_merge('F', 'G')
902
 
        # This is one of the main differences between plan_merge and
903
 
        # plan_lca_merge. plan_lca_merge generates a conflict for 'x => z',
904
 
        # because 'x' was not present in one of the bases. However, in this
905
 
        # case it is spurious because 'x' does not exist in the global base A.
906
 
        self.assertEqual([
907
 
                          ('unchanged', 'h\n'),
908
 
                          ('unchanged', 'a\n'),
909
 
                          ('conflicted-a', 'x\n'),
910
 
                          ('new-b', 'z\n'),
911
 
                          ('unchanged', 'c\n'),
912
 
                          ('unchanged', 'd\n'),
913
 
                          ('unchanged', 'y\n'),
914
 
                          ('unchanged', 'f\n'),
915
 
                          ('unchanged', 'g\n')],
916
 
                         list(plan))
917
 
 
918
 
    def test_criss_cross_flip_flop(self):
919
 
        # This is specificly trying to trigger problems when using limited
920
 
        # ancestry and weaves. The ancestry graph looks like:
921
 
        #       XX      unused ancestor, should not show up in the weave
922
 
        #       |
923
 
        #       A       Unique LCA
924
 
        #      / \  
925
 
        #     B   C     B & C both introduce a new line
926
 
        #     |\ /|  
927
 
        #     | X |  
928
 
        #     |/ \| 
929
 
        #     D   E     B & C are both merged, so both are common ancestors
930
 
        #               In the process of merging, both sides order the new
931
 
        #               lines differently
932
 
        #
933
 
        self.add_rev('root', 'XX', [], 'qrs')
934
 
        self.add_rev('root', 'A', ['XX'], 'abcdef')
935
 
        self.add_rev('root', 'B', ['A'], 'abcdgef')
936
 
        self.add_rev('root', 'C', ['A'], 'abcdhef')
937
 
        self.add_rev('root', 'D', ['B', 'C'], 'abcdghef')
938
 
        self.add_rev('root', 'E', ['C', 'B'], 'abcdhgef')
939
 
        plan = list(self.plan_merge_vf.plan_merge('D', 'E'))
940
 
        self.assertEqual([
941
 
                          ('unchanged', 'a\n'),
942
 
                          ('unchanged', 'b\n'),
943
 
                          ('unchanged', 'c\n'),
944
 
                          ('unchanged', 'd\n'),
945
 
                          ('new-b', 'h\n'),
946
 
                          ('unchanged', 'g\n'),
947
 
                          ('killed-b', 'h\n'),
948
 
                          ('unchanged', 'e\n'),
949
 
                          ('unchanged', 'f\n'),
950
 
                         ], plan)
951
 
        pwm = versionedfile.PlanWeaveMerge(plan)
952
 
        self.assertEqualDiff('\n'.join('abcdghef') + '\n',
953
 
                             ''.join(pwm.base_from_plan()))
954
 
        # Reversing the order reverses the merge plan, and final order of 'hg'
955
 
        # => 'gh'
956
 
        plan = list(self.plan_merge_vf.plan_merge('E', 'D'))
957
 
        self.assertEqual([
958
 
                          ('unchanged', 'a\n'),
959
 
                          ('unchanged', 'b\n'),
960
 
                          ('unchanged', 'c\n'),
961
 
                          ('unchanged', 'd\n'),
962
 
                          ('new-b', 'g\n'),
963
 
                          ('unchanged', 'h\n'),
964
 
                          ('killed-b', 'g\n'),
965
 
                          ('unchanged', 'e\n'),
966
 
                          ('unchanged', 'f\n'),
967
 
                         ], plan)
968
 
        pwm = versionedfile.PlanWeaveMerge(plan)
969
 
        self.assertEqualDiff('\n'.join('abcdhgef') + '\n',
970
 
                             ''.join(pwm.base_from_plan()))
971
 
        # This is where lca differs, in that it (fairly correctly) determines
972
 
        # that there is a conflict because both sides resolved the merge
973
 
        # differently
974
 
        plan = list(self.plan_merge_vf.plan_lca_merge('D', 'E'))
975
 
        self.assertEqual([
976
 
                          ('unchanged', 'a\n'),
977
 
                          ('unchanged', 'b\n'),
978
 
                          ('unchanged', 'c\n'),
979
 
                          ('unchanged', 'd\n'),
980
 
                          ('conflicted-b', 'h\n'),
981
 
                          ('unchanged', 'g\n'),
982
 
                          ('conflicted-a', 'h\n'),
983
 
                          ('unchanged', 'e\n'),
984
 
                          ('unchanged', 'f\n'),
985
 
                         ], plan)
986
 
        pwm = versionedfile.PlanWeaveMerge(plan)
987
 
        self.assertEqualDiff('\n'.join('abcdgef') + '\n',
988
 
                             ''.join(pwm.base_from_plan()))
989
 
        # Reversing it changes what line is doubled, but still gives a
990
 
        # double-conflict
991
 
        plan = list(self.plan_merge_vf.plan_lca_merge('E', 'D'))
992
 
        self.assertEqual([
993
 
                          ('unchanged', 'a\n'),
994
 
                          ('unchanged', 'b\n'),
995
 
                          ('unchanged', 'c\n'),
996
 
                          ('unchanged', 'd\n'),
997
 
                          ('conflicted-b', 'g\n'),
998
 
                          ('unchanged', 'h\n'),
999
 
                          ('conflicted-a', 'g\n'),
1000
 
                          ('unchanged', 'e\n'),
1001
 
                          ('unchanged', 'f\n'),
1002
 
                         ], plan)
1003
 
        pwm = versionedfile.PlanWeaveMerge(plan)
1004
 
        self.assertEqualDiff('\n'.join('abcdhef') + '\n',
1005
 
                             ''.join(pwm.base_from_plan()))
1006
830
 
1007
831
    def assertRemoveExternalReferences(self, filtered_parent_map,
1008
832
                                       child_map, tails, parent_map):
1208
1032
                         ], list(plan))
1209
1033
 
1210
1034
 
 
1035
class TestMergeImplementation(object):
 
1036
 
 
1037
    def do_merge(self, target_tree, source_tree, **kwargs):
 
1038
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
1039
            target_tree, source_tree.last_revision(),
 
1040
            other_branch=source_tree.branch)
 
1041
        merger.merge_type=self.merge_type
 
1042
        for name, value in kwargs.items():
 
1043
            setattr(merger, name, value)
 
1044
        merger.do_merge()
 
1045
 
 
1046
    def test_merge_specific_file(self):
 
1047
        this_tree = self.make_branch_and_tree('this')
 
1048
        this_tree.lock_write()
 
1049
        self.addCleanup(this_tree.unlock)
 
1050
        self.build_tree_contents([
 
1051
            ('this/file1', 'a\nb\n'),
 
1052
            ('this/file2', 'a\nb\n')
 
1053
        ])
 
1054
        this_tree.add(['file1', 'file2'])
 
1055
        this_tree.commit('Added files')
 
1056
        other_tree = this_tree.bzrdir.sprout('other').open_workingtree()
 
1057
        self.build_tree_contents([
 
1058
            ('other/file1', 'a\nb\nc\n'),
 
1059
            ('other/file2', 'a\nb\nc\n')
 
1060
        ])
 
1061
        other_tree.commit('modified both')
 
1062
        self.build_tree_contents([
 
1063
            ('this/file1', 'd\na\nb\n'),
 
1064
            ('this/file2', 'd\na\nb\n')
 
1065
        ])
 
1066
        this_tree.commit('modified both')
 
1067
        self.do_merge(this_tree, other_tree, interesting_files=['file1'])
 
1068
        self.assertFileEqual('d\na\nb\nc\n', 'this/file1')
 
1069
        self.assertFileEqual('d\na\nb\n', 'this/file2')
 
1070
 
 
1071
    def test_merge_move_and_change(self):
 
1072
        this_tree = self.make_branch_and_tree('this')
 
1073
        this_tree.lock_write()
 
1074
        self.addCleanup(this_tree.unlock)
 
1075
        self.build_tree_contents([
 
1076
            ('this/file1', 'line 1\nline 2\nline 3\nline 4\n'),
 
1077
        ])
 
1078
        this_tree.add('file1',)
 
1079
        this_tree.commit('Added file')
 
1080
        other_tree = this_tree.bzrdir.sprout('other').open_workingtree()
 
1081
        self.build_tree_contents([
 
1082
            ('other/file1', 'line 1\nline 2 to 2.1\nline 3\nline 4\n'),
 
1083
        ])
 
1084
        other_tree.commit('Changed 2 to 2.1')
 
1085
        self.build_tree_contents([
 
1086
            ('this/file1', 'line 1\nline 3\nline 2\nline 4\n'),
 
1087
        ])
 
1088
        this_tree.commit('Swapped 2 & 3')
 
1089
        self.do_merge(this_tree, other_tree)
 
1090
        self.assertFileEqual('line 1\n'
 
1091
            '<<<<<<< TREE\n'
 
1092
            'line 3\n'
 
1093
            'line 2\n'
 
1094
            '=======\n'
 
1095
            'line 2 to 2.1\n'
 
1096
            'line 3\n'
 
1097
            '>>>>>>> MERGE-SOURCE\n'
 
1098
            'line 4\n', 'this/file1')
 
1099
 
 
1100
    def test_modify_conflicts_with_delete(self):
 
1101
        # If one side deletes a line, and the other modifies that line, then
 
1102
        # the modification should be considered a conflict
 
1103
        builder = self.make_branch_builder('test')
 
1104
        builder.start_series()
 
1105
        builder.build_snapshot('BASE-id', None,
 
1106
            [('add', ('', None, 'directory', None)),
 
1107
             ('add', ('foo', 'foo-id', 'file', 'a\nb\nc\nd\ne\n')),
 
1108
            ])
 
1109
        # Delete 'b\n'
 
1110
        builder.build_snapshot('OTHER-id', ['BASE-id'],
 
1111
            [('modify', ('foo-id', 'a\nc\nd\ne\n'))])
 
1112
        # Modify 'b\n', add 'X\n'
 
1113
        builder.build_snapshot('THIS-id', ['BASE-id'],
 
1114
            [('modify', ('foo-id', 'a\nb2\nc\nd\nX\ne\n'))])
 
1115
        builder.finish_series()
 
1116
        branch = builder.get_branch()
 
1117
        this_tree = branch.bzrdir.create_workingtree()
 
1118
        this_tree.lock_write()
 
1119
        self.addCleanup(this_tree.unlock)
 
1120
        other_tree = this_tree.bzrdir.sprout('other', 'OTHER-id').open_workingtree()
 
1121
        self.do_merge(this_tree, other_tree)
 
1122
        if self.merge_type is _mod_merge.LCAMerger:
 
1123
            self.expectFailure("lca merge doesn't track deleted lines",
 
1124
                self.assertFileEqual,
 
1125
                    'a\n'
 
1126
                    '<<<<<<< TREE\n'
 
1127
                    'b2\n'
 
1128
                    '=======\n'
 
1129
                    '>>>>>>> MERGE-SOURCE\n'
 
1130
                    'c\n'
 
1131
                    'd\n'
 
1132
                    'X\n'
 
1133
                    'e\n', 'test/foo')
 
1134
        else:
 
1135
            self.assertFileEqual(
 
1136
                'a\n'
 
1137
                '<<<<<<< TREE\n'
 
1138
                'b2\n'
 
1139
                '=======\n'
 
1140
                '>>>>>>> MERGE-SOURCE\n'
 
1141
                'c\n'
 
1142
                'd\n'
 
1143
                'X\n'
 
1144
                'e\n', 'test/foo')
 
1145
 
 
1146
    def get_limbodir_deletiondir(self, wt):
 
1147
        transform = TreeTransform(wt)
 
1148
        limbodir = transform._limbodir
 
1149
        deletiondir = transform._deletiondir
 
1150
        transform.finalize()
 
1151
        return (limbodir, deletiondir)
 
1152
    
 
1153
    def test_merge_with_existing_limbo(self):
 
1154
        wt = self.make_branch_and_tree('this')
 
1155
        (limbodir, deletiondir) =  self.get_limbodir_deletiondir(wt)
 
1156
        os.mkdir(limbodir)
 
1157
        self.assertRaises(errors.ExistingLimbo, self.do_merge, wt, wt)
 
1158
        self.assertRaises(errors.LockError, wt.unlock)
 
1159
 
 
1160
    def test_merge_with_pending_deletion(self):
 
1161
        wt = self.make_branch_and_tree('this')
 
1162
        (limbodir, deletiondir) =  self.get_limbodir_deletiondir(wt)
 
1163
        os.mkdir(deletiondir)
 
1164
        self.assertRaises(errors.ExistingPendingDeletion, self.do_merge, wt, wt)
 
1165
        self.assertRaises(errors.LockError, wt.unlock)
 
1166
 
 
1167
 
 
1168
class TestMerge3Merge(TestCaseWithTransport, TestMergeImplementation):
 
1169
 
 
1170
    merge_type = _mod_merge.Merge3Merger
 
1171
 
 
1172
 
 
1173
class TestWeaveMerge(TestCaseWithTransport, TestMergeImplementation):
 
1174
 
 
1175
    merge_type = _mod_merge.WeaveMerger
 
1176
 
 
1177
 
 
1178
class TestLCAMerge(TestCaseWithTransport, TestMergeImplementation):
 
1179
 
 
1180
    merge_type = _mod_merge.LCAMerger
 
1181
 
 
1182
    def test_merge_move_and_change(self):
 
1183
        self.expectFailure("lca merge doesn't conflict for move and change",
 
1184
            super(TestLCAMerge, self).test_merge_move_and_change)
 
1185
 
 
1186
 
1211
1187
class LoggingMerger(object):
1212
1188
    # These seem to be the required attributes
1213
1189
    requires_base = False
1268
1244
        mem_tree = memorytree.MemoryTree.create_on_branch(builder.get_branch())
1269
1245
        mem_tree.lock_write()
1270
1246
        self.addCleanup(mem_tree.unlock)
1271
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
1247
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
1272
1248
            mem_tree, other_revision_id)
1273
1249
        merger.set_interesting_files(interesting_files)
1274
1250
        # It seems there is no matching function for set_interesting_ids
1337
1313
        self.assertEqual(['B-id', 'C-id', 'F-id'],
1338
1314
                         [t.get_revision_id() for t in merger._lca_trees])
1339
1315
 
1340
 
    def test_find_base_new_root_criss_cross(self):
1341
 
        # A   B
1342
 
        # |\ /|
1343
 
        # | X |
1344
 
        # |/ \|
1345
 
        # C   D
1346
 
        
1347
 
        builder = self.get_builder()
1348
 
        builder.build_snapshot('A-id', None,
1349
 
            [('add', ('', None, 'directory', None))])
1350
 
        builder.build_snapshot('B-id', [],
1351
 
            [('add', ('', None, 'directory', None))])
1352
 
        builder.build_snapshot('D-id', ['A-id', 'B-id'], [])
1353
 
        builder.build_snapshot('C-id', ['A-id', 'B-id'], [])
1354
 
        merger = self.make_Merger(builder, 'D-id')
1355
 
        self.assertEqual('A-id', merger.base_rev_id)
1356
 
        self.assertTrue(merger._is_criss_cross)
1357
 
        self.assertEqual(['A-id', 'B-id'], [t.get_revision_id()
1358
 
                                            for t in merger._lca_trees])
1359
 
 
1360
1316
    def test_no_criss_cross_passed_to_merge_type(self):
1361
1317
        class LCATreesMerger(LoggingMerger):
1362
1318
            supports_lca_trees = True
1894
1850
        builder.build_snapshot('C-id', ['A-id'], [])
1895
1851
        builder.build_snapshot('E-id', ['C-id', 'B-id'],
1896
1852
            [('unversion', 'a-id'),
1897
 
             ('flush', None),
1898
1853
             ('add', (u'a', 'a-id', 'directory', None))])
1899
1854
        builder.build_snapshot('D-id', ['B-id', 'C-id'], [])
1900
1855
        merge_obj = self.make_merge_obj(builder, 'E-id')
1918
1873
        builder.build_snapshot('E-id', ['C-id', 'B-id'], [])
1919
1874
        builder.build_snapshot('D-id', ['B-id', 'C-id'],
1920
1875
            [('unversion', 'a-id'),
1921
 
             ('flush', None),
1922
1876
             ('add', (u'a', 'a-id', 'directory', None))])
1923
1877
        merge_obj = self.make_merge_obj(builder, 'E-id')
1924
1878
        entries = list(merge_obj._entries_lca())
2070
2024
 
2071
2025
    def do_merge(self, builder, other_revision_id):
2072
2026
        wt = self.get_wt_from_builder(builder)
2073
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
2027
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
2074
2028
            wt, other_revision_id)
2075
2029
        merger.merge_type = _mod_merge.Merge3Merger
2076
2030
        return wt, merger.do_merge()
2187
2141
        self.assertTrue(wt.is_executable('foo-id'))
2188
2142
 
2189
2143
    def test_create_symlink(self):
2190
 
        self.requireFeature(features.SymlinkFeature)
 
2144
        self.requireFeature(tests.SymlinkFeature)
2191
2145
        #   A
2192
2146
        #  / \
2193
2147
        # B   C
2252
2206
                             wt.get_file_text('foo-id'))
2253
2207
 
2254
2208
    def test_modified_symlink(self):
2255
 
        self.requireFeature(features.SymlinkFeature)
 
2209
        self.requireFeature(tests.SymlinkFeature)
2256
2210
        #   A       Create symlink foo => bar
2257
2211
        #  / \
2258
2212
        # B   C     B relinks foo => baz
2297
2251
        self.assertEqual('bing', wt.get_symlink_target('foo-id'))
2298
2252
 
2299
2253
    def test_renamed_symlink(self):
2300
 
        self.requireFeature(features.SymlinkFeature)
 
2254
        self.requireFeature(tests.SymlinkFeature)
2301
2255
        #   A       Create symlink foo => bar
2302
2256
        #  / \
2303
2257
        # B   C     B renames foo => barry
2336
2290
        wt.commit('D merges B & C', rev_id='D-id')
2337
2291
        self.assertEqual('barry', wt.id2path('foo-id'))
2338
2292
        # Check the output of the Merger object directly
2339
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
2293
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
2340
2294
            wt, 'F-id')
2341
2295
        merger.merge_type = _mod_merge.Merge3Merger
2342
2296
        merge_obj = merger.make_merger()
2353
2307
        self.assertEqual('blah', wt.id2path('foo-id'))
2354
2308
 
2355
2309
    def test_symlink_no_content_change(self):
2356
 
        self.requireFeature(features.SymlinkFeature)
 
2310
        self.requireFeature(tests.SymlinkFeature)
2357
2311
        #   A       Create symlink foo => bar
2358
2312
        #  / \
2359
2313
        # B   C     B relinks foo => baz
2392
2346
        wt.commit('F foo => bing', rev_id='F-id')
2393
2347
 
2394
2348
        # Check the output of the Merger object directly
2395
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
2349
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
2396
2350
            wt, 'E-id')
2397
2351
        merger.merge_type = _mod_merge.Merge3Merger
2398
2352
        merge_obj = merger.make_merger()
2404
2358
        self.assertEqual('bing', wt.get_symlink_target('foo-id'))
2405
2359
 
2406
2360
    def test_symlink_this_changed_kind(self):
2407
 
        self.requireFeature(features.SymlinkFeature)
 
2361
        self.requireFeature(tests.SymlinkFeature)
2408
2362
        #   A       Nothing
2409
2363
        #  / \
2410
2364
        # B   C     B creates symlink foo => bar
2443
2397
        list(wt.iter_changes(wt.basis_tree()))
2444
2398
        wt.commit('D merges B & C, makes it a file', rev_id='D-id')
2445
2399
 
2446
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
2400
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
2447
2401
            wt, 'E-id')
2448
2402
        merger.merge_type = _mod_merge.Merge3Merger
2449
2403
        merge_obj = merger.make_merger()
2457
2411
 
2458
2412
    def test_symlink_all_wt(self):
2459
2413
        """Check behavior if all trees are Working Trees."""
2460
 
        self.requireFeature(features.SymlinkFeature)
 
2414
        self.requireFeature(tests.SymlinkFeature)
2461
2415
        # The big issue is that entry.symlink_target is None for WorkingTrees.
2462
2416
        # So we need to make sure we handle that case correctly.
2463
2417
        #   A   foo => bar
2634
2588
        # Tested with a real WT, because BranchBuilder/MemoryTree don't handle
2635
2589
        # 'tree-reference'
2636
2590
        wt = self.make_branch_and_tree('tree',
2637
 
            format='development-subtree')
 
2591
            format='dirstate-with-subtree')
2638
2592
        wt.lock_write()
2639
2593
        self.addCleanup(wt.unlock)
2640
2594
        sub_tree = self.make_branch_and_tree('tree/sub-tree',
2641
 
            format='development-subtree')
 
2595
            format='dirstate-with-subtree')
2642
2596
        wt.set_root_id('a-root-id')
2643
2597
        sub_tree.set_root_id('sub-tree-root')
2644
2598
        self.build_tree_contents([('tree/sub-tree/file', 'text1')])
2658
2612
        wt.branch.set_last_revision_info(2, 'B-id')
2659
2613
        wt.commit('D', rev_id='D-id', recursive=None)
2660
2614
 
2661
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
2615
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
2662
2616
            wt, 'E-id')
2663
2617
        merger.merge_type = _mod_merge.Merge3Merger
2664
2618
        merge_obj = merger.make_merger()
2669
2623
        # Tested with a real WT, because BranchBuilder/MemoryTree don't handle
2670
2624
        # 'tree-reference'
2671
2625
        wt = self.make_branch_and_tree('tree',
2672
 
            format='development-subtree')
 
2626
            format='dirstate-with-subtree')
2673
2627
        wt.lock_write()
2674
2628
        self.addCleanup(wt.unlock)
2675
2629
        sub_tree = self.make_branch_and_tree('tree/sub',
2676
 
            format='development-subtree')
 
2630
            format='dirstate-with-subtree')
2677
2631
        wt.set_root_id('a-root-id')
2678
2632
        sub_tree.set_root_id('sub-tree-root')
2679
2633
        self.build_tree_contents([('tree/sub/file', 'text1')])
2695
2649
        wt.branch.set_last_revision_info(2, 'B-id')
2696
2650
        wt.commit('D', rev_id='D-id', recursive=None)
2697
2651
 
2698
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
2652
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
2699
2653
            wt, 'E-id')
2700
2654
        merger.merge_type = _mod_merge.Merge3Merger
2701
2655
        merge_obj = merger.make_merger()
2708
2662
        # Tested with a real WT, because BranchBuilder/MemoryTree don't handle
2709
2663
        # 'tree-reference'
2710
2664
        wt = self.make_branch_and_tree('tree',
2711
 
            format='development-subtree')
 
2665
            format='dirstate-with-subtree')
2712
2666
        wt.lock_write()
2713
2667
        self.addCleanup(wt.unlock)
2714
2668
        sub_tree = self.make_branch_and_tree('tree/sub',
2715
 
            format='development-subtree')
 
2669
            format='dirstate-with-subtree')
2716
2670
        wt.set_root_id('a-root-id')
2717
2671
        sub_tree.set_root_id('sub-tree-root')
2718
2672
        self.build_tree_contents([('tree/sub/file', 'text1')])
2735
2689
        wt.branch.set_last_revision_info(2, 'B-id')
2736
2690
        wt.commit('D', rev_id='D-id', recursive=None)
2737
2691
 
2738
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
2692
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
2739
2693
            wt, 'E-id')
2740
2694
        merger.merge_type = _mod_merge.Merge3Merger
2741
2695
        merge_obj = merger.make_merger()
2751
2705
        # Tested with a real WT, because BranchBuilder/MemoryTree don't handle
2752
2706
        # 'tree-reference'
2753
2707
        wt = self.make_branch_and_tree('tree',
2754
 
            format='development-subtree')
 
2708
            format='dirstate-with-subtree')
2755
2709
        wt.lock_write()
2756
2710
        self.addCleanup(wt.unlock)
2757
2711
        sub_tree = self.make_branch_and_tree('tree/sub',
2758
 
            format='development-subtree')
 
2712
            format='dirstate-with-subtree')
2759
2713
        wt.set_root_id('a-root-id')
2760
2714
        sub_tree.set_root_id('sub-tree-root')
2761
2715
        self.build_tree_contents([('tree/sub/file', 'text1')])
2780
2734
        wt.branch.set_last_revision_info(2, 'B-id')
2781
2735
        wt.commit('D', rev_id='D-id', recursive=None)
2782
2736
 
2783
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
2737
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
2784
2738
            wt, 'E-id')
2785
2739
        merger.merge_type = _mod_merge.Merge3Merger
2786
2740
        merge_obj = merger.make_merger()
2922
2876
            'bval', ['lca1val', 'lca2val', 'lca2val'], 'oval', 'tval')
2923
2877
        self.assertLCAMultiWay('conflict',
2924
2878
            'bval', ['lca1val', 'lca2val', 'lca3val'], 'oval', 'tval')
2925
 
 
2926
 
 
2927
 
class TestConfigurableFileMerger(tests.TestCaseWithTransport):
2928
 
 
2929
 
    def setUp(self):
2930
 
        super(TestConfigurableFileMerger, self).setUp()
2931
 
        self.calls = []
2932
 
 
2933
 
    def get_merger_factory(self):
2934
 
        # Allows  the inner methods to access the test attributes
2935
 
        calls = self.calls
2936
 
 
2937
 
        class FooMerger(_mod_merge.ConfigurableFileMerger):
2938
 
            name_prefix = "foo"
2939
 
            default_files = ['bar']
2940
 
 
2941
 
            def merge_text(self, params):
2942
 
                calls.append('merge_text')
2943
 
                return ('not_applicable', None)
2944
 
 
2945
 
        def factory(merger):
2946
 
            result = FooMerger(merger)
2947
 
            # Make sure we start with a clean slate
2948
 
            self.assertEqual(None, result.affected_files)
2949
 
            # Track the original merger
2950
 
            self.merger = result
2951
 
            return result
2952
 
 
2953
 
        return factory
2954
 
 
2955
 
    def _install_hook(self, factory):
2956
 
        _mod_merge.Merger.hooks.install_named_hook('merge_file_content',
2957
 
                                                   factory, 'test factory')
2958
 
 
2959
 
    def make_builder(self):
2960
 
        builder = test_merge_core.MergeBuilder(self.test_base_dir)
2961
 
        self.addCleanup(builder.cleanup)
2962
 
        return builder
2963
 
 
2964
 
    def make_text_conflict(self, file_name='bar'):
2965
 
        factory = self.get_merger_factory()
2966
 
        self._install_hook(factory)
2967
 
        builder = self.make_builder()
2968
 
        builder.add_file('bar-id', builder.tree_root, file_name, 'text1', True)
2969
 
        builder.change_contents('bar-id', other='text4', this='text3')
2970
 
        return builder
2971
 
 
2972
 
    def make_kind_change(self):
2973
 
        factory = self.get_merger_factory()
2974
 
        self._install_hook(factory)
2975
 
        builder = self.make_builder()
2976
 
        builder.add_file('bar-id', builder.tree_root, 'bar', 'text1', True,
2977
 
                         this=False)
2978
 
        builder.add_dir('bar-dir', builder.tree_root, 'bar-id',
2979
 
                        base=False, other=False)
2980
 
        return builder
2981
 
 
2982
 
    def test_uses_this_branch(self):
2983
 
        builder = self.make_text_conflict()
2984
 
        tt = builder.make_preview_transform()
2985
 
        self.addCleanup(tt.finalize)
2986
 
 
2987
 
    def test_affected_files_cached(self):
2988
 
        """Ensures that the config variable is cached"""
2989
 
        builder = self.make_text_conflict()
2990
 
        conflicts = builder.merge()
2991
 
        # The hook should set the variable
2992
 
        self.assertEqual(['bar'], self.merger.affected_files)
2993
 
        self.assertEqual(1, len(conflicts))
2994
 
 
2995
 
    def test_hook_called_for_text_conflicts(self):
2996
 
        builder = self.make_text_conflict()
2997
 
        conflicts = builder.merge()
2998
 
        # The hook should call the merge_text() method
2999
 
        self.assertEqual(['merge_text'], self.calls)
3000
 
 
3001
 
    def test_hook_not_called_for_kind_change(self):
3002
 
        builder = self.make_kind_change()
3003
 
        conflicts = builder.merge()
3004
 
        # The hook should not call the merge_text() method
3005
 
        self.assertEqual([], self.calls)
3006
 
 
3007
 
    def test_hook_not_called_for_other_files(self):
3008
 
        builder = self.make_text_conflict('foobar')
3009
 
        conflicts = builder.merge()
3010
 
        # The hook should not call the merge_text() method
3011
 
        self.assertEqual([], self.calls)
3012
 
 
3013
 
 
3014
 
class TestMergeIntoBase(tests.TestCaseWithTransport):
3015
 
 
3016
 
    def setup_simple_branch(self, relpath, shape=None, root_id=None):
3017
 
        """One commit, containing tree specified by optional shape.
3018
 
        
3019
 
        Default is empty tree (just root entry).
3020
 
        """
3021
 
        if root_id is None:
3022
 
            root_id = '%s-root-id' % (relpath,)
3023
 
        wt = self.make_branch_and_tree(relpath)
3024
 
        wt.set_root_id(root_id)
3025
 
        if shape is not None:
3026
 
            adjusted_shape = [relpath + '/' + elem for elem in shape]
3027
 
            self.build_tree(adjusted_shape)
3028
 
            ids = ['%s-%s-id' % (relpath, basename(elem.rstrip('/')))
3029
 
                   for elem in shape]
3030
 
            wt.add(shape, ids=ids)
3031
 
        rev_id = 'r1-%s' % (relpath,)
3032
 
        wt.commit("Initial commit of %s" % (relpath,), rev_id=rev_id)
3033
 
        self.assertEqual(root_id, wt.path2id(''))
3034
 
        return wt
3035
 
 
3036
 
    def setup_two_branches(self, custom_root_ids=True):
3037
 
        """Setup 2 branches, one will be a library, the other a project."""
3038
 
        if custom_root_ids:
3039
 
            root_id = None
3040
 
        else:
3041
 
            root_id = inventory.ROOT_ID
3042
 
        project_wt = self.setup_simple_branch(
3043
 
            'project', ['README', 'dir/', 'dir/file.c'],
3044
 
            root_id)
3045
 
        lib_wt = self.setup_simple_branch(
3046
 
            'lib1', ['README', 'Makefile', 'foo.c'], root_id)
3047
 
 
3048
 
        return project_wt, lib_wt
3049
 
 
3050
 
    def do_merge_into(self, location, merge_as):
3051
 
        """Helper for using MergeIntoMerger.
3052
 
        
3053
 
        :param location: location of directory to merge from, either the
3054
 
            location of a branch or of a path inside a branch.
3055
 
        :param merge_as: the path in a tree to add the new directory as.
3056
 
        :returns: the conflicts from 'do_merge'.
3057
 
        """
3058
 
        operation = cleanup.OperationWithCleanups(self._merge_into)
3059
 
        return operation.run(location, merge_as)
3060
 
 
3061
 
    def _merge_into(self, op, location, merge_as):
3062
 
        # Open and lock the various tree and branch objects
3063
 
        wt, subdir_relpath = WorkingTree.open_containing(merge_as)
3064
 
        op.add_cleanup(wt.lock_write().unlock)
3065
 
        branch_to_merge, subdir_to_merge = _mod_branch.Branch.open_containing(
3066
 
            location)
3067
 
        op.add_cleanup(branch_to_merge.lock_read().unlock)
3068
 
        other_tree = branch_to_merge.basis_tree()
3069
 
        op.add_cleanup(other_tree.lock_read().unlock)
3070
 
        # Perform the merge
3071
 
        merger = _mod_merge.MergeIntoMerger(this_tree=wt, other_tree=other_tree,
3072
 
            other_branch=branch_to_merge, target_subdir=subdir_relpath,
3073
 
            source_subpath=subdir_to_merge)
3074
 
        merger.set_base_revision(_mod_revision.NULL_REVISION, branch_to_merge)
3075
 
        conflicts = merger.do_merge()
3076
 
        merger.set_pending()
3077
 
        return conflicts
3078
 
 
3079
 
    def assertTreeEntriesEqual(self, expected_entries, tree):
3080
 
        """Assert that 'tree' contains the expected inventory entries.
3081
 
 
3082
 
        :param expected_entries: sequence of (path, file-id) pairs.
3083
 
        """
3084
 
        files = [(path, ie.file_id) for path, ie in tree.iter_entries_by_dir()]
3085
 
        self.assertEqual(expected_entries, files)
3086
 
 
3087
 
 
3088
 
class TestMergeInto(TestMergeIntoBase):
3089
 
 
3090
 
    def test_newdir_with_unique_roots(self):
3091
 
        """Merge a branch with a unique root into a new directory."""
3092
 
        project_wt, lib_wt = self.setup_two_branches()
3093
 
        self.do_merge_into('lib1', 'project/lib1')
3094
 
        project_wt.lock_read()
3095
 
        self.addCleanup(project_wt.unlock)
3096
 
        # The r1-lib1 revision should be merged into this one
3097
 
        self.assertEqual(['r1-project', 'r1-lib1'], project_wt.get_parent_ids())
3098
 
        self.assertTreeEntriesEqual(
3099
 
            [('', 'project-root-id'),
3100
 
             ('README', 'project-README-id'),
3101
 
             ('dir', 'project-dir-id'),
3102
 
             ('lib1', 'lib1-root-id'),
3103
 
             ('dir/file.c', 'project-file.c-id'),
3104
 
             ('lib1/Makefile', 'lib1-Makefile-id'),
3105
 
             ('lib1/README', 'lib1-README-id'),
3106
 
             ('lib1/foo.c', 'lib1-foo.c-id'),
3107
 
            ], project_wt)
3108
 
 
3109
 
    def test_subdir(self):
3110
 
        """Merge a branch into a subdirectory of an existing directory."""
3111
 
        project_wt, lib_wt = self.setup_two_branches()
3112
 
        self.do_merge_into('lib1', 'project/dir/lib1')
3113
 
        project_wt.lock_read()
3114
 
        self.addCleanup(project_wt.unlock)
3115
 
        # The r1-lib1 revision should be merged into this one
3116
 
        self.assertEqual(['r1-project', 'r1-lib1'], project_wt.get_parent_ids())
3117
 
        self.assertTreeEntriesEqual(
3118
 
            [('', 'project-root-id'),
3119
 
             ('README', 'project-README-id'),
3120
 
             ('dir', 'project-dir-id'),
3121
 
             ('dir/file.c', 'project-file.c-id'),
3122
 
             ('dir/lib1', 'lib1-root-id'),
3123
 
             ('dir/lib1/Makefile', 'lib1-Makefile-id'),
3124
 
             ('dir/lib1/README', 'lib1-README-id'),
3125
 
             ('dir/lib1/foo.c', 'lib1-foo.c-id'),
3126
 
            ], project_wt)
3127
 
 
3128
 
    def test_newdir_with_repeat_roots(self):
3129
 
        """If the file-id of the dir to be merged already exists a new ID will
3130
 
        be allocated to let the merge happen.
3131
 
        """
3132
 
        project_wt, lib_wt = self.setup_two_branches(custom_root_ids=False)
3133
 
        root_id = project_wt.path2id('')
3134
 
        self.do_merge_into('lib1', 'project/lib1')
3135
 
        project_wt.lock_read()
3136
 
        self.addCleanup(project_wt.unlock)
3137
 
        # The r1-lib1 revision should be merged into this one
3138
 
        self.assertEqual(['r1-project', 'r1-lib1'], project_wt.get_parent_ids())
3139
 
        new_lib1_id = project_wt.path2id('lib1')
3140
 
        self.assertNotEqual(None, new_lib1_id)
3141
 
        self.assertTreeEntriesEqual(
3142
 
            [('', root_id),
3143
 
             ('README', 'project-README-id'),
3144
 
             ('dir', 'project-dir-id'),
3145
 
             ('lib1', new_lib1_id),
3146
 
             ('dir/file.c', 'project-file.c-id'),
3147
 
             ('lib1/Makefile', 'lib1-Makefile-id'),
3148
 
             ('lib1/README', 'lib1-README-id'),
3149
 
             ('lib1/foo.c', 'lib1-foo.c-id'),
3150
 
            ], project_wt)
3151
 
 
3152
 
    def test_name_conflict(self):
3153
 
        """When the target directory name already exists a conflict is
3154
 
        generated and the original directory is renamed to foo.moved.
3155
 
        """
3156
 
        dest_wt = self.setup_simple_branch('dest', ['dir/', 'dir/file.txt'])
3157
 
        src_wt = self.setup_simple_branch('src', ['README'])
3158
 
        conflicts = self.do_merge_into('src', 'dest/dir')
3159
 
        self.assertEqual(1, conflicts)
3160
 
        dest_wt.lock_read()
3161
 
        self.addCleanup(dest_wt.unlock)
3162
 
        # The r1-lib1 revision should be merged into this one
3163
 
        self.assertEqual(['r1-dest', 'r1-src'], dest_wt.get_parent_ids())
3164
 
        self.assertTreeEntriesEqual(
3165
 
            [('', 'dest-root-id'),
3166
 
             ('dir', 'src-root-id'),
3167
 
             ('dir.moved', 'dest-dir-id'),
3168
 
             ('dir/README', 'src-README-id'),
3169
 
             ('dir.moved/file.txt', 'dest-file.txt-id'),
3170
 
            ], dest_wt)
3171
 
 
3172
 
    def test_file_id_conflict(self):
3173
 
        """A conflict is generated if the merge-into adds a file (or other
3174
 
        inventory entry) with a file-id that already exists in the target tree.
3175
 
        """
3176
 
        dest_wt = self.setup_simple_branch('dest', ['file.txt'])
3177
 
        # Make a second tree with a file-id that will clash with file.txt in
3178
 
        # dest.
3179
 
        src_wt = self.make_branch_and_tree('src')
3180
 
        self.build_tree(['src/README'])
3181
 
        src_wt.add(['README'], ids=['dest-file.txt-id'])
3182
 
        src_wt.commit("Rev 1 of src.", rev_id='r1-src')
3183
 
        conflicts = self.do_merge_into('src', 'dest/dir')
3184
 
        # This is an edge case that shouldn't happen to users very often.  So
3185
 
        # we don't care really about the exact presentation of the conflict,
3186
 
        # just that there is one.
3187
 
        self.assertEqual(1, conflicts)
3188
 
 
3189
 
    def test_only_subdir(self):
3190
 
        """When the location points to just part of a tree, merge just that
3191
 
        subtree.
3192
 
        """
3193
 
        dest_wt = self.setup_simple_branch('dest')
3194
 
        src_wt = self.setup_simple_branch(
3195
 
            'src', ['hello.txt', 'dir/', 'dir/foo.c'])
3196
 
        conflicts = self.do_merge_into('src/dir', 'dest/dir')
3197
 
        dest_wt.lock_read()
3198
 
        self.addCleanup(dest_wt.unlock)
3199
 
        # The r1-lib1 revision should NOT be merged into this one (this is a
3200
 
        # partial merge).
3201
 
        self.assertEqual(['r1-dest'], dest_wt.get_parent_ids())
3202
 
        self.assertTreeEntriesEqual(
3203
 
            [('', 'dest-root-id'),
3204
 
             ('dir', 'src-dir-id'),
3205
 
             ('dir/foo.c', 'src-foo.c-id'),
3206
 
            ], dest_wt)
3207
 
 
3208
 
    def test_only_file(self):
3209
 
        """An edge case: merge just one file, not a whole dir."""
3210
 
        dest_wt = self.setup_simple_branch('dest')
3211
 
        two_file_wt = self.setup_simple_branch(
3212
 
            'two-file', ['file1.txt', 'file2.txt'])
3213
 
        conflicts = self.do_merge_into('two-file/file1.txt', 'dest/file1.txt')
3214
 
        dest_wt.lock_read()
3215
 
        self.addCleanup(dest_wt.unlock)
3216
 
        # The r1-lib1 revision should NOT be merged into this one
3217
 
        self.assertEqual(['r1-dest'], dest_wt.get_parent_ids())
3218
 
        self.assertTreeEntriesEqual(
3219
 
            [('', 'dest-root-id'), ('file1.txt', 'two-file-file1.txt-id')],
3220
 
            dest_wt)
3221
 
 
3222
 
    def test_no_such_source_path(self):
3223
 
        """PathNotInTree is raised if the specified path in the source tree
3224
 
        does not exist.
3225
 
        """
3226
 
        dest_wt = self.setup_simple_branch('dest')
3227
 
        two_file_wt = self.setup_simple_branch('src', ['dir/'])
3228
 
        self.assertRaises(_mod_merge.PathNotInTree, self.do_merge_into,
3229
 
            'src/no-such-dir', 'dest/foo')
3230
 
        dest_wt.lock_read()
3231
 
        self.addCleanup(dest_wt.unlock)
3232
 
        # The dest tree is unmodified.
3233
 
        self.assertEqual(['r1-dest'], dest_wt.get_parent_ids())
3234
 
        self.assertTreeEntriesEqual([('', 'dest-root-id')], dest_wt)
3235
 
 
3236
 
    def test_no_such_target_path(self):
3237
 
        """PathNotInTree is also raised if the specified path in the target
3238
 
        tree does not exist.
3239
 
        """
3240
 
        dest_wt = self.setup_simple_branch('dest')
3241
 
        two_file_wt = self.setup_simple_branch('src', ['file.txt'])
3242
 
        self.assertRaises(_mod_merge.PathNotInTree, self.do_merge_into,
3243
 
            'src', 'dest/no-such-dir/foo')
3244
 
        dest_wt.lock_read()
3245
 
        self.addCleanup(dest_wt.unlock)
3246
 
        # The dest tree is unmodified.
3247
 
        self.assertEqual(['r1-dest'], dest_wt.get_parent_ids())
3248
 
        self.assertTreeEntriesEqual([('', 'dest-root-id')], dest_wt)
3249
 
 
3250
 
 
3251
 
class TestMergeHooks(TestCaseWithTransport):
3252
 
 
3253
 
    def setUp(self):
3254
 
        super(TestMergeHooks, self).setUp()
3255
 
        self.tree_a = self.make_branch_and_tree('tree_a')
3256
 
        self.build_tree_contents([('tree_a/file', 'content_1')])
3257
 
        self.tree_a.add('file', 'file-id')
3258
 
        self.tree_a.commit('added file')
3259
 
 
3260
 
        self.tree_b = self.tree_a.bzrdir.sprout('tree_b').open_workingtree()
3261
 
        self.build_tree_contents([('tree_b/file', 'content_2')])
3262
 
        self.tree_b.commit('modify file')
3263
 
 
3264
 
    def test_pre_merge_hook_inject_different_tree(self):
3265
 
        tree_c = self.tree_b.bzrdir.sprout('tree_c').open_workingtree()
3266
 
        self.build_tree_contents([('tree_c/file', 'content_3')])
3267
 
        tree_c.commit("more content")
3268
 
        calls = []
3269
 
        def factory(merger):
3270
 
            self.assertIsInstance(merger, _mod_merge.Merge3Merger)
3271
 
            merger.other_tree = tree_c
3272
 
            calls.append(merger)
3273
 
        _mod_merge.Merger.hooks.install_named_hook('pre_merge',
3274
 
                                                   factory, 'test factory')
3275
 
        self.tree_a.merge_from_branch(self.tree_b.branch)
3276
 
 
3277
 
        self.assertFileEqual("content_3", 'tree_a/file')
3278
 
        self.assertLength(1, calls)
3279
 
 
3280
 
    def test_post_merge_hook_called(self):
3281
 
        calls = []
3282
 
        def factory(merger):
3283
 
            self.assertIsInstance(merger, _mod_merge.Merge3Merger)
3284
 
            calls.append(merger)
3285
 
        _mod_merge.Merger.hooks.install_named_hook('post_merge',
3286
 
                                                   factory, 'test factory')
3287
 
 
3288
 
        self.tree_a.merge_from_branch(self.tree_b.branch)
3289
 
 
3290
 
        self.assertFileEqual("content_2", 'tree_a/file')
3291
 
        self.assertLength(1, calls)