~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-10-21 21:27:19 UTC
  • mto: This revision was merged to the branch mainline in revision 4771.
  • Revision ID: john@arbash-meinel.com-20091021212719-05zh4t7oo5kaird3
More cleanups and clarifications.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2010 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
29
29
    transform,
30
30
    versionedfile,
31
31
    )
 
32
from bzrlib.branch import Branch
32
33
from bzrlib.conflicts import ConflictList, TextConflict
33
 
from bzrlib.errors import UnrelatedBranches, NoCommits
 
34
from bzrlib.errors import UnrelatedBranches, NoCommits, BzrCommandError
34
35
from bzrlib.merge import transform_tree, merge_inner, _PlanMerge
35
36
from bzrlib.osutils import pathjoin, file_kind
36
 
from bzrlib.tests import (
37
 
    TestCaseWithMemoryTransport,
38
 
    TestCaseWithTransport,
39
 
    test_merge_core,
40
 
    )
 
37
from bzrlib.tests import TestCaseWithTransport, TestCaseWithMemoryTransport
41
38
from bzrlib.workingtree import WorkingTree
42
 
 
 
39
from bzrlib.transform import TreeTransform
43
40
 
44
41
class TestMerge(TestCaseWithTransport):
45
42
    """Test appending more than one revision"""
154
151
        log = StringIO()
155
152
        merge_inner(tree_b.branch, tree_a, tree_b.basis_tree(),
156
153
                    this_tree=tree_b, ignore_zero=True)
157
 
        self.failUnless('All changes applied successfully.\n' not in
158
 
            self.get_log())
 
154
        log = self._get_log(keep_log_file=True)
 
155
        self.failUnless('All changes applied successfully.\n' not in log)
159
156
        tree_b.revert()
160
157
        merge_inner(tree_b.branch, tree_a, tree_b.basis_tree(),
161
158
                    this_tree=tree_b, ignore_zero=False)
162
 
        self.failUnless('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)
163
161
 
164
162
    def test_merge_inner_conflicts(self):
165
163
        tree_a = self.make_branch_and_tree('a')
295
293
        tree_a.commit('commit 2')
296
294
        tree_b = tree_a.bzrdir.sprout('b').open_workingtree()
297
295
        tree_b.rename_one('file_1', 'renamed')
298
 
        merger = _mod_merge.Merger.from_uncommitted(tree_a, tree_b)
 
296
        merger = _mod_merge.Merger.from_uncommitted(tree_a, tree_b,
 
297
                                                    progress.DummyProgress())
299
298
        merger.merge_type = _mod_merge.Merge3Merger
300
299
        merger.do_merge()
301
300
        self.assertEqual(tree_a.get_parent_ids(), [tree_b.last_revision()])
309
308
        tree_a.commit('commit 2')
310
309
        tree_b = tree_a.bzrdir.sprout('b').open_workingtree()
311
310
        tree_b.rename_one('file_1', 'renamed')
312
 
        merger = _mod_merge.Merger.from_uncommitted(tree_a, tree_b)
 
311
        merger = _mod_merge.Merger.from_uncommitted(tree_a, tree_b,
 
312
                                                    progress.DummyProgress())
313
313
        merger.merge_type = _mod_merge.WeaveMerger
314
314
        merger.do_merge()
315
315
        self.assertEqual(tree_a.get_parent_ids(), [tree_b.last_revision()])
316
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
 
317
322
    def prepare_cherrypick(self):
318
323
        """Prepare a pair of trees for cherrypicking tests.
319
324
 
340
345
 
341
346
    def test_weave_cherrypick(self):
342
347
        this_tree, other_tree = self.prepare_cherrypick()
343
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
348
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
344
349
            this_tree, 'rev3b', 'rev2b', other_tree.branch)
345
350
        merger.merge_type = _mod_merge.WeaveMerger
346
351
        merger.do_merge()
348
353
 
349
354
    def test_weave_cannot_reverse_cherrypick(self):
350
355
        this_tree, other_tree = self.prepare_cherrypick()
351
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
356
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
352
357
            this_tree, 'rev2b', 'rev3b', other_tree.branch)
353
358
        merger.merge_type = _mod_merge.WeaveMerger
354
359
        self.assertRaises(errors.CannotReverseCherrypick, merger.do_merge)
355
360
 
356
361
    def test_merge3_can_reverse_cherrypick(self):
357
362
        this_tree, other_tree = self.prepare_cherrypick()
358
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
363
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
359
364
            this_tree, 'rev2b', 'rev3b', other_tree.branch)
360
365
        merger.merge_type = _mod_merge.Merge3Merger
361
366
        merger.do_merge()
373
378
        this_tree.lock_write()
374
379
        self.addCleanup(this_tree.unlock)
375
380
 
376
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
381
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
377
382
            this_tree, 'rev3b', 'rev2b', other_tree.branch)
378
383
        merger.merge_type = _mod_merge.Merge3Merger
379
384
        merger.do_merge()
392
397
        other_tree.commit('rev2', rev_id='rev2b')
393
398
        this_tree.lock_write()
394
399
        self.addCleanup(this_tree.unlock)
395
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
400
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress,
396
401
            this_tree, 'rev2b', other_branch=other_tree.branch)
397
402
        merger.merge_type = _mod_merge.Merge3Merger
398
403
        tree_merger = merger.make_merger()
412
417
        other_tree.commit('rev2', rev_id='rev2b')
413
418
        this_tree.lock_write()
414
419
        self.addCleanup(this_tree.unlock)
415
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
420
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
416
421
            this_tree, 'rev2b', other_branch=other_tree.branch)
417
422
        merger.merge_type = _mod_merge.Merge3Merger
418
423
        tree_merger = merger.make_merger()
442
447
        other_tree.commit('rev2', rev_id='rev2b')
443
448
        this_tree.lock_write()
444
449
        self.addCleanup(this_tree.unlock)
445
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
450
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
446
451
            this_tree, 'rev2b', other_branch=other_tree.branch)
447
452
        merger.merge_type = _mod_merge.Merge3Merger
448
453
        tree_merger = merger.make_merger()
519
524
        self.add_uncommitted_version(('root', 'C:'), [('root', 'A')], 'fabg')
520
525
        return _PlanMerge('B:', 'C:', self.plan_merge_vf, ('root',))
521
526
 
522
 
    def test_base_from_plan(self):
523
 
        self.setup_plan_merge()
524
 
        plan = self.plan_merge_vf.plan_merge('B', 'C')
525
 
        pwm = versionedfile.PlanWeaveMerge(plan)
526
 
        self.assertEqual(['a\n', 'b\n', 'c\n'], pwm.base_from_plan())
527
 
 
528
527
    def test_unique_lines(self):
529
528
        plan = self.setup_plan_merge()
530
529
        self.assertEqual(plan._unique_lines(
828
827
                          ('unchanged', 'f\n'),
829
828
                          ('unchanged', 'g\n')],
830
829
                         list(plan))
831
 
        plan = self.plan_merge_vf.plan_lca_merge('F', 'G')
832
 
        # This is one of the main differences between plan_merge and
833
 
        # plan_lca_merge. plan_lca_merge generates a conflict for 'x => z',
834
 
        # because 'x' was not present in one of the bases. However, in this
835
 
        # case it is spurious because 'x' does not exist in the global base A.
836
 
        self.assertEqual([
837
 
                          ('unchanged', 'h\n'),
838
 
                          ('unchanged', 'a\n'),
839
 
                          ('conflicted-a', 'x\n'),
840
 
                          ('new-b', 'z\n'),
841
 
                          ('unchanged', 'c\n'),
842
 
                          ('unchanged', 'd\n'),
843
 
                          ('unchanged', 'y\n'),
844
 
                          ('unchanged', 'f\n'),
845
 
                          ('unchanged', 'g\n')],
846
 
                         list(plan))
847
 
 
848
 
    def test_criss_cross_flip_flop(self):
849
 
        # This is specificly trying to trigger problems when using limited
850
 
        # ancestry and weaves. The ancestry graph looks like:
851
 
        #       XX      unused ancestor, should not show up in the weave
852
 
        #       |
853
 
        #       A       Unique LCA
854
 
        #      / \  
855
 
        #     B   C     B & C both introduce a new line
856
 
        #     |\ /|  
857
 
        #     | X |  
858
 
        #     |/ \| 
859
 
        #     D   E     B & C are both merged, so both are common ancestors
860
 
        #               In the process of merging, both sides order the new
861
 
        #               lines differently
862
 
        #
863
 
        self.add_rev('root', 'XX', [], 'qrs')
864
 
        self.add_rev('root', 'A', ['XX'], 'abcdef')
865
 
        self.add_rev('root', 'B', ['A'], 'abcdgef')
866
 
        self.add_rev('root', 'C', ['A'], 'abcdhef')
867
 
        self.add_rev('root', 'D', ['B', 'C'], 'abcdghef')
868
 
        self.add_rev('root', 'E', ['C', 'B'], 'abcdhgef')
869
 
        plan = list(self.plan_merge_vf.plan_merge('D', 'E'))
870
 
        self.assertEqual([
871
 
                          ('unchanged', 'a\n'),
872
 
                          ('unchanged', 'b\n'),
873
 
                          ('unchanged', 'c\n'),
874
 
                          ('unchanged', 'd\n'),
875
 
                          ('new-b', 'h\n'),
876
 
                          ('unchanged', 'g\n'),
877
 
                          ('killed-b', 'h\n'),
878
 
                          ('unchanged', 'e\n'),
879
 
                          ('unchanged', 'f\n'),
880
 
                         ], plan)
881
 
        pwm = versionedfile.PlanWeaveMerge(plan)
882
 
        self.assertEqualDiff('\n'.join('abcdghef') + '\n',
883
 
                             ''.join(pwm.base_from_plan()))
884
 
        # Reversing the order reverses the merge plan, and final order of 'hg'
885
 
        # => 'gh'
886
 
        plan = list(self.plan_merge_vf.plan_merge('E', 'D'))
887
 
        self.assertEqual([
888
 
                          ('unchanged', 'a\n'),
889
 
                          ('unchanged', 'b\n'),
890
 
                          ('unchanged', 'c\n'),
891
 
                          ('unchanged', 'd\n'),
892
 
                          ('new-b', 'g\n'),
893
 
                          ('unchanged', 'h\n'),
894
 
                          ('killed-b', 'g\n'),
895
 
                          ('unchanged', 'e\n'),
896
 
                          ('unchanged', 'f\n'),
897
 
                         ], plan)
898
 
        pwm = versionedfile.PlanWeaveMerge(plan)
899
 
        self.assertEqualDiff('\n'.join('abcdhgef') + '\n',
900
 
                             ''.join(pwm.base_from_plan()))
901
 
        # This is where lca differs, in that it (fairly correctly) determines
902
 
        # that there is a conflict because both sides resolved the merge
903
 
        # differently
904
 
        plan = list(self.plan_merge_vf.plan_lca_merge('D', 'E'))
905
 
        self.assertEqual([
906
 
                          ('unchanged', 'a\n'),
907
 
                          ('unchanged', 'b\n'),
908
 
                          ('unchanged', 'c\n'),
909
 
                          ('unchanged', 'd\n'),
910
 
                          ('conflicted-b', 'h\n'),
911
 
                          ('unchanged', 'g\n'),
912
 
                          ('conflicted-a', 'h\n'),
913
 
                          ('unchanged', 'e\n'),
914
 
                          ('unchanged', 'f\n'),
915
 
                         ], plan)
916
 
        pwm = versionedfile.PlanWeaveMerge(plan)
917
 
        self.assertEqualDiff('\n'.join('abcdgef') + '\n',
918
 
                             ''.join(pwm.base_from_plan()))
919
 
        # Reversing it changes what line is doubled, but still gives a
920
 
        # double-conflict
921
 
        plan = list(self.plan_merge_vf.plan_lca_merge('E', 'D'))
922
 
        self.assertEqual([
923
 
                          ('unchanged', 'a\n'),
924
 
                          ('unchanged', 'b\n'),
925
 
                          ('unchanged', 'c\n'),
926
 
                          ('unchanged', 'd\n'),
927
 
                          ('conflicted-b', 'g\n'),
928
 
                          ('unchanged', 'h\n'),
929
 
                          ('conflicted-a', 'g\n'),
930
 
                          ('unchanged', 'e\n'),
931
 
                          ('unchanged', 'f\n'),
932
 
                         ], plan)
933
 
        pwm = versionedfile.PlanWeaveMerge(plan)
934
 
        self.assertEqualDiff('\n'.join('abcdhef') + '\n',
935
 
                             ''.join(pwm.base_from_plan()))
936
830
 
937
831
    def assertRemoveExternalReferences(self, filtered_parent_map,
938
832
                                       child_map, tails, parent_map):
1138
1032
                         ], list(plan))
1139
1033
 
1140
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
 
1141
1187
class LoggingMerger(object):
1142
1188
    # These seem to be the required attributes
1143
1189
    requires_base = False
1198
1244
        mem_tree = memorytree.MemoryTree.create_on_branch(builder.get_branch())
1199
1245
        mem_tree.lock_write()
1200
1246
        self.addCleanup(mem_tree.unlock)
1201
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
1247
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
1202
1248
            mem_tree, other_revision_id)
1203
1249
        merger.set_interesting_files(interesting_files)
1204
1250
        # It seems there is no matching function for set_interesting_ids
1978
2024
 
1979
2025
    def do_merge(self, builder, other_revision_id):
1980
2026
        wt = self.get_wt_from_builder(builder)
1981
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
2027
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
1982
2028
            wt, other_revision_id)
1983
2029
        merger.merge_type = _mod_merge.Merge3Merger
1984
2030
        return wt, merger.do_merge()
2244
2290
        wt.commit('D merges B & C', rev_id='D-id')
2245
2291
        self.assertEqual('barry', wt.id2path('foo-id'))
2246
2292
        # Check the output of the Merger object directly
2247
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
2293
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
2248
2294
            wt, 'F-id')
2249
2295
        merger.merge_type = _mod_merge.Merge3Merger
2250
2296
        merge_obj = merger.make_merger()
2300
2346
        wt.commit('F foo => bing', rev_id='F-id')
2301
2347
 
2302
2348
        # Check the output of the Merger object directly
2303
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
2349
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
2304
2350
            wt, 'E-id')
2305
2351
        merger.merge_type = _mod_merge.Merge3Merger
2306
2352
        merge_obj = merger.make_merger()
2351
2397
        list(wt.iter_changes(wt.basis_tree()))
2352
2398
        wt.commit('D merges B & C, makes it a file', rev_id='D-id')
2353
2399
 
2354
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
2400
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
2355
2401
            wt, 'E-id')
2356
2402
        merger.merge_type = _mod_merge.Merge3Merger
2357
2403
        merge_obj = merger.make_merger()
2566
2612
        wt.branch.set_last_revision_info(2, 'B-id')
2567
2613
        wt.commit('D', rev_id='D-id', recursive=None)
2568
2614
 
2569
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
2615
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
2570
2616
            wt, 'E-id')
2571
2617
        merger.merge_type = _mod_merge.Merge3Merger
2572
2618
        merge_obj = merger.make_merger()
2603
2649
        wt.branch.set_last_revision_info(2, 'B-id')
2604
2650
        wt.commit('D', rev_id='D-id', recursive=None)
2605
2651
 
2606
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
2652
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
2607
2653
            wt, 'E-id')
2608
2654
        merger.merge_type = _mod_merge.Merge3Merger
2609
2655
        merge_obj = merger.make_merger()
2643
2689
        wt.branch.set_last_revision_info(2, 'B-id')
2644
2690
        wt.commit('D', rev_id='D-id', recursive=None)
2645
2691
 
2646
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
2692
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
2647
2693
            wt, 'E-id')
2648
2694
        merger.merge_type = _mod_merge.Merge3Merger
2649
2695
        merge_obj = merger.make_merger()
2688
2734
        wt.branch.set_last_revision_info(2, 'B-id')
2689
2735
        wt.commit('D', rev_id='D-id', recursive=None)
2690
2736
 
2691
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
2737
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
2692
2738
            wt, 'E-id')
2693
2739
        merger.merge_type = _mod_merge.Merge3Merger
2694
2740
        merge_obj = merger.make_merger()
2830
2876
            'bval', ['lca1val', 'lca2val', 'lca2val'], 'oval', 'tval')
2831
2877
        self.assertLCAMultiWay('conflict',
2832
2878
            'bval', ['lca1val', 'lca2val', 'lca3val'], 'oval', 'tval')
2833
 
 
2834
 
 
2835
 
class TestConfigurableFileMerger(tests.TestCaseWithTransport):
2836
 
 
2837
 
    def setUp(self):
2838
 
        super(TestConfigurableFileMerger, self).setUp()
2839
 
        self.calls = []
2840
 
 
2841
 
    def get_merger_factory(self):
2842
 
        # Allows  the inner methods to access the test attributes
2843
 
        test = self
2844
 
 
2845
 
        class FooMerger(_mod_merge.ConfigurableFileMerger):
2846
 
            name_prefix = "foo"
2847
 
            default_files = ['bar']
2848
 
 
2849
 
            def merge_text(self, params):
2850
 
                test.calls.append('merge_text')
2851
 
                return ('not_applicable', None)
2852
 
 
2853
 
        def factory(merger):
2854
 
            result = FooMerger(merger)
2855
 
            # Make sure we start with a clean slate
2856
 
            self.assertEqual(None, result.affected_files)
2857
 
            # Track the original merger
2858
 
            self.merger = result
2859
 
            return result
2860
 
 
2861
 
        return factory
2862
 
 
2863
 
    def _install_hook(self, factory):
2864
 
        _mod_merge.Merger.hooks.install_named_hook('merge_file_content',
2865
 
                                                   factory, 'test factory')
2866
 
 
2867
 
    def make_builder(self):
2868
 
        builder = test_merge_core.MergeBuilder(self.test_base_dir)
2869
 
        self.addCleanup(builder.cleanup)
2870
 
        return builder
2871
 
 
2872
 
    def make_text_conflict(self, file_name='bar'):
2873
 
        factory = self.get_merger_factory()
2874
 
        self._install_hook(factory)
2875
 
        builder = self.make_builder()
2876
 
        builder.add_file('bar-id', builder.tree_root, file_name, 'text1', True)
2877
 
        builder.change_contents('bar-id', other='text4', this='text3')
2878
 
        return builder
2879
 
 
2880
 
    def make_kind_change(self):
2881
 
        factory = self.get_merger_factory()
2882
 
        self._install_hook(factory)
2883
 
        builder = self.make_builder()
2884
 
        builder.add_file('bar-id', builder.tree_root, 'bar', 'text1', True,
2885
 
                         this=False)
2886
 
        builder.add_dir('bar-dir', builder.tree_root, 'bar-id',
2887
 
                        base=False, other=False)
2888
 
        return builder
2889
 
 
2890
 
    def test_affected_files_cached(self):
2891
 
        """Ensures that the config variable is cached"""
2892
 
        builder = self.make_text_conflict()
2893
 
        conflicts = builder.merge()
2894
 
        # The hook should set the variable
2895
 
        self.assertEqual(['bar'], self.merger.affected_files)
2896
 
        self.assertEqual(1, len(conflicts))
2897
 
 
2898
 
    def test_hook_called_for_text_conflicts(self):
2899
 
        builder = self.make_text_conflict()
2900
 
        conflicts = builder.merge()
2901
 
        # The hook should call the merge_text() method
2902
 
        self.assertEqual(['merge_text'], self.calls)
2903
 
 
2904
 
    def test_hook_not_called_for_kind_change(self):
2905
 
        builder = self.make_kind_change()
2906
 
        conflicts = builder.merge()
2907
 
        # The hook should not call the merge_text() method
2908
 
        self.assertEqual([], self.calls)
2909
 
 
2910
 
    def test_hook_not_called_for_other_files(self):
2911
 
        builder = self.make_text_conflict('foobar')
2912
 
        conflicts = builder.merge()
2913
 
        # The hook should not call the merge_text() method
2914
 
        self.assertEqual([], self.calls)