/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_merge.py

  • Committer: Jelmer Vernooij
  • Date: 2017-07-23 22:06:41 UTC
  • mfrom: (6738 trunk)
  • mto: This revision was merged to the branch mainline in revision 6739.
  • Revision ID: jelmer@jelmer.uk-20170723220641-69eczax9bmv8d6kk
Merge trunk, address review comments.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_merge.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2012, 2016 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
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
import os
18
 
from StringIO import StringIO
19
18
 
20
 
from bzrlib import (
 
19
from .. import (
 
20
    branch as _mod_branch,
 
21
    cleanup,
21
22
    conflicts,
22
23
    errors,
23
 
    knit,
24
24
    memorytree,
25
25
    merge as _mod_merge,
26
26
    option,
27
 
    progress,
 
27
    revision as _mod_revision,
28
28
    tests,
29
29
    transform,
 
30
    )
 
31
from ..bzr import (
 
32
    inventory,
 
33
    knit,
30
34
    versionedfile,
31
35
    )
32
 
from bzrlib.conflicts import ConflictList, TextConflict
33
 
from bzrlib.errors import UnrelatedBranches, NoCommits
34
 
from bzrlib.merge import transform_tree, merge_inner, _PlanMerge
35
 
from bzrlib.osutils import pathjoin, file_kind
36
 
from bzrlib.tests import (
 
36
from ..conflicts import ConflictList, TextConflict
 
37
from ..errors import UnrelatedBranches, NoCommits
 
38
from ..merge import transform_tree, merge_inner, _PlanMerge
 
39
from ..osutils import basename, pathjoin, file_kind
 
40
from . import (
 
41
    features,
37
42
    TestCaseWithMemoryTransport,
38
43
    TestCaseWithTransport,
39
44
    test_merge_core,
40
45
    )
41
 
from bzrlib.workingtree import WorkingTree
 
46
from ..workingtree import WorkingTree
42
47
 
43
48
 
44
49
class TestMerge(TestCaseWithTransport):
79
84
        tip = wt1.commit('empty commit')
80
85
        wt2 = self.make_branch_and_tree('branch2')
81
86
        wt2.pull(wt1.branch)
82
 
        file('branch1/foo', 'wb').write('foo')
83
 
        file('branch1/bar', 'wb').write('bar')
 
87
        with file('branch1/foo', 'wb') as f:
 
88
            f.write('foo')
 
89
        with file('branch1/bar', 'wb') as f:
 
90
            f.write('bar')
84
91
        wt1.add('foo')
85
92
        wt1.add('bar')
86
93
        wt1.commit('add foobar')
87
 
        os.chdir('branch2')
88
 
        self.run_bzr('merge ../branch1/baz', retcode=3)
89
 
        self.run_bzr('merge ../branch1/foo')
90
 
        self.failUnlessExists('foo')
91
 
        self.failIfExists('bar')
92
 
        wt2 = WorkingTree.open('.') # opens branch2
 
94
        self.run_bzr('merge ../branch1/baz', retcode=3, working_dir='branch2')
 
95
        self.run_bzr('merge ../branch1/foo', working_dir='branch2')
 
96
        self.assertPathExists('branch2/foo')
 
97
        self.assertPathDoesNotExist('branch2/bar')
 
98
        wt2 = WorkingTree.open('branch2')
93
99
        self.assertEqual([tip], wt2.get_parent_ids())
94
100
 
95
101
    def test_pending_with_null(self):
118
124
        finally:
119
125
            wt1.unlock()
120
126
 
 
127
    def test_merge_into_null_tree(self):
 
128
        wt = self.make_branch_and_tree('tree')
 
129
        null_tree = wt.basis_tree()
 
130
        self.build_tree(['tree/file'])
 
131
        wt.add('file')
 
132
        wt.commit('tree with root')
 
133
        merger = _mod_merge.Merge3Merger(null_tree, null_tree, null_tree, wt,
 
134
                                         this_branch=wt.branch,
 
135
                                         do_merge=False)
 
136
        with merger.make_preview_transform() as tt:
 
137
            self.assertEqual([], tt.find_conflicts())
 
138
            preview = tt.get_preview_tree()
 
139
            self.assertEqual(wt.get_root_id(), preview.get_root_id())
 
140
 
 
141
    def test_merge_unrelated_retains_root(self):
 
142
        wt = self.make_branch_and_tree('tree')
 
143
        other_tree = self.make_branch_and_tree('other')
 
144
        self.addCleanup(other_tree.lock_read().unlock)
 
145
        merger = _mod_merge.Merge3Merger(wt, wt, wt.basis_tree(), other_tree,
 
146
                                         this_branch=wt.branch,
 
147
                                         do_merge=False)
 
148
        with transform.TransformPreview(wt) as merger.tt:
 
149
            merger._compute_transform()
 
150
            new_root_id = merger.tt.final_file_id(merger.tt.root)
 
151
            self.assertEqual(wt.get_root_id(), new_root_id)
 
152
 
121
153
    def test_create_rename(self):
122
154
        """Rename an inventory entry while creating the file"""
123
155
        tree =self.make_branch_and_tree('.')
124
 
        file('name1', 'wb').write('Hello')
 
156
        with file('name1', 'wb') as f: f.write('Hello')
125
157
        tree.add('name1')
126
158
        tree.commit(message="hello")
127
159
        tree.rename_one('name1', 'name2')
134
166
        os.mkdir('dirname1')
135
167
        tree.add('dirname1')
136
168
        filename = pathjoin('dirname1', 'name1')
137
 
        file(filename, 'wb').write('Hello')
 
169
        with file(filename, 'wb') as f: f.write('Hello')
138
170
        tree.add(filename)
139
171
        tree.commit(message="hello")
140
172
        filename2 = pathjoin('dirname1', 'name2')
146
178
        # Test that merge_inner's ignore zero parameter is effective
147
179
        tree_a =self.make_branch_and_tree('a')
148
180
        tree_a.commit(message="hello")
149
 
        dir_b = tree_a.bzrdir.sprout('b')
 
181
        dir_b = tree_a.controldir.sprout('b')
150
182
        tree_b = dir_b.open_workingtree()
151
183
        tree_b.lock_write()
152
184
        self.addCleanup(tree_b.unlock)
153
185
        tree_a.commit(message="hello again")
154
 
        log = StringIO()
155
186
        merge_inner(tree_b.branch, tree_a, tree_b.basis_tree(),
156
187
                    this_tree=tree_b, ignore_zero=True)
157
 
        self.failUnless('All changes applied successfully.\n' not in
 
188
        self.assertTrue('All changes applied successfully.\n' not in
158
189
            self.get_log())
159
190
        tree_b.revert()
160
191
        merge_inner(tree_b.branch, tree_a, tree_b.basis_tree(),
161
192
                    this_tree=tree_b, ignore_zero=False)
162
 
        self.failUnless('All changes applied successfully.\n' in self.get_log())
 
193
        self.assertTrue('All changes applied successfully.\n' in self.get_log())
163
194
 
164
195
    def test_merge_inner_conflicts(self):
165
196
        tree_a = self.make_branch_and_tree('a')
176
207
        # the basis tree. This mutates the tree after grabbing basis, so go to
177
208
        # the repository.
178
209
        base_tree = tree_a.branch.repository.revision_tree(tree_a.last_revision())
179
 
        tree_z = tree_a.bzrdir.sprout('z').open_workingtree()
 
210
        tree_z = tree_a.controldir.sprout('z').open_workingtree()
180
211
        self.build_tree(['a/b/c'])
181
212
        tree_a.add('b/c')
182
213
        tree_a.commit('added c')
195
226
            tree_a.conflicts())
196
227
 
197
228
    def test_nested_merge(self):
 
229
        self.knownFailure(
 
230
            'iter_changes doesn\'t work with changes in nested trees')
198
231
        tree = self.make_branch_and_tree('tree',
199
 
            format='dirstate-with-subtree')
 
232
            format='development-subtree')
200
233
        sub_tree = self.make_branch_and_tree('tree/sub-tree',
201
 
            format='dirstate-with-subtree')
 
234
            format='development-subtree')
202
235
        sub_tree.set_root_id('sub-tree-root')
203
236
        self.build_tree_contents([('tree/sub-tree/file', 'text1')])
204
237
        sub_tree.add('file')
205
238
        sub_tree.commit('foo')
206
239
        tree.add_reference(sub_tree)
207
240
        tree.commit('set text to 1')
208
 
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
 
241
        tree2 = tree.controldir.sprout('tree2').open_workingtree()
209
242
        # modify the file in the subtree
210
243
        self.build_tree_contents([('tree2/sub-tree/file', 'text2')])
211
244
        # and merge the changes from the diverged subtree into the containing
223
256
        # the basis tree. This test commits to the tree after grabbing basis,
224
257
        # so we go to the repository.
225
258
        base_tree = tree_a.branch.repository.revision_tree(tree_a.last_revision())
226
 
        tree_b = tree_a.bzrdir.sprout('tree_b').open_workingtree()
 
259
        tree_b = tree_a.controldir.sprout('tree_b').open_workingtree()
227
260
        self.build_tree_contents([('tree_a/file', 'content_2')])
228
261
        tree_a.commit('commit other')
229
262
        other_tree = tree_a.basis_tree()
237
270
        self.build_tree_contents([('tree_a/file', 'content_1')])
238
271
        tree_a.add('file', 'file-id')
239
272
        tree_a.commit('added file')
240
 
        tree_b = tree_a.bzrdir.sprout('tree_b').open_workingtree()
 
273
        tree_b = tree_a.controldir.sprout('tree_b').open_workingtree()
241
274
        os.unlink('tree_a/file')
242
275
        self.build_tree(['tree_a/file/'])
243
276
        tree_a.commit('changed file to directory')
257
290
        self.assertFalse('merge4' in [x[0] for x in
258
291
                        merge_type_option.iter_switches()])
259
292
        registry = _mod_merge.get_merge_type_registry()
260
 
        registry.register_lazy('merge4', 'bzrlib.merge', 'Merge4Merger',
 
293
        registry.register_lazy('merge4', 'breezy.merge', 'Merge4Merger',
261
294
                               'time-travelling merge')
262
295
        self.assertTrue('merge4' in [x[0] for x in
263
296
                        merge_type_option.iter_switches()])
275
308
        tree_a.flush()
276
309
        tree_a.rename_one('a', 'b')
277
310
        tree_a.commit('2')
278
 
        bzrdir_b = tree_a.bzrdir.sprout('B', revision_id='rev-1')
 
311
        bzrdir_b = tree_a.controldir.sprout('B', revision_id='rev-1')
279
312
        tree_b = bzrdir_b.open_workingtree()
280
313
        tree_b.lock_write()
281
314
        self.addCleanup(tree_b.unlock)
293
326
        tree_a.commit('commit 1')
294
327
        tree_a.add(['file_2'])
295
328
        tree_a.commit('commit 2')
296
 
        tree_b = tree_a.bzrdir.sprout('b').open_workingtree()
 
329
        tree_b = tree_a.controldir.sprout('b').open_workingtree()
297
330
        tree_b.rename_one('file_1', 'renamed')
298
331
        merger = _mod_merge.Merger.from_uncommitted(tree_a, tree_b)
299
332
        merger.merge_type = _mod_merge.Merge3Merger
307
340
        tree_a.commit('commit 1')
308
341
        tree_a.add(['file_2'])
309
342
        tree_a.commit('commit 2')
310
 
        tree_b = tree_a.bzrdir.sprout('b').open_workingtree()
 
343
        tree_b = tree_a.controldir.sprout('b').open_workingtree()
311
344
        tree_b.rename_one('file_1', 'renamed')
312
345
        merger = _mod_merge.Merger.from_uncommitted(tree_a, tree_b)
313
346
        merger.merge_type = _mod_merge.WeaveMerger
329
362
        self.build_tree_contents([('this/file', "a\n")])
330
363
        this_tree.add('file')
331
364
        this_tree.commit('rev1')
332
 
        other_tree = this_tree.bzrdir.sprout('other').open_workingtree()
 
365
        other_tree = this_tree.controldir.sprout('other').open_workingtree()
333
366
        self.build_tree_contents([('other/file', "a\nb\n")])
334
367
        other_tree.commit('rev2b', rev_id='rev2b')
335
368
        self.build_tree_contents([('other/file', "c\na\nb\n")])
340
373
 
341
374
    def test_weave_cherrypick(self):
342
375
        this_tree, other_tree = self.prepare_cherrypick()
343
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
376
        merger = _mod_merge.Merger.from_revision_ids(
344
377
            this_tree, 'rev3b', 'rev2b', other_tree.branch)
345
378
        merger.merge_type = _mod_merge.WeaveMerger
346
379
        merger.do_merge()
348
381
 
349
382
    def test_weave_cannot_reverse_cherrypick(self):
350
383
        this_tree, other_tree = self.prepare_cherrypick()
351
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
384
        merger = _mod_merge.Merger.from_revision_ids(
352
385
            this_tree, 'rev2b', 'rev3b', other_tree.branch)
353
386
        merger.merge_type = _mod_merge.WeaveMerger
354
387
        self.assertRaises(errors.CannotReverseCherrypick, merger.do_merge)
355
388
 
356
389
    def test_merge3_can_reverse_cherrypick(self):
357
390
        this_tree, other_tree = self.prepare_cherrypick()
358
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
391
        merger = _mod_merge.Merger.from_revision_ids(
359
392
            this_tree, 'rev2b', 'rev3b', other_tree.branch)
360
393
        merger.merge_type = _mod_merge.Merge3Merger
361
394
        merger.do_merge()
365
398
        self.build_tree_contents([('this/file', "a\n")])
366
399
        this_tree.add('file')
367
400
        this_tree.commit('rev1')
368
 
        other_tree = this_tree.bzrdir.sprout('other').open_workingtree()
 
401
        other_tree = this_tree.controldir.sprout('other').open_workingtree()
369
402
        self.build_tree_contents([('other/file', "a\nb\n")])
370
403
        other_tree.commit('rev2b', rev_id='rev2b')
371
404
        self.build_tree_contents([('other/file', "a\nb\nc\n")])
373
406
        this_tree.lock_write()
374
407
        self.addCleanup(this_tree.unlock)
375
408
 
376
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
409
        merger = _mod_merge.Merger.from_revision_ids(
377
410
            this_tree, 'rev3b', 'rev2b', other_tree.branch)
378
411
        merger.merge_type = _mod_merge.Merge3Merger
379
412
        merger.do_merge()
384
417
                             '>>>>>>> MERGE-SOURCE\n',
385
418
                             'this/file')
386
419
 
 
420
    def test_merge_reverse_revision_range(self):
 
421
        tree = self.make_branch_and_tree(".")
 
422
        tree.lock_write()
 
423
        self.addCleanup(tree.unlock)
 
424
        self.build_tree(['a'])
 
425
        tree.add('a')
 
426
        first_rev = tree.commit("added a")
 
427
        merger = _mod_merge.Merger.from_revision_ids(tree,
 
428
                                          _mod_revision.NULL_REVISION,
 
429
                                          first_rev)
 
430
        merger.merge_type = _mod_merge.Merge3Merger
 
431
        merger.interesting_files = 'a'
 
432
        conflict_count = merger.do_merge()
 
433
        self.assertEqual(0, conflict_count)
 
434
 
 
435
        self.assertPathDoesNotExist("a")
 
436
        tree.revert()
 
437
        self.assertPathExists("a")
 
438
 
387
439
    def test_make_merger(self):
388
440
        this_tree = self.make_branch_and_tree('this')
389
441
        this_tree.commit('rev1', rev_id='rev1')
390
 
        other_tree = this_tree.bzrdir.sprout('other').open_workingtree()
 
442
        other_tree = this_tree.controldir.sprout('other').open_workingtree()
391
443
        this_tree.commit('rev2', rev_id='rev2a')
392
444
        other_tree.commit('rev2', rev_id='rev2b')
393
445
        this_tree.lock_write()
394
446
        self.addCleanup(this_tree.unlock)
395
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
447
        merger = _mod_merge.Merger.from_revision_ids(
396
448
            this_tree, 'rev2b', other_branch=other_tree.branch)
397
449
        merger.merge_type = _mod_merge.Merge3Merger
398
450
        tree_merger = merger.make_merger()
399
451
        self.assertIs(_mod_merge.Merge3Merger, tree_merger.__class__)
400
 
        self.assertEqual('rev2b', tree_merger.other_tree.get_revision_id())
401
 
        self.assertEqual('rev1', tree_merger.base_tree.get_revision_id())
 
452
        self.assertEqual('rev2b',
 
453
            tree_merger.other_tree.get_revision_id())
 
454
        self.assertEqual('rev1',
 
455
            tree_merger.base_tree.get_revision_id())
 
456
        self.assertEqual(other_tree.branch, tree_merger.other_branch)
402
457
 
403
458
    def test_make_preview_transform(self):
404
459
        this_tree = self.make_branch_and_tree('this')
405
460
        self.build_tree_contents([('this/file', '1\n')])
406
461
        this_tree.add('file', 'file-id')
407
462
        this_tree.commit('rev1', rev_id='rev1')
408
 
        other_tree = this_tree.bzrdir.sprout('other').open_workingtree()
 
463
        other_tree = this_tree.controldir.sprout('other').open_workingtree()
409
464
        self.build_tree_contents([('this/file', '1\n2a\n')])
410
465
        this_tree.commit('rev2', rev_id='rev2a')
411
466
        self.build_tree_contents([('other/file', '2b\n1\n')])
412
467
        other_tree.commit('rev2', rev_id='rev2b')
413
468
        this_tree.lock_write()
414
469
        self.addCleanup(this_tree.unlock)
415
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
470
        merger = _mod_merge.Merger.from_revision_ids(
416
471
            this_tree, 'rev2b', other_branch=other_tree.branch)
417
472
        merger.merge_type = _mod_merge.Merge3Merger
418
473
        tree_merger = merger.make_merger()
435
490
        self.build_tree_contents([('this/file', '1\n')])
436
491
        this_tree.add('file', 'file-id')
437
492
        this_tree.commit('rev1', rev_id='rev1')
438
 
        other_tree = this_tree.bzrdir.sprout('other').open_workingtree()
 
493
        other_tree = this_tree.controldir.sprout('other').open_workingtree()
439
494
        self.build_tree_contents([('this/file', '1\n2a\n')])
440
495
        this_tree.commit('rev2', rev_id='rev2a')
441
496
        self.build_tree_contents([('other/file', '2b\n1\n')])
442
497
        other_tree.commit('rev2', rev_id='rev2b')
443
498
        this_tree.lock_write()
444
499
        self.addCleanup(this_tree.unlock)
445
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
500
        merger = _mod_merge.Merger.from_revision_ids(
446
501
            this_tree, 'rev2b', other_branch=other_tree.branch)
447
502
        merger.merge_type = _mod_merge.Merge3Merger
448
503
        tree_merger = merger.make_merger()
453
508
        finally:
454
509
            tree_file.close()
455
510
 
 
511
    def test_merge_require_tree_root(self):
 
512
        tree = self.make_branch_and_tree(".")
 
513
        tree.lock_write()
 
514
        self.addCleanup(tree.unlock)
 
515
        self.build_tree(['a'])
 
516
        tree.add('a')
 
517
        first_rev = tree.commit("added a")
 
518
        old_root_id = tree.get_root_id()
 
519
        merger = _mod_merge.Merger.from_revision_ids(tree,
 
520
                                          _mod_revision.NULL_REVISION,
 
521
                                          first_rev)
 
522
        merger.merge_type = _mod_merge.Merge3Merger
 
523
        conflict_count = merger.do_merge()
 
524
        self.assertEqual(0, conflict_count)
 
525
        self.assertEqual({old_root_id}, tree.all_file_ids())
 
526
        tree.set_parent_ids([])
 
527
 
456
528
    def test_merge_add_into_deleted_root(self):
457
529
        # Yes, people actually do this.  And report bugs if it breaks.
458
530
        source = self.make_branch_and_tree('source', format='rich-root-pack')
459
531
        self.build_tree(['source/foo/'])
460
532
        source.add('foo', 'foo-id')
461
533
        source.commit('Add foo')
462
 
        target = source.bzrdir.sprout('target').open_workingtree()
 
534
        target = source.controldir.sprout('target').open_workingtree()
463
535
        subtree = target.extract('foo-id')
464
536
        subtree.commit('Delete root')
465
537
        self.build_tree(['source/bar'])
476
548
        self.build_tree(['target/bla'])
477
549
        target.add('bla')
478
550
        target.commit('Add bla')
479
 
        nested = source.bzrdir.sprout('target/subtree').open_workingtree()
 
551
        nested = source.controldir.sprout('target/subtree').open_workingtree()
480
552
        target.subsume(nested)
481
553
        target.commit('Join nested')
482
554
        self.build_tree(['source/bar'])
489
561
class TestPlanMerge(TestCaseWithMemoryTransport):
490
562
 
491
563
    def setUp(self):
492
 
        TestCaseWithMemoryTransport.setUp(self)
 
564
        super(TestPlanMerge, self).setUp()
493
565
        mapper = versionedfile.PrefixMapper()
494
566
        factory = knit.make_file_factory(True, mapper)
495
567
        self.vf = factory(self.get_transport())
975
1047
 
976
1048
    def assertPruneTails(self, pruned_map, tails, parent_map):
977
1049
        child_map = {}
978
 
        for key, parent_keys in parent_map.iteritems():
 
1050
        for key, parent_keys in parent_map.items():
979
1051
            child_map.setdefault(key, [])
980
1052
            for pkey in parent_keys:
981
1053
                child_map.setdefault(pkey, []).append(key)
1198
1270
        mem_tree = memorytree.MemoryTree.create_on_branch(builder.get_branch())
1199
1271
        mem_tree.lock_write()
1200
1272
        self.addCleanup(mem_tree.unlock)
1201
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
1273
        merger = _mod_merge.Merger.from_revision_ids(
1202
1274
            mem_tree, other_revision_id)
1203
1275
        merger.set_interesting_files(interesting_files)
1204
1276
        # It seems there is no matching function for set_interesting_ids
1267
1339
        self.assertEqual(['B-id', 'C-id', 'F-id'],
1268
1340
                         [t.get_revision_id() for t in merger._lca_trees])
1269
1341
 
 
1342
    def test_find_base_new_root_criss_cross(self):
 
1343
        # A   B
 
1344
        # |\ /|
 
1345
        # | X |
 
1346
        # |/ \|
 
1347
        # C   D
 
1348
        
 
1349
        builder = self.get_builder()
 
1350
        builder.build_snapshot('A-id', None,
 
1351
            [('add', ('', None, 'directory', None))])
 
1352
        builder.build_snapshot('B-id', [],
 
1353
            [('add', ('', None, 'directory', None))])
 
1354
        builder.build_snapshot('D-id', ['A-id', 'B-id'], [])
 
1355
        builder.build_snapshot('C-id', ['A-id', 'B-id'], [])
 
1356
        merger = self.make_Merger(builder, 'D-id')
 
1357
        self.assertEqual('A-id', merger.base_rev_id)
 
1358
        self.assertTrue(merger._is_criss_cross)
 
1359
        self.assertEqual(['A-id', 'B-id'], [t.get_revision_id()
 
1360
                                            for t in merger._lca_trees])
 
1361
 
1270
1362
    def test_no_criss_cross_passed_to_merge_type(self):
1271
1363
        class LCATreesMerger(LoggingMerger):
1272
1364
            supports_lca_trees = True
1804
1896
        builder.build_snapshot('C-id', ['A-id'], [])
1805
1897
        builder.build_snapshot('E-id', ['C-id', 'B-id'],
1806
1898
            [('unversion', 'a-id'),
 
1899
             ('flush', None),
1807
1900
             ('add', (u'a', 'a-id', 'directory', None))])
1808
1901
        builder.build_snapshot('D-id', ['B-id', 'C-id'], [])
1809
1902
        merge_obj = self.make_merge_obj(builder, 'E-id')
1827
1920
        builder.build_snapshot('E-id', ['C-id', 'B-id'], [])
1828
1921
        builder.build_snapshot('D-id', ['B-id', 'C-id'],
1829
1922
            [('unversion', 'a-id'),
 
1923
             ('flush', None),
1830
1924
             ('add', (u'a', 'a-id', 'directory', None))])
1831
1925
        merge_obj = self.make_merge_obj(builder, 'E-id')
1832
1926
        entries = list(merge_obj._entries_lca())
1966
2060
    def get_wt_from_builder(self, builder):
1967
2061
        """Get a real WorkingTree from the builder."""
1968
2062
        the_branch = builder.get_branch()
1969
 
        wt = the_branch.bzrdir.create_workingtree()
 
2063
        wt = the_branch.controldir.create_workingtree()
1970
2064
        # Note: This is a little bit ugly, but we are holding the branch
1971
2065
        #       write-locked as part of the build process, and we would like to
1972
2066
        #       maintain that. So we just force the WT to re-use the same
1978
2072
 
1979
2073
    def do_merge(self, builder, other_revision_id):
1980
2074
        wt = self.get_wt_from_builder(builder)
1981
 
        merger = _mod_merge.Merger.from_revision_ids(None,
 
2075
        merger = _mod_merge.Merger.from_revision_ids(
1982
2076
            wt, other_revision_id)
1983
2077
        merger.merge_type = _mod_merge.Merge3Merger
1984
2078
        return wt, merger.do_merge()
2095
2189
        self.assertTrue(wt.is_executable('foo-id'))
2096
2190
 
2097
2191
    def test_create_symlink(self):
2098
 
        self.requireFeature(tests.SymlinkFeature)
 
2192
        self.requireFeature(features.SymlinkFeature)
2099
2193
        #   A
2100
2194
        #  / \
2101
2195
        # B   C
2160
2254
                             wt.get_file_text('foo-id'))
2161
2255
 
2162
2256
    def test_modified_symlink(self):
2163
 
        self.requireFeature(tests.SymlinkFeature)
 
2257
        self.requireFeature(features.SymlinkFeature)
2164
2258
        #   A       Create symlink foo => bar
2165
2259
        #  / \
2166
2260
        # B   C     B relinks foo => baz
2205
2299
        self.assertEqual('bing', wt.get_symlink_target('foo-id'))
2206
2300
 
2207
2301
    def test_renamed_symlink(self):
2208
 
        self.requireFeature(tests.SymlinkFeature)
 
2302
        self.requireFeature(features.SymlinkFeature)
2209
2303
        #   A       Create symlink foo => bar
2210
2304
        #  / \
2211
2305
        # B   C     B renames foo => barry
2244
2338
        wt.commit('D merges B & C', rev_id='D-id')
2245
2339
        self.assertEqual('barry', wt.id2path('foo-id'))
2246
2340
        # Check the output of the Merger object directly
2247
 
        merger = _mod_merge.Merger.from_revision_ids(None,
2248
 
            wt, 'F-id')
 
2341
        merger = _mod_merge.Merger.from_revision_ids(wt, 'F-id')
2249
2342
        merger.merge_type = _mod_merge.Merge3Merger
2250
2343
        merge_obj = merger.make_merger()
2251
2344
        root_id = wt.path2id('')
2261
2354
        self.assertEqual('blah', wt.id2path('foo-id'))
2262
2355
 
2263
2356
    def test_symlink_no_content_change(self):
2264
 
        self.requireFeature(tests.SymlinkFeature)
 
2357
        self.requireFeature(features.SymlinkFeature)
2265
2358
        #   A       Create symlink foo => bar
2266
2359
        #  / \
2267
2360
        # B   C     B relinks foo => baz
2300
2393
        wt.commit('F foo => bing', rev_id='F-id')
2301
2394
 
2302
2395
        # Check the output of the Merger object directly
2303
 
        merger = _mod_merge.Merger.from_revision_ids(None,
2304
 
            wt, 'E-id')
 
2396
        merger = _mod_merge.Merger.from_revision_ids(wt, 'E-id')
2305
2397
        merger.merge_type = _mod_merge.Merge3Merger
2306
2398
        merge_obj = merger.make_merger()
2307
2399
        # Nothing interesting happened in OTHER relative to BASE
2312
2404
        self.assertEqual('bing', wt.get_symlink_target('foo-id'))
2313
2405
 
2314
2406
    def test_symlink_this_changed_kind(self):
2315
 
        self.requireFeature(tests.SymlinkFeature)
 
2407
        self.requireFeature(features.SymlinkFeature)
2316
2408
        #   A       Nothing
2317
2409
        #  / \
2318
2410
        # B   C     B creates symlink foo => bar
2351
2443
        list(wt.iter_changes(wt.basis_tree()))
2352
2444
        wt.commit('D merges B & C, makes it a file', rev_id='D-id')
2353
2445
 
2354
 
        merger = _mod_merge.Merger.from_revision_ids(None,
2355
 
            wt, 'E-id')
 
2446
        merger = _mod_merge.Merger.from_revision_ids(wt, 'E-id')
2356
2447
        merger.merge_type = _mod_merge.Merge3Merger
2357
2448
        merge_obj = merger.make_merger()
2358
2449
        entries = list(merge_obj._entries_lca())
2365
2456
 
2366
2457
    def test_symlink_all_wt(self):
2367
2458
        """Check behavior if all trees are Working Trees."""
2368
 
        self.requireFeature(tests.SymlinkFeature)
 
2459
        self.requireFeature(features.SymlinkFeature)
2369
2460
        # The big issue is that entry.symlink_target is None for WorkingTrees.
2370
2461
        # So we need to make sure we handle that case correctly.
2371
2462
        #   A   foo => bar
2402
2493
        wt.revert()
2403
2494
        wt.merge_from_branch(wt.branch, 'C-id')
2404
2495
        wt.commit('D merges B & C', rev_id='D-id')
2405
 
        wt_base = wt.bzrdir.sprout('base', 'A-id').open_workingtree()
 
2496
        wt_base = wt.controldir.sprout('base', 'A-id').open_workingtree()
2406
2497
        wt_base.lock_read()
2407
2498
        self.addCleanup(wt_base.unlock)
2408
 
        wt_lca1 = wt.bzrdir.sprout('b-tree', 'B-id').open_workingtree()
 
2499
        wt_lca1 = wt.controldir.sprout('b-tree', 'B-id').open_workingtree()
2409
2500
        wt_lca1.lock_read()
2410
2501
        self.addCleanup(wt_lca1.unlock)
2411
 
        wt_lca2 = wt.bzrdir.sprout('c-tree', 'C-id').open_workingtree()
 
2502
        wt_lca2 = wt.controldir.sprout('c-tree', 'C-id').open_workingtree()
2412
2503
        wt_lca2.lock_read()
2413
2504
        self.addCleanup(wt_lca2.unlock)
2414
 
        wt_other = wt.bzrdir.sprout('other', 'F-id').open_workingtree()
 
2505
        wt_other = wt.controldir.sprout('other', 'F-id').open_workingtree()
2415
2506
        wt_other.lock_read()
2416
2507
        self.addCleanup(wt_other.unlock)
2417
2508
        merge_obj = _mod_merge.Merge3Merger(wt, wt, wt_base,
2512
2603
        builder.build_snapshot('D-id', ['B-id', 'C-id'],
2513
2604
            [('rename', ('a', 'b'))]) # merged change
2514
2605
        wt_this = self.get_wt_from_builder(builder)
2515
 
        wt_base = wt_this.bzrdir.sprout('base', 'A-id').open_workingtree()
 
2606
        wt_base = wt_this.controldir.sprout('base', 'A-id').open_workingtree()
2516
2607
        wt_base.lock_read()
2517
2608
        self.addCleanup(wt_base.unlock)
2518
 
        wt_lca1 = wt_this.bzrdir.sprout('b-tree', 'B-id').open_workingtree()
 
2609
        wt_lca1 = wt_this.controldir.sprout('b-tree', 'B-id').open_workingtree()
2519
2610
        wt_lca1.lock_read()
2520
2611
        self.addCleanup(wt_lca1.unlock)
2521
 
        wt_lca2 = wt_this.bzrdir.sprout('c-tree', 'C-id').open_workingtree()
 
2612
        wt_lca2 = wt_this.controldir.sprout('c-tree', 'C-id').open_workingtree()
2522
2613
        wt_lca2.lock_read()
2523
2614
        self.addCleanup(wt_lca2.unlock)
2524
 
        wt_other = wt_this.bzrdir.sprout('other', 'E-id').open_workingtree()
 
2615
        wt_other = wt_this.controldir.sprout('other', 'E-id').open_workingtree()
2525
2616
        wt_other.lock_read()
2526
2617
        self.addCleanup(wt_other.unlock)
2527
2618
        merge_obj = _mod_merge.Merge3Merger(wt_this, wt_this, wt_base,
2542
2633
        # Tested with a real WT, because BranchBuilder/MemoryTree don't handle
2543
2634
        # 'tree-reference'
2544
2635
        wt = self.make_branch_and_tree('tree',
2545
 
            format='dirstate-with-subtree')
 
2636
            format='development-subtree')
2546
2637
        wt.lock_write()
2547
2638
        self.addCleanup(wt.unlock)
2548
2639
        sub_tree = self.make_branch_and_tree('tree/sub-tree',
2549
 
            format='dirstate-with-subtree')
 
2640
            format='development-subtree')
2550
2641
        wt.set_root_id('a-root-id')
2551
2642
        sub_tree.set_root_id('sub-tree-root')
2552
2643
        self.build_tree_contents([('tree/sub-tree/file', 'text1')])
2566
2657
        wt.branch.set_last_revision_info(2, 'B-id')
2567
2658
        wt.commit('D', rev_id='D-id', recursive=None)
2568
2659
 
2569
 
        merger = _mod_merge.Merger.from_revision_ids(None,
2570
 
            wt, 'E-id')
 
2660
        merger = _mod_merge.Merger.from_revision_ids(wt, 'E-id')
2571
2661
        merger.merge_type = _mod_merge.Merge3Merger
2572
2662
        merge_obj = merger.make_merger()
2573
2663
        entries = list(merge_obj._entries_lca())
2577
2667
        # Tested with a real WT, because BranchBuilder/MemoryTree don't handle
2578
2668
        # 'tree-reference'
2579
2669
        wt = self.make_branch_and_tree('tree',
2580
 
            format='dirstate-with-subtree')
 
2670
            format='development-subtree')
2581
2671
        wt.lock_write()
2582
2672
        self.addCleanup(wt.unlock)
2583
2673
        sub_tree = self.make_branch_and_tree('tree/sub',
2584
 
            format='dirstate-with-subtree')
 
2674
            format='development-subtree')
2585
2675
        wt.set_root_id('a-root-id')
2586
2676
        sub_tree.set_root_id('sub-tree-root')
2587
2677
        self.build_tree_contents([('tree/sub/file', 'text1')])
2603
2693
        wt.branch.set_last_revision_info(2, 'B-id')
2604
2694
        wt.commit('D', rev_id='D-id', recursive=None)
2605
2695
 
2606
 
        merger = _mod_merge.Merger.from_revision_ids(None,
2607
 
            wt, 'E-id')
 
2696
        merger = _mod_merge.Merger.from_revision_ids(wt, 'E-id')
2608
2697
        merger.merge_type = _mod_merge.Merge3Merger
2609
2698
        merge_obj = merger.make_merger()
2610
2699
        entries = list(merge_obj._entries_lca())
2616
2705
        # Tested with a real WT, because BranchBuilder/MemoryTree don't handle
2617
2706
        # 'tree-reference'
2618
2707
        wt = self.make_branch_and_tree('tree',
2619
 
            format='dirstate-with-subtree')
 
2708
            format='development-subtree')
2620
2709
        wt.lock_write()
2621
2710
        self.addCleanup(wt.unlock)
2622
2711
        sub_tree = self.make_branch_and_tree('tree/sub',
2623
 
            format='dirstate-with-subtree')
 
2712
            format='development-subtree')
2624
2713
        wt.set_root_id('a-root-id')
2625
2714
        sub_tree.set_root_id('sub-tree-root')
2626
2715
        self.build_tree_contents([('tree/sub/file', 'text1')])
2643
2732
        wt.branch.set_last_revision_info(2, 'B-id')
2644
2733
        wt.commit('D', rev_id='D-id', recursive=None)
2645
2734
 
2646
 
        merger = _mod_merge.Merger.from_revision_ids(None,
2647
 
            wt, 'E-id')
 
2735
        merger = _mod_merge.Merger.from_revision_ids(wt, 'E-id')
2648
2736
        merger.merge_type = _mod_merge.Merge3Merger
2649
2737
        merge_obj = merger.make_merger()
2650
2738
        entries = list(merge_obj._entries_lca())
2659
2747
        # Tested with a real WT, because BranchBuilder/MemoryTree don't handle
2660
2748
        # 'tree-reference'
2661
2749
        wt = self.make_branch_and_tree('tree',
2662
 
            format='dirstate-with-subtree')
 
2750
            format='development-subtree')
2663
2751
        wt.lock_write()
2664
2752
        self.addCleanup(wt.unlock)
2665
2753
        sub_tree = self.make_branch_and_tree('tree/sub',
2666
 
            format='dirstate-with-subtree')
 
2754
            format='development-subtree')
2667
2755
        wt.set_root_id('a-root-id')
2668
2756
        sub_tree.set_root_id('sub-tree-root')
2669
2757
        self.build_tree_contents([('tree/sub/file', 'text1')])
2688
2776
        wt.branch.set_last_revision_info(2, 'B-id')
2689
2777
        wt.commit('D', rev_id='D-id', recursive=None)
2690
2778
 
2691
 
        merger = _mod_merge.Merger.from_revision_ids(None,
2692
 
            wt, 'E-id')
 
2779
        merger = _mod_merge.Merger.from_revision_ids(wt, 'E-id')
2693
2780
        merger.merge_type = _mod_merge.Merge3Merger
2694
2781
        merge_obj = merger.make_merger()
2695
2782
        entries = list(merge_obj._entries_lca())
2840
2927
 
2841
2928
    def get_merger_factory(self):
2842
2929
        # Allows  the inner methods to access the test attributes
2843
 
        test = self
 
2930
        calls = self.calls
2844
2931
 
2845
2932
        class FooMerger(_mod_merge.ConfigurableFileMerger):
2846
2933
            name_prefix = "foo"
2847
2934
            default_files = ['bar']
2848
2935
 
2849
2936
            def merge_text(self, params):
2850
 
                test.calls.append('merge_text')
 
2937
                calls.append('merge_text')
2851
2938
                return ('not_applicable', None)
2852
2939
 
2853
2940
        def factory(merger):
2917
3004
        conflicts = builder.merge()
2918
3005
        # The hook should not call the merge_text() method
2919
3006
        self.assertEqual([], self.calls)
 
3007
 
 
3008
 
 
3009
class TestMergeIntoBase(tests.TestCaseWithTransport):
 
3010
 
 
3011
    def setup_simple_branch(self, relpath, shape=None, root_id=None):
 
3012
        """One commit, containing tree specified by optional shape.
 
3013
        
 
3014
        Default is empty tree (just root entry).
 
3015
        """
 
3016
        if root_id is None:
 
3017
            root_id = '%s-root-id' % (relpath,)
 
3018
        wt = self.make_branch_and_tree(relpath)
 
3019
        wt.set_root_id(root_id)
 
3020
        if shape is not None:
 
3021
            adjusted_shape = [relpath + '/' + elem for elem in shape]
 
3022
            self.build_tree(adjusted_shape)
 
3023
            ids = ['%s-%s-id' % (relpath, basename(elem.rstrip('/')))
 
3024
                   for elem in shape]
 
3025
            wt.add(shape, ids=ids)
 
3026
        rev_id = 'r1-%s' % (relpath,)
 
3027
        wt.commit("Initial commit of %s" % (relpath,), rev_id=rev_id)
 
3028
        self.assertEqual(root_id, wt.path2id(''))
 
3029
        return wt
 
3030
 
 
3031
    def setup_two_branches(self, custom_root_ids=True):
 
3032
        """Setup 2 branches, one will be a library, the other a project."""
 
3033
        if custom_root_ids:
 
3034
            root_id = None
 
3035
        else:
 
3036
            root_id = inventory.ROOT_ID
 
3037
        project_wt = self.setup_simple_branch(
 
3038
            'project', ['README', 'dir/', 'dir/file.c'],
 
3039
            root_id)
 
3040
        lib_wt = self.setup_simple_branch(
 
3041
            'lib1', ['README', 'Makefile', 'foo.c'], root_id)
 
3042
 
 
3043
        return project_wt, lib_wt
 
3044
 
 
3045
    def do_merge_into(self, location, merge_as):
 
3046
        """Helper for using MergeIntoMerger.
 
3047
        
 
3048
        :param location: location of directory to merge from, either the
 
3049
            location of a branch or of a path inside a branch.
 
3050
        :param merge_as: the path in a tree to add the new directory as.
 
3051
        :returns: the conflicts from 'do_merge'.
 
3052
        """
 
3053
        operation = cleanup.OperationWithCleanups(self._merge_into)
 
3054
        return operation.run(location, merge_as)
 
3055
 
 
3056
    def _merge_into(self, op, location, merge_as):
 
3057
        # Open and lock the various tree and branch objects
 
3058
        wt, subdir_relpath = WorkingTree.open_containing(merge_as)
 
3059
        op.add_cleanup(wt.lock_write().unlock)
 
3060
        branch_to_merge, subdir_to_merge = _mod_branch.Branch.open_containing(
 
3061
            location)
 
3062
        op.add_cleanup(branch_to_merge.lock_read().unlock)
 
3063
        other_tree = branch_to_merge.basis_tree()
 
3064
        op.add_cleanup(other_tree.lock_read().unlock)
 
3065
        # Perform the merge
 
3066
        merger = _mod_merge.MergeIntoMerger(this_tree=wt, other_tree=other_tree,
 
3067
            other_branch=branch_to_merge, target_subdir=subdir_relpath,
 
3068
            source_subpath=subdir_to_merge)
 
3069
        merger.set_base_revision(_mod_revision.NULL_REVISION, branch_to_merge)
 
3070
        conflicts = merger.do_merge()
 
3071
        merger.set_pending()
 
3072
        return conflicts
 
3073
 
 
3074
    def assertTreeEntriesEqual(self, expected_entries, tree):
 
3075
        """Assert that 'tree' contains the expected inventory entries.
 
3076
 
 
3077
        :param expected_entries: sequence of (path, file-id) pairs.
 
3078
        """
 
3079
        files = [(path, ie.file_id) for path, ie in tree.iter_entries_by_dir()]
 
3080
        self.assertEqual(expected_entries, files)
 
3081
 
 
3082
 
 
3083
class TestMergeInto(TestMergeIntoBase):
 
3084
 
 
3085
    def test_newdir_with_unique_roots(self):
 
3086
        """Merge a branch with a unique root into a new directory."""
 
3087
        project_wt, lib_wt = self.setup_two_branches()
 
3088
        self.do_merge_into('lib1', 'project/lib1')
 
3089
        project_wt.lock_read()
 
3090
        self.addCleanup(project_wt.unlock)
 
3091
        # The r1-lib1 revision should be merged into this one
 
3092
        self.assertEqual(['r1-project', 'r1-lib1'], project_wt.get_parent_ids())
 
3093
        self.assertTreeEntriesEqual(
 
3094
            [('', 'project-root-id'),
 
3095
             ('README', 'project-README-id'),
 
3096
             ('dir', 'project-dir-id'),
 
3097
             ('lib1', 'lib1-root-id'),
 
3098
             ('dir/file.c', 'project-file.c-id'),
 
3099
             ('lib1/Makefile', 'lib1-Makefile-id'),
 
3100
             ('lib1/README', 'lib1-README-id'),
 
3101
             ('lib1/foo.c', 'lib1-foo.c-id'),
 
3102
            ], project_wt)
 
3103
 
 
3104
    def test_subdir(self):
 
3105
        """Merge a branch into a subdirectory of an existing directory."""
 
3106
        project_wt, lib_wt = self.setup_two_branches()
 
3107
        self.do_merge_into('lib1', 'project/dir/lib1')
 
3108
        project_wt.lock_read()
 
3109
        self.addCleanup(project_wt.unlock)
 
3110
        # The r1-lib1 revision should be merged into this one
 
3111
        self.assertEqual(['r1-project', 'r1-lib1'], project_wt.get_parent_ids())
 
3112
        self.assertTreeEntriesEqual(
 
3113
            [('', 'project-root-id'),
 
3114
             ('README', 'project-README-id'),
 
3115
             ('dir', 'project-dir-id'),
 
3116
             ('dir/file.c', 'project-file.c-id'),
 
3117
             ('dir/lib1', 'lib1-root-id'),
 
3118
             ('dir/lib1/Makefile', 'lib1-Makefile-id'),
 
3119
             ('dir/lib1/README', 'lib1-README-id'),
 
3120
             ('dir/lib1/foo.c', 'lib1-foo.c-id'),
 
3121
            ], project_wt)
 
3122
 
 
3123
    def test_newdir_with_repeat_roots(self):
 
3124
        """If the file-id of the dir to be merged already exists a new ID will
 
3125
        be allocated to let the merge happen.
 
3126
        """
 
3127
        project_wt, lib_wt = self.setup_two_branches(custom_root_ids=False)
 
3128
        root_id = project_wt.path2id('')
 
3129
        self.do_merge_into('lib1', 'project/lib1')
 
3130
        project_wt.lock_read()
 
3131
        self.addCleanup(project_wt.unlock)
 
3132
        # The r1-lib1 revision should be merged into this one
 
3133
        self.assertEqual(['r1-project', 'r1-lib1'], project_wt.get_parent_ids())
 
3134
        new_lib1_id = project_wt.path2id('lib1')
 
3135
        self.assertNotEqual(None, new_lib1_id)
 
3136
        self.assertTreeEntriesEqual(
 
3137
            [('', root_id),
 
3138
             ('README', 'project-README-id'),
 
3139
             ('dir', 'project-dir-id'),
 
3140
             ('lib1', new_lib1_id),
 
3141
             ('dir/file.c', 'project-file.c-id'),
 
3142
             ('lib1/Makefile', 'lib1-Makefile-id'),
 
3143
             ('lib1/README', 'lib1-README-id'),
 
3144
             ('lib1/foo.c', 'lib1-foo.c-id'),
 
3145
            ], project_wt)
 
3146
 
 
3147
    def test_name_conflict(self):
 
3148
        """When the target directory name already exists a conflict is
 
3149
        generated and the original directory is renamed to foo.moved.
 
3150
        """
 
3151
        dest_wt = self.setup_simple_branch('dest', ['dir/', 'dir/file.txt'])
 
3152
        src_wt = self.setup_simple_branch('src', ['README'])
 
3153
        conflicts = self.do_merge_into('src', 'dest/dir')
 
3154
        self.assertEqual(1, conflicts)
 
3155
        dest_wt.lock_read()
 
3156
        self.addCleanup(dest_wt.unlock)
 
3157
        # The r1-lib1 revision should be merged into this one
 
3158
        self.assertEqual(['r1-dest', 'r1-src'], dest_wt.get_parent_ids())
 
3159
        self.assertTreeEntriesEqual(
 
3160
            [('', 'dest-root-id'),
 
3161
             ('dir', 'src-root-id'),
 
3162
             ('dir.moved', 'dest-dir-id'),
 
3163
             ('dir/README', 'src-README-id'),
 
3164
             ('dir.moved/file.txt', 'dest-file.txt-id'),
 
3165
            ], dest_wt)
 
3166
 
 
3167
    def test_file_id_conflict(self):
 
3168
        """A conflict is generated if the merge-into adds a file (or other
 
3169
        inventory entry) with a file-id that already exists in the target tree.
 
3170
        """
 
3171
        dest_wt = self.setup_simple_branch('dest', ['file.txt'])
 
3172
        # Make a second tree with a file-id that will clash with file.txt in
 
3173
        # dest.
 
3174
        src_wt = self.make_branch_and_tree('src')
 
3175
        self.build_tree(['src/README'])
 
3176
        src_wt.add(['README'], ids=['dest-file.txt-id'])
 
3177
        src_wt.commit("Rev 1 of src.", rev_id='r1-src')
 
3178
        conflicts = self.do_merge_into('src', 'dest/dir')
 
3179
        # This is an edge case that shouldn't happen to users very often.  So
 
3180
        # we don't care really about the exact presentation of the conflict,
 
3181
        # just that there is one.
 
3182
        self.assertEqual(1, conflicts)
 
3183
 
 
3184
    def test_only_subdir(self):
 
3185
        """When the location points to just part of a tree, merge just that
 
3186
        subtree.
 
3187
        """
 
3188
        dest_wt = self.setup_simple_branch('dest')
 
3189
        src_wt = self.setup_simple_branch(
 
3190
            'src', ['hello.txt', 'dir/', 'dir/foo.c'])
 
3191
        conflicts = self.do_merge_into('src/dir', 'dest/dir')
 
3192
        dest_wt.lock_read()
 
3193
        self.addCleanup(dest_wt.unlock)
 
3194
        # The r1-lib1 revision should NOT be merged into this one (this is a
 
3195
        # partial merge).
 
3196
        self.assertEqual(['r1-dest'], dest_wt.get_parent_ids())
 
3197
        self.assertTreeEntriesEqual(
 
3198
            [('', 'dest-root-id'),
 
3199
             ('dir', 'src-dir-id'),
 
3200
             ('dir/foo.c', 'src-foo.c-id'),
 
3201
            ], dest_wt)
 
3202
 
 
3203
    def test_only_file(self):
 
3204
        """An edge case: merge just one file, not a whole dir."""
 
3205
        dest_wt = self.setup_simple_branch('dest')
 
3206
        two_file_wt = self.setup_simple_branch(
 
3207
            'two-file', ['file1.txt', 'file2.txt'])
 
3208
        conflicts = self.do_merge_into('two-file/file1.txt', 'dest/file1.txt')
 
3209
        dest_wt.lock_read()
 
3210
        self.addCleanup(dest_wt.unlock)
 
3211
        # The r1-lib1 revision should NOT be merged into this one
 
3212
        self.assertEqual(['r1-dest'], dest_wt.get_parent_ids())
 
3213
        self.assertTreeEntriesEqual(
 
3214
            [('', 'dest-root-id'), ('file1.txt', 'two-file-file1.txt-id')],
 
3215
            dest_wt)
 
3216
 
 
3217
    def test_no_such_source_path(self):
 
3218
        """PathNotInTree is raised if the specified path in the source tree
 
3219
        does not exist.
 
3220
        """
 
3221
        dest_wt = self.setup_simple_branch('dest')
 
3222
        two_file_wt = self.setup_simple_branch('src', ['dir/'])
 
3223
        self.assertRaises(_mod_merge.PathNotInTree, self.do_merge_into,
 
3224
            'src/no-such-dir', 'dest/foo')
 
3225
        dest_wt.lock_read()
 
3226
        self.addCleanup(dest_wt.unlock)
 
3227
        # The dest tree is unmodified.
 
3228
        self.assertEqual(['r1-dest'], dest_wt.get_parent_ids())
 
3229
        self.assertTreeEntriesEqual([('', 'dest-root-id')], dest_wt)
 
3230
 
 
3231
    def test_no_such_target_path(self):
 
3232
        """PathNotInTree is also raised if the specified path in the target
 
3233
        tree does not exist.
 
3234
        """
 
3235
        dest_wt = self.setup_simple_branch('dest')
 
3236
        two_file_wt = self.setup_simple_branch('src', ['file.txt'])
 
3237
        self.assertRaises(_mod_merge.PathNotInTree, self.do_merge_into,
 
3238
            'src', 'dest/no-such-dir/foo')
 
3239
        dest_wt.lock_read()
 
3240
        self.addCleanup(dest_wt.unlock)
 
3241
        # The dest tree is unmodified.
 
3242
        self.assertEqual(['r1-dest'], dest_wt.get_parent_ids())
 
3243
        self.assertTreeEntriesEqual([('', 'dest-root-id')], dest_wt)
 
3244
 
 
3245
 
 
3246
class TestMergeHooks(TestCaseWithTransport):
 
3247
 
 
3248
    def setUp(self):
 
3249
        super(TestMergeHooks, self).setUp()
 
3250
        self.tree_a = self.make_branch_and_tree('tree_a')
 
3251
        self.build_tree_contents([('tree_a/file', 'content_1')])
 
3252
        self.tree_a.add('file', 'file-id')
 
3253
        self.tree_a.commit('added file')
 
3254
 
 
3255
        self.tree_b = self.tree_a.controldir.sprout('tree_b').open_workingtree()
 
3256
        self.build_tree_contents([('tree_b/file', 'content_2')])
 
3257
        self.tree_b.commit('modify file')
 
3258
 
 
3259
    def test_pre_merge_hook_inject_different_tree(self):
 
3260
        tree_c = self.tree_b.controldir.sprout('tree_c').open_workingtree()
 
3261
        self.build_tree_contents([('tree_c/file', 'content_3')])
 
3262
        tree_c.commit("more content")
 
3263
        calls = []
 
3264
        def factory(merger):
 
3265
            self.assertIsInstance(merger, _mod_merge.Merge3Merger)
 
3266
            merger.other_tree = tree_c
 
3267
            calls.append(merger)
 
3268
        _mod_merge.Merger.hooks.install_named_hook('pre_merge',
 
3269
                                                   factory, 'test factory')
 
3270
        self.tree_a.merge_from_branch(self.tree_b.branch)
 
3271
 
 
3272
        self.assertFileEqual("content_3", 'tree_a/file')
 
3273
        self.assertLength(1, calls)
 
3274
 
 
3275
    def test_post_merge_hook_called(self):
 
3276
        calls = []
 
3277
        def factory(merger):
 
3278
            self.assertIsInstance(merger, _mod_merge.Merge3Merger)
 
3279
            calls.append(merger)
 
3280
        _mod_merge.Merger.hooks.install_named_hook('post_merge',
 
3281
                                                   factory, 'test factory')
 
3282
 
 
3283
        self.tree_a.merge_from_branch(self.tree_b.branch)
 
3284
 
 
3285
        self.assertFileEqual("content_2", 'tree_a/file')
 
3286
        self.assertLength(1, calls)