← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_merge.py

  • Committer: Wouter van Heyst
  • Date: 2006-06-07 16:05:27 UTC
  • mto: This revision was merged to the branch mainline in revision 1752.
  • Revision ID: larstiq@larstiq.dyndns.org-20060607160527-2b3649154d0e2e84
more code cleanup

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_merge.py
1
 
# Copyright (C) 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2006 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
23
23
 
24
24
from bzrlib.branch import Branch
25
25
from bzrlib.bzrdir import BzrDir
26
 
from bzrlib.conflicts import ConflictList, ContentsConflict
27
 
from bzrlib.osutils import abspath, file_kind
 
26
from bzrlib.osutils import abspath
28
27
from bzrlib.tests.blackbox import ExternalBase
29
28
import bzrlib.urlutils as urlutils
30
29
from bzrlib.workingtree import WorkingTree
33
32
class TestMerge(ExternalBase):
34
33
 
35
34
    def example_branch(test):
36
 
        test.run_bzr('init')
 
35
        test.runbzr('init')
37
36
        file('hello', 'wt').write('foo')
38
 
        test.run_bzr('add hello')
39
 
        test.run_bzr('commit -m setup hello')
 
37
        test.runbzr('add hello')
 
38
        test.runbzr('commit -m setup hello')
40
39
        file('goodbye', 'wt').write('baz')
41
 
        test.run_bzr('add goodbye')
42
 
        test.run_bzr('commit -m setup goodbye')
 
40
        test.runbzr('add goodbye')
 
41
        test.runbzr('commit -m setup goodbye')
43
42
 
44
43
    def test_merge_reprocess(self):
45
44
        d = BzrDir.create_standalone_workingtree('.')
52
51
        os.mkdir('a')
53
52
        os.chdir('a')
54
53
        self.example_branch()
55
 
        ancestor = Branch.open('.').revno()
56
54
        os.chdir('..')
57
 
        self.run_bzr('branch a b')
 
55
        self.runbzr('branch a b')
58
56
        os.chdir('b')
59
57
        file('goodbye', 'wt').write('quux')
60
 
        self.run_bzr(['commit',  '-m',  "more u's are always good"])
 
58
        self.runbzr(['commit',  '-m',  "more u's are always good"])
61
59
 
62
60
        os.chdir('../a')
63
61
        file('hello', 'wt').write('quuux')
64
62
        # We can't merge when there are in-tree changes
65
 
        self.run_bzr('merge ../b', retcode=3)
66
 
        a = WorkingTree.open('.')
67
 
        a_tip = a.commit("Like an epidemic of u's")
68
 
        self.run_bzr('merge ../b -r last:1..last:1 --merge-type blooof',
 
63
        self.runbzr('merge ../b', retcode=3)
 
64
        self.runbzr(['commit', '-m', "Like an epidemic of u's"])
 
65
        self.runbzr('merge ../b -r last:1..last:1 --merge-type blooof',
69
66
                    retcode=3)
70
 
        self.run_bzr('merge ../b -r last:1..last:1 --merge-type merge3')
71
 
        self.run_bzr('revert --no-backup')
72
 
        self.run_bzr('merge ../b -r last:1..last:1 --merge-type weave')
73
 
        self.run_bzr('revert --no-backup')
74
 
        self.run_bzr('merge ../b -r last:1..last:1 --reprocess')
75
 
        self.run_bzr('revert --no-backup')
76
 
        self.run_bzr('merge ../b -r last:1')
 
67
        self.runbzr('merge ../b -r last:1..last:1 --merge-type merge3')
 
68
        self.runbzr('revert --no-backup')
 
69
        self.runbzr('merge ../b -r last:1..last:1 --merge-type weave')
 
70
        self.runbzr('revert --no-backup')
 
71
        self.runbzr('merge ../b -r last:1..last:1 --reprocess')
 
72
        self.runbzr('revert --no-backup')
 
73
        self.runbzr('merge ../b -r last:1')
77
74
        self.check_file_contents('goodbye', 'quux')
78
75
        # Merging a branch pulls its revision into the tree
 
76
        a = WorkingTree.open('.')
79
77
        b = Branch.open('../b')
80
 
        b_tip = b.last_revision()
81
 
        self.failUnless(a.branch.repository.has_revision(b_tip))
82
 
        self.assertEqual([a_tip, b_tip], a.get_parent_ids())
83
 
        self.run_bzr('revert --no-backup')
84
 
        out, err = self.run_bzr('merge -r revno:1:./hello', retcode=3)
85
 
        self.assertTrue("Not a branch" in err)
86
 
        self.run_bzr('merge -r revno:%d:./..revno:%d:../b'
87
 
                    %(ancestor,b.revno()))
88
 
        self.assertEquals(a.get_parent_ids(), 
89
 
                          [a.branch.last_revision(), b.last_revision()])
90
 
        self.check_file_contents('goodbye', 'quux')
91
 
        self.run_bzr('revert --no-backup')
92
 
        self.run_bzr('merge -r revno:%d:../b'%b.revno())
93
 
        self.assertEquals(a.get_parent_ids(),
94
 
                          [a.branch.last_revision(), b.last_revision()])
95
 
        a_tip = a.commit('merged')
96
 
        self.run_bzr('merge ../b -r last:1')
97
 
        self.assertEqual([a_tip], a.get_parent_ids())
 
78
        a.branch.repository.get_revision_xml(b.last_revision())
 
79
        self.log('pending merges: %s', a.pending_merges())
 
80
        self.assertEquals(a.pending_merges(),
 
81
                          [b.last_revision()])
 
82
        self.runbzr('commit -m merged')
 
83
        self.runbzr('merge ../b -r last:1')
 
84
        self.assertEqual(a.pending_merges(), [])
98
85
 
99
86
    def test_merge_with_missing_file(self):
100
87
        """Merge handles missing file conflicts"""
104
91
        print >> file('sub/a.txt', 'wb'), "hello"
105
92
        print >> file('b.txt', 'wb'), "hello"
106
93
        print >> file('sub/c.txt', 'wb'), "hello"
107
 
        self.run_bzr('init')
108
 
        self.run_bzr('add')
109
 
        self.run_bzr(['commit', '-m', 'added a'])
110
 
        self.run_bzr('branch . ../b')
 
94
        self.runbzr('init')
 
95
        self.runbzr('add')
 
96
        self.runbzr(('commit', '-m', 'added a'))
 
97
        self.runbzr('branch . ../b')
111
98
        print >> file('sub/a.txt', 'ab'), "there"
112
99
        print >> file('b.txt', 'ab'), "there"
113
100
        print >> file('sub/c.txt', 'ab'), "there"
114
 
        self.run_bzr(['commit', '-m', 'Added there'])
 
101
        self.runbzr(('commit', '-m', 'Added there'))
115
102
        os.unlink('sub/a.txt')
116
103
        os.unlink('sub/c.txt')
117
104
        os.rmdir('sub')
118
105
        os.unlink('b.txt')
119
 
        self.run_bzr(['commit', '-m', 'Removed a.txt'])
 
106
        self.runbzr(('commit', '-m', 'Removed a.txt'))
120
107
        os.chdir('../b')
121
108
        print >> file('sub/a.txt', 'ab'), "something"
122
109
        print >> file('b.txt', 'ab'), "something"
123
110
        print >> file('sub/c.txt', 'ab'), "something"
124
 
        self.run_bzr(['commit', '-m', 'Modified a.txt'])
125
 
        self.run_bzr('merge ../a/', retcode=1)
 
111
        self.runbzr(('commit', '-m', 'Modified a.txt'))
 
112
        self.runbzr('merge ../a/', retcode=1)
126
113
        self.assert_(os.path.exists('sub/a.txt.THIS'))
127
114
        self.assert_(os.path.exists('sub/a.txt.BASE'))
128
115
        os.chdir('../a')
129
 
        self.run_bzr('merge ../b/', retcode=1)
 
116
        self.runbzr('merge ../b/', retcode=1)
130
117
        self.assert_(os.path.exists('sub/a.txt.OTHER'))
131
118
        self.assert_(os.path.exists('sub/a.txt.BASE'))
132
119
 
153
140
        self.assertEqual(None, branch_b.get_parent())
154
141
        # test merge for failure without parent set
155
142
        os.chdir('branch_b')
156
 
        out = self.run_bzr('merge', retcode=3)
 
143
        out = self.runbzr('merge', retcode=3)
157
144
        self.assertEquals(out,
158
145
                ('','bzr: ERROR: No location specified or remembered\n'))
159
146
        # test implicit --remember when no parent set, this merge conflicts
160
147
        self.build_tree(['d'])
161
148
        tree_b.add('d')
162
 
        out = self.run_bzr('merge ../branch_a', retcode=3)
 
149
        out = self.runbzr('merge ../branch_a', retcode=3)
163
150
        self.assertEquals(out,
164
151
                ('','bzr: ERROR: Working tree has uncommitted changes.\n'))
165
152
        self.assertEquals(abspath(branch_b.get_parent()), abspath(parent))
166
153
        # test implicit --remember after resolving conflict
167
154
        tree_b.commit('commit d')
168
 
        out, err = self.run_bzr('merge')
 
155
        out, err = self.runbzr('merge')
169
156
        
170
157
        base = urlutils.local_path_from_url(branch_a.base)
171
158
        self.assertEquals(out, 'Merging from remembered location %s\n' % (base,))
172
 
        self.assertEquals(err, '+N  b\nAll changes applied successfully.\n')
 
159
        self.assertEquals(err, 'All changes applied successfully.\n')
173
160
        self.assertEquals(abspath(branch_b.get_parent()), abspath(parent))
174
 
        # re-open tree as external run_bzr modified it
 
161
        # re-open tree as external runbzr modified it
175
162
        tree_b = branch_b.bzrdir.open_workingtree()
176
163
        tree_b.commit('merge branch_a')
177
164
        # test explicit --remember
178
 
        out, err = self.run_bzr('merge ../branch_c --remember')
 
165
        out, err = self.runbzr('merge ../branch_c --remember')
179
166
        self.assertEquals(out, '')
180
 
        self.assertEquals(err, '+N  c\nAll changes applied successfully.\n')
 
167
        self.assertEquals(err, 'All changes applied successfully.\n')
181
168
        self.assertEquals(abspath(branch_b.get_parent()),
182
169
                          abspath(branch_c.bzrdir.root_transport.base))
183
 
        # re-open tree as external run_bzr modified it
 
170
        # re-open tree as external runbzr modified it
184
171
        tree_b = branch_b.bzrdir.open_workingtree()
185
172
        tree_b.commit('merge branch_c')
186
173
 
204
191
        f.close()
205
192
        tree_b.commit('message')
206
193
        os.chdir('branch_b')
207
 
        file('../bundle', 'wb').write(self.run_bzr('bundle ../branch_a')[0])
 
194
        file('../bundle', 'wb').write(self.runbzr('bundle ../branch_a')[0])
208
195
        os.chdir('../branch_a')
209
 
        self.run_bzr('merge ../bundle', retcode=1)
210
 
        testament_a = Testament.from_revision(tree_a.branch.repository,
211
 
                                              tree_b.get_parent_ids()[0])
 
196
        self.runbzr('merge ../bundle', retcode=1)
 
197
        testament_a = Testament.from_revision(tree_a.branch.repository, 
 
198
                                              tree_b.last_revision())
212
199
        testament_b = Testament.from_revision(tree_b.branch.repository,
213
 
                                              tree_b.get_parent_ids()[0])
 
200
                                              tree_b.last_revision())
214
201
        self.assertEqualDiff(testament_a.as_text(),
215
202
                         testament_b.as_text())
216
 
        tree_a.set_conflicts(ConflictList())
217
 
        tree_a.commit('message')
218
 
        # it is legal to attempt to merge an already-merged bundle
219
 
        output = self.run_bzr('merge ../bundle')[1]
220
 
        # but it does nothing
221
 
        self.assertFalse(tree_a.changes_from(tree_a.basis_tree()).has_changed())
222
 
        self.assertEqual('Nothing to do.\n', output)
223
 
 
224
 
    def test_merge_uncommitted(self):
225
 
        """Check that merge --uncommitted behaves properly"""
226
 
        tree_a = self.make_branch_and_tree('a')
227
 
        self.build_tree(['a/file_1', 'a/file_2'])
228
 
        tree_a.add(['file_1', 'file_2'])
229
 
        tree_a.commit('commit 1')
230
 
        tree_b = tree_a.bzrdir.sprout('b').open_workingtree()
231
 
        self.failUnlessExists('b/file_1')
232
 
        tree_a.rename_one('file_1', 'file_i')
233
 
        tree_a.commit('commit 2')
234
 
        tree_a.rename_one('file_2', 'file_ii')
235
 
        ## os.chdir('b')
236
 
        self.run_bzr('merge', 'a', '--uncommitted', '-d', 'b')
237
 
        self.failUnlessExists('b/file_1')
238
 
        self.failUnlessExists('b/file_ii')
239
 
        tree_b.revert([])
240
 
        self.run_bzr_error(('Cannot use --uncommitted and --revision',),
241
 
                           'merge', '/a', '--uncommitted', '-r1',
242
 
                           '-d', 'b')
243
 
 
244
 
    def pullable_branch(self):
245
 
        os.mkdir('a')
246
 
        os.chdir('a')
247
 
        self.example_branch()
248
 
        os.chdir('..')
249
 
        self.run_bzr('branch a b')
250
 
        os.chdir('b')
251
 
        file('goodbye', 'wt').write('quux')
252
 
        self.run_bzr(['commit', '-m', "mode u's are always good"])
253
 
        os.chdir('../a')
254
 
 
255
 
    def pullable_branch(self):
256
 
        tree_a = self.make_branch_and_tree('a')
257
 
        self.build_tree(['a/file'])
258
 
        tree_a.add(['file'])
259
 
        self.id1 = tree_a.commit('commit 1')
260
 
        
261
 
        tree_b = self.make_branch_and_tree('b')
262
 
        tree_b.pull(tree_a.branch)
263
 
        file('b/file', 'wb').write('foo')
264
 
        self.id2 = tree_b.commit('commit 2')
265
 
 
266
 
    def test_merge_pull(self):
267
 
        self.pullable_branch()
268
 
        os.chdir('a')
269
 
        (out, err) = self.run_bzr('merge', '--pull', '../b')
270
 
        self.assertContainsRe(err, 'Now on revision 2\\.')
271
 
        tree_a = WorkingTree.open('.')
272
 
        self.assertEqual([self.id2], tree_a.get_parent_ids())
273
 
 
274
 
    def test_merge_kind_change(self):
275
 
        tree_a = self.make_branch_and_tree('tree_a')
276
 
        self.build_tree_contents([('tree_a/file', 'content_1')])
277
 
        tree_a.add('file', 'file-id')
278
 
        tree_a.commit('added file')
279
 
        tree_b = tree_a.bzrdir.sprout('tree_b').open_workingtree()
280
 
        os.unlink('tree_a/file')
281
 
        self.build_tree(['tree_a/file/'])
282
 
        tree_a.commit('changed file to directory')
283
 
        os.chdir('tree_b')
284
 
        self.run_bzr('merge', '../tree_a')
285
 
        self.assertEqual('directory', file_kind('file'))
286
 
        tree_b.revert([])
287
 
        self.assertEqual('file', file_kind('file'))
288
 
        self.build_tree_contents([('file', 'content_2')])
289
 
        tree_b.commit('content change')
290
 
        self.run_bzr('merge', '../tree_a', retcode=1)
291
 
        self.assertEqual(tree_b.conflicts(),
292
 
                         [ContentsConflict('file', file_id='file-id')])