← 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 Ferlito
  • Date: 2009-05-25 10:59:42 UTC
  • mto: (4665.4.1 ppa-doc)
  • mto: This revision was merged to the branch mainline in revision 4693.
  • Revision ID: johnf@inodes.org-20090525105942-5xkcbe37m1u5lp5z
Update packaging scripts to make deployment a bit easier
Update documentation for deploying to PPA

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_merge.py
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
 
43
40
 
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')
220
218
        tree_a.add('file')
221
219
        tree_a.commit('commit base')
222
220
        # basis_tree() is only guaranteed to be valid as long as it is actually
223
 
        # the basis tree. This test commits to the tree after grabbing basis,
224
 
        # so we go to the repository.
 
221
        # the basis tree. This mutates the tree after grabbing basis, so go to
 
222
        # the repository.
225
223
        base_tree = tree_a.branch.repository.revision_tree(tree_a.last_revision())
226
224
        tree_b = tree_a.bzrdir.sprout('tree_b').open_workingtree()
227
225
        self.build_tree_contents([('tree_a/file', 'content_2')])
228
226
        tree_a.commit('commit other')
229
227
        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.
232
228
        os.unlink('tree_b/file')
233
229
        merge_inner(tree_b.branch, other_tree, base_tree, this_tree=tree_b)
234
230
 
526
522
        self.add_uncommitted_version(('root', 'C:'), [('root', 'A')], 'fabg')
527
523
        return _PlanMerge('B:', 'C:', self.plan_merge_vf, ('root',))
528
524
 
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
 
 
535
525
    def test_unique_lines(self):
536
526
        plan = self.setup_plan_merge()
537
527
        self.assertEqual(plan._unique_lines(
835
825
                          ('unchanged', 'f\n'),
836
826
                          ('unchanged', 'g\n')],
837
827
                         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()))
943
828
 
944
829
    def assertRemoveExternalReferences(self, filtered_parent_map,
945
830
                                       child_map, tails, parent_map):
1145
1030
                         ], list(plan))
1146
1031
 
1147
1032
 
 
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
 
1148
1164
class LoggingMerger(object):
1149
1165
    # These seem to be the required attributes
1150
1166
    requires_base = False
1216
1232
 
1217
1233
class TestMergerInMemory(TestMergerBase):
1218
1234
 
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
 
 
1240
1235
    def test_find_base(self):
1241
1236
        merger = self.make_Merger(self.setup_simple_graph(), 'C-id')
1242
1237
        self.assertEqual('A-id', merger.base_rev_id)
2837
2832
            'bval', ['lca1val', 'lca2val', 'lca2val'], 'oval', 'tval')
2838
2833
        self.assertLCAMultiWay('conflict',
2839
2834
            'bval', ['lca1val', 'lca2val', 'lca3val'], 'oval', 'tval')
2840
 
 
2841
 
 
2842
 
class TestConfigurableFileMerger(tests.TestCaseWithTransport):
2843
 
 
2844
 
    def test_affected_files_cached(self):
2845
 
        """Ensures that the config variable is cached"""
2846
 
        class SimplePlan(_mod_merge.ConfigurableFileMerger):
2847
 
            name_prefix = "foo"
2848
 
            default_files = ["my default"]
2849
 
            def merge_text(self, params):
2850
 
                return ('not applicable', None)
2851
 
        def factory(merger):
2852
 
            result = SimplePlan(merger)
2853
 
            self.assertEqual(None, result.affected_files)
2854
 
            self.merger = result
2855
 
            return result
2856
 
        _mod_merge.Merger.hooks.install_named_hook('merge_file_content',
2857
 
            factory, 'test factory')
2858
 
        builder = test_merge_core.MergeBuilder(self.test_base_dir)
2859
 
        self.addCleanup(builder.cleanup)
2860
 
        builder.add_file('NEWS', builder.tree_root, 'name1', 'text1', True)
2861
 
        builder.change_contents('NEWS', other='text4', this='text3')
2862
 
        conflicts = builder.merge()
2863
 
        # The hook should set the variable
2864
 
        self.assertEqual(["my default"], self.merger.affected_files)