← 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: Aaron Bentley
  • Date: 2006-06-21 14:30:57 UTC
  • mfrom: (1801.1.1 bzr.dev)
  • mto: This revision was merged to the branch mainline in revision 1803.
  • Revision ID: abentley@panoramicfeedback.com-20060621143057-776e4b8d707e430e
Install benchmarks. (Jelmer Vernooij)

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
2
 
#
 
1
# Copyright (C) 2005 by Canonical Ltd
 
2
# -*- coding: utf-8 -*-
 
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
5
6
# the Free Software Foundation; either version 2 of the License, or
6
7
# (at your option) any later version.
7
 
#
 
8
 
8
9
# This program is distributed in the hope that it will be useful,
9
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
12
# GNU General Public License for more details.
12
 
#
 
13
 
13
14
# You should have received a copy of the GNU General Public License
14
15
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
17
 
17
18
 
18
19
"""Black-box tests for bzr pull."""
21
22
import sys
22
23
 
23
24
from bzrlib.branch import Branch
24
 
from bzrlib.directory_service import directories
25
 
from bzrlib.osutils import pathjoin
26
25
from bzrlib.tests.blackbox import ExternalBase
27
26
from bzrlib.uncommit import uncommit
28
 
from bzrlib.workingtree import WorkingTree
29
 
from bzrlib import urlutils
30
27
 
31
28
 
32
29
class TestPull(ExternalBase):
33
30
 
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
 
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')
44
39
 
45
40
    def test_pull(self):
46
41
        """Pull changes from one branch to another."""
47
 
        a_tree = self.example_branch('a')
 
42
        os.mkdir('a')
48
43
        os.chdir('a')
49
 
        self.run_bzr('pull', retcode=3)
50
 
        self.run_bzr('missing', retcode=3)
51
 
        self.run_bzr('missing .')
52
 
        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')
53
50
        # this will work on windows because we check for the same branch
54
51
        # in pull - if it fails, it is a regression
55
 
        self.run_bzr('pull')
56
 
        self.run_bzr('pull /', retcode=3)
 
52
        self.runbzr('pull')
 
53
        self.runbzr('pull /', retcode=3)
57
54
        if sys.platform not in ('win32', 'cygwin'):
58
 
            self.run_bzr('pull')
 
55
            self.runbzr('pull')
59
56
 
60
57
        os.chdir('..')
61
 
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
 
58
        self.runbzr('branch a b')
62
59
        os.chdir('b')
63
 
        self.run_bzr('pull')
 
60
        self.runbzr('pull')
64
61
        os.mkdir('subdir')
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)
 
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')
78
73
        # no overwrite
79
 
        os.chdir('../b')
80
 
        self.run_bzr('pull ../a', retcode=3)
 
74
        self.runbzr('pull ../a', retcode=3)
81
75
        os.chdir('..')
82
 
        b_tree.bzrdir.sprout('overwriteme')
 
76
        self.runbzr('branch b overwriteme')
83
77
        os.chdir('overwriteme')
84
 
        self.run_bzr('pull --overwrite ../a')
 
78
        self.runbzr('pull --overwrite ../a')
85
79
        overwritten = Branch.open('.')
86
80
        self.assertEqual(overwritten.revision_history(),
87
81
                         a.revision_history())
88
 
        a_tree.merge_from_branch(b_tree.branch)
89
 
        a_tree.commit(message="blah4", allow_pointless=True)
 
82
        os.chdir('../a')
 
83
        self.runbzr('merge ../b')
 
84
        self.runbzr('commit -m blah4 --unchanged')
90
85
        os.chdir('../b/subdir')
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)
 
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')
96
90
        os.chdir('..')
97
 
        self.run_bzr('pull ../a')
 
91
        self.runbzr('pull ../a')
98
92
        os.chdir('../a')
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')
104
 
 
105
 
    def test_pull_dash_d(self):
106
 
        self.example_branch('a')
107
 
        self.make_branch_and_tree('b')
108
 
        self.make_branch_and_tree('c')
109
 
        # pull into that branch
110
 
        self.run_bzr('pull -d b a')
111
 
        # pull into a branch specified by a url
112
 
        c_url = urlutils.local_path_to_url('c')
113
 
        self.assertStartsWith(c_url, 'file://')
114
 
        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')
115
98
 
116
99
    def test_pull_revision(self):
117
100
        """Pull some changes from one branch to another."""
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()
 
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')
129
114
        os.chdir('b')
130
 
        self.run_bzr('pull -r 2')
 
115
        self.runbzr('pull -r 2')
131
116
        a = Branch.open('../a')
132
117
        b = Branch.open('.')
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())
 
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())
139
124
 
140
125
 
141
126
    def test_overwrite_uptodate(self):
142
127
        # Make sure pull --overwrite overwrites
143
128
        # even if the target branch has merged
144
129
        # everything already.
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)
 
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)
170
166
 
171
167
        self.assertEqual(rev_history_b, rev_history_a)
172
168
 
173
169
    def test_overwrite_children(self):
174
170
        # Make sure pull --overwrite sets the revision-history
175
171
        # to be identical to the pull source, even if we have convergence
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)
 
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)
201
211
 
202
212
        # With convergence, we could just pull over the
203
213
        # new change, but with --overwrite, we want to switch our history
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)
 
214
        os.chdir('../b')
 
215
        bzr('pull', '--overwrite', '../a')
 
216
        rev_history_b = get_rh(4)
208
217
 
209
218
        self.assertEqual(rev_history_b, rev_history_a)
210
219
 
229
238
        self.assertEqual(None, branch_b.get_parent())
230
239
        # test pull for failure without parent set
231
240
        os.chdir('branch_b')
232
 
        out = self.run_bzr('pull', retcode=3)
233
 
        self.assertEqual(out,
 
241
        out = self.runbzr('pull', retcode=3)
 
242
        self.assertEquals(out,
234
243
                ('','bzr: ERROR: No pull location known or specified.\n'))
235
244
        # test implicit --remember when no parent set, this pull conflicts
236
245
        self.build_tree(['d'])
237
246
        tree_b.add('d')
238
247
        tree_b.commit('commit d')
239
 
        out = self.run_bzr('pull ../branch_a', retcode=3)
240
 
        self.assertEqual(out,
241
 
                ('','bzr: ERROR: These branches have diverged.'
242
 
                    ' Use the missing command to see how.\n'
243
 
                    'Use the merge command to reconcile them.\n'))
244
 
        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)
245
252
        # test implicit --remember after resolving previous failure
246
253
        uncommit(branch=branch_b, tree=tree_b)
247
254
        transport.delete('branch_b/d')
248
 
        self.run_bzr('pull')
249
 
        self.assertEqual(branch_b.get_parent(), parent)
 
255
        self.runbzr('pull')
 
256
        self.assertEquals(branch_b.get_parent(), parent)
250
257
        # test explicit --remember
251
 
        self.run_bzr('pull ../branch_c --remember')
252
 
        self.assertEqual(branch_b.get_parent(),
 
258
        self.runbzr('pull ../branch_c --remember')
 
259
        self.assertEquals(branch_b.get_parent(),
253
260
                          branch_c.bzrdir.root_transport.base)
254
261
 
255
262
    def test_pull_bundle(self):
272
279
 
273
280
        # Create the bundle for 'b' to pull
274
281
        os.chdir('branch_a')
275
 
        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()
276
285
 
277
286
        os.chdir('../branch_b')
278
 
        out, err = self.run_bzr('pull ../bundle')
279
 
        self.assertEqual(out,
280
 
                         'Now on revision 2.\n')
281
 
        self.assertEqual(err,
282
 
                ' 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])
283
291
 
284
292
        self.assertEqualDiff(tree_a.branch.revision_history(),
285
293
                             tree_b.branch.revision_history())
286
294
 
287
 
        testament_a = Testament.from_revision(tree_a.branch.repository,
288
 
                                              tree_a.get_parent_ids()[0])
 
295
        testament_a = Testament.from_revision(tree_a.branch.repository, 
 
296
                                              tree_a.last_revision())
289
297
        testament_b = Testament.from_revision(tree_b.branch.repository,
290
 
                                              tree_b.get_parent_ids()[0])
 
298
                                              tree_b.last_revision())
291
299
        self.assertEqualDiff(testament_a.as_text(),
292
300
                             testament_b.as_text())
293
301
 
294
302
        # it is legal to attempt to pull an already-merged bundle
295
 
        out, err = self.run_bzr('pull ../bundle')
296
 
        self.assertEqual(err, '')
297
 
        self.assertEqual(out, 'No revisions to pull.\n')
298
 
 
299
 
    def test_pull_verbose_no_files(self):
300
 
        """Pull --verbose should not list modified files"""
301
 
        tree_a = self.make_branch_and_tree('tree_a')
302
 
        self.build_tree(['tree_a/foo'])
303
 
        tree_a.add('foo')
304
 
        tree_a.commit('bar')
305
 
        tree_b = self.make_branch_and_tree('tree_b')
306
 
        out = self.run_bzr('pull --verbose -d tree_b tree_a')[0]
307
 
        self.assertContainsRe(out, 'bar')
308
 
        self.assertNotContainsRe(out, 'added:')
309
 
        self.assertNotContainsRe(out, 'foo')
310
 
 
311
 
    def test_pull_quiet(self):
312
 
        """Check that bzr pull --quiet does not print anything"""
313
 
        tree_a = self.make_branch_and_tree('tree_a')
314
 
        self.build_tree(['tree_a/foo'])
315
 
        tree_a.add('foo')
316
 
        revision_id = tree_a.commit('bar')
317
 
        tree_b = tree_a.bzrdir.sprout('tree_b').open_workingtree()
318
 
        out, err = self.run_bzr('pull --quiet -d tree_b')
319
 
        self.assertEqual(out, '')
320
 
        self.assertEqual(err, '')
321
 
        self.assertEqual(tree_b.last_revision(), revision_id)
322
 
        self.build_tree(['tree_a/moo'])
323
 
        tree_a.add('moo')
324
 
        revision_id = tree_a.commit('quack')
325
 
        out, err = self.run_bzr('pull --quiet -d tree_b')
326
 
        self.assertEqual(out, '')
327
 
        self.assertEqual(err, '')
328
 
        self.assertEqual(tree_b.last_revision(), revision_id)
329
 
 
330
 
    def test_pull_from_directory_service(self):
331
 
        source = self.make_branch_and_tree('source')
332
 
        source.commit('commit 1')
333
 
        target = source.bzrdir.sprout('target').open_workingtree()
334
 
        source_last = source.commit('commit 2')
335
 
        class FooService(object):
336
 
            """A directory service that always returns source"""
337
 
 
338
 
            def look_up(self, name, url):
339
 
                return 'source'
340
 
        directories.register('foo:', FooService, 'Testing directory service')
341
 
        self.addCleanup(lambda: directories.remove('foo:'))
342
 
        self.run_bzr('pull foo:bar -d target')
343
 
        self.assertEqual(source_last, target.last_revision())
344
 
 
345
 
    def test_pull_verbose_defaults_to_long(self):
346
 
        tree = self.example_branch('source')
347
 
        target = self.make_branch_and_tree('target')
348
 
        out = self.run_bzr('pull -v source -d target')[0]
349
 
        self.assertContainsRe(out,
350
 
                              r'revno: 1\ncommitter: .*\nbranch nick: source')
351
 
        self.assertNotContainsRe(out, r'\n {4}1 .*\n {6}setup\n')
352
 
 
353
 
    def test_pull_verbose_uses_default_log(self):
354
 
        tree = self.example_branch('source')
355
 
        target = self.make_branch_and_tree('target')
356
 
        target_config = target.branch.get_config()
357
 
        target_config.set_user_option('log_format', 'short')
358
 
        out = self.run_bzr('pull -v source -d target')[0]
359
 
        self.assertContainsRe(out, r'\n {4}1 .*\n {6}setup\n')
360
 
        self.assertNotContainsRe(
361
 
            out, r'revno: 1\ncommitter: .*\nbranch nick: source')
362
 
 
363
 
    def test_pull_smart_stacked_streaming_acceptance(self):
364
 
        """'bzr pull -r 123' works on stacked, smart branches, even when the
365
 
        revision specified by the revno is only present in the fallback
366
 
        repository.
367
 
 
368
 
        See <https://launchpad.net/bugs/380314>
369
 
        """
370
 
        self.setup_smart_server_with_call_log()
371
 
        # Make a stacked-on branch with two commits so that the
372
 
        # revision-history can't be determined just by looking at the parent
373
 
        # field in the revision in the stacked repo.
374
 
        parent = self.make_branch_and_tree('parent', format='1.9')
375
 
        parent.commit(message='first commit')
376
 
        parent.commit(message='second commit')
377
 
        local = parent.bzrdir.sprout('local').open_workingtree()
378
 
        local.commit(message='local commit')
379
 
        local.branch.create_clone_on_transport(
380
 
            self.get_transport('stacked'), stacked_on=self.get_url('parent'))
381
 
        empty = self.make_branch_and_tree('empty', format='1.9')
382
 
        self.reset_smart_call_log()
383
 
        self.run_bzr(['pull', '-r', '1', self.get_url('stacked')],
384
 
            working_dir='empty')
385
 
        # This figure represent the amount of work to perform this use case. It
386
 
        # is entirely ok to reduce this number if a test fails due to rpc_count
387
 
        # being too low. If rpc_count increases, more network roundtrips have
388
 
        # become necessary for this use case. Please do not adjust this number
389
 
        # upwards without agreement from bzr's network support maintainers.
390
 
        self.assertLength(18, self.hpss_calls)
391
 
        remote = Branch.open('stacked')
392
 
        self.assertEndsWith(remote.get_stacked_on_url(), '/parent')
393
 
 
 
303
        output = self.run_bzr('pull', '../bundle')
 
304
        self.assertEqual('', output[0])
 
305
        self.assertEqual('0 revision(s) pulled.\n', output[1])