← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

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

  • Committer: Alexander Belchenko
  • Date: 2007-01-30 23:05:35 UTC
  • mto: This revision was merged to the branch mainline in revision 2259.
  • Revision ID: bialix@ukr.net-20070130230535-kx1rd478rtigyc3v
standalone installer: win98 support

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_pull.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005 Canonical Ltd
 
2
# -*- coding: utf-8 -*-
2
3
#
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
21
22
import sys
22
23
 
23
24
from bzrlib.branch import Branch
24
 
from bzrlib.osutils import pathjoin
25
25
from bzrlib.tests.blackbox import ExternalBase
26
26
from bzrlib.uncommit import uncommit
27
 
from bzrlib.workingtree import WorkingTree
28
 
from bzrlib import urlutils
29
27
 
30
28
 
31
29
class TestPull(ExternalBase):
32
30
 
33
 
    def example_branch(self, path='.'):
34
 
        tree = self.make_branch_and_tree(path)
35
 
        self.build_tree_contents([
36
 
            (pathjoin(path, 'hello'),   'foo'),
37
 
            (pathjoin(path, 'goodbye'), 'baz')])
38
 
        tree.add('hello')
39
 
        tree.commit(message='setup')
40
 
        tree.add('goodbye')
41
 
        tree.commit(message='setup')
42
 
        return tree
 
31
    def example_branch(test):
 
32
        test.runbzr('init')
 
33
        file('hello', 'wt').write('foo')
 
34
        test.runbzr('add hello')
 
35
        test.runbzr('commit -m setup hello')
 
36
        file('goodbye', 'wt').write('baz')
 
37
        test.runbzr('add goodbye')
 
38
        test.runbzr('commit -m setup goodbye')
43
39
 
44
40
    def test_pull(self):
45
41
        """Pull changes from one branch to another."""
46
 
        a_tree = self.example_branch('a')
 
42
        os.mkdir('a')
47
43
        os.chdir('a')
48
 
        self.run_bzr('pull', retcode=3)
49
 
        self.run_bzr('missing', retcode=3)
50
 
        self.run_bzr('missing .')
51
 
        self.run_bzr('missing')
 
44
 
 
45
        self.example_branch()
 
46
        self.runbzr('pull', retcode=3)
 
47
        self.runbzr('missing', retcode=3)
 
48
        self.runbzr('missing .')
 
49
        self.runbzr('missing')
52
50
        # this will work on windows because we check for the same branch
53
51
        # in pull - if it fails, it is a regression
54
 
        self.run_bzr('pull')
55
 
        self.run_bzr('pull /', retcode=3)
 
52
        self.runbzr('pull')
 
53
        self.runbzr('pull /', retcode=3)
56
54
        if sys.platform not in ('win32', 'cygwin'):
57
 
            self.run_bzr('pull')
 
55
            self.runbzr('pull')
58
56
 
59
57
        os.chdir('..')
60
 
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
 
58
        self.runbzr('branch a b')
61
59
        os.chdir('b')
62
 
        self.run_bzr('pull')
 
60
        self.runbzr('pull')
63
61
        os.mkdir('subdir')
64
 
        b_tree.add('subdir')
65
 
        b_tree.commit(message='blah', allow_pointless=True)
66
 
 
67
 
        os.chdir('..')
68
 
        a = Branch.open('a')
69
 
        b = Branch.open('b')
70
 
        self.assertEqual(a.revision_history(), b.revision_history()[:-1])
71
 
 
72
 
        os.chdir('a')
73
 
        self.run_bzr('pull ../b')
74
 
        self.assertEqual(a.revision_history(), b.revision_history())
75
 
        a_tree.commit(message='blah2', allow_pointless=True)
76
 
        b_tree.commit(message='blah3', allow_pointless=True)
 
62
        self.runbzr('add subdir')
 
63
        self.runbzr('commit -m blah --unchanged')
 
64
        os.chdir('../a')
 
65
        a = Branch.open('.')
 
66
        b = Branch.open('../b')
 
67
        self.assertEquals(a.revision_history(), b.revision_history()[:-1])
 
68
        self.runbzr('pull ../b')
 
69
        self.assertEquals(a.revision_history(), b.revision_history())
 
70
        self.runbzr('commit -m blah2 --unchanged')
 
71
        os.chdir('../b')
 
72
        self.runbzr('commit -m blah3 --unchanged')
77
73
        # no overwrite
78
 
        os.chdir('../b')
79
 
        self.run_bzr('pull ../a', retcode=3)
 
74
        self.runbzr('pull ../a', retcode=3)
80
75
        os.chdir('..')
81
 
        b_tree.bzrdir.sprout('overwriteme')
 
76
        self.runbzr('branch b overwriteme')
82
77
        os.chdir('overwriteme')
83
 
        self.run_bzr('pull --overwrite ../a')
 
78
        self.runbzr('pull --overwrite ../a')
84
79
        overwritten = Branch.open('.')
85
80
        self.assertEqual(overwritten.revision_history(),
86
81
                         a.revision_history())
87
 
        a_tree.merge_from_branch(b_tree.branch)
88
 
        a_tree.commit(message="blah4", allow_pointless=True)
 
82
        os.chdir('../a')
 
83
        self.runbzr('merge ../b')
 
84
        self.runbzr('commit -m blah4 --unchanged')
89
85
        os.chdir('../b/subdir')
90
 
        self.run_bzr('pull ../../a')
91
 
        self.assertEqual(a.revision_history()[-1], b.revision_history()[-1])
92
 
        sub_tree = WorkingTree.open_containing('.')[0]
93
 
        sub_tree.commit(message="blah5", allow_pointless=True)
94
 
        sub_tree.commit(message="blah6", allow_pointless=True)
 
86
        self.runbzr('pull ../../a')
 
87
        self.assertEquals(a.revision_history()[-1], b.revision_history()[-1])
 
88
        self.runbzr('commit -m blah5 --unchanged')
 
89
        self.runbzr('commit -m blah6 --unchanged')
95
90
        os.chdir('..')
96
 
        self.run_bzr('pull ../a')
 
91
        self.runbzr('pull ../a')
97
92
        os.chdir('../a')
98
 
        a_tree.commit(message="blah7", allow_pointless=True)
99
 
        a_tree.merge_from_branch(b_tree.branch)
100
 
        a_tree.commit(message="blah8", allow_pointless=True)
101
 
        self.run_bzr('pull ../b')
102
 
        self.run_bzr('pull ../b')
103
 
 
104
 
    def test_pull_dash_d(self):
105
 
        self.example_branch('a')
106
 
        self.make_branch_and_tree('b')
107
 
        self.make_branch_and_tree('c')
108
 
        # pull into that branch
109
 
        self.run_bzr('pull -d b a')
110
 
        # pull into a branch specified by a url
111
 
        c_url = urlutils.local_path_to_url('c')
112
 
        self.assertStartsWith(c_url, 'file://')
113
 
        self.run_bzr(['pull', '-d', c_url, 'a'])
 
93
        self.runbzr('commit -m blah7 --unchanged')
 
94
        self.runbzr('merge ../b')
 
95
        self.runbzr('commit -m blah8 --unchanged')
 
96
        self.runbzr('pull ../b')
 
97
        self.runbzr('pull ../b')
114
98
 
115
99
    def test_pull_revision(self):
116
100
        """Pull some changes from one branch to another."""
117
 
        a_tree = self.example_branch('a')
118
 
        self.build_tree_contents([
119
 
            ('a/hello2',   'foo'),
120
 
            ('a/goodbye2', 'baz')])
121
 
        a_tree.add('hello2')
122
 
        a_tree.commit(message="setup")
123
 
        a_tree.add('goodbye2')
124
 
        a_tree.commit(message="setup")
125
 
 
126
 
        b_tree = a_tree.bzrdir.sprout('b',
127
 
                   revision_id=a_tree.branch.get_rev_id(1)).open_workingtree()
 
101
        os.mkdir('a')
 
102
        os.chdir('a')
 
103
 
 
104
        self.example_branch()
 
105
        file('hello2', 'wt').write('foo')
 
106
        self.runbzr('add hello2')
 
107
        self.runbzr('commit -m setup hello2')
 
108
        file('goodbye2', 'wt').write('baz')
 
109
        self.runbzr('add goodbye2')
 
110
        self.runbzr('commit -m setup goodbye2')
 
111
 
 
112
        os.chdir('..')
 
113
        self.runbzr('branch -r 1 a b')
128
114
        os.chdir('b')
129
 
        self.run_bzr('pull -r 2')
 
115
        self.runbzr('pull -r 2')
130
116
        a = Branch.open('../a')
131
117
        b = Branch.open('.')
132
 
        self.assertEqual(a.revno(),4)
133
 
        self.assertEqual(b.revno(),2)
134
 
        self.run_bzr('pull -r 3')
135
 
        self.assertEqual(b.revno(),3)
136
 
        self.run_bzr('pull -r 4')
137
 
        self.assertEqual(a.revision_history(), b.revision_history())
 
118
        self.assertEquals(a.revno(),4)
 
119
        self.assertEquals(b.revno(),2)
 
120
        self.runbzr('pull -r 3')
 
121
        self.assertEquals(b.revno(),3)
 
122
        self.runbzr('pull -r 4')
 
123
        self.assertEquals(a.revision_history(), b.revision_history())
138
124
 
139
125
 
140
126
    def test_overwrite_uptodate(self):
141
127
        # Make sure pull --overwrite overwrites
142
128
        # even if the target branch has merged
143
129
        # everything already.
144
 
        a_tree = self.make_branch_and_tree('a')
145
 
        self.build_tree_contents([('a/foo', 'original\n')])
146
 
        a_tree.add('foo')
147
 
        a_tree.commit(message='initial commit')
148
 
 
149
 
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
150
 
 
151
 
        self.build_tree_contents([('a/foo', 'changed\n')])
152
 
        a_tree.commit(message='later change')
153
 
 
154
 
        self.build_tree_contents([('a/foo', 'a third change')])
155
 
        a_tree.commit(message='a third change')
156
 
 
157
 
        rev_history_a = a_tree.branch.revision_history()
158
 
        self.assertEqual(len(rev_history_a), 3)
159
 
 
160
 
        b_tree.merge_from_branch(a_tree.branch)
161
 
        b_tree.commit(message='merge')
162
 
 
163
 
        self.assertEqual(len(b_tree.branch.revision_history()), 2)
164
 
 
165
 
        os.chdir('b')
166
 
        self.run_bzr('pull --overwrite ../a')
167
 
        rev_history_b = b_tree.branch.revision_history()
168
 
        self.assertEqual(len(rev_history_b), 3)
 
130
        bzr = self.run_bzr
 
131
 
 
132
        def get_rh(expected_len):
 
133
            rh = self.capture('revision-history')
 
134
            # Make sure we don't have trailing empty revisions
 
135
            rh = rh.strip().split('\n')
 
136
            self.assertEqual(len(rh), expected_len)
 
137
            return rh
 
138
 
 
139
        os.mkdir('a')
 
140
        os.chdir('a')
 
141
        bzr('init')
 
142
        open('foo', 'wb').write('original\n')
 
143
        bzr('add', 'foo')
 
144
        bzr('commit', '-m', 'initial commit')
 
145
 
 
146
        os.chdir('..')
 
147
        bzr('branch', 'a', 'b')
 
148
 
 
149
        os.chdir('a')
 
150
        open('foo', 'wb').write('changed\n')
 
151
        bzr('commit', '-m', 'later change')
 
152
 
 
153
        open('foo', 'wb').write('another\n')
 
154
        bzr('commit', '-m', 'a third change')
 
155
 
 
156
        rev_history_a = get_rh(3)
 
157
 
 
158
        os.chdir('../b')
 
159
        bzr('merge', '../a')
 
160
        bzr('commit', '-m', 'merge')
 
161
 
 
162
        rev_history_b = get_rh(2)
 
163
 
 
164
        bzr('pull', '--overwrite', '../a')
 
165
        rev_history_b = get_rh(3)
169
166
 
170
167
        self.assertEqual(rev_history_b, rev_history_a)
171
168
 
172
169
    def test_overwrite_children(self):
173
170
        # Make sure pull --overwrite sets the revision-history
174
171
        # to be identical to the pull source, even if we have convergence
175
 
        a_tree = self.make_branch_and_tree('a')
176
 
        self.build_tree_contents([('a/foo', 'original\n')])
177
 
        a_tree.add('foo')
178
 
        a_tree.commit(message='initial commit')
179
 
 
180
 
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
181
 
 
182
 
        self.build_tree_contents([('a/foo', 'changed\n')])
183
 
        a_tree.commit(message='later change')
184
 
 
185
 
        self.build_tree_contents([('a/foo', 'a third change')])
186
 
        a_tree.commit(message='a third change')
187
 
 
188
 
        self.assertEqual(len(a_tree.branch.revision_history()), 3)
189
 
 
190
 
        b_tree.merge_from_branch(a_tree.branch)
191
 
        b_tree.commit(message='merge')
192
 
 
193
 
        self.assertEqual(len(b_tree.branch.revision_history()), 2)
194
 
 
195
 
        self.build_tree_contents([('a/foo', 'a fourth change\n')])
196
 
        a_tree.commit(message='a fourth change')
197
 
 
198
 
        rev_history_a = a_tree.branch.revision_history()
199
 
        self.assertEqual(len(rev_history_a), 4)
 
172
        bzr = self.run_bzr
 
173
 
 
174
        def get_rh(expected_len):
 
175
            rh = self.capture('revision-history')
 
176
            # Make sure we don't have trailing empty revisions
 
177
            rh = rh.strip().split('\n')
 
178
            self.assertEqual(len(rh), expected_len)
 
179
            return rh
 
180
 
 
181
        os.mkdir('a')
 
182
        os.chdir('a')
 
183
        bzr('init')
 
184
        open('foo', 'wb').write('original\n')
 
185
        bzr('add', 'foo')
 
186
        bzr('commit', '-m', 'initial commit')
 
187
 
 
188
        os.chdir('..')
 
189
        bzr('branch', 'a', 'b')
 
190
 
 
191
        os.chdir('a')
 
192
        open('foo', 'wb').write('changed\n')
 
193
        bzr('commit', '-m', 'later change')
 
194
 
 
195
        open('foo', 'wb').write('another\n')
 
196
        bzr('commit', '-m', 'a third change')
 
197
 
 
198
        rev_history_a = get_rh(3)
 
199
 
 
200
        os.chdir('../b')
 
201
        bzr('merge', '../a')
 
202
        bzr('commit', '-m', 'merge')
 
203
 
 
204
        rev_history_b = get_rh(2)
 
205
 
 
206
        os.chdir('../a')
 
207
        open('foo', 'wb').write('a fourth change\n')
 
208
        bzr('commit', '-m', 'a fourth change')
 
209
 
 
210
        rev_history_a = get_rh(4)
200
211
 
201
212
        # With convergence, we could just pull over the
202
213
        # new change, but with --overwrite, we want to switch our history
203
 
        os.chdir('b')
204
 
        self.run_bzr('pull --overwrite ../a')
205
 
        rev_history_b = b_tree.branch.revision_history()
206
 
        self.assertEqual(len(rev_history_b), 4)
 
214
        os.chdir('../b')
 
215
        bzr('pull', '--overwrite', '../a')
 
216
        rev_history_b = get_rh(4)
207
217
 
208
218
        self.assertEqual(rev_history_b, rev_history_a)
209
219
 
228
238
        self.assertEqual(None, branch_b.get_parent())
229
239
        # test pull for failure without parent set
230
240
        os.chdir('branch_b')
231
 
        out = self.run_bzr('pull', retcode=3)
232
 
        self.assertEqual(out,
 
241
        out = self.runbzr('pull', retcode=3)
 
242
        self.assertEquals(out,
233
243
                ('','bzr: ERROR: No pull location known or specified.\n'))
234
244
        # test implicit --remember when no parent set, this pull conflicts
235
245
        self.build_tree(['d'])
236
246
        tree_b.add('d')
237
247
        tree_b.commit('commit d')
238
 
        out = self.run_bzr('pull ../branch_a', retcode=3)
239
 
        self.assertEqual(out,
240
 
                ('','bzr: ERROR: These branches have diverged.'
241
 
                    ' Use the merge command to reconcile them.\n'))
242
 
        self.assertEqual(branch_b.get_parent(), parent)
 
248
        out = self.runbzr('pull ../branch_a', retcode=3)
 
249
        self.assertEquals(out,
 
250
                ('','bzr: ERROR: These branches have diverged.  Use the merge command to reconcile them.\n'))
 
251
        self.assertEquals(branch_b.get_parent(), parent)
243
252
        # test implicit --remember after resolving previous failure
244
253
        uncommit(branch=branch_b, tree=tree_b)
245
254
        transport.delete('branch_b/d')
246
 
        self.run_bzr('pull')
247
 
        self.assertEqual(branch_b.get_parent(), parent)
 
255
        self.runbzr('pull')
 
256
        self.assertEquals(branch_b.get_parent(), parent)
248
257
        # test explicit --remember
249
 
        self.run_bzr('pull ../branch_c --remember')
250
 
        self.assertEqual(branch_b.get_parent(),
 
258
        self.runbzr('pull ../branch_c --remember')
 
259
        self.assertEquals(branch_b.get_parent(),
251
260
                          branch_c.bzrdir.root_transport.base)
252
261
 
253
262
    def test_pull_bundle(self):
270
279
 
271
280
        # Create the bundle for 'b' to pull
272
281
        os.chdir('branch_a')
273
 
        self.run_bzr('bundle ../branch_b -o ../bundle')
 
282
        bundle_file = open('../bundle', 'wb')
 
283
        bundle_file.write(self.run_bzr('bundle', '../branch_b')[0])
 
284
        bundle_file.close()
274
285
 
275
286
        os.chdir('../branch_b')
276
 
        out, err = self.run_bzr('pull ../bundle')
277
 
        self.assertEqual(out,
278
 
                         'Now on revision 2.\n')
279
 
        self.assertEqual(err,
280
 
                ' M  a\nAll changes applied successfully.\n')
 
287
        output = self.run_bzr('pull', '../bundle')
 
288
        self.assertEqual('', output[0])
 
289
        self.assertEqual('All changes applied successfully.\n'
 
290
                         '1 revision(s) pulled.\n', output[1])
281
291
 
282
292
        self.assertEqualDiff(tree_a.branch.revision_history(),
283
293
                             tree_b.branch.revision_history())
290
300
                             testament_b.as_text())
291
301
 
292
302
        # it is legal to attempt to pull an already-merged bundle
293
 
        out, err = self.run_bzr('pull ../bundle')
294
 
        self.assertEqual(err, '')
295
 
        self.assertEqual(out, 'No revisions to pull.\n')
296
 
 
297
 
    def test_pull_verbose_no_files(self):
298
 
        """Pull --verbose should not list modified files"""
299
 
        tree_a = self.make_branch_and_tree('tree_a')
300
 
        self.build_tree(['tree_a/foo'])
301
 
        tree_a.add('foo')
302
 
        tree_a.commit('bar')
303
 
        tree_b = self.make_branch_and_tree('tree_b')
304
 
        out = self.run_bzr('pull --verbose -d tree_b tree_a')[0]
305
 
        self.assertContainsRe(out, 'bar')
306
 
        self.assertNotContainsRe(out, 'added:')
307
 
        self.assertNotContainsRe(out, 'foo')
308
 
 
309
 
    def test_pull_quiet(self):
310
 
        """Check that bzr pull --quiet does not print anything"""
311
 
        tree_a = self.make_branch_and_tree('tree_a')
312
 
        self.build_tree(['tree_a/foo'])
313
 
        tree_a.add('foo')
314
 
        revision_id = tree_a.commit('bar')
315
 
        tree_b = tree_a.bzrdir.sprout('tree_b').open_workingtree()
316
 
        out, err = self.run_bzr('pull --quiet -d tree_b')
317
 
        self.assertEqual(out, '')
318
 
        self.assertEqual(err, '')
319
 
        self.assertEqual(tree_b.last_revision(), revision_id)
320
 
        self.build_tree(['tree_a/moo'])
321
 
        tree_a.add('moo')
322
 
        revision_id = tree_a.commit('quack')
323
 
        out, err = self.run_bzr('pull --quiet -d tree_b')
324
 
        self.assertEqual(out, '')
325
 
        self.assertEqual(err, '')
326
 
        self.assertEqual(tree_b.last_revision(), revision_id)
 
303
        output = self.run_bzr('pull', '../bundle')
 
304
        self.assertEqual('', output[0])
 
305
        self.assertEqual('0 revision(s) pulled.\n', output[1])