← 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: Canonical.com Patch Queue Manager
  • Date: 2008-05-29 15:57:16 UTC
  • mfrom: (3427.5.9 dep_warnings)
  • Revision ID: pqm@pqm.ubuntu.com-20080529155716-0w3kic8lioa63231
(jam) Enable Deprecation Warnings when running -Werror and when
        running selftest

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
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
1
17
import os
2
18
from StringIO import StringIO
3
19
 
 
20
from bzrlib import (
 
21
    conflicts,
 
22
    errors,
 
23
    knit,
 
24
    merge as _mod_merge,
 
25
    option,
 
26
    progress,
 
27
    transform,
 
28
    versionedfile,
 
29
    )
4
30
from bzrlib.branch import Branch
5
 
from bzrlib.builtins import merge
6
 
from bzrlib.commit import commit
 
31
from bzrlib.conflicts import ConflictList, TextConflict
7
32
from bzrlib.errors import UnrelatedBranches, NoCommits, BzrCommandError
8
 
from bzrlib.merge import transform_tree, merge_inner
9
 
from bzrlib.osutils import pathjoin
10
 
from bzrlib.revision import common_ancestor
11
 
from bzrlib.tests import TestCaseWithTransport
 
33
from bzrlib.merge import transform_tree, merge_inner, _PlanMerge
 
34
from bzrlib.osutils import pathjoin, file_kind
 
35
from bzrlib.tests import TestCaseWithTransport, TestCaseWithMemoryTransport
12
36
from bzrlib.trace import (enable_test_log, disable_test_log)
13
37
from bzrlib.workingtree import WorkingTree
14
38
 
18
42
 
19
43
    def test_pending(self):
20
44
        wt = self.make_branch_and_tree('.')
21
 
        wt.commit("lala!")
22
 
        self.assertEquals(len(wt.pending_merges()), 0)
23
 
        merge([u'.', -1], [None, None])
24
 
        self.assertEquals(len(wt.pending_merges()), 0)
 
45
        rev_a = wt.commit("lala!")
 
46
        self.assertEqual([rev_a], wt.get_parent_ids())
 
47
        self.assertRaises(errors.PointlessMerge, wt.merge_from_branch,
 
48
                          wt.branch)
 
49
        self.assertEqual([rev_a], wt.get_parent_ids())
 
50
        return wt
25
51
 
26
52
    def test_undo(self):
27
53
        wt = self.make_branch_and_tree('.')
28
54
        wt.commit("lala!")
29
55
        wt.commit("haha!")
30
56
        wt.commit("blabla!")
31
 
        merge([u'.', 2], [u'.', 1])
 
57
        wt.merge_from_branch(wt.branch, wt.branch.get_rev_id(2),
 
58
                             wt.branch.get_rev_id(1))
32
59
 
33
60
    def test_nocommits(self):
34
 
        self.test_pending()
 
61
        wt = self.test_pending()
35
62
        wt2 = self.make_branch_and_tree('branch2')
36
 
        self.assertRaises(NoCommits, merge, ['branch2', -1], 
37
 
                          [None, None])
38
 
        return wt2
 
63
        self.assertRaises(NoCommits, wt.merge_from_branch, wt2.branch)
 
64
        return wt, wt2
39
65
 
40
66
    def test_unrelated(self):
41
 
        wt2 = self.test_nocommits()
 
67
        wt, wt2 = self.test_nocommits()
42
68
        wt2.commit("blah")
43
 
        self.assertRaises(UnrelatedBranches, merge, ['branch2', -1], 
44
 
                          [None, None])
 
69
        self.assertRaises(UnrelatedBranches, wt.merge_from_branch, wt2.branch)
45
70
        return wt2
46
71
 
47
 
    def test_merge_one(self):
 
72
    def test_merge_one_file(self):
 
73
        """Do a partial merge of a tree which should not affect tree parents."""
48
74
        wt1 = self.make_branch_and_tree('branch1')
49
 
        wt1.commit('empty commit')
 
75
        tip = wt1.commit('empty commit')
50
76
        wt2 = self.make_branch_and_tree('branch2')
51
77
        wt2.pull(wt1.branch)
52
78
        file('branch1/foo', 'wb').write('foo')
55
81
        wt1.add('bar')
56
82
        wt1.commit('add foobar')
57
83
        os.chdir('branch2')
58
 
        self.run_bzr('merge', '../branch1/baz', retcode=3)
59
 
        self.run_bzr('merge', '../branch1/foo')
 
84
        self.run_bzr('merge ../branch1/baz', retcode=3)
 
85
        self.run_bzr('merge ../branch1/foo')
60
86
        self.failUnlessExists('foo')
61
87
        self.failIfExists('bar')
62
 
        wt2 = WorkingTree.open_containing('branch2')[0]
63
 
        self.assertEqual(wt2.pending_merges(), [])
64
 
 
 
88
        wt2 = WorkingTree.open('.') # opens branch2
 
89
        self.assertEqual([tip], wt2.get_parent_ids())
 
90
        
65
91
    def test_pending_with_null(self):
66
 
        """When base is forced to revno 0, pending_merges is set"""
 
92
        """When base is forced to revno 0, parent_ids are set"""
67
93
        wt2 = self.test_unrelated()
68
94
        wt1 = WorkingTree.open('.')
69
95
        br1 = wt1.branch
70
96
        br1.fetch(wt2.branch)
71
97
        # merge all of branch 2 into branch 1 even though they 
72
98
        # are not related.
73
 
        self.assertRaises(BzrCommandError, merge, ['branch2', -1], 
74
 
                          ['branch2', 0], reprocess=True, show_base=True)
75
 
        merge(['branch2', -1], ['branch2', 0], reprocess=True)
76
 
        self.assertEquals(len(wt1.pending_merges()), 1)
 
99
        wt1.merge_from_branch(wt2.branch, wt2.last_revision(), 'null:')
 
100
        self.assertEqual([br1.last_revision(), wt2.branch.last_revision()],
 
101
            wt1.get_parent_ids())
77
102
        return (wt1, wt2.branch)
78
103
 
79
104
    def test_two_roots(self):
80
105
        """Merge base is sane when two unrelated branches are merged"""
81
106
        wt1, br2 = self.test_pending_with_null()
82
107
        wt1.commit("blah")
83
 
        last = wt1.branch.last_revision()
84
 
        self.assertEquals(common_ancestor(last, last, wt1.branch.repository), last)
 
108
        wt1.lock_read()
 
109
        try:
 
110
            last = wt1.branch.last_revision()
 
111
            last2 = br2.last_revision()
 
112
            graph = wt1.branch.repository.get_graph()
 
113
            self.assertEqual(last2, graph.find_unique_lca(last, last2))
 
114
        finally:
 
115
            wt1.unlock()
85
116
 
86
117
    def test_create_rename(self):
87
118
        """Rename an inventory entry while creating the file"""
108
139
        transform_tree(tree, tree.branch.basis_tree())
109
140
 
110
141
    def test_ignore_zero_merge_inner(self):
111
 
        # Test that merge_inner's ignore zero paramter is effective
 
142
        # Test that merge_inner's ignore zero parameter is effective
112
143
        tree_a =self.make_branch_and_tree('a')
113
144
        tree_a.commit(message="hello")
114
145
        dir_b = tree_a.bzrdir.sprout('b')
115
146
        tree_b = dir_b.open_workingtree()
 
147
        tree_b.lock_write()
 
148
        self.addCleanup(tree_b.unlock)
116
149
        tree_a.commit(message="hello again")
117
150
        log = StringIO()
118
151
        merge_inner(tree_b.branch, tree_a, tree_b.basis_tree(), 
119
152
                    this_tree=tree_b, ignore_zero=True)
120
 
        log = self._get_log()
 
153
        log = self._get_log(keep_log_file=True)
121
154
        self.failUnless('All changes applied successfully.\n' not in log)
122
 
        tree_b.revert([])
 
155
        tree_b.revert()
123
156
        merge_inner(tree_b.branch, tree_a, tree_b.basis_tree(), 
124
157
                    this_tree=tree_b, ignore_zero=False)
125
 
        log = self._get_log()
 
158
        log = self._get_log(keep_log_file=True)
126
159
        self.failUnless('All changes applied successfully.\n' in log)
 
160
 
 
161
    def test_merge_inner_conflicts(self):
 
162
        tree_a = self.make_branch_and_tree('a')
 
163
        tree_a.set_conflicts(ConflictList([TextConflict('patha')]))
 
164
        merge_inner(tree_a.branch, tree_a, tree_a, this_tree=tree_a)
 
165
        self.assertEqual(1, len(tree_a.conflicts()))
 
166
 
 
167
    def test_rmdir_conflict(self):
 
168
        tree_a = self.make_branch_and_tree('a')
 
169
        self.build_tree(['a/b/'])
 
170
        tree_a.add('b', 'b-id')
 
171
        tree_a.commit('added b')
 
172
        # basis_tree() is only guaranteed to be valid as long as it is actually
 
173
        # the basis tree. This mutates the tree after grabbing basis, so go to
 
174
        # the repository.
 
175
        base_tree = tree_a.branch.repository.revision_tree(tree_a.last_revision())
 
176
        tree_z = tree_a.bzrdir.sprout('z').open_workingtree()
 
177
        self.build_tree(['a/b/c'])
 
178
        tree_a.add('b/c')
 
179
        tree_a.commit('added c')
 
180
        os.rmdir('z/b')
 
181
        tree_z.commit('removed b')
 
182
        merge_inner(tree_z.branch, tree_a, base_tree, this_tree=tree_z)
 
183
        self.assertEqual([
 
184
            conflicts.MissingParent('Created directory', 'b', 'b-id'),
 
185
            conflicts.UnversionedParent('Versioned directory', 'b', 'b-id')],
 
186
            tree_z.conflicts())
 
187
        merge_inner(tree_a.branch, tree_z.basis_tree(), base_tree,
 
188
                    this_tree=tree_a)
 
189
        self.assertEqual([
 
190
            conflicts.DeletingParent('Not deleting', 'b', 'b-id'),
 
191
            conflicts.UnversionedParent('Versioned directory', 'b', 'b-id')],
 
192
            tree_a.conflicts())
 
193
 
 
194
    def test_nested_merge(self):
 
195
        tree = self.make_branch_and_tree('tree',
 
196
            format='dirstate-with-subtree')
 
197
        sub_tree = self.make_branch_and_tree('tree/sub-tree',
 
198
            format='dirstate-with-subtree')
 
199
        sub_tree.set_root_id('sub-tree-root')
 
200
        self.build_tree_contents([('tree/sub-tree/file', 'text1')])
 
201
        sub_tree.add('file')
 
202
        sub_tree.commit('foo')
 
203
        tree.add_reference(sub_tree)
 
204
        tree.commit('set text to 1')
 
205
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
 
206
        # modify the file in the subtree
 
207
        self.build_tree_contents([('tree2/sub-tree/file', 'text2')])
 
208
        # and merge the changes from the diverged subtree into the containing
 
209
        # tree
 
210
        tree2.commit('changed file text')
 
211
        tree.merge_from_branch(tree2.branch)
 
212
        self.assertFileEqual('text2', 'tree/sub-tree/file')
 
213
 
 
214
    def test_merge_with_missing(self):
 
215
        tree_a = self.make_branch_and_tree('tree_a')
 
216
        self.build_tree_contents([('tree_a/file', 'content_1')])
 
217
        tree_a.add('file')
 
218
        tree_a.commit('commit base')
 
219
        # basis_tree() is only guaranteed to be valid as long as it is actually
 
220
        # the basis tree. This mutates the tree after grabbing basis, so go to
 
221
        # the repository.
 
222
        base_tree = tree_a.branch.repository.revision_tree(tree_a.last_revision())
 
223
        tree_b = tree_a.bzrdir.sprout('tree_b').open_workingtree()
 
224
        self.build_tree_contents([('tree_a/file', 'content_2')])
 
225
        tree_a.commit('commit other')
 
226
        other_tree = tree_a.basis_tree()
 
227
        os.unlink('tree_b/file')
 
228
        merge_inner(tree_b.branch, other_tree, base_tree, this_tree=tree_b)
 
229
 
 
230
    def test_merge_kind_change(self):
 
231
        tree_a = self.make_branch_and_tree('tree_a')
 
232
        self.build_tree_contents([('tree_a/file', 'content_1')])
 
233
        tree_a.add('file', 'file-id')
 
234
        tree_a.commit('added file')
 
235
        tree_b = tree_a.bzrdir.sprout('tree_b').open_workingtree()
 
236
        os.unlink('tree_a/file')
 
237
        self.build_tree(['tree_a/file/'])
 
238
        tree_a.commit('changed file to directory')
 
239
        tree_b.merge_from_branch(tree_a.branch)
 
240
        self.assertEqual('directory', file_kind('tree_b/file'))
 
241
        tree_b.revert()
 
242
        self.assertEqual('file', file_kind('tree_b/file'))
 
243
        self.build_tree_contents([('tree_b/file', 'content_2')])
 
244
        tree_b.commit('content change')
 
245
        tree_b.merge_from_branch(tree_a.branch)
 
246
        self.assertEqual(tree_b.conflicts(),
 
247
                         [conflicts.ContentsConflict('file',
 
248
                          file_id='file-id')])
 
249
    
 
250
    def test_merge_type_registry(self):
 
251
        merge_type_option = option.Option.OPTIONS['merge-type']
 
252
        self.assertFalse('merge4' in [x[0] for x in 
 
253
                        merge_type_option.iter_switches()])
 
254
        registry = _mod_merge.get_merge_type_registry()
 
255
        registry.register_lazy('merge4', 'bzrlib.merge', 'Merge4Merger',
 
256
                               'time-travelling merge')
 
257
        self.assertTrue('merge4' in [x[0] for x in 
 
258
                        merge_type_option.iter_switches()])
 
259
        registry.remove('merge4')
 
260
        self.assertFalse('merge4' in [x[0] for x in 
 
261
                        merge_type_option.iter_switches()])
 
262
 
 
263
    def test_merge_other_moves_we_deleted(self):
 
264
        tree_a = self.make_branch_and_tree('A')
 
265
        tree_a.lock_write()
 
266
        self.addCleanup(tree_a.unlock)
 
267
        self.build_tree(['A/a'])
 
268
        tree_a.add('a')
 
269
        tree_a.commit('1', rev_id='rev-1')
 
270
        tree_a.flush()
 
271
        tree_a.rename_one('a', 'b')
 
272
        tree_a.commit('2')
 
273
        bzrdir_b = tree_a.bzrdir.sprout('B', revision_id='rev-1')
 
274
        tree_b = bzrdir_b.open_workingtree()
 
275
        tree_b.lock_write()
 
276
        self.addCleanup(tree_b.unlock)
 
277
        os.unlink('B/a')
 
278
        tree_b.commit('3')
 
279
        try:
 
280
            tree_b.merge_from_branch(tree_a.branch)
 
281
        except AttributeError:
 
282
            self.fail('tried to join a path when name was None')
 
283
 
 
284
    def test_merge_uncommitted_otherbasis_ancestor_of_thisbasis(self):
 
285
        tree_a = self.make_branch_and_tree('a')
 
286
        self.build_tree(['a/file_1', 'a/file_2'])
 
287
        tree_a.add(['file_1'])
 
288
        tree_a.commit('commit 1')
 
289
        tree_a.add(['file_2'])
 
290
        tree_a.commit('commit 2')
 
291
        tree_b = tree_a.bzrdir.sprout('b').open_workingtree()
 
292
        tree_b.rename_one('file_1', 'renamed')
 
293
        merger = _mod_merge.Merger.from_uncommitted(tree_a, tree_b,
 
294
                                                    progress.DummyProgress())
 
295
        merger.merge_type = _mod_merge.Merge3Merger
 
296
        merger.do_merge()
 
297
        self.assertEqual(tree_a.get_parent_ids(), [tree_b.last_revision()])
 
298
 
 
299
    def test_merge_uncommitted_otherbasis_ancestor_of_thisbasis_weave(self):
 
300
        tree_a = self.make_branch_and_tree('a')
 
301
        self.build_tree(['a/file_1', 'a/file_2'])
 
302
        tree_a.add(['file_1'])
 
303
        tree_a.commit('commit 1')
 
304
        tree_a.add(['file_2'])
 
305
        tree_a.commit('commit 2')
 
306
        tree_b = tree_a.bzrdir.sprout('b').open_workingtree()
 
307
        tree_b.rename_one('file_1', 'renamed')
 
308
        merger = _mod_merge.Merger.from_uncommitted(tree_a, tree_b,
 
309
                                                    progress.DummyProgress())
 
310
        merger.merge_type = _mod_merge.WeaveMerger
 
311
        merger.do_merge()
 
312
        self.assertEqual(tree_a.get_parent_ids(), [tree_b.last_revision()])
 
313
 
 
314
    def prepare_cherrypick(self):
 
315
        """Prepare a pair of trees for cherrypicking tests.
 
316
 
 
317
        Both trees have a file, 'file'.
 
318
        rev1 sets content to 'a'.
 
319
        rev2b adds 'b'.
 
320
        rev3b adds 'c'.
 
321
        A full merge of rev2b and rev3b into this_tree would add both 'b' and
 
322
        'c'.  A successful cherrypick of rev2b-rev3b into this_tree will add
 
323
        'c', but not 'b'.
 
324
        """
 
325
        this_tree = self.make_branch_and_tree('this')
 
326
        self.build_tree_contents([('this/file', "a\n")])
 
327
        this_tree.add('file')
 
328
        this_tree.commit('rev1')
 
329
        other_tree = this_tree.bzrdir.sprout('other').open_workingtree()
 
330
        self.build_tree_contents([('other/file', "a\nb\n")])
 
331
        other_tree.commit('rev2b', rev_id='rev2b')
 
332
        self.build_tree_contents([('other/file', "c\na\nb\n")])
 
333
        other_tree.commit('rev3b', rev_id='rev3b')
 
334
        this_tree.lock_write()
 
335
        self.addCleanup(this_tree.unlock)
 
336
        return this_tree, other_tree
 
337
 
 
338
    def test_weave_cherrypick(self):
 
339
        this_tree, other_tree = self.prepare_cherrypick()
 
340
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
341
            this_tree, 'rev3b', 'rev2b', other_tree.branch)
 
342
        merger.merge_type = _mod_merge.WeaveMerger
 
343
        merger.do_merge()
 
344
        self.assertFileEqual('c\na\n', 'this/file')
 
345
 
 
346
    def test_weave_cannot_reverse_cherrypick(self):
 
347
        this_tree, other_tree = self.prepare_cherrypick()
 
348
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
349
            this_tree, 'rev2b', 'rev3b', other_tree.branch)
 
350
        merger.merge_type = _mod_merge.WeaveMerger
 
351
        self.assertRaises(errors.CannotReverseCherrypick, merger.do_merge)
 
352
 
 
353
    def test_merge3_can_reverse_cherrypick(self):
 
354
        this_tree, other_tree = self.prepare_cherrypick()
 
355
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
356
            this_tree, 'rev2b', 'rev3b', other_tree.branch)
 
357
        merger.merge_type = _mod_merge.Merge3Merger
 
358
        merger.do_merge()
 
359
 
 
360
    def test_merge3_will_detect_cherrypick(self):
 
361
        this_tree = self.make_branch_and_tree('this')
 
362
        self.build_tree_contents([('this/file', "a\n")])
 
363
        this_tree.add('file')
 
364
        this_tree.commit('rev1')
 
365
        other_tree = this_tree.bzrdir.sprout('other').open_workingtree()
 
366
        self.build_tree_contents([('other/file', "a\nb\n")])
 
367
        other_tree.commit('rev2b', rev_id='rev2b')
 
368
        self.build_tree_contents([('other/file', "a\nb\nc\n")])
 
369
        other_tree.commit('rev3b', rev_id='rev3b')
 
370
        this_tree.lock_write()
 
371
        self.addCleanup(this_tree.unlock)
 
372
 
 
373
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
374
            this_tree, 'rev3b', 'rev2b', other_tree.branch)
 
375
        merger.merge_type = _mod_merge.Merge3Merger
 
376
        merger.do_merge()
 
377
        self.assertFileEqual('a\n'
 
378
                             '<<<<<<< TREE\n'
 
379
                             '=======\n'
 
380
                             'c\n'
 
381
                             '>>>>>>> MERGE-SOURCE\n',
 
382
                             'this/file')
 
383
 
 
384
    def test_make_merger(self):
 
385
        this_tree = self.make_branch_and_tree('this')
 
386
        this_tree.commit('rev1', rev_id='rev1')
 
387
        other_tree = this_tree.bzrdir.sprout('other').open_workingtree()
 
388
        this_tree.commit('rev2', rev_id='rev2a')
 
389
        other_tree.commit('rev2', rev_id='rev2b')
 
390
        this_tree.lock_write()
 
391
        self.addCleanup(this_tree.unlock)
 
392
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress,
 
393
            this_tree, 'rev2b', other_branch=other_tree.branch)
 
394
        merger.merge_type = _mod_merge.Merge3Merger
 
395
        tree_merger = merger.make_merger()
 
396
        self.assertIs(_mod_merge.Merge3Merger, tree_merger.__class__)
 
397
        self.assertEqual('rev2b', tree_merger.other_tree.get_revision_id())
 
398
        self.assertEqual('rev1', tree_merger.base_tree.get_revision_id())
 
399
 
 
400
    def test_make_preview_transform(self):
 
401
        this_tree = self.make_branch_and_tree('this')
 
402
        self.build_tree_contents([('this/file', '1\n')])
 
403
        this_tree.add('file', 'file-id')
 
404
        this_tree.commit('rev1', rev_id='rev1')
 
405
        other_tree = this_tree.bzrdir.sprout('other').open_workingtree()
 
406
        self.build_tree_contents([('this/file', '1\n2a\n')])
 
407
        this_tree.commit('rev2', rev_id='rev2a')
 
408
        self.build_tree_contents([('other/file', '2b\n1\n')])
 
409
        other_tree.commit('rev2', rev_id='rev2b')
 
410
        this_tree.lock_write()
 
411
        self.addCleanup(this_tree.unlock)
 
412
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
413
            this_tree, 'rev2b', other_branch=other_tree.branch)
 
414
        merger.merge_type = _mod_merge.Merge3Merger
 
415
        tree_merger = merger.make_merger()
 
416
        tt = tree_merger.make_preview_transform()
 
417
        self.addCleanup(tt.finalize)
 
418
        preview_tree = tt.get_preview_tree()
 
419
        tree_file = this_tree.get_file('file-id')
 
420
        try:
 
421
            self.assertEqual('1\n2a\n', tree_file.read())
 
422
        finally:
 
423
            tree_file.close()
 
424
        preview_file = preview_tree.get_file('file-id')
 
425
        try:
 
426
            self.assertEqual('2b\n1\n2a\n', preview_file.read())
 
427
        finally:
 
428
            preview_file.close()
 
429
 
 
430
    def test_do_merge(self):
 
431
        this_tree = self.make_branch_and_tree('this')
 
432
        self.build_tree_contents([('this/file', '1\n')])
 
433
        this_tree.add('file', 'file-id')
 
434
        this_tree.commit('rev1', rev_id='rev1')
 
435
        other_tree = this_tree.bzrdir.sprout('other').open_workingtree()
 
436
        self.build_tree_contents([('this/file', '1\n2a\n')])
 
437
        this_tree.commit('rev2', rev_id='rev2a')
 
438
        self.build_tree_contents([('other/file', '2b\n1\n')])
 
439
        other_tree.commit('rev2', rev_id='rev2b')
 
440
        this_tree.lock_write()
 
441
        self.addCleanup(this_tree.unlock)
 
442
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
443
            this_tree, 'rev2b', other_branch=other_tree.branch)
 
444
        merger.merge_type = _mod_merge.Merge3Merger
 
445
        tree_merger = merger.make_merger()
 
446
        tt = tree_merger.do_merge()
 
447
        tree_file = this_tree.get_file('file-id')
 
448
        try:
 
449
            self.assertEqual('2b\n1\n2a\n', tree_file.read())
 
450
        finally:
 
451
            tree_file.close()
 
452
 
 
453
    def test_merge_add_into_deleted_root(self):
 
454
        # Yes, people actually do this.  And report bugs if it breaks.
 
455
        source = self.make_branch_and_tree('source', format='rich-root-pack')
 
456
        self.build_tree(['source/foo/'])
 
457
        source.add('foo', 'foo-id')
 
458
        source.commit('Add foo')
 
459
        target = source.bzrdir.sprout('target').open_workingtree()
 
460
        subtree = target.extract('foo-id')
 
461
        subtree.commit('Delete root')
 
462
        self.build_tree(['source/bar'])
 
463
        source.add('bar', 'bar-id')
 
464
        source.commit('Add bar')
 
465
        subtree.merge_from_branch(source.branch)
 
466
 
 
467
 
 
468
class TestPlanMerge(TestCaseWithMemoryTransport):
 
469
 
 
470
    def setUp(self):
 
471
        TestCaseWithMemoryTransport.setUp(self)
 
472
        self.vf = knit.make_file_knit('root', self.get_transport(),
 
473
            create=True)
 
474
        self.plan_merge_vf = versionedfile._PlanMergeVersionedFile('root',
 
475
                                                                   [self.vf])
 
476
 
 
477
    def add_version(self, version_id, parents, text):
 
478
        self.vf.add_lines(version_id, parents, [c+'\n' for c in text])
 
479
 
 
480
    def add_uncommitted_version(self, version_id, parents, text):
 
481
        self.plan_merge_vf.add_lines(version_id, parents,
 
482
                                     [c+'\n' for c in text])
 
483
 
 
484
    def setup_plan_merge(self):
 
485
        self.add_version('A', [], 'abc')
 
486
        self.add_version('B', ['A'], 'acehg')
 
487
        self.add_version('C', ['A'], 'fabg')
 
488
        return _PlanMerge('B', 'C', self.plan_merge_vf)
 
489
 
 
490
    def setup_plan_merge_uncommitted(self):
 
491
        self.add_version('A', [], 'abc')
 
492
        self.add_uncommitted_version('B:', ['A'], 'acehg')
 
493
        self.add_uncommitted_version('C:', ['A'], 'fabg')
 
494
        return _PlanMerge('B:', 'C:', self.plan_merge_vf)
 
495
 
 
496
    def test_unique_lines(self):
 
497
        plan = self.setup_plan_merge()
 
498
        self.assertEqual(plan._unique_lines(
 
499
            plan._get_matching_blocks('B', 'C')),
 
500
            ([1, 2, 3], [0, 2]))
 
501
 
 
502
    def test_find_new(self):
 
503
        plan = self.setup_plan_merge()
 
504
        self.assertEqual(set([2, 3, 4]), plan._find_new('B'))
 
505
        self.assertEqual(set([0, 3]), plan._find_new('C'))
 
506
 
 
507
    def test_find_new2(self):
 
508
        self.add_version('A', [], 'abc')
 
509
        self.add_version('B', ['A'], 'abcde')
 
510
        self.add_version('C', ['A'], 'abcefg')
 
511
        self.add_version('D', ['A', 'B', 'C'], 'abcdegh')
 
512
        my_plan = _PlanMerge('B', 'D', self.plan_merge_vf)
 
513
        self.assertEqual(set([5, 6]), my_plan._find_new('D'))
 
514
        self.assertEqual(set(), my_plan._find_new('A'))
 
515
 
 
516
    def test_find_new_no_ancestors(self):
 
517
        self.add_version('A', [], 'abc')
 
518
        self.add_version('B', [], 'xyz')
 
519
        my_plan = _PlanMerge('A', 'B', self.vf)
 
520
        self.assertEqual(set([0, 1, 2]), my_plan._find_new('A'))
 
521
 
 
522
    def test_plan_merge(self):
 
523
        self.setup_plan_merge()
 
524
        plan = self.plan_merge_vf.plan_merge('B', 'C')
 
525
        self.assertEqual([
 
526
                          ('new-b', 'f\n'),
 
527
                          ('unchanged', 'a\n'),
 
528
                          ('killed-b', 'c\n'),
 
529
                          ('new-a', 'e\n'),
 
530
                          ('new-a', 'h\n'),
 
531
                          ('killed-a', 'b\n'),
 
532
                          ('unchanged', 'g\n')],
 
533
                         list(plan))
 
534
 
 
535
    def test_plan_merge_uncommitted_files(self):
 
536
        self.setup_plan_merge_uncommitted()
 
537
        plan = self.plan_merge_vf.plan_merge('B:', 'C:')
 
538
        self.assertEqual([
 
539
                          ('new-b', 'f\n'),
 
540
                          ('unchanged', 'a\n'),
 
541
                          ('killed-b', 'c\n'),
 
542
                          ('new-a', 'e\n'),
 
543
                          ('new-a', 'h\n'),
 
544
                          ('killed-a', 'b\n'),
 
545
                          ('unchanged', 'g\n')],
 
546
                         list(plan))
 
547
 
 
548
    def test_subtract_plans(self):
 
549
        old_plan = [
 
550
        ('unchanged', 'a\n'),
 
551
        ('new-a', 'b\n'),
 
552
        ('killed-a', 'c\n'),
 
553
        ('new-b', 'd\n'),
 
554
        ('new-b', 'e\n'),
 
555
        ('killed-b', 'f\n'),
 
556
        ('killed-b', 'g\n'),
 
557
        ]
 
558
        new_plan = [
 
559
        ('unchanged', 'a\n'),
 
560
        ('new-a', 'b\n'),
 
561
        ('killed-a', 'c\n'),
 
562
        ('new-b', 'd\n'),
 
563
        ('new-b', 'h\n'),
 
564
        ('killed-b', 'f\n'),
 
565
        ('killed-b', 'i\n'),
 
566
        ]
 
567
        subtracted_plan = [
 
568
        ('unchanged', 'a\n'),
 
569
        ('new-a', 'b\n'),
 
570
        ('killed-a', 'c\n'),
 
571
        ('new-b', 'h\n'),
 
572
        ('unchanged', 'f\n'),
 
573
        ('killed-b', 'i\n'),
 
574
        ]
 
575
        self.assertEqual(subtracted_plan,
 
576
            list(_PlanMerge._subtract_plans(old_plan, new_plan)))
 
577
 
 
578
    def setup_merge_with_base(self):
 
579
        self.add_version('COMMON', [], 'abc')
 
580
        self.add_version('THIS', ['COMMON'], 'abcd')
 
581
        self.add_version('BASE', ['COMMON'], 'eabc')
 
582
        self.add_version('OTHER', ['BASE'], 'eafb')
 
583
 
 
584
    def test_plan_merge_with_base(self):
 
585
        self.setup_merge_with_base()
 
586
        plan = self.plan_merge_vf.plan_merge('THIS', 'OTHER', 'BASE')
 
587
        self.assertEqual([('unchanged', 'a\n'),
 
588
                          ('new-b', 'f\n'),
 
589
                          ('unchanged', 'b\n'),
 
590
                          ('killed-b', 'c\n'),
 
591
                          ('new-a', 'd\n')
 
592
                         ], list(plan))
 
593
 
 
594
    def test_plan_lca_merge(self):
 
595
        self.setup_plan_merge()
 
596
        plan = self.plan_merge_vf.plan_lca_merge('B', 'C')
 
597
        self.assertEqual([
 
598
                          ('new-b', 'f\n'),
 
599
                          ('unchanged', 'a\n'),
 
600
                          ('killed-b', 'c\n'),
 
601
                          ('new-a', 'e\n'),
 
602
                          ('new-a', 'h\n'),
 
603
                          ('killed-a', 'b\n'),
 
604
                          ('unchanged', 'g\n')],
 
605
                         list(plan))
 
606
 
 
607
    def test_plan_lca_merge_uncommitted_files(self):
 
608
        self.setup_plan_merge_uncommitted()
 
609
        plan = self.plan_merge_vf.plan_lca_merge('B:', 'C:')
 
610
        self.assertEqual([
 
611
                          ('new-b', 'f\n'),
 
612
                          ('unchanged', 'a\n'),
 
613
                          ('killed-b', 'c\n'),
 
614
                          ('new-a', 'e\n'),
 
615
                          ('new-a', 'h\n'),
 
616
                          ('killed-a', 'b\n'),
 
617
                          ('unchanged', 'g\n')],
 
618
                         list(plan))
 
619
 
 
620
    def test_plan_lca_merge_with_base(self):
 
621
        self.setup_merge_with_base()
 
622
        plan = self.plan_merge_vf.plan_lca_merge('THIS', 'OTHER', 'BASE')
 
623
        self.assertEqual([('unchanged', 'a\n'),
 
624
                          ('new-b', 'f\n'),
 
625
                          ('unchanged', 'b\n'),
 
626
                          ('killed-b', 'c\n'),
 
627
                          ('new-a', 'd\n')
 
628
                         ], list(plan))
 
629
 
 
630
    def test_plan_lca_merge_with_criss_cross(self):
 
631
        self.add_version('ROOT', [], 'abc')
 
632
        # each side makes a change
 
633
        self.add_version('REV1', ['ROOT'], 'abcd')
 
634
        self.add_version('REV2', ['ROOT'], 'abce')
 
635
        # both sides merge, discarding others' changes
 
636
        self.add_version('LCA1', ['REV1', 'REV2'], 'abcd')
 
637
        self.add_version('LCA2', ['REV1', 'REV2'], 'fabce')
 
638
        plan = self.plan_merge_vf.plan_lca_merge('LCA1', 'LCA2')
 
639
        self.assertEqual([('new-b', 'f\n'),
 
640
                          ('unchanged', 'a\n'),
 
641
                          ('unchanged', 'b\n'),
 
642
                          ('unchanged', 'c\n'),
 
643
                          ('conflicted-a', 'd\n'),
 
644
                          ('conflicted-b', 'e\n'),
 
645
                         ], list(plan))
 
646
 
 
647
 
 
648
class TestMergeImplementation(object):
 
649
 
 
650
    def do_merge(self, target_tree, source_tree, **kwargs):
 
651
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
652
            target_tree, source_tree.last_revision(),
 
653
            other_branch=source_tree.branch)
 
654
        merger.merge_type=self.merge_type
 
655
        for name, value in kwargs.items():
 
656
            setattr(merger, name, value)
 
657
        merger.do_merge()
 
658
 
 
659
    def test_merge_specific_file(self):
 
660
        this_tree = self.make_branch_and_tree('this')
 
661
        this_tree.lock_write()
 
662
        self.addCleanup(this_tree.unlock)
 
663
        self.build_tree_contents([
 
664
            ('this/file1', 'a\nb\n'),
 
665
            ('this/file2', 'a\nb\n')
 
666
        ])
 
667
        this_tree.add(['file1', 'file2'])
 
668
        this_tree.commit('Added files')
 
669
        other_tree = this_tree.bzrdir.sprout('other').open_workingtree()
 
670
        self.build_tree_contents([
 
671
            ('other/file1', 'a\nb\nc\n'),
 
672
            ('other/file2', 'a\nb\nc\n')
 
673
        ])
 
674
        other_tree.commit('modified both')
 
675
        self.build_tree_contents([
 
676
            ('this/file1', 'd\na\nb\n'),
 
677
            ('this/file2', 'd\na\nb\n')
 
678
        ])
 
679
        this_tree.commit('modified both')
 
680
        self.do_merge(this_tree, other_tree, interesting_files=['file1'])
 
681
        self.assertFileEqual('d\na\nb\nc\n', 'this/file1')
 
682
        self.assertFileEqual('d\na\nb\n', 'this/file2')
 
683
 
 
684
 
 
685
class TestMerge3Merge(TestCaseWithTransport, TestMergeImplementation):
 
686
 
 
687
    merge_type = _mod_merge.Merge3Merger
 
688
 
 
689
 
 
690
class TestWeaveMerge(TestCaseWithTransport, TestMergeImplementation):
 
691
 
 
692
    merge_type = _mod_merge.WeaveMerger
 
693
 
 
694
 
 
695
class TestLCAMerge(TestCaseWithTransport, TestMergeImplementation):
 
696
 
 
697
    merge_type = _mod_merge.LCAMerger