← 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: Ian Clatworthy
  • Date: 2010-02-19 03:02:07 UTC
  • mto: (4797.23.1 integration-2.1)
  • mto: This revision was merged to the branch mainline in revision 5055.
  • Revision ID: ian.clatworthy@canonical.com-20100219030207-zpbzx021zavx4sqt
What's New in 2.1 - a summary of changes since 2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_merge.py
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
42
 
40
43
 
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')
218
220
        tree_a.add('file')
219
221
        tree_a.commit('commit base')
220
222
        # basis_tree() is only guaranteed to be valid as long as it is actually
221
 
        # the basis tree. This mutates the tree after grabbing basis, so go to
222
 
        # the repository.
 
223
        # the basis tree. This test commits to the tree after grabbing basis,
 
224
        # so we go to the repository.
223
225
        base_tree = tree_a.branch.repository.revision_tree(tree_a.last_revision())
224
226
        tree_b = tree_a.bzrdir.sprout('tree_b').open_workingtree()
225
227
        self.build_tree_contents([('tree_a/file', 'content_2')])
226
228
        tree_a.commit('commit other')
227
229
        other_tree = tree_a.basis_tree()
 
230
        # 'file' is now missing but isn't altered in any commit in b so no
 
231
        # change should be applied.
228
232
        os.unlink('tree_b/file')
229
233
        merge_inner(tree_b.branch, other_tree, base_tree, this_tree=tree_b)
230
234
 
522
526
        self.add_uncommitted_version(('root', 'C:'), [('root', 'A')], 'fabg')
523
527
        return _PlanMerge('B:', 'C:', self.plan_merge_vf, ('root',))
524
528
 
 
529
    def test_base_from_plan(self):
 
530
        self.setup_plan_merge()
 
531
        plan = self.plan_merge_vf.plan_merge('B', 'C')
 
532
        pwm = versionedfile.PlanWeaveMerge(plan)
 
533
        self.assertEqual(['a\n', 'b\n', 'c\n'], pwm.base_from_plan())
 
534
 
525
535
    def test_unique_lines(self):
526
536
        plan = self.setup_plan_merge()
527
537
        self.assertEqual(plan._unique_lines(
825
835
                          ('unchanged', 'f\n'),
826
836
                          ('unchanged', 'g\n')],
827
837
                         list(plan))
 
838
        plan = self.plan_merge_vf.plan_lca_merge('F', 'G')
 
839
        # This is one of the main differences between plan_merge and
 
840
        # plan_lca_merge. plan_lca_merge generates a conflict for 'x => z',
 
841
        # because 'x' was not present in one of the bases. However, in this
 
842
        # case it is spurious because 'x' does not exist in the global base A.
 
843
        self.assertEqual([
 
844
                          ('unchanged', 'h\n'),
 
845
                          ('unchanged', 'a\n'),
 
846
                          ('conflicted-a', 'x\n'),
 
847
                          ('new-b', 'z\n'),
 
848
                          ('unchanged', 'c\n'),
 
849
                          ('unchanged', 'd\n'),
 
850
                          ('unchanged', 'y\n'),
 
851
                          ('unchanged', 'f\n'),
 
852
                          ('unchanged', 'g\n')],
 
853
                         list(plan))
 
854
 
 
855
    def test_criss_cross_flip_flop(self):
 
856
        # This is specificly trying to trigger problems when using limited
 
857
        # ancestry and weaves. The ancestry graph looks like:
 
858
        #       XX      unused ancestor, should not show up in the weave
 
859
        #       |
 
860
        #       A       Unique LCA
 
861
        #      / \  
 
862
        #     B   C     B & C both introduce a new line
 
863
        #     |\ /|  
 
864
        #     | X |  
 
865
        #     |/ \| 
 
866
        #     D   E     B & C are both merged, so both are common ancestors
 
867
        #               In the process of merging, both sides order the new
 
868
        #               lines differently
 
869
        #
 
870
        self.add_rev('root', 'XX', [], 'qrs')
 
871
        self.add_rev('root', 'A', ['XX'], 'abcdef')
 
872
        self.add_rev('root', 'B', ['A'], 'abcdgef')
 
873
        self.add_rev('root', 'C', ['A'], 'abcdhef')
 
874
        self.add_rev('root', 'D', ['B', 'C'], 'abcdghef')
 
875
        self.add_rev('root', 'E', ['C', 'B'], 'abcdhgef')
 
876
        plan = list(self.plan_merge_vf.plan_merge('D', 'E'))
 
877
        self.assertEqual([
 
878
                          ('unchanged', 'a\n'),
 
879
                          ('unchanged', 'b\n'),
 
880
                          ('unchanged', 'c\n'),
 
881
                          ('unchanged', 'd\n'),
 
882
                          ('new-b', 'h\n'),
 
883
                          ('unchanged', 'g\n'),
 
884
                          ('killed-b', 'h\n'),
 
885
                          ('unchanged', 'e\n'),
 
886
                          ('unchanged', 'f\n'),
 
887
                         ], plan)
 
888
        pwm = versionedfile.PlanWeaveMerge(plan)
 
889
        self.assertEqualDiff('\n'.join('abcdghef') + '\n',
 
890
                             ''.join(pwm.base_from_plan()))
 
891
        # Reversing the order reverses the merge plan, and final order of 'hg'
 
892
        # => 'gh'
 
893
        plan = list(self.plan_merge_vf.plan_merge('E', 'D'))
 
894
        self.assertEqual([
 
895
                          ('unchanged', 'a\n'),
 
896
                          ('unchanged', 'b\n'),
 
897
                          ('unchanged', 'c\n'),
 
898
                          ('unchanged', 'd\n'),
 
899
                          ('new-b', 'g\n'),
 
900
                          ('unchanged', 'h\n'),
 
901
                          ('killed-b', 'g\n'),
 
902
                          ('unchanged', 'e\n'),
 
903
                          ('unchanged', 'f\n'),
 
904
                         ], plan)
 
905
        pwm = versionedfile.PlanWeaveMerge(plan)
 
906
        self.assertEqualDiff('\n'.join('abcdhgef') + '\n',
 
907
                             ''.join(pwm.base_from_plan()))
 
908
        # This is where lca differs, in that it (fairly correctly) determines
 
909
        # that there is a conflict because both sides resolved the merge
 
910
        # differently
 
911
        plan = list(self.plan_merge_vf.plan_lca_merge('D', 'E'))
 
912
        self.assertEqual([
 
913
                          ('unchanged', 'a\n'),
 
914
                          ('unchanged', 'b\n'),
 
915
                          ('unchanged', 'c\n'),
 
916
                          ('unchanged', 'd\n'),
 
917
                          ('conflicted-b', 'h\n'),
 
918
                          ('unchanged', 'g\n'),
 
919
                          ('conflicted-a', 'h\n'),
 
920
                          ('unchanged', 'e\n'),
 
921
                          ('unchanged', 'f\n'),
 
922
                         ], plan)
 
923
        pwm = versionedfile.PlanWeaveMerge(plan)
 
924
        self.assertEqualDiff('\n'.join('abcdgef') + '\n',
 
925
                             ''.join(pwm.base_from_plan()))
 
926
        # Reversing it changes what line is doubled, but still gives a
 
927
        # double-conflict
 
928
        plan = list(self.plan_merge_vf.plan_lca_merge('E', 'D'))
 
929
        self.assertEqual([
 
930
                          ('unchanged', 'a\n'),
 
931
                          ('unchanged', 'b\n'),
 
932
                          ('unchanged', 'c\n'),
 
933
                          ('unchanged', 'd\n'),
 
934
                          ('conflicted-b', 'g\n'),
 
935
                          ('unchanged', 'h\n'),
 
936
                          ('conflicted-a', 'g\n'),
 
937
                          ('unchanged', 'e\n'),
 
938
                          ('unchanged', 'f\n'),
 
939
                         ], plan)
 
940
        pwm = versionedfile.PlanWeaveMerge(plan)
 
941
        self.assertEqualDiff('\n'.join('abcdhef') + '\n',
 
942
                             ''.join(pwm.base_from_plan()))
828
943
 
829
944
    def assertRemoveExternalReferences(self, filtered_parent_map,
830
945
                                       child_map, tails, parent_map):
1030
1145
                         ], list(plan))
1031
1146
 
1032
1147
 
1033
 
class TestMergeImplementation(object):
1034
 
 
1035
 
    def do_merge(self, target_tree, source_tree, **kwargs):
1036
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
1037
 
            target_tree, source_tree.last_revision(),
1038
 
            other_branch=source_tree.branch)
1039
 
        merger.merge_type=self.merge_type
1040
 
        for name, value in kwargs.items():
1041
 
            setattr(merger, name, value)
1042
 
        merger.do_merge()
1043
 
 
1044
 
    def test_merge_specific_file(self):
1045
 
        this_tree = self.make_branch_and_tree('this')
1046
 
        this_tree.lock_write()
1047
 
        self.addCleanup(this_tree.unlock)
1048
 
        self.build_tree_contents([
1049
 
            ('this/file1', 'a\nb\n'),
1050
 
            ('this/file2', 'a\nb\n')
1051
 
        ])
1052
 
        this_tree.add(['file1', 'file2'])
1053
 
        this_tree.commit('Added files')
1054
 
        other_tree = this_tree.bzrdir.sprout('other').open_workingtree()
1055
 
        self.build_tree_contents([
1056
 
            ('other/file1', 'a\nb\nc\n'),
1057
 
            ('other/file2', 'a\nb\nc\n')
1058
 
        ])
1059
 
        other_tree.commit('modified both')
1060
 
        self.build_tree_contents([
1061
 
            ('this/file1', 'd\na\nb\n'),
1062
 
            ('this/file2', 'd\na\nb\n')
1063
 
        ])
1064
 
        this_tree.commit('modified both')
1065
 
        self.do_merge(this_tree, other_tree, interesting_files=['file1'])
1066
 
        self.assertFileEqual('d\na\nb\nc\n', 'this/file1')
1067
 
        self.assertFileEqual('d\na\nb\n', 'this/file2')
1068
 
 
1069
 
    def test_merge_move_and_change(self):
1070
 
        this_tree = self.make_branch_and_tree('this')
1071
 
        this_tree.lock_write()
1072
 
        self.addCleanup(this_tree.unlock)
1073
 
        self.build_tree_contents([
1074
 
            ('this/file1', 'line 1\nline 2\nline 3\nline 4\n'),
1075
 
        ])
1076
 
        this_tree.add('file1',)
1077
 
        this_tree.commit('Added file')
1078
 
        other_tree = this_tree.bzrdir.sprout('other').open_workingtree()
1079
 
        self.build_tree_contents([
1080
 
            ('other/file1', 'line 1\nline 2 to 2.1\nline 3\nline 4\n'),
1081
 
        ])
1082
 
        other_tree.commit('Changed 2 to 2.1')
1083
 
        self.build_tree_contents([
1084
 
            ('this/file1', 'line 1\nline 3\nline 2\nline 4\n'),
1085
 
        ])
1086
 
        this_tree.commit('Swapped 2 & 3')
1087
 
        self.do_merge(this_tree, other_tree)
1088
 
        self.assertFileEqual('line 1\n'
1089
 
            '<<<<<<< TREE\n'
1090
 
            'line 3\n'
1091
 
            'line 2\n'
1092
 
            '=======\n'
1093
 
            'line 2 to 2.1\n'
1094
 
            'line 3\n'
1095
 
            '>>>>>>> MERGE-SOURCE\n'
1096
 
            'line 4\n', 'this/file1')
1097
 
 
1098
 
    def test_modify_conflicts_with_delete(self):
1099
 
        # If one side deletes a line, and the other modifies that line, then
1100
 
        # the modification should be considered a conflict
1101
 
        builder = self.make_branch_builder('test')
1102
 
        builder.start_series()
1103
 
        builder.build_snapshot('BASE-id', None,
1104
 
            [('add', ('', None, 'directory', None)),
1105
 
             ('add', ('foo', 'foo-id', 'file', 'a\nb\nc\nd\ne\n')),
1106
 
            ])
1107
 
        # Delete 'b\n'
1108
 
        builder.build_snapshot('OTHER-id', ['BASE-id'],
1109
 
            [('modify', ('foo-id', 'a\nc\nd\ne\n'))])
1110
 
        # Modify 'b\n', add 'X\n'
1111
 
        builder.build_snapshot('THIS-id', ['BASE-id'],
1112
 
            [('modify', ('foo-id', 'a\nb2\nc\nd\nX\ne\n'))])
1113
 
        builder.finish_series()
1114
 
        branch = builder.get_branch()
1115
 
        this_tree = branch.bzrdir.create_workingtree()
1116
 
        this_tree.lock_write()
1117
 
        self.addCleanup(this_tree.unlock)
1118
 
        other_tree = this_tree.bzrdir.sprout('other', 'OTHER-id').open_workingtree()
1119
 
        self.do_merge(this_tree, other_tree)
1120
 
        if self.merge_type is _mod_merge.LCAMerger:
1121
 
            self.expectFailure("lca merge doesn't track deleted lines",
1122
 
                self.assertFileEqual,
1123
 
                    'a\n'
1124
 
                    '<<<<<<< TREE\n'
1125
 
                    'b2\n'
1126
 
                    '=======\n'
1127
 
                    '>>>>>>> MERGE-SOURCE\n'
1128
 
                    'c\n'
1129
 
                    'd\n'
1130
 
                    'X\n'
1131
 
                    'e\n', 'test/foo')
1132
 
        else:
1133
 
            self.assertFileEqual(
1134
 
                'a\n'
1135
 
                '<<<<<<< TREE\n'
1136
 
                'b2\n'
1137
 
                '=======\n'
1138
 
                '>>>>>>> MERGE-SOURCE\n'
1139
 
                'c\n'
1140
 
                'd\n'
1141
 
                'X\n'
1142
 
                'e\n', 'test/foo')
1143
 
 
1144
 
 
1145
 
class TestMerge3Merge(TestCaseWithTransport, TestMergeImplementation):
1146
 
 
1147
 
    merge_type = _mod_merge.Merge3Merger
1148
 
 
1149
 
 
1150
 
class TestWeaveMerge(TestCaseWithTransport, TestMergeImplementation):
1151
 
 
1152
 
    merge_type = _mod_merge.WeaveMerger
1153
 
 
1154
 
 
1155
 
class TestLCAMerge(TestCaseWithTransport, TestMergeImplementation):
1156
 
 
1157
 
    merge_type = _mod_merge.LCAMerger
1158
 
 
1159
 
    def test_merge_move_and_change(self):
1160
 
        self.expectFailure("lca merge doesn't conflict for move and change",
1161
 
            super(TestLCAMerge, self).test_merge_move_and_change)
1162
 
 
1163
 
 
1164
1148
class LoggingMerger(object):
1165
1149
    # These seem to be the required attributes
1166
1150
    requires_base = False
1232
1216
 
1233
1217
class TestMergerInMemory(TestMergerBase):
1234
1218
 
 
1219
    def test_cache_trees_with_revision_ids_None(self):
 
1220
        merger = self.make_Merger(self.setup_simple_graph(), 'C-id')
 
1221
        original_cache = dict(merger._cached_trees)
 
1222
        merger.cache_trees_with_revision_ids([None])
 
1223
        self.assertEqual(original_cache, merger._cached_trees)
 
1224
 
 
1225
    def test_cache_trees_with_revision_ids_no_revision_id(self):
 
1226
        merger = self.make_Merger(self.setup_simple_graph(), 'C-id')
 
1227
        original_cache = dict(merger._cached_trees)
 
1228
        tree = self.make_branch_and_memory_tree('tree')
 
1229
        merger.cache_trees_with_revision_ids([tree])
 
1230
        self.assertEqual(original_cache, merger._cached_trees)
 
1231
 
 
1232
    def test_cache_trees_with_revision_ids_having_revision_id(self):
 
1233
        merger = self.make_Merger(self.setup_simple_graph(), 'C-id')
 
1234
        original_cache = dict(merger._cached_trees)
 
1235
        tree = merger.this_branch.repository.revision_tree('B-id')
 
1236
        original_cache['B-id'] = tree
 
1237
        merger.cache_trees_with_revision_ids([tree])
 
1238
        self.assertEqual(original_cache, merger._cached_trees)
 
1239
 
1235
1240
    def test_find_base(self):
1236
1241
        merger = self.make_Merger(self.setup_simple_graph(), 'C-id')
1237
1242
        self.assertEqual('A-id', merger.base_rev_id)
2832
2837
            'bval', ['lca1val', 'lca2val', 'lca2val'], 'oval', 'tval')
2833
2838
        self.assertLCAMultiWay('conflict',
2834
2839
            'bval', ['lca1val', 'lca2val', 'lca3val'], 'oval', 'tval')
 
2840
 
 
2841
 
 
2842
class TestConfigurableFileMerger(tests.TestCaseWithTransport):
 
2843
 
 
2844
    def setUp(self):
 
2845
        super(TestConfigurableFileMerger, self).setUp()
 
2846
        self.calls = []
 
2847
 
 
2848
    def get_merger_factory(self):
 
2849
        # Allows  the inner methods to access the test attributes
 
2850
        test = self
 
2851
 
 
2852
        class FooMerger(_mod_merge.ConfigurableFileMerger):
 
2853
            name_prefix = "foo"
 
2854
            default_files = ['bar']
 
2855
 
 
2856
            def merge_text(self, params):
 
2857
                test.calls.append('merge_text')
 
2858
                return ('not_applicable', None)
 
2859
 
 
2860
        def factory(merger):
 
2861
            result = FooMerger(merger)
 
2862
            # Make sure we start with a clean slate
 
2863
            self.assertEqual(None, result.affected_files)
 
2864
            # Track the original merger
 
2865
            self.merger = result
 
2866
            return result
 
2867
 
 
2868
        return factory
 
2869
 
 
2870
    def _install_hook(self, factory):
 
2871
        _mod_merge.Merger.hooks.install_named_hook('merge_file_content',
 
2872
                                                   factory, 'test factory')
 
2873
 
 
2874
    def make_builder(self):
 
2875
        builder = test_merge_core.MergeBuilder(self.test_base_dir)
 
2876
        self.addCleanup(builder.cleanup)
 
2877
        return builder
 
2878
 
 
2879
    def make_text_conflict(self, file_name='bar'):
 
2880
        factory = self.get_merger_factory()
 
2881
        self._install_hook(factory)
 
2882
        builder = self.make_builder()
 
2883
        builder.add_file('bar-id', builder.tree_root, file_name, 'text1', True)
 
2884
        builder.change_contents('bar-id', other='text4', this='text3')
 
2885
        return builder
 
2886
 
 
2887
    def make_kind_change(self):
 
2888
        factory = self.get_merger_factory()
 
2889
        self._install_hook(factory)
 
2890
        builder = self.make_builder()
 
2891
        builder.add_file('bar-id', builder.tree_root, 'bar', 'text1', True,
 
2892
                         this=False)
 
2893
        builder.add_dir('bar-dir', builder.tree_root, 'bar-id',
 
2894
                        base=False, other=False)
 
2895
        return builder
 
2896
 
 
2897
    def test_uses_this_branch(self):
 
2898
        builder = self.make_text_conflict()
 
2899
        tt = builder.make_preview_transform()
 
2900
        self.addCleanup(tt.finalize)
 
2901
 
 
2902
    def test_affected_files_cached(self):
 
2903
        """Ensures that the config variable is cached"""
 
2904
        builder = self.make_text_conflict()
 
2905
        conflicts = builder.merge()
 
2906
        # The hook should set the variable
 
2907
        self.assertEqual(['bar'], self.merger.affected_files)
 
2908
        self.assertEqual(1, len(conflicts))
 
2909
 
 
2910
    def test_hook_called_for_text_conflicts(self):
 
2911
        builder = self.make_text_conflict()
 
2912
        conflicts = builder.merge()
 
2913
        # The hook should call the merge_text() method
 
2914
        self.assertEqual(['merge_text'], self.calls)
 
2915
 
 
2916
    def test_hook_not_called_for_kind_change(self):
 
2917
        builder = self.make_kind_change()
 
2918
        conflicts = builder.merge()
 
2919
        # The hook should not call the merge_text() method
 
2920
        self.assertEqual([], self.calls)
 
2921
 
 
2922
    def test_hook_not_called_for_other_files(self):
 
2923
        builder = self.make_text_conflict('foobar')
 
2924
        conflicts = builder.merge()
 
2925
        # The hook should not call the merge_text() method
 
2926
        self.assertEqual([], self.calls)