~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_merge.py

  • Committer: Andrew Bennetts
  • Date: 2010-02-12 04:33:05 UTC
  • mfrom: (5031 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5032.
  • Revision ID: andrew.bennetts@canonical.com-20100212043305-ujdbsdoviql2t7i3
MergeĀ lp:bzr

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005-2010 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
33
32
from bzrlib.conflicts import ConflictList, TextConflict
34
 
from bzrlib.errors import UnrelatedBranches, NoCommits, BzrCommandError
 
33
from bzrlib.errors import UnrelatedBranches, NoCommits
35
34
from bzrlib.merge import transform_tree, merge_inner, _PlanMerge
36
35
from bzrlib.osutils import pathjoin, file_kind
37
 
from bzrlib.tests import TestCaseWithTransport, TestCaseWithMemoryTransport
 
36
from bzrlib.tests import (
 
37
    TestCaseWithMemoryTransport,
 
38
    TestCaseWithTransport,
 
39
    test_merge_core,
 
40
    )
38
41
from bzrlib.workingtree import WorkingTree
39
 
from bzrlib.transform import TreeTransform
 
42
 
40
43
 
41
44
class TestMerge(TestCaseWithTransport):
42
45
    """Test appending more than one revision"""
151
154
        log = StringIO()
152
155
        merge_inner(tree_b.branch, tree_a, tree_b.basis_tree(),
153
156
                    this_tree=tree_b, ignore_zero=True)
154
 
        log = self._get_log(keep_log_file=True)
155
 
        self.failUnless('All changes applied successfully.\n' not in log)
 
157
        self.failUnless('All changes applied successfully.\n' not in
 
158
            self.get_log())
156
159
        tree_b.revert()
157
160
        merge_inner(tree_b.branch, tree_a, tree_b.basis_tree(),
158
161
                    this_tree=tree_b, ignore_zero=False)
159
 
        log = self._get_log(keep_log_file=True)
160
 
        self.failUnless('All changes applied successfully.\n' in log)
 
162
        self.failUnless('All changes applied successfully.\n' in self.get_log())
161
163
 
162
164
    def test_merge_inner_conflicts(self):
163
165
        tree_a = self.make_branch_and_tree('a')
293
295
        tree_a.commit('commit 2')
294
296
        tree_b = tree_a.bzrdir.sprout('b').open_workingtree()
295
297
        tree_b.rename_one('file_1', 'renamed')
296
 
        merger = _mod_merge.Merger.from_uncommitted(tree_a, tree_b,
297
 
                                                    progress.DummyProgress())
 
298
        merger = _mod_merge.Merger.from_uncommitted(tree_a, tree_b)
298
299
        merger.merge_type = _mod_merge.Merge3Merger
299
300
        merger.do_merge()
300
301
        self.assertEqual(tree_a.get_parent_ids(), [tree_b.last_revision()])
308
309
        tree_a.commit('commit 2')
309
310
        tree_b = tree_a.bzrdir.sprout('b').open_workingtree()
310
311
        tree_b.rename_one('file_1', 'renamed')
311
 
        merger = _mod_merge.Merger.from_uncommitted(tree_a, tree_b,
312
 
                                                    progress.DummyProgress())
 
312
        merger = _mod_merge.Merger.from_uncommitted(tree_a, tree_b)
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
 
 
322
317
    def prepare_cherrypick(self):
323
318
        """Prepare a pair of trees for cherrypicking tests.
324
319
 
345
340
 
346
341
    def test_weave_cherrypick(self):
347
342
        this_tree, other_tree = self.prepare_cherrypick()
348
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
343
        merger = _mod_merge.Merger.from_revision_ids(None,
349
344
            this_tree, 'rev3b', 'rev2b', other_tree.branch)
350
345
        merger.merge_type = _mod_merge.WeaveMerger
351
346
        merger.do_merge()
353
348
 
354
349
    def test_weave_cannot_reverse_cherrypick(self):
355
350
        this_tree, other_tree = self.prepare_cherrypick()
356
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
351
        merger = _mod_merge.Merger.from_revision_ids(None,
357
352
            this_tree, 'rev2b', 'rev3b', other_tree.branch)
358
353
        merger.merge_type = _mod_merge.WeaveMerger
359
354
        self.assertRaises(errors.CannotReverseCherrypick, merger.do_merge)
360
355
 
361
356
    def test_merge3_can_reverse_cherrypick(self):
362
357
        this_tree, other_tree = self.prepare_cherrypick()
363
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
358
        merger = _mod_merge.Merger.from_revision_ids(None,
364
359
            this_tree, 'rev2b', 'rev3b', other_tree.branch)
365
360
        merger.merge_type = _mod_merge.Merge3Merger
366
361
        merger.do_merge()
378
373
        this_tree.lock_write()
379
374
        self.addCleanup(this_tree.unlock)
380
375
 
381
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
376
        merger = _mod_merge.Merger.from_revision_ids(None,
382
377
            this_tree, 'rev3b', 'rev2b', other_tree.branch)
383
378
        merger.merge_type = _mod_merge.Merge3Merger
384
379
        merger.do_merge()
397
392
        other_tree.commit('rev2', rev_id='rev2b')
398
393
        this_tree.lock_write()
399
394
        self.addCleanup(this_tree.unlock)
400
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress,
 
395
        merger = _mod_merge.Merger.from_revision_ids(None,
401
396
            this_tree, 'rev2b', other_branch=other_tree.branch)
402
397
        merger.merge_type = _mod_merge.Merge3Merger
403
398
        tree_merger = merger.make_merger()
417
412
        other_tree.commit('rev2', rev_id='rev2b')
418
413
        this_tree.lock_write()
419
414
        self.addCleanup(this_tree.unlock)
420
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
415
        merger = _mod_merge.Merger.from_revision_ids(None,
421
416
            this_tree, 'rev2b', other_branch=other_tree.branch)
422
417
        merger.merge_type = _mod_merge.Merge3Merger
423
418
        tree_merger = merger.make_merger()
447
442
        other_tree.commit('rev2', rev_id='rev2b')
448
443
        this_tree.lock_write()
449
444
        self.addCleanup(this_tree.unlock)
450
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
445
        merger = _mod_merge.Merger.from_revision_ids(None,
451
446
            this_tree, 'rev2b', other_branch=other_tree.branch)
452
447
        merger.merge_type = _mod_merge.Merge3Merger
453
448
        tree_merger = merger.make_merger()
524
519
        self.add_uncommitted_version(('root', 'C:'), [('root', 'A')], 'fabg')
525
520
        return _PlanMerge('B:', 'C:', self.plan_merge_vf, ('root',))
526
521
 
 
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
 
527
528
    def test_unique_lines(self):
528
529
        plan = self.setup_plan_merge()
529
530
        self.assertEqual(plan._unique_lines(
827
828
                          ('unchanged', 'f\n'),
828
829
                          ('unchanged', 'g\n')],
829
830
                         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()))
830
936
 
831
937
    def assertRemoveExternalReferences(self, filtered_parent_map,
832
938
                                       child_map, tails, parent_map):
1032
1138
                         ], list(plan))
1033
1139
 
1034
1140
 
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
 
 
1187
1141
class LoggingMerger(object):
1188
1142
    # These seem to be the required attributes
1189
1143
    requires_base = False
1244
1198
        mem_tree = memorytree.MemoryTree.create_on_branch(builder.get_branch())
1245
1199
        mem_tree.lock_write()
1246
1200
        self.addCleanup(mem_tree.unlock)
1247
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
1201
        merger = _mod_merge.Merger.from_revision_ids(None,
1248
1202
            mem_tree, other_revision_id)
1249
1203
        merger.set_interesting_files(interesting_files)
1250
1204
        # It seems there is no matching function for set_interesting_ids
2024
1978
 
2025
1979
    def do_merge(self, builder, other_revision_id):
2026
1980
        wt = self.get_wt_from_builder(builder)
2027
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
1981
        merger = _mod_merge.Merger.from_revision_ids(None,
2028
1982
            wt, other_revision_id)
2029
1983
        merger.merge_type = _mod_merge.Merge3Merger
2030
1984
        return wt, merger.do_merge()
2290
2244
        wt.commit('D merges B & C', rev_id='D-id')
2291
2245
        self.assertEqual('barry', wt.id2path('foo-id'))
2292
2246
        # Check the output of the Merger object directly
2293
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
2247
        merger = _mod_merge.Merger.from_revision_ids(None,
2294
2248
            wt, 'F-id')
2295
2249
        merger.merge_type = _mod_merge.Merge3Merger
2296
2250
        merge_obj = merger.make_merger()
2346
2300
        wt.commit('F foo => bing', rev_id='F-id')
2347
2301
 
2348
2302
        # Check the output of the Merger object directly
2349
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
2303
        merger = _mod_merge.Merger.from_revision_ids(None,
2350
2304
            wt, 'E-id')
2351
2305
        merger.merge_type = _mod_merge.Merge3Merger
2352
2306
        merge_obj = merger.make_merger()
2397
2351
        list(wt.iter_changes(wt.basis_tree()))
2398
2352
        wt.commit('D merges B & C, makes it a file', rev_id='D-id')
2399
2353
 
2400
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
2354
        merger = _mod_merge.Merger.from_revision_ids(None,
2401
2355
            wt, 'E-id')
2402
2356
        merger.merge_type = _mod_merge.Merge3Merger
2403
2357
        merge_obj = merger.make_merger()
2612
2566
        wt.branch.set_last_revision_info(2, 'B-id')
2613
2567
        wt.commit('D', rev_id='D-id', recursive=None)
2614
2568
 
2615
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
2569
        merger = _mod_merge.Merger.from_revision_ids(None,
2616
2570
            wt, 'E-id')
2617
2571
        merger.merge_type = _mod_merge.Merge3Merger
2618
2572
        merge_obj = merger.make_merger()
2649
2603
        wt.branch.set_last_revision_info(2, 'B-id')
2650
2604
        wt.commit('D', rev_id='D-id', recursive=None)
2651
2605
 
2652
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
2606
        merger = _mod_merge.Merger.from_revision_ids(None,
2653
2607
            wt, 'E-id')
2654
2608
        merger.merge_type = _mod_merge.Merge3Merger
2655
2609
        merge_obj = merger.make_merger()
2689
2643
        wt.branch.set_last_revision_info(2, 'B-id')
2690
2644
        wt.commit('D', rev_id='D-id', recursive=None)
2691
2645
 
2692
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
2646
        merger = _mod_merge.Merger.from_revision_ids(None,
2693
2647
            wt, 'E-id')
2694
2648
        merger.merge_type = _mod_merge.Merge3Merger
2695
2649
        merge_obj = merger.make_merger()
2734
2688
        wt.branch.set_last_revision_info(2, 'B-id')
2735
2689
        wt.commit('D', rev_id='D-id', recursive=None)
2736
2690
 
2737
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
2691
        merger = _mod_merge.Merger.from_revision_ids(None,
2738
2692
            wt, 'E-id')
2739
2693
        merger.merge_type = _mod_merge.Merge3Merger
2740
2694
        merge_obj = merger.make_merger()
2876
2830
            'bval', ['lca1val', 'lca2val', 'lca2val'], 'oval', 'tval')
2877
2831
        self.assertLCAMultiWay('conflict',
2878
2832
            '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)