← 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: Vincent Ladeuil
  • Date: 2008-01-29 15:16:31 UTC
  • mto: (3206.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 3207.
  • Revision ID: v.ladeuil+lp@free.fr-20080129151631-vqjd13tb405mobx6
Fix two more leaking tmp dirs, by reworking TransformPreview lock handling.

* bzrlib/tests/test_transform.py:
(TestTransformMerge): Revert previous patch and cleanly call
preview.finalize now that we can.

* bzrlib/tests/test_merge.py:
(TestMerge.test_make_preview_transform): Catch TransformPreview
leak.

* bzrlib/builtins.py:
(cmd_merge._do_preview): Finalize the TransformPreview or the
limbodir will stay in /tmp.

* bzrlib/transform.py:
(TreeTransformBase.__init__): Create the _deletiondir since it's
reffered to by finalize.
(TreeTransformBase.finalize): Delete the dir only if _deletiondir
is set.
(TreeTransform.__init__): Use a temp var for deletiondir and set
the attribute after the base class __init__ has been called.
(TransformPreview.__init__): Read locks the tree since finalize
wants to unlock it (as suggested by Aaron).

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