← 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: Canonical.com Patch Queue Manager
  • Date: 2008-04-07 07:52:50 UTC
  • mfrom: (3340.1.1 208418-1.4)
  • Revision ID: pqm@pqm.ubuntu.com-20080407075250-phs53xnslo8boaeo
Return the correct knit serialisation method in _StreamAccess.
        (Andrew Bennetts, Martin Pool, Robert Collins)

Show diffs side-by-side

added added

removed removed

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