← 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: 2011-08-17 18:13:57 UTC
  • mfrom: (5268.7.29 transport-segments)
  • Revision ID: pqm@pqm.ubuntu.com-20110817181357-y5q5eth1hk8bl3om
(jelmer) Allow specifying the colocated branch to use in the branch URL,
 and retrieving the branch name using ControlDir._get_selected_branch.
 (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_merge.py
18
18
from StringIO import StringIO
19
19
 
20
20
from bzrlib import (
 
21
    branch as _mod_branch,
 
22
    cleanup,
21
23
    conflicts,
22
24
    errors,
 
25
    inventory,
23
26
    knit,
24
27
    memorytree,
25
28
    merge as _mod_merge,
26
29
    option,
27
 
    progress,
 
30
    revision as _mod_revision,
28
31
    tests,
29
32
    transform,
30
33
    versionedfile,
32
35
from bzrlib.conflicts import ConflictList, TextConflict
33
36
from bzrlib.errors import UnrelatedBranches, NoCommits
34
37
from bzrlib.merge import transform_tree, merge_inner, _PlanMerge
35
 
from bzrlib.osutils import pathjoin, file_kind
 
38
from bzrlib.osutils import basename, pathjoin, file_kind
36
39
from bzrlib.tests import (
 
40
    features,
37
41
    TestCaseWithMemoryTransport,
38
42
    TestCaseWithTransport,
39
43
    test_merge_core,
87
91
        os.chdir('branch2')
88
92
        self.run_bzr('merge ../branch1/baz', retcode=3)
89
93
        self.run_bzr('merge ../branch1/foo')
90
 
        self.failUnlessExists('foo')
91
 
        self.failIfExists('bar')
 
94
        self.assertPathExists('foo')
 
95
        self.assertPathDoesNotExist('bar')
92
96
        wt2 = WorkingTree.open('.') # opens branch2
93
97
        self.assertEqual([tip], wt2.get_parent_ids())
94
98
 
118
122
        finally:
119
123
            wt1.unlock()
120
124
 
 
125
    def test_merge_into_null_tree(self):
 
126
        wt = self.make_branch_and_tree('tree')
 
127
        null_tree = wt.basis_tree()
 
128
        self.build_tree(['tree/file'])
 
129
        wt.add('file')
 
130
        wt.commit('tree with root')
 
131
        merger = _mod_merge.Merge3Merger(null_tree, null_tree, null_tree, wt,
 
132
                                         this_branch=wt.branch,
 
133
                                         do_merge=False)
 
134
        with merger.make_preview_transform() as tt:
 
135
            self.assertEqual([], tt.find_conflicts())
 
136
            preview = tt.get_preview_tree()
 
137
            self.assertEqual(wt.get_root_id(), preview.get_root_id())
 
138
 
 
139
    def test_merge_unrelated_retains_root(self):
 
140
        wt = self.make_branch_and_tree('tree')
 
141
        other_tree = self.make_branch_and_tree('other')
 
142
        self.addCleanup(other_tree.lock_read().unlock)
 
143
        merger = _mod_merge.Merge3Merger(wt, wt, wt.basis_tree(), other_tree,
 
144
                                         this_branch=wt.branch,
 
145
                                         do_merge=False)
 
146
        with transform.TransformPreview(wt) as merger.tt:
 
147
            merger._compute_transform()
 
148
            new_root_id = merger.tt.final_file_id(merger.tt.root)
 
149
            self.assertEqual(wt.get_root_id(), new_root_id)
 
150
 
121
151
    def test_create_rename(self):
122
152
        """Rename an inventory entry while creating the file"""
123
153
        tree =self.make_branch_and_tree('.')
154
184
        log = StringIO()
155
185
        merge_inner(tree_b.branch, tree_a, tree_b.basis_tree(),
156
186
                    this_tree=tree_b, ignore_zero=True)
157
 
        self.failUnless('All changes applied successfully.\n' not in
 
187
        self.assertTrue('All changes applied successfully.\n' not in
158
188
            self.get_log())
159
189
        tree_b.revert()
160
190
        merge_inner(tree_b.branch, tree_a, tree_b.basis_tree(),
161
191
                    this_tree=tree_b, ignore_zero=False)
162
 
        self.failUnless('All changes applied successfully.\n' in self.get_log())
 
192
        self.assertTrue('All changes applied successfully.\n' in self.get_log())
163
193
 
164
194
    def test_merge_inner_conflicts(self):
165
195
        tree_a = self.make_branch_and_tree('a')
295
325
        tree_a.commit('commit 2')
296
326
        tree_b = tree_a.bzrdir.sprout('b').open_workingtree()
297
327
        tree_b.rename_one('file_1', 'renamed')
298
 
        merger = _mod_merge.Merger.from_uncommitted(tree_a, tree_b,
299
 
                                                    progress.DummyProgress())
 
328
        merger = _mod_merge.Merger.from_uncommitted(tree_a, tree_b)
300
329
        merger.merge_type = _mod_merge.Merge3Merger
301
330
        merger.do_merge()
302
331
        self.assertEqual(tree_a.get_parent_ids(), [tree_b.last_revision()])
310
339
        tree_a.commit('commit 2')
311
340
        tree_b = tree_a.bzrdir.sprout('b').open_workingtree()
312
341
        tree_b.rename_one('file_1', 'renamed')
313
 
        merger = _mod_merge.Merger.from_uncommitted(tree_a, tree_b,
314
 
                                                    progress.DummyProgress())
 
342
        merger = _mod_merge.Merger.from_uncommitted(tree_a, tree_b)
315
343
        merger.merge_type = _mod_merge.WeaveMerger
316
344
        merger.do_merge()
317
345
        self.assertEqual(tree_a.get_parent_ids(), [tree_b.last_revision()])
318
346
 
319
 
    def test_Merger_defaults_to_DummyProgress(self):
320
 
        branch = self.make_branch('branch')
321
 
        merger = _mod_merge.Merger(branch, pb=None)
322
 
        self.assertIsInstance(merger._pb, progress.DummyProgress)
323
 
 
324
347
    def prepare_cherrypick(self):
325
348
        """Prepare a pair of trees for cherrypicking tests.
326
349
 
347
370
 
348
371
    def test_weave_cherrypick(self):
349
372
        this_tree, other_tree = self.prepare_cherrypick()
350
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
373
        merger = _mod_merge.Merger.from_revision_ids(None,
351
374
            this_tree, 'rev3b', 'rev2b', other_tree.branch)
352
375
        merger.merge_type = _mod_merge.WeaveMerger
353
376
        merger.do_merge()
355
378
 
356
379
    def test_weave_cannot_reverse_cherrypick(self):
357
380
        this_tree, other_tree = self.prepare_cherrypick()
358
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
381
        merger = _mod_merge.Merger.from_revision_ids(None,
359
382
            this_tree, 'rev2b', 'rev3b', other_tree.branch)
360
383
        merger.merge_type = _mod_merge.WeaveMerger
361
384
        self.assertRaises(errors.CannotReverseCherrypick, merger.do_merge)
362
385
 
363
386
    def test_merge3_can_reverse_cherrypick(self):
364
387
        this_tree, other_tree = self.prepare_cherrypick()
365
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
388
        merger = _mod_merge.Merger.from_revision_ids(None,
366
389
            this_tree, 'rev2b', 'rev3b', other_tree.branch)
367
390
        merger.merge_type = _mod_merge.Merge3Merger
368
391
        merger.do_merge()
380
403
        this_tree.lock_write()
381
404
        self.addCleanup(this_tree.unlock)
382
405
 
383
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
406
        merger = _mod_merge.Merger.from_revision_ids(None,
384
407
            this_tree, 'rev3b', 'rev2b', other_tree.branch)
385
408
        merger.merge_type = _mod_merge.Merge3Merger
386
409
        merger.do_merge()
391
414
                             '>>>>>>> MERGE-SOURCE\n',
392
415
                             'this/file')
393
416
 
 
417
    def test_merge_reverse_revision_range(self):
 
418
        tree = self.make_branch_and_tree(".")
 
419
        tree.lock_write()
 
420
        self.addCleanup(tree.unlock)
 
421
        self.build_tree(['a'])
 
422
        tree.add('a')
 
423
        tree.commit("added a")
 
424
        first_rev = tree.branch.revision_history()[0]
 
425
        merger = _mod_merge.Merger.from_revision_ids(None, tree,
 
426
                                          _mod_revision.NULL_REVISION,
 
427
                                          first_rev)
 
428
        merger.merge_type = _mod_merge.Merge3Merger
 
429
        merger.interesting_files = 'a'
 
430
        conflict_count = merger.do_merge()
 
431
        self.assertEqual(0, conflict_count)
 
432
 
 
433
        self.assertPathDoesNotExist("a")
 
434
        tree.revert()
 
435
        self.assertPathExists("a")
 
436
 
394
437
    def test_make_merger(self):
395
438
        this_tree = self.make_branch_and_tree('this')
396
439
        this_tree.commit('rev1', rev_id='rev1')
399
442
        other_tree.commit('rev2', rev_id='rev2b')
400
443
        this_tree.lock_write()
401
444
        self.addCleanup(this_tree.unlock)
402
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress,
 
445
        merger = _mod_merge.Merger.from_revision_ids(None,
403
446
            this_tree, 'rev2b', other_branch=other_tree.branch)
404
447
        merger.merge_type = _mod_merge.Merge3Merger
405
448
        tree_merger = merger.make_merger()
419
462
        other_tree.commit('rev2', rev_id='rev2b')
420
463
        this_tree.lock_write()
421
464
        self.addCleanup(this_tree.unlock)
422
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
465
        merger = _mod_merge.Merger.from_revision_ids(None,
423
466
            this_tree, 'rev2b', other_branch=other_tree.branch)
424
467
        merger.merge_type = _mod_merge.Merge3Merger
425
468
        tree_merger = merger.make_merger()
449
492
        other_tree.commit('rev2', rev_id='rev2b')
450
493
        this_tree.lock_write()
451
494
        self.addCleanup(this_tree.unlock)
452
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
495
        merger = _mod_merge.Merger.from_revision_ids(None,
453
496
            this_tree, 'rev2b', other_branch=other_tree.branch)
454
497
        merger.merge_type = _mod_merge.Merge3Merger
455
498
        tree_merger = merger.make_merger()
460
503
        finally:
461
504
            tree_file.close()
462
505
 
 
506
    def test_merge_require_tree_root(self):
 
507
        tree = self.make_branch_and_tree(".")
 
508
        tree.lock_write()
 
509
        self.addCleanup(tree.unlock)
 
510
        self.build_tree(['a'])
 
511
        tree.add('a')
 
512
        tree.commit("added a")
 
513
        old_root_id = tree.get_root_id()
 
514
        first_rev = tree.branch.revision_history()[0]
 
515
        merger = _mod_merge.Merger.from_revision_ids(None, tree,
 
516
                                          _mod_revision.NULL_REVISION,
 
517
                                          first_rev)
 
518
        merger.merge_type = _mod_merge.Merge3Merger
 
519
        conflict_count = merger.do_merge()
 
520
        self.assertEqual(0, conflict_count)
 
521
        self.assertEquals(set([old_root_id]), tree.all_file_ids())
 
522
        tree.set_parent_ids([])
 
523
 
463
524
    def test_merge_add_into_deleted_root(self):
464
525
        # Yes, people actually do this.  And report bugs if it breaks.
465
526
        source = self.make_branch_and_tree('source', format='rich-root-pack')
1205
1266
        mem_tree = memorytree.MemoryTree.create_on_branch(builder.get_branch())
1206
1267
        mem_tree.lock_write()
1207
1268
        self.addCleanup(mem_tree.unlock)
1208
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
1269
        merger = _mod_merge.Merger.from_revision_ids(None,
1209
1270
            mem_tree, other_revision_id)
1210
1271
        merger.set_interesting_files(interesting_files)
1211
1272
        # It seems there is no matching function for set_interesting_ids
1274
1335
        self.assertEqual(['B-id', 'C-id', 'F-id'],
1275
1336
                         [t.get_revision_id() for t in merger._lca_trees])
1276
1337
 
 
1338
    def test_find_base_new_root_criss_cross(self):
 
1339
        # A   B
 
1340
        # |\ /|
 
1341
        # | X |
 
1342
        # |/ \|
 
1343
        # C   D
 
1344
        
 
1345
        builder = self.get_builder()
 
1346
        builder.build_snapshot('A-id', None,
 
1347
            [('add', ('', None, 'directory', None))])
 
1348
        builder.build_snapshot('B-id', [],
 
1349
            [('add', ('', None, 'directory', None))])
 
1350
        builder.build_snapshot('D-id', ['A-id', 'B-id'], [])
 
1351
        builder.build_snapshot('C-id', ['A-id', 'B-id'], [])
 
1352
        merger = self.make_Merger(builder, 'D-id')
 
1353
        self.assertEqual('A-id', merger.base_rev_id)
 
1354
        self.assertTrue(merger._is_criss_cross)
 
1355
        self.assertEqual(['A-id', 'B-id'], [t.get_revision_id()
 
1356
                                            for t in merger._lca_trees])
 
1357
 
1277
1358
    def test_no_criss_cross_passed_to_merge_type(self):
1278
1359
        class LCATreesMerger(LoggingMerger):
1279
1360
            supports_lca_trees = True
1811
1892
        builder.build_snapshot('C-id', ['A-id'], [])
1812
1893
        builder.build_snapshot('E-id', ['C-id', 'B-id'],
1813
1894
            [('unversion', 'a-id'),
 
1895
             ('flush', None),
1814
1896
             ('add', (u'a', 'a-id', 'directory', None))])
1815
1897
        builder.build_snapshot('D-id', ['B-id', 'C-id'], [])
1816
1898
        merge_obj = self.make_merge_obj(builder, 'E-id')
1834
1916
        builder.build_snapshot('E-id', ['C-id', 'B-id'], [])
1835
1917
        builder.build_snapshot('D-id', ['B-id', 'C-id'],
1836
1918
            [('unversion', 'a-id'),
 
1919
             ('flush', None),
1837
1920
             ('add', (u'a', 'a-id', 'directory', None))])
1838
1921
        merge_obj = self.make_merge_obj(builder, 'E-id')
1839
1922
        entries = list(merge_obj._entries_lca())
1985
2068
 
1986
2069
    def do_merge(self, builder, other_revision_id):
1987
2070
        wt = self.get_wt_from_builder(builder)
1988
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
2071
        merger = _mod_merge.Merger.from_revision_ids(None,
1989
2072
            wt, other_revision_id)
1990
2073
        merger.merge_type = _mod_merge.Merge3Merger
1991
2074
        return wt, merger.do_merge()
2102
2185
        self.assertTrue(wt.is_executable('foo-id'))
2103
2186
 
2104
2187
    def test_create_symlink(self):
2105
 
        self.requireFeature(tests.SymlinkFeature)
 
2188
        self.requireFeature(features.SymlinkFeature)
2106
2189
        #   A
2107
2190
        #  / \
2108
2191
        # B   C
2167
2250
                             wt.get_file_text('foo-id'))
2168
2251
 
2169
2252
    def test_modified_symlink(self):
2170
 
        self.requireFeature(tests.SymlinkFeature)
 
2253
        self.requireFeature(features.SymlinkFeature)
2171
2254
        #   A       Create symlink foo => bar
2172
2255
        #  / \
2173
2256
        # B   C     B relinks foo => baz
2212
2295
        self.assertEqual('bing', wt.get_symlink_target('foo-id'))
2213
2296
 
2214
2297
    def test_renamed_symlink(self):
2215
 
        self.requireFeature(tests.SymlinkFeature)
 
2298
        self.requireFeature(features.SymlinkFeature)
2216
2299
        #   A       Create symlink foo => bar
2217
2300
        #  / \
2218
2301
        # B   C     B renames foo => barry
2251
2334
        wt.commit('D merges B & C', rev_id='D-id')
2252
2335
        self.assertEqual('barry', wt.id2path('foo-id'))
2253
2336
        # Check the output of the Merger object directly
2254
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
2337
        merger = _mod_merge.Merger.from_revision_ids(None,
2255
2338
            wt, 'F-id')
2256
2339
        merger.merge_type = _mod_merge.Merge3Merger
2257
2340
        merge_obj = merger.make_merger()
2268
2351
        self.assertEqual('blah', wt.id2path('foo-id'))
2269
2352
 
2270
2353
    def test_symlink_no_content_change(self):
2271
 
        self.requireFeature(tests.SymlinkFeature)
 
2354
        self.requireFeature(features.SymlinkFeature)
2272
2355
        #   A       Create symlink foo => bar
2273
2356
        #  / \
2274
2357
        # B   C     B relinks foo => baz
2307
2390
        wt.commit('F foo => bing', rev_id='F-id')
2308
2391
 
2309
2392
        # Check the output of the Merger object directly
2310
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
2393
        merger = _mod_merge.Merger.from_revision_ids(None,
2311
2394
            wt, 'E-id')
2312
2395
        merger.merge_type = _mod_merge.Merge3Merger
2313
2396
        merge_obj = merger.make_merger()
2319
2402
        self.assertEqual('bing', wt.get_symlink_target('foo-id'))
2320
2403
 
2321
2404
    def test_symlink_this_changed_kind(self):
2322
 
        self.requireFeature(tests.SymlinkFeature)
 
2405
        self.requireFeature(features.SymlinkFeature)
2323
2406
        #   A       Nothing
2324
2407
        #  / \
2325
2408
        # B   C     B creates symlink foo => bar
2358
2441
        list(wt.iter_changes(wt.basis_tree()))
2359
2442
        wt.commit('D merges B & C, makes it a file', rev_id='D-id')
2360
2443
 
2361
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
2444
        merger = _mod_merge.Merger.from_revision_ids(None,
2362
2445
            wt, 'E-id')
2363
2446
        merger.merge_type = _mod_merge.Merge3Merger
2364
2447
        merge_obj = merger.make_merger()
2372
2455
 
2373
2456
    def test_symlink_all_wt(self):
2374
2457
        """Check behavior if all trees are Working Trees."""
2375
 
        self.requireFeature(tests.SymlinkFeature)
 
2458
        self.requireFeature(features.SymlinkFeature)
2376
2459
        # The big issue is that entry.symlink_target is None for WorkingTrees.
2377
2460
        # So we need to make sure we handle that case correctly.
2378
2461
        #   A   foo => bar
2573
2656
        wt.branch.set_last_revision_info(2, 'B-id')
2574
2657
        wt.commit('D', rev_id='D-id', recursive=None)
2575
2658
 
2576
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
2659
        merger = _mod_merge.Merger.from_revision_ids(None,
2577
2660
            wt, 'E-id')
2578
2661
        merger.merge_type = _mod_merge.Merge3Merger
2579
2662
        merge_obj = merger.make_merger()
2610
2693
        wt.branch.set_last_revision_info(2, 'B-id')
2611
2694
        wt.commit('D', rev_id='D-id', recursive=None)
2612
2695
 
2613
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
2696
        merger = _mod_merge.Merger.from_revision_ids(None,
2614
2697
            wt, 'E-id')
2615
2698
        merger.merge_type = _mod_merge.Merge3Merger
2616
2699
        merge_obj = merger.make_merger()
2650
2733
        wt.branch.set_last_revision_info(2, 'B-id')
2651
2734
        wt.commit('D', rev_id='D-id', recursive=None)
2652
2735
 
2653
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
2736
        merger = _mod_merge.Merger.from_revision_ids(None,
2654
2737
            wt, 'E-id')
2655
2738
        merger.merge_type = _mod_merge.Merge3Merger
2656
2739
        merge_obj = merger.make_merger()
2695
2778
        wt.branch.set_last_revision_info(2, 'B-id')
2696
2779
        wt.commit('D', rev_id='D-id', recursive=None)
2697
2780
 
2698
 
        merger = _mod_merge.Merger.from_revision_ids(progress.DummyProgress(),
 
2781
        merger = _mod_merge.Merger.from_revision_ids(None,
2699
2782
            wt, 'E-id')
2700
2783
        merger.merge_type = _mod_merge.Merge3Merger
2701
2784
        merge_obj = merger.make_merger()
2847
2930
 
2848
2931
    def get_merger_factory(self):
2849
2932
        # Allows  the inner methods to access the test attributes
2850
 
        test = self
 
2933
        calls = self.calls
2851
2934
 
2852
2935
        class FooMerger(_mod_merge.ConfigurableFileMerger):
2853
2936
            name_prefix = "foo"
2854
2937
            default_files = ['bar']
2855
2938
 
2856
2939
            def merge_text(self, params):
2857
 
                test.calls.append('merge_text')
 
2940
                calls.append('merge_text')
2858
2941
                return ('not_applicable', None)
2859
2942
 
2860
2943
        def factory(merger):
2894
2977
                        base=False, other=False)
2895
2978
        return builder
2896
2979
 
 
2980
    def test_uses_this_branch(self):
 
2981
        builder = self.make_text_conflict()
 
2982
        tt = builder.make_preview_transform()
 
2983
        self.addCleanup(tt.finalize)
 
2984
 
2897
2985
    def test_affected_files_cached(self):
2898
2986
        """Ensures that the config variable is cached"""
2899
2987
        builder = self.make_text_conflict()
2919
3007
        conflicts = builder.merge()
2920
3008
        # The hook should not call the merge_text() method
2921
3009
        self.assertEqual([], self.calls)
 
3010
 
 
3011
 
 
3012
class TestMergeIntoBase(tests.TestCaseWithTransport):
 
3013
 
 
3014
    def setup_simple_branch(self, relpath, shape=None, root_id=None):
 
3015
        """One commit, containing tree specified by optional shape.
 
3016
        
 
3017
        Default is empty tree (just root entry).
 
3018
        """
 
3019
        if root_id is None:
 
3020
            root_id = '%s-root-id' % (relpath,)
 
3021
        wt = self.make_branch_and_tree(relpath)
 
3022
        wt.set_root_id(root_id)
 
3023
        if shape is not None:
 
3024
            adjusted_shape = [relpath + '/' + elem for elem in shape]
 
3025
            self.build_tree(adjusted_shape)
 
3026
            ids = ['%s-%s-id' % (relpath, basename(elem.rstrip('/')))
 
3027
                   for elem in shape]
 
3028
            wt.add(shape, ids=ids)
 
3029
        rev_id = 'r1-%s' % (relpath,)
 
3030
        wt.commit("Initial commit of %s" % (relpath,), rev_id=rev_id)
 
3031
        self.assertEqual(root_id, wt.path2id(''))
 
3032
        return wt
 
3033
 
 
3034
    def setup_two_branches(self, custom_root_ids=True):
 
3035
        """Setup 2 branches, one will be a library, the other a project."""
 
3036
        if custom_root_ids:
 
3037
            root_id = None
 
3038
        else:
 
3039
            root_id = inventory.ROOT_ID
 
3040
        project_wt = self.setup_simple_branch(
 
3041
            'project', ['README', 'dir/', 'dir/file.c'],
 
3042
            root_id)
 
3043
        lib_wt = self.setup_simple_branch(
 
3044
            'lib1', ['README', 'Makefile', 'foo.c'], root_id)
 
3045
 
 
3046
        return project_wt, lib_wt
 
3047
 
 
3048
    def do_merge_into(self, location, merge_as):
 
3049
        """Helper for using MergeIntoMerger.
 
3050
        
 
3051
        :param location: location of directory to merge from, either the
 
3052
            location of a branch or of a path inside a branch.
 
3053
        :param merge_as: the path in a tree to add the new directory as.
 
3054
        :returns: the conflicts from 'do_merge'.
 
3055
        """
 
3056
        operation = cleanup.OperationWithCleanups(self._merge_into)
 
3057
        return operation.run(location, merge_as)
 
3058
 
 
3059
    def _merge_into(self, op, location, merge_as):
 
3060
        # Open and lock the various tree and branch objects
 
3061
        wt, subdir_relpath = WorkingTree.open_containing(merge_as)
 
3062
        op.add_cleanup(wt.lock_write().unlock)
 
3063
        branch_to_merge, subdir_to_merge = _mod_branch.Branch.open_containing(
 
3064
            location)
 
3065
        op.add_cleanup(branch_to_merge.lock_read().unlock)
 
3066
        other_tree = branch_to_merge.basis_tree()
 
3067
        op.add_cleanup(other_tree.lock_read().unlock)
 
3068
        # Perform the merge
 
3069
        merger = _mod_merge.MergeIntoMerger(this_tree=wt, other_tree=other_tree,
 
3070
            other_branch=branch_to_merge, target_subdir=subdir_relpath,
 
3071
            source_subpath=subdir_to_merge)
 
3072
        merger.set_base_revision(_mod_revision.NULL_REVISION, branch_to_merge)
 
3073
        conflicts = merger.do_merge()
 
3074
        merger.set_pending()
 
3075
        return conflicts
 
3076
 
 
3077
    def assertTreeEntriesEqual(self, expected_entries, tree):
 
3078
        """Assert that 'tree' contains the expected inventory entries.
 
3079
 
 
3080
        :param expected_entries: sequence of (path, file-id) pairs.
 
3081
        """
 
3082
        files = [(path, ie.file_id) for path, ie in tree.iter_entries_by_dir()]
 
3083
        self.assertEqual(expected_entries, files)
 
3084
 
 
3085
 
 
3086
class TestMergeInto(TestMergeIntoBase):
 
3087
 
 
3088
    def test_newdir_with_unique_roots(self):
 
3089
        """Merge a branch with a unique root into a new directory."""
 
3090
        project_wt, lib_wt = self.setup_two_branches()
 
3091
        self.do_merge_into('lib1', 'project/lib1')
 
3092
        project_wt.lock_read()
 
3093
        self.addCleanup(project_wt.unlock)
 
3094
        # The r1-lib1 revision should be merged into this one
 
3095
        self.assertEqual(['r1-project', 'r1-lib1'], project_wt.get_parent_ids())
 
3096
        self.assertTreeEntriesEqual(
 
3097
            [('', 'project-root-id'),
 
3098
             ('README', 'project-README-id'),
 
3099
             ('dir', 'project-dir-id'),
 
3100
             ('lib1', 'lib1-root-id'),
 
3101
             ('dir/file.c', 'project-file.c-id'),
 
3102
             ('lib1/Makefile', 'lib1-Makefile-id'),
 
3103
             ('lib1/README', 'lib1-README-id'),
 
3104
             ('lib1/foo.c', 'lib1-foo.c-id'),
 
3105
            ], project_wt)
 
3106
 
 
3107
    def test_subdir(self):
 
3108
        """Merge a branch into a subdirectory of an existing directory."""
 
3109
        project_wt, lib_wt = self.setup_two_branches()
 
3110
        self.do_merge_into('lib1', 'project/dir/lib1')
 
3111
        project_wt.lock_read()
 
3112
        self.addCleanup(project_wt.unlock)
 
3113
        # The r1-lib1 revision should be merged into this one
 
3114
        self.assertEqual(['r1-project', 'r1-lib1'], project_wt.get_parent_ids())
 
3115
        self.assertTreeEntriesEqual(
 
3116
            [('', 'project-root-id'),
 
3117
             ('README', 'project-README-id'),
 
3118
             ('dir', 'project-dir-id'),
 
3119
             ('dir/file.c', 'project-file.c-id'),
 
3120
             ('dir/lib1', 'lib1-root-id'),
 
3121
             ('dir/lib1/Makefile', 'lib1-Makefile-id'),
 
3122
             ('dir/lib1/README', 'lib1-README-id'),
 
3123
             ('dir/lib1/foo.c', 'lib1-foo.c-id'),
 
3124
            ], project_wt)
 
3125
 
 
3126
    def test_newdir_with_repeat_roots(self):
 
3127
        """If the file-id of the dir to be merged already exists a new ID will
 
3128
        be allocated to let the merge happen.
 
3129
        """
 
3130
        project_wt, lib_wt = self.setup_two_branches(custom_root_ids=False)
 
3131
        root_id = project_wt.path2id('')
 
3132
        self.do_merge_into('lib1', 'project/lib1')
 
3133
        project_wt.lock_read()
 
3134
        self.addCleanup(project_wt.unlock)
 
3135
        # The r1-lib1 revision should be merged into this one
 
3136
        self.assertEqual(['r1-project', 'r1-lib1'], project_wt.get_parent_ids())
 
3137
        new_lib1_id = project_wt.path2id('lib1')
 
3138
        self.assertNotEqual(None, new_lib1_id)
 
3139
        self.assertTreeEntriesEqual(
 
3140
            [('', root_id),
 
3141
             ('README', 'project-README-id'),
 
3142
             ('dir', 'project-dir-id'),
 
3143
             ('lib1', new_lib1_id),
 
3144
             ('dir/file.c', 'project-file.c-id'),
 
3145
             ('lib1/Makefile', 'lib1-Makefile-id'),
 
3146
             ('lib1/README', 'lib1-README-id'),
 
3147
             ('lib1/foo.c', 'lib1-foo.c-id'),
 
3148
            ], project_wt)
 
3149
 
 
3150
    def test_name_conflict(self):
 
3151
        """When the target directory name already exists a conflict is
 
3152
        generated and the original directory is renamed to foo.moved.
 
3153
        """
 
3154
        dest_wt = self.setup_simple_branch('dest', ['dir/', 'dir/file.txt'])
 
3155
        src_wt = self.setup_simple_branch('src', ['README'])
 
3156
        conflicts = self.do_merge_into('src', 'dest/dir')
 
3157
        self.assertEqual(1, conflicts)
 
3158
        dest_wt.lock_read()
 
3159
        self.addCleanup(dest_wt.unlock)
 
3160
        # The r1-lib1 revision should be merged into this one
 
3161
        self.assertEqual(['r1-dest', 'r1-src'], dest_wt.get_parent_ids())
 
3162
        self.assertTreeEntriesEqual(
 
3163
            [('', 'dest-root-id'),
 
3164
             ('dir', 'src-root-id'),
 
3165
             ('dir.moved', 'dest-dir-id'),
 
3166
             ('dir/README', 'src-README-id'),
 
3167
             ('dir.moved/file.txt', 'dest-file.txt-id'),
 
3168
            ], dest_wt)
 
3169
 
 
3170
    def test_file_id_conflict(self):
 
3171
        """A conflict is generated if the merge-into adds a file (or other
 
3172
        inventory entry) with a file-id that already exists in the target tree.
 
3173
        """
 
3174
        dest_wt = self.setup_simple_branch('dest', ['file.txt'])
 
3175
        # Make a second tree with a file-id that will clash with file.txt in
 
3176
        # dest.
 
3177
        src_wt = self.make_branch_and_tree('src')
 
3178
        self.build_tree(['src/README'])
 
3179
        src_wt.add(['README'], ids=['dest-file.txt-id'])
 
3180
        src_wt.commit("Rev 1 of src.", rev_id='r1-src')
 
3181
        conflicts = self.do_merge_into('src', 'dest/dir')
 
3182
        # This is an edge case that shouldn't happen to users very often.  So
 
3183
        # we don't care really about the exact presentation of the conflict,
 
3184
        # just that there is one.
 
3185
        self.assertEqual(1, conflicts)
 
3186
 
 
3187
    def test_only_subdir(self):
 
3188
        """When the location points to just part of a tree, merge just that
 
3189
        subtree.
 
3190
        """
 
3191
        dest_wt = self.setup_simple_branch('dest')
 
3192
        src_wt = self.setup_simple_branch(
 
3193
            'src', ['hello.txt', 'dir/', 'dir/foo.c'])
 
3194
        conflicts = self.do_merge_into('src/dir', 'dest/dir')
 
3195
        dest_wt.lock_read()
 
3196
        self.addCleanup(dest_wt.unlock)
 
3197
        # The r1-lib1 revision should NOT be merged into this one (this is a
 
3198
        # partial merge).
 
3199
        self.assertEqual(['r1-dest'], dest_wt.get_parent_ids())
 
3200
        self.assertTreeEntriesEqual(
 
3201
            [('', 'dest-root-id'),
 
3202
             ('dir', 'src-dir-id'),
 
3203
             ('dir/foo.c', 'src-foo.c-id'),
 
3204
            ], dest_wt)
 
3205
 
 
3206
    def test_only_file(self):
 
3207
        """An edge case: merge just one file, not a whole dir."""
 
3208
        dest_wt = self.setup_simple_branch('dest')
 
3209
        two_file_wt = self.setup_simple_branch(
 
3210
            'two-file', ['file1.txt', 'file2.txt'])
 
3211
        conflicts = self.do_merge_into('two-file/file1.txt', 'dest/file1.txt')
 
3212
        dest_wt.lock_read()
 
3213
        self.addCleanup(dest_wt.unlock)
 
3214
        # The r1-lib1 revision should NOT be merged into this one
 
3215
        self.assertEqual(['r1-dest'], dest_wt.get_parent_ids())
 
3216
        self.assertTreeEntriesEqual(
 
3217
            [('', 'dest-root-id'), ('file1.txt', 'two-file-file1.txt-id')],
 
3218
            dest_wt)
 
3219
 
 
3220
    def test_no_such_source_path(self):
 
3221
        """PathNotInTree is raised if the specified path in the source tree
 
3222
        does not exist.
 
3223
        """
 
3224
        dest_wt = self.setup_simple_branch('dest')
 
3225
        two_file_wt = self.setup_simple_branch('src', ['dir/'])
 
3226
        self.assertRaises(_mod_merge.PathNotInTree, self.do_merge_into,
 
3227
            'src/no-such-dir', 'dest/foo')
 
3228
        dest_wt.lock_read()
 
3229
        self.addCleanup(dest_wt.unlock)
 
3230
        # The dest tree is unmodified.
 
3231
        self.assertEqual(['r1-dest'], dest_wt.get_parent_ids())
 
3232
        self.assertTreeEntriesEqual([('', 'dest-root-id')], dest_wt)
 
3233
 
 
3234
    def test_no_such_target_path(self):
 
3235
        """PathNotInTree is also raised if the specified path in the target
 
3236
        tree does not exist.
 
3237
        """
 
3238
        dest_wt = self.setup_simple_branch('dest')
 
3239
        two_file_wt = self.setup_simple_branch('src', ['file.txt'])
 
3240
        self.assertRaises(_mod_merge.PathNotInTree, self.do_merge_into,
 
3241
            'src', 'dest/no-such-dir/foo')
 
3242
        dest_wt.lock_read()
 
3243
        self.addCleanup(dest_wt.unlock)
 
3244
        # The dest tree is unmodified.
 
3245
        self.assertEqual(['r1-dest'], dest_wt.get_parent_ids())
 
3246
        self.assertTreeEntriesEqual([('', 'dest-root-id')], dest_wt)