← 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: John Arbash Meinel
  • Date: 2009-10-02 20:32:50 UTC
  • mto: (4679.6.1 2.1-export-c-api)
  • mto: This revision was merged to the branch mainline in revision 4735.
  • Revision ID: john@arbash-meinel.com-20091002203250-q6iv6o2mwjqp4g53
Add __iter__ support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_pull.py
1
 
# Copyright (C) 2005 by Canonical Ltd
2
 
# -*- coding: utf-8 -*-
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
3
2
#
4
3
# This program is free software; you can redistribute it and/or modify
5
4
# it under the terms of the GNU General Public License as published by
13
12
#
14
13
# You should have received a copy of the GNU General Public License
15
14
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
16
 
18
17
 
19
18
"""Black-box tests for bzr pull."""
22
21
import sys
23
22
 
24
23
from bzrlib.branch import Branch
 
24
from bzrlib.directory_service import directories
 
25
from bzrlib.osutils import pathjoin
25
26
from bzrlib.tests.blackbox import ExternalBase
26
27
from bzrlib.uncommit import uncommit
 
28
from bzrlib.workingtree import WorkingTree
 
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')
 
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'])
98
115
 
99
116
    def test_pull_revision(self):
100
117
        """Pull some changes from one branch to another."""
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')
 
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()
114
129
        os.chdir('b')
115
 
        self.runbzr('pull -r 2')
 
130
        self.run_bzr('pull -r 2')
116
131
        a = Branch.open('../a')
117
132
        b = Branch.open('.')
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())
 
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())
124
139
 
125
140
 
126
141
    def test_overwrite_uptodate(self):
127
142
        # Make sure pull --overwrite overwrites
128
143
        # even if the target branch has merged
129
144
        # everything already.
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)
 
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)
166
170
 
167
171
        self.assertEqual(rev_history_b, rev_history_a)
168
172
 
169
173
    def test_overwrite_children(self):
170
174
        # Make sure pull --overwrite sets the revision-history
171
175
        # to be identical to the pull source, even if we have convergence
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)
 
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)
211
201
 
212
202
        # With convergence, we could just pull over the
213
203
        # new change, but with --overwrite, we want to switch our history
214
 
        os.chdir('../b')
215
 
        bzr('pull', '--overwrite', '../a')
216
 
        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)
217
208
 
218
209
        self.assertEqual(rev_history_b, rev_history_a)
219
210
 
238
229
        self.assertEqual(None, branch_b.get_parent())
239
230
        # test pull for failure without parent set
240
231
        os.chdir('branch_b')
241
 
        out = self.runbzr('pull', retcode=3)
242
 
        self.assertEquals(out,
 
232
        out = self.run_bzr('pull', retcode=3)
 
233
        self.assertEqual(out,
243
234
                ('','bzr: ERROR: No pull location known or specified.\n'))
244
235
        # test implicit --remember when no parent set, this pull conflicts
245
236
        self.build_tree(['d'])
246
237
        tree_b.add('d')
247
238
        tree_b.commit('commit d')
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)
 
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)
252
245
        # test implicit --remember after resolving previous failure
253
246
        uncommit(branch=branch_b, tree=tree_b)
254
247
        transport.delete('branch_b/d')
255
 
        self.runbzr('pull')
256
 
        self.assertEquals(branch_b.get_parent(), parent)
 
248
        self.run_bzr('pull')
 
249
        self.assertEqual(branch_b.get_parent(), parent)
257
250
        # test explicit --remember
258
 
        self.runbzr('pull ../branch_c --remember')
259
 
        self.assertEquals(branch_b.get_parent(),
 
251
        self.run_bzr('pull ../branch_c --remember')
 
252
        self.assertEqual(branch_b.get_parent(),
260
253
                          branch_c.bzrdir.root_transport.base)
261
254
 
262
255
    def test_pull_bundle(self):
279
272
 
280
273
        # Create the bundle for 'b' to pull
281
274
        os.chdir('branch_a')
282
 
        bundle_file = open('../bundle', 'wb')
283
 
        bundle_file.write(self.run_bzr('bundle', '../branch_b')[0])
284
 
        bundle_file.close()
 
275
        self.run_bzr('bundle ../branch_b -o ../bundle')
285
276
 
286
277
        os.chdir('../branch_b')
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])
 
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')
291
283
 
292
284
        self.assertEqualDiff(tree_a.branch.revision_history(),
293
285
                             tree_b.branch.revision_history())
294
286
 
295
 
        testament_a = Testament.from_revision(tree_a.branch.repository, 
296
 
                                              tree_a.last_revision())
 
287
        testament_a = Testament.from_revision(tree_a.branch.repository,
 
288
                                              tree_a.get_parent_ids()[0])
297
289
        testament_b = Testament.from_revision(tree_b.branch.repository,
298
 
                                              tree_b.last_revision())
 
290
                                              tree_b.get_parent_ids()[0])
299
291
        self.assertEqualDiff(testament_a.as_text(),
300
292
                             testament_b.as_text())
301
293
 
302
294
        # it is legal to attempt to pull an already-merged bundle
303
 
        output = self.run_bzr('pull', '../bundle')
304
 
        self.assertEqual('', output[0])
305
 
        self.assertEqual('0 revision(s) pulled.\n', output[1])
 
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