/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 bzrlib/tests/blackbox/test_merge.py

  • Committer: John Arbash Meinel
  • Date: 2009-06-17 19:08:25 UTC
  • mto: This revision was merged to the branch mainline in revision 4460.
  • Revision ID: john@arbash-meinel.com-20090617190825-ktfk82li57rf2im6
It seems that fetch() no longer returns the number of revisions fetched.
It still does for *some* InterRepository fetch paths, but the generic one does not.
It is also not easy to get it to, since the Source and Sink are the ones
that would know how many keys were transmitted, and they are potentially 'remote'
objects.

This was also only tested to occur as a by-product in a random 'test_commit' test.
I assume if we really wanted the assurance, we would have a per_repo or interrepo
test for it.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_merge.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
21
21
 
22
22
import os
23
23
 
24
 
from bzrlib import (
25
 
    branch,
26
 
    bzrdir,
27
 
    conflicts,
28
 
    errors,
29
 
    merge_directive,
30
 
    osutils,
31
 
    tests,
32
 
    urlutils,
33
 
    workingtree,
34
 
    )
35
 
 
36
 
 
37
 
class TestMerge(tests.TestCaseWithTransport):
 
24
from bzrlib import merge_directive
 
25
from bzrlib.branch import Branch
 
26
from bzrlib.bzrdir import BzrDir
 
27
from bzrlib.conflicts import ConflictList, ContentsConflict
 
28
from bzrlib.osutils import abspath, file_kind, pathjoin
 
29
from bzrlib.tests.blackbox import ExternalBase
 
30
import bzrlib.urlutils as urlutils
 
31
from bzrlib.workingtree import WorkingTree
 
32
 
 
33
 
 
34
class TestMerge(ExternalBase):
38
35
 
39
36
    def example_branch(self, path='.'):
40
37
        tree = self.make_branch_and_tree(path)
41
38
        self.build_tree_contents([
42
 
            (osutils.pathjoin(path, 'hello'), 'foo'),
43
 
            (osutils.pathjoin(path, 'goodbye'), 'baz')])
 
39
            (pathjoin(path, 'hello'), 'foo'),
 
40
            (pathjoin(path, 'goodbye'), 'baz')])
44
41
        tree.add('hello')
45
42
        tree.commit(message='setup')
46
43
        tree.add('goodbye')
66
63
        return tree, other
67
64
 
68
65
    def test_merge_reprocess(self):
69
 
        d = bzrdir.BzrDir.create_standalone_workingtree('.')
 
66
        d = BzrDir.create_standalone_workingtree('.')
70
67
        d.commit('h')
71
68
        self.run_bzr('merge . --reprocess --merge-type weave')
72
69
 
73
70
    def test_merge(self):
 
71
        from bzrlib.branch import Branch
 
72
 
74
73
        a_tree = self.example_branch('a')
75
74
        ancestor = a_tree.branch.revno()
76
75
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
81
80
        # We can't merge when there are in-tree changes
82
81
        os.chdir('a')
83
82
        self.run_bzr('merge ../b', retcode=3)
84
 
        a = workingtree.WorkingTree.open('.')
 
83
        a = WorkingTree.open('.')
85
84
        a_tip = a.commit("Like an epidemic of u's")
86
85
        self.run_bzr('merge ../b -r last:1..last:1 --merge-type blooof',
87
86
                    retcode=3)
100
99
        self.run_bzr('merge ../b -r last:1')
101
100
        self.check_file_contents('goodbye', 'quux')
102
101
        # Merging a branch pulls its revision into the tree
103
 
        b = branch.Branch.open('../b')
 
102
        b = Branch.open('../b')
104
103
        b_tip = b.last_revision()
105
104
        self.failUnless(a.branch.repository.has_revision(b_tip))
106
105
        self.assertEqual([a_tip, b_tip], a.get_parent_ids())
211
210
        self.failUnlessExists('sub/a.txt.OTHER')
212
211
        self.failUnlessExists('sub/a.txt.BASE')
213
212
 
214
 
    def test_conflict_leaves_base_this_other_files(self):
215
 
        tree, other = self.create_conflicting_branches()
216
 
        self.run_bzr('merge ../other', working_dir='tree',
217
 
                     retcode=1)
218
 
        self.assertFileEqual('a\nb\nc\n', 'tree/fname.BASE')
219
 
        self.assertFileEqual('a\nB\nD\n', 'tree/fname.OTHER')
220
 
        self.assertFileEqual('a\nB\nC\n', 'tree/fname.THIS')
221
 
 
222
 
    def test_weave_conflict_leaves_base_this_other_files(self):
223
 
        tree, other = self.create_conflicting_branches()
224
 
        self.run_bzr('merge ../other --weave', working_dir='tree',
225
 
                     retcode=1)
226
 
        self.assertFileEqual('a\nb\nc\n', 'tree/fname.BASE')
227
 
        self.assertFileEqual('a\nB\nD\n', 'tree/fname.OTHER')
228
 
        self.assertFileEqual('a\nB\nC\n', 'tree/fname.THIS')
229
 
 
230
213
    def test_merge_remember(self):
231
214
        """Merge changes from one branch to another, test submit location."""
232
215
        tree_a = self.make_branch_and_tree('branch_a')
266
249
 
267
250
        base = urlutils.local_path_from_url(branch_a.base)
268
251
        self.assertEndsWith(err, '+N  b\nAll changes applied successfully.\n')
269
 
        self.assertEquals(osutils.abspath(branch_b.get_submit_branch()),
270
 
                          osutils.abspath(parent))
 
252
        self.assertEquals(abspath(branch_b.get_submit_branch()),
 
253
                          abspath(parent))
271
254
        # test implicit --remember when committing new file
272
255
        self.build_tree(['e'])
273
256
        tree_b.add('e')
282
265
        out, err = self.run_bzr('merge ../branch_c --remember')
283
266
        self.assertEquals(out, '')
284
267
        self.assertEquals(err, '+N  c\nAll changes applied successfully.\n')
285
 
        self.assertEquals(osutils.abspath(branch_b.get_submit_branch()),
286
 
                          osutils.abspath(branch_c.bzrdir.root_transport.base))
 
268
        self.assertEquals(abspath(branch_b.get_submit_branch()),
 
269
                          abspath(branch_c.bzrdir.root_transport.base))
287
270
        # re-open tree as external run_bzr modified it
288
271
        tree_b = branch_b.bzrdir.open_workingtree()
289
272
        tree_b.commit('merge branch_c')
311
294
                                              tree_b.get_parent_ids()[0])
312
295
        self.assertEqualDiff(testament_a.as_text(),
313
296
                         testament_b.as_text())
314
 
        tree_a.set_conflicts(conflicts.ConflictList())
 
297
        tree_a.set_conflicts(ConflictList())
315
298
        tree_a.commit('message')
316
299
        # it is legal to attempt to merge an already-merged bundle
317
300
        output = self.run_bzr('merge ../bundle')[1]
366
349
        os.chdir('a')
367
350
        (out, err) = self.run_bzr('merge --pull ../b')
368
351
        self.assertContainsRe(out, 'Now on revision 2\\.')
369
 
        tree_a = workingtree.WorkingTree.open('.')
 
352
        tree_a = WorkingTree.open('.')
370
353
        self.assertEqual([self.id2], tree_a.get_parent_ids())
371
354
 
372
355
    def test_merge_kind_change(self):
380
363
        tree_a.commit('changed file to directory')
381
364
        os.chdir('tree_b')
382
365
        self.run_bzr('merge ../tree_a')
383
 
        self.assertEqual('directory', osutils.file_kind('file'))
 
366
        self.assertEqual('directory', file_kind('file'))
384
367
        tree_b.revert()
385
 
        self.assertEqual('file', osutils.file_kind('file'))
 
368
        self.assertEqual('file', file_kind('file'))
386
369
        self.build_tree_contents([('file', 'content_2')])
387
370
        tree_b.commit('content change')
388
371
        self.run_bzr('merge ../tree_a', retcode=1)
389
372
        self.assertEqual(tree_b.conflicts(),
390
 
                         [conflicts.ContentsConflict('file',
391
 
                                                     file_id='file-id')])
 
373
                         [ContentsConflict('file', file_id='file-id')])
392
374
 
393
375
    def test_directive_cherrypick(self):
394
376
        source = self.make_branch_and_tree('source')
395
 
        source.commit("nothing")
396
 
        # see https://bugs.edge.launchpad.net/bzr/+bug/409688 - trying to
397
 
        # cherrypick from one branch into another unrelated branch with a
398
 
        # different root id will give shape conflicts.  as a workaround we
399
 
        # make sure they share the same root id.
400
 
        target = source.bzrdir.sprout('target').open_workingtree()
401
377
        self.build_tree(['source/a'])
402
378
        source.add('a')
403
379
        source.commit('Added a', rev_id='rev1')
404
380
        self.build_tree(['source/b'])
405
381
        source.add('b')
406
382
        source.commit('Added b', rev_id='rev2')
 
383
        target = self.make_branch_and_tree('target')
407
384
        target.commit('empty commit')
408
385
        self.write_directive('directive', source.branch, 'target', 'rev2',
409
386
                             'rev1')
514
491
        out, err = self.run_bzr(['merge', '-d', 'a', 'b'])
515
492
        self.assertContainsRe(err, 'Warning: criss-cross merge encountered.')
516
493
 
 
494
    def test_merge_force(self):
 
495
        tree_a = self.make_branch_and_tree('a')
 
496
        self.build_tree(['a/foo'])
 
497
        tree_a.add(['foo'])
 
498
        tree_a.commit('add file')
 
499
        tree_b = tree_a.bzrdir.sprout('b').open_workingtree()
 
500
        self.build_tree_contents([('a/foo', 'change 1')])
 
501
        tree_a.commit('change file')
 
502
        tree_b.merge_from_branch(tree_a.branch)
 
503
        tree_a.commit('empty change to allow merge to run')
 
504
        self.run_bzr(['merge', '../a', '--force'], working_dir='b')
 
505
 
517
506
    def test_merge_from_submit(self):
518
507
        tree_a = self.make_branch_and_tree('a')
519
508
        tree_b = tree_a.bzrdir.sprout('b').open_workingtree()
566
555
        tree_a.merge_from_branch(tree_b.branch)
567
556
        self.build_tree_contents([('a/file',
568
557
                                   'base-contents\nthis-contents\n')])
569
 
        tree_a.set_conflicts(conflicts.ConflictList())
 
558
        tree_a.set_conflicts(ConflictList())
570
559
        tree_b.merge_from_branch(tree_a.branch)
571
560
        self.build_tree_contents([('b/file',
572
561
                                   'base-contents\nother-contents\n')])
573
 
        tree_b.set_conflicts(conflicts.ConflictList())
 
562
        tree_b.set_conflicts(ConflictList())
574
563
        tree_a.commit('', rev_id='rev3a')
575
564
        tree_b.commit('', rev_id='rev3b')
576
565
        out, err = self.run_bzr(['merge', '-d', 'a', 'b', '--lca'], retcode=1)
593
582
        self.addCleanup(this_tree.unlock)
594
583
        self.assertEqual([],
595
584
                         list(this_tree.iter_changes(this_tree.basis_tree())))
596
 
 
597
 
    def test_merge_missing_second_revision_spec(self):
598
 
        """Merge uses branch basis when the second revision is unspecified."""
599
 
        this = self.make_branch_and_tree('this')
600
 
        this.commit('rev1')
601
 
        other = self.make_branch_and_tree('other')
602
 
        self.build_tree(['other/other_file'])
603
 
        other.add('other_file')
604
 
        other.commit('rev1b')
605
 
        self.run_bzr('merge -d this other -r0..')
606
 
        self.failUnlessExists('this/other_file')
607
 
 
608
 
    def test_merge_interactive_unlocks_branch(self):
609
 
        this = self.make_branch_and_tree('this')
610
 
        other = self.make_branch_and_tree('other')
611
 
        other.commit('empty commit')
612
 
        self.run_bzr('merge -i -d this other')
613
 
        this.lock_write()
614
 
        this.unlock()
615
 
 
616
 
    def test_merge_reversed_revision_range(self):
617
 
        tree = self.make_branch_and_tree(".")
618
 
        for f in ("a", "b"):
619
 
            self.build_tree([f])
620
 
            tree.add(f)
621
 
            tree.commit("added "+f)
622
 
        for context in (".", "", "a"):
623
 
            self.run_bzr("merge -r 1..0 " + context)
624
 
            self.failIfExists("a")
625
 
            tree.revert()
626
 
            self.failUnlessExists("a")
627
 
 
628
 
 
629
 
class TestMergeForce(tests.TestCaseWithTransport):
630
 
 
631
 
    def setUp(self):
632
 
        super(TestMergeForce, self).setUp()
633
 
        self.tree_a = self.make_branch_and_tree('a')
634
 
        self.build_tree(['a/foo'])
635
 
        self.tree_a.add(['foo'])
636
 
        self.tree_a.commit('add file')
637
 
        self.tree_b = self.tree_a.bzrdir.sprout('b').open_workingtree()
638
 
        self.build_tree_contents([('a/foo', 'change 1')])
639
 
        self.tree_a.commit('change file')
640
 
        self.tree_b.merge_from_branch(self.tree_a.branch)
641
 
 
642
 
    def test_merge_force(self):
643
 
        self.tree_a.commit('empty change to allow merge to run')
644
 
        # Second merge on top of the uncommitted one
645
 
        self.run_bzr(['merge', '../a', '--force'], working_dir='b')
646
 
 
647
 
 
648
 
    def test_merge_with_uncommitted_changes(self):
649
 
        self.run_bzr_error(['Working tree .* has uncommitted changes'],
650
 
                           ['merge', '../a'], working_dir='b')
651
 
 
652
 
    def test_merge_with_pending_merges(self):
653
 
        # Revert the changes keeping the pending merge
654
 
        self.run_bzr(['revert', 'b'])
655
 
        self.run_bzr_error(['Working tree .* has uncommitted changes'],
656
 
                           ['merge', '../a'], working_dir='b')