/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

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

  • Committer: Marius Kruger
  • Date: 2010-07-10 21:28:56 UTC
  • mto: (5384.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5385.
  • Revision ID: marius.kruger@enerweb.co.za-20100710212856-uq4ji3go0u5se7hx
* Update documentation
* add NEWS

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_send.py
1
 
# Copyright (C) 2006-2012, 2016 Canonical Ltd
 
1
# Copyright (C) 2006-2010 Canonical Ltd
2
2
# Authors: Aaron Bentley
3
3
#
4
4
# This program is free software; you can redistribute it and/or modify
16
16
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
17
 
18
18
 
19
 
from ... import (
 
19
import sys
 
20
from cStringIO import StringIO
 
21
 
 
22
from bzrlib import (
20
23
    branch,
 
24
    bzrdir,
21
25
    merge_directive,
22
26
    tests,
23
27
    )
24
 
from ...controldir import ControlDir
25
 
from ...bzr.bundle import serializer
26
 
from ...sixish import (
27
 
    BytesIO,
28
 
    )
29
 
from ...transport import memory
30
 
from .. import (
31
 
    scenarios,
32
 
    )
33
 
from ..matchers import ContainsNoVfsCalls
34
 
 
35
 
 
36
 
load_tests = scenarios.load_tests_apply_scenarios
 
28
from bzrlib.bundle import serializer
 
29
from bzrlib.transport import memory
 
30
 
 
31
 
 
32
def load_tests(standard_tests, module, loader):
 
33
    """Multiply tests for the send command."""
 
34
    result = loader.suiteClass()
 
35
 
 
36
    # one for each king of change
 
37
    changes_tests, remaining_tests = tests.split_suite_by_condition(
 
38
        standard_tests, tests.condition_isinstance((
 
39
                TestSendStrictWithChanges,
 
40
                )))
 
41
    changes_scenarios = [
 
42
        ('uncommitted',
 
43
         dict(_changes_type='_uncommitted_changes')),
 
44
        ('pending_merges',
 
45
         dict(_changes_type='_pending_merges')),
 
46
        ('out-of-sync-trees',
 
47
         dict(_changes_type='_out_of_sync_trees')),
 
48
        ]
 
49
    tests.multiply_tests(changes_tests, changes_scenarios, result)
 
50
    # No parametrization for the remaining tests
 
51
    result.addTests(remaining_tests)
 
52
 
 
53
    return result
37
54
 
38
55
 
39
56
class TestSendMixin(object):
42
59
    _default_wd = 'branch'
43
60
 
44
61
    def run_send(self, args, cmd=None, rc=0, wd=None, err_re=None):
45
 
        if cmd is None:
46
 
            cmd = self._default_command
47
 
        if wd is None:
48
 
            wd = self._default_wd
49
 
        if err_re is None:
50
 
            err_re = []
 
62
        if cmd is None: cmd = self._default_command
 
63
        if wd is None: wd = self._default_wd
 
64
        if err_re is None: err_re = []
51
65
        return self.run_bzr(cmd + args, retcode=rc,
52
66
                            working_dir=wd,
53
67
                            error_regexes=err_re)
54
68
 
55
69
    def get_MD(self, args, cmd=None, wd='branch'):
56
 
        md = self.run_send(args, cmd=cmd, wd=wd)[0]
57
 
        out = BytesIO(md.encode('utf-8'))
 
70
        out = StringIO(self.run_send(args, cmd=cmd, wd=wd)[0])
58
71
        return merge_directive.MergeDirective.from_lines(out)
59
72
 
60
73
    def assertBundleContains(self, revs, args, cmd=None, wd='branch'):
61
74
        md = self.get_MD(args, cmd=cmd, wd=wd)
62
 
        br = serializer.read_bundle(BytesIO(md.get_raw_bundle()))
 
75
        br = serializer.read_bundle(StringIO(md.get_raw_bundle()))
63
76
        self.assertEqual(set(revs), set(r.revision_id for r in br.revisions))
64
77
 
65
78
 
67
80
 
68
81
    def setUp(self):
69
82
        super(TestSend, self).setUp()
70
 
        grandparent_tree = ControlDir.create_standalone_workingtree(
 
83
        grandparent_tree = bzrdir.BzrDir.create_standalone_workingtree(
71
84
            'grandparent')
72
 
        self.build_tree_contents([('grandparent/file1', b'grandparent')])
 
85
        self.build_tree_contents([('grandparent/file1', 'grandparent')])
73
86
        grandparent_tree.add('file1')
74
 
        grandparent_tree.commit('initial commit', rev_id=b'rev1')
 
87
        grandparent_tree.commit('initial commit', rev_id='rev1')
75
88
 
76
 
        parent_bzrdir = grandparent_tree.controldir.sprout('parent')
 
89
        parent_bzrdir = grandparent_tree.bzrdir.sprout('parent')
77
90
        parent_tree = parent_bzrdir.open_workingtree()
78
 
        parent_tree.commit('next commit', rev_id=b'rev2')
 
91
        parent_tree.commit('next commit', rev_id='rev2')
79
92
 
80
 
        branch_tree = parent_tree.controldir.sprout(
81
 
            'branch').open_workingtree()
82
 
        self.build_tree_contents([('branch/file1', b'branch')])
83
 
        branch_tree.commit('last commit', rev_id=b'rev3')
 
93
        branch_tree = parent_tree.bzrdir.sprout('branch').open_workingtree()
 
94
        self.build_tree_contents([('branch/file1', 'branch')])
 
95
        branch_tree.commit('last commit', rev_id='rev3')
84
96
 
85
97
    def assertFormatIs(self, fmt_string, md):
86
98
        self.assertEqual(fmt_string, md.get_raw_bundle().splitlines()[0])
91
103
        self.assertContainsRe(errmsg, 'No submit branch known or specified')
92
104
        stdout, stderr = self.run_send([])
93
105
        self.assertEqual(stderr.count('Using saved parent location'), 1)
94
 
        self.assertBundleContains([b'rev3'], [])
 
106
        self.assertBundleContains(['rev3'], [])
95
107
 
96
108
    def test_bundle(self):
97
109
        """Bundle works like send, except -o is not required"""
99
111
        self.assertContainsRe(errmsg, 'No submit branch known or specified')
100
112
        stdout, stderr = self.run_send([], cmd=['bundle'])
101
113
        self.assertEqual(stderr.count('Using saved parent location'), 1)
102
 
        self.assertBundleContains([b'rev3'], [], cmd=['bundle'])
 
114
        self.assertBundleContains(['rev3'], [], cmd=['bundle'])
103
115
 
104
116
    def test_uses_submit(self):
105
117
        """Submit location can be used and set"""
106
 
        self.assertBundleContains([b'rev3'], [])
107
 
        self.assertBundleContains([b'rev3', b'rev2'], ['../grandparent'])
 
118
        self.assertBundleContains(['rev3'], [])
 
119
        self.assertBundleContains(['rev3', 'rev2'], ['../grandparent'])
108
120
        # submit location should be auto-remembered
109
 
        self.assertBundleContains([b'rev3', b'rev2'], [])
 
121
        self.assertBundleContains(['rev3', 'rev2'], [])
110
122
 
111
123
        self.run_send(['../parent'])
112
124
        # We still point to ../grandparent
113
 
        self.assertBundleContains([b'rev3', b'rev2'], [])
 
125
        self.assertBundleContains(['rev3', 'rev2'], [])
114
126
        # Remember parent now
115
127
        self.run_send(['../parent', '--remember'])
116
128
        # Now we point to parent
117
 
        self.assertBundleContains([b'rev3'], [])
 
129
        self.assertBundleContains(['rev3'], [])
118
130
 
119
131
        err = self.run_send(['--remember'], rc=3)[1]
120
132
        self.assertContainsRe(err,
121
133
                              '--remember requires a branch to be specified.')
122
134
 
123
135
    def test_revision_branch_interaction(self):
124
 
        self.assertBundleContains([b'rev3', b'rev2'], ['../grandparent'])
125
 
        self.assertBundleContains([b'rev2'], ['../grandparent', '-r-2'])
126
 
        self.assertBundleContains([b'rev3', b'rev2'],
 
136
        self.assertBundleContains(['rev3', 'rev2'], ['../grandparent'])
 
137
        self.assertBundleContains(['rev2'], ['../grandparent', '-r-2'])
 
138
        self.assertBundleContains(['rev3', 'rev2'],
127
139
                                  ['../grandparent', '-r-2..-1'])
128
140
        md = self.get_MD(['-r-2..-1'])
129
 
        self.assertEqual(b'rev2', md.base_revision_id)
130
 
        self.assertEqual(b'rev3', md.revision_id)
 
141
        self.assertEqual('rev2', md.base_revision_id)
 
142
        self.assertEqual('rev3', md.revision_id)
131
143
 
132
144
    def test_output(self):
133
145
        # check output for consistency
134
146
        # win32 stdout converts LF to CRLF,
135
147
        # which would break patch-based bundles
136
 
        self.assertBundleContains([b'rev3'], [])
 
148
        self.assertBundleContains(['rev3'], [])
137
149
 
138
150
    def test_no_common_ancestor(self):
139
151
        foo = self.make_branch_and_tree('foo')
163
175
        self.assertIsNot(None, md.patch)
164
176
 
165
177
        md = self.get_MD(['--no-bundle', '--format=0.9', '../parent',
166
 
                          '.'])
 
178
                                  '.'])
167
179
        self.assertIs(None, md.bundle)
168
180
        self.assertIsNot(None, md.patch)
169
181
 
179
191
    def test_from_option(self):
180
192
        self.run_bzr('send', retcode=3)
181
193
        md = self.get_MD(['--from', 'branch'])
182
 
        self.assertEqual(b'rev3', md.revision_id)
 
194
        self.assertEqual('rev3', md.revision_id)
183
195
        md = self.get_MD(['-f', 'branch'])
184
 
        self.assertEqual(b'rev3', md.revision_id)
 
196
        self.assertEqual('rev3', md.revision_id)
185
197
 
186
198
    def test_output_option(self):
187
199
        stdout = self.run_bzr('send -f branch --output file1')[0]
188
200
        self.assertEqual('', stdout)
189
201
        md_file = open('file1', 'rb')
190
202
        self.addCleanup(md_file.close)
191
 
        self.assertContainsRe(md_file.read(), b'rev3')
 
203
        self.assertContainsRe(md_file.read(), 'rev3')
192
204
        stdout = self.run_bzr('send -f branch --output -')[0]
193
205
        self.assertContainsRe(stdout, 'rev3')
194
206
 
195
207
    def test_note_revisions(self):
196
208
        stderr = self.run_send([])[1]
197
 
        self.assertEndsWith(stderr, '\nBundling 1 revision.\n')
 
209
        self.assertEndsWith(stderr, '\nBundling 1 revision(s).\n')
198
210
 
199
211
    def test_mailto_option(self):
200
212
        b = branch.Branch.open('branch')
201
 
        b.get_config_stack().set('mail_client', 'editor')
 
213
        b.get_config().set_user_option('mail_client', 'editor')
202
214
        self.run_bzr_error(
203
215
            ('No mail-to address \\(--mail-to\\) or output \\(-o\\) specified',
204
 
             ), 'send -f branch')
205
 
        b.get_config_stack().set('mail_client', 'bogus')
 
216
            ), 'send -f branch')
 
217
        b.get_config().set_user_option('mail_client', 'bogus')
206
218
        self.run_send([])
207
 
        self.run_bzr_error(('Bad value "bogus" for option "mail_client"',),
 
219
        self.run_bzr_error(('Unknown mail client: bogus',),
208
220
                           'send -f branch --mail-to jrandom@example.org')
209
 
        b.get_config_stack().set('submit_to', 'jrandom@example.org')
210
 
        self.run_bzr_error(('Bad value "bogus" for option "mail_client"',),
 
221
        b.get_config().set_user_option('submit_to', 'jrandom@example.org')
 
222
        self.run_bzr_error(('Unknown mail client: bogus',),
211
223
                           'send -f branch')
212
224
 
213
225
    def test_mailto_child_option(self):
214
226
        """Make sure that child_submit_to is used."""
215
227
        b = branch.Branch.open('branch')
216
 
        b.get_config_stack().set('mail_client', 'bogus')
 
228
        b.get_config().set_user_option('mail_client', 'bogus')
217
229
        parent = branch.Branch.open('parent')
218
 
        parent.get_config_stack().set('child_submit_to', 'somebody@example.org')
219
 
        self.run_bzr_error(('Bad value "bogus" for option "mail_client"',),
 
230
        parent.get_config().set_user_option('child_submit_to',
 
231
                           'somebody@example.org')
 
232
        self.run_bzr_error(('Unknown mail client: bogus',),
220
233
                           'send -f branch')
221
234
 
222
235
    def test_format(self):
223
236
        md = self.get_MD(['--format=4'])
224
237
        self.assertIs(merge_directive.MergeDirective2, md.__class__)
225
 
        self.assertFormatIs(b'# Bazaar revision bundle v4', md)
 
238
        self.assertFormatIs('# Bazaar revision bundle v4', md)
226
239
 
227
240
        md = self.get_MD(['--format=0.9'])
228
 
        self.assertFormatIs(b'# Bazaar revision bundle v0.9', md)
 
241
        self.assertFormatIs('# Bazaar revision bundle v0.9', md)
229
242
 
230
243
        md = self.get_MD(['--format=0.9'], cmd=['bundle'])
231
 
        self.assertFormatIs(b'# Bazaar revision bundle v0.9', md)
 
244
        self.assertFormatIs('# Bazaar revision bundle v0.9', md)
232
245
        self.assertIs(merge_directive.MergeDirective, md.__class__)
233
246
 
234
247
        self.run_bzr_error(['Bad value .* for option .format.'],
235
 
                           'send -f branch -o- --format=0.999')[0]
 
248
                            'send -f branch -o- --format=0.999')[0]
236
249
 
237
250
    def test_format_child_option(self):
238
 
        br = branch.Branch.open('parent')
239
 
        conf = br.get_config_stack()
240
 
        conf.set('child_submit_format', '4')
 
251
        parent_config = branch.Branch.open('parent').get_config()
 
252
        parent_config.set_user_option('child_submit_format', '4')
241
253
        md = self.get_MD([])
242
254
        self.assertIs(merge_directive.MergeDirective2, md.__class__)
243
255
 
244
 
        conf.set('child_submit_format', '0.9')
 
256
        parent_config.set_user_option('child_submit_format', '0.9')
245
257
        md = self.get_MD([])
246
 
        self.assertFormatIs(b'# Bazaar revision bundle v0.9', md)
 
258
        self.assertFormatIs('# Bazaar revision bundle v0.9', md)
247
259
 
248
260
        md = self.get_MD([], cmd=['bundle'])
249
 
        self.assertFormatIs(b'# Bazaar revision bundle v0.9', md)
 
261
        self.assertFormatIs('# Bazaar revision bundle v0.9', md)
250
262
        self.assertIs(merge_directive.MergeDirective, md.__class__)
251
263
 
252
 
        conf.set('child_submit_format', '0.999')
 
264
        parent_config.set_user_option('child_submit_format', '0.999')
253
265
        self.run_bzr_error(["No such send format '0.999'"],
254
 
                           'send -f branch -o-')[0]
 
266
                            'send -f branch -o-')[0]
255
267
 
256
268
    def test_message_option(self):
257
269
        self.run_bzr('send', retcode=3)
262
274
 
263
275
    def test_omitted_revision(self):
264
276
        md = self.get_MD(['-r-2..'])
265
 
        self.assertEqual(b'rev2', md.base_revision_id)
266
 
        self.assertEqual(b'rev3', md.revision_id)
 
277
        self.assertEqual('rev2', md.base_revision_id)
 
278
        self.assertEqual('rev3', md.revision_id)
267
279
        md = self.get_MD(['-r..3', '--from', 'branch', 'grandparent'], wd='.')
268
 
        self.assertEqual(b'rev1', md.base_revision_id)
269
 
        self.assertEqual(b'rev3', md.revision_id)
 
280
        self.assertEqual('rev1', md.base_revision_id)
 
281
        self.assertEqual('rev3', md.revision_id)
270
282
 
271
283
    def test_nonexistant_branch(self):
272
284
        self.vfs_transport_factory = memory.MemoryServer
273
285
        location = self.get_url('absentdir/')
274
286
        out, err = self.run_bzr(["send", "--from", location], retcode=3)
275
287
        self.assertEqual(out, '')
276
 
        self.assertEqual(err, 'brz: ERROR: Not a branch: "%s".\n' % location)
 
288
        self.assertEqual(err, 'bzr: ERROR: Not a branch: "%s".\n' % location)
277
289
 
278
290
 
279
291
class TestSendStrictMixin(TestSendMixin):
280
292
 
281
293
    def make_parent_and_local_branches(self):
282
294
        # Create a 'parent' branch as the base
283
 
        self.parent_tree = ControlDir.create_standalone_workingtree('parent')
284
 
        self.build_tree_contents([('parent/file', b'parent')])
 
295
        self.parent_tree = bzrdir.BzrDir.create_standalone_workingtree('parent')
 
296
        self.build_tree_contents([('parent/file', 'parent')])
285
297
        self.parent_tree.add('file')
286
 
        self.parent_tree.commit('first commit', rev_id=b'parent')
 
298
        self.parent_tree.commit('first commit', rev_id='parent')
287
299
        # Branch 'local' from parent and do a change
288
 
        local_bzrdir = self.parent_tree.controldir.sprout('local')
 
300
        local_bzrdir = self.parent_tree.bzrdir.sprout('local')
289
301
        self.local_tree = local_bzrdir.open_workingtree()
290
 
        self.build_tree_contents([('local/file', b'local')])
291
 
        self.local_tree.commit('second commit', rev_id=b'local')
 
302
        self.build_tree_contents([('local/file', 'local')])
 
303
        self.local_tree.commit('second commit', rev_id='local')
292
304
 
293
305
    _default_command = ['send', '-o-', '../parent']
294
306
    _default_wd = 'local'
295
 
    _default_sent_revs = [b'local']
 
307
    _default_sent_revs = ['local']
296
308
    _default_errors = ['Working tree ".*/local/" has uncommitted '
297
 
                       'changes \\(See brz status\\)\\.', ]
 
309
                       'changes \(See bzr status\)\.',]
298
310
    _default_additional_error = 'Use --no-strict to force the send.\n'
299
311
    _default_additional_warning = 'Uncommitted changes will not be sent.'
300
312
 
301
313
    def set_config_send_strict(self, value):
302
 
        br = branch.Branch.open('local')
303
 
        br.get_config_stack().set('send_strict', value)
 
314
        # set config var (any of bazaar.conf, locations.conf, branch.conf
 
315
        # should do)
 
316
        conf = self.local_tree.branch.get_config()
 
317
        conf.set_user_option('send_strict', value)
304
318
 
305
319
    def assertSendFails(self, args):
306
320
        out, err = self.run_send(args, rc=3, err_re=self._default_errors)
314
328
        if revs is None:
315
329
            revs = self._default_sent_revs
316
330
        out, err = self.run_send(args, err_re=err_re)
317
 
        if len(revs) == 1:
318
 
            bundling_revs = 'Bundling %d revision.\n' % len(revs)
319
 
        else:
320
 
            bundling_revs = 'Bundling %d revisions.\n' % len(revs)
 
331
        bundling_revs = 'Bundling %d revision(s).\n' % len(revs)
321
332
        if with_warning:
322
333
            self.assertContainsRe(err, self._default_additional_warning)
323
334
            self.assertEndsWith(err, bundling_revs)
324
335
        else:
325
 
            self.assertEqual(bundling_revs, err)
326
 
        md = merge_directive.MergeDirective.from_lines(
327
 
            BytesIO(out.encode('utf-8')))
328
 
        self.assertEqual(b'parent', md.base_revision_id)
329
 
        br = serializer.read_bundle(BytesIO(md.get_raw_bundle()))
 
336
            self.assertEquals(bundling_revs, err)
 
337
        md = merge_directive.MergeDirective.from_lines(StringIO(out))
 
338
        self.assertEqual('parent', md.base_revision_id)
 
339
        br = serializer.read_bundle(StringIO(md.get_raw_bundle()))
330
340
        self.assertEqual(set(revs), set(r.revision_id for r in br.revisions))
331
341
 
332
342
 
337
347
        super(TestSendStrictWithoutChanges, self).setUp()
338
348
        self.make_parent_and_local_branches()
339
349
 
340
 
    def test_send_without_workingtree(self):
341
 
        ControlDir.open("local").destroy_workingtree()
342
 
        self.assertSendSucceeds([])
343
 
 
344
350
    def test_send_default(self):
345
351
        self.assertSendSucceeds([])
346
352
 
360
366
 
361
367
 
362
368
class TestSendStrictWithChanges(tests.TestCaseWithTransport,
363
 
                                TestSendStrictMixin):
364
 
 
365
 
    # These are textually the same as test_push.strict_push_change_scenarios,
366
 
    # but since the functions are reimplemented here, the definitions are left
367
 
    # here too.
368
 
    scenarios = [
369
 
        ('uncommitted',
370
 
         dict(_changes_type='_uncommitted_changes')),
371
 
        ('pending_merges',
372
 
         dict(_changes_type='_pending_merges')),
373
 
        ('out-of-sync-trees',
374
 
         dict(_changes_type='_out_of_sync_trees')),
375
 
        ]
376
 
 
377
 
    _changes_type = None  # Set by load_tests
 
369
                                   TestSendStrictMixin):
 
370
 
 
371
    _changes_type = None # Set by load_tests
378
372
 
379
373
    def setUp(self):
380
374
        super(TestSendStrictWithChanges, self).setUp()
386
380
    def _uncommitted_changes(self):
387
381
        self.make_parent_and_local_branches()
388
382
        # Make a change without committing it
389
 
        self.build_tree_contents([('local/file', b'modified')])
 
383
        self.build_tree_contents([('local/file', 'modified')])
390
384
 
391
385
    def _pending_merges(self):
392
386
        self.make_parent_and_local_branches()
393
387
        # Create 'other' branch containing a new file
394
 
        other_bzrdir = self.parent_tree.controldir.sprout('other')
 
388
        other_bzrdir = self.parent_tree.bzrdir.sprout('other')
395
389
        other_tree = other_bzrdir.open_workingtree()
396
 
        self.build_tree_contents([('other/other-file', b'other')])
 
390
        self.build_tree_contents([('other/other-file', 'other')])
397
391
        other_tree.add('other-file')
398
 
        other_tree.commit('other commit', rev_id=b'other')
 
392
        other_tree.commit('other commit', rev_id='other')
399
393
        # Merge and revert, leaving a pending merge
400
394
        self.local_tree.merge_from_branch(other_tree.branch)
401
395
        self.local_tree.revert(filenames=['other-file'], backups=False)
404
398
        self.make_parent_and_local_branches()
405
399
        self.run_bzr(['checkout', '--lightweight', 'local', 'checkout'])
406
400
        # Make a change and commit it
407
 
        self.build_tree_contents([('local/file', b'modified in local')])
408
 
        self.local_tree.commit('modify file', rev_id=b'modified-in-local')
 
401
        self.build_tree_contents([('local/file', 'modified in local')])
 
402
        self.local_tree.commit('modify file', rev_id='modified-in-local')
409
403
        # Exercise commands from the checkout directory
410
404
        self._default_wd = 'checkout'
411
405
        self._default_errors = ["Working tree is out of date, please run"
412
 
                                " 'brz update'\\.", ]
413
 
        self._default_sent_revs = [b'modified-in-local', b'local']
 
406
                                " 'bzr update'\.",]
 
407
        self._default_sent_revs = ['modified-in-local', 'local']
414
408
 
415
409
    def test_send_default(self):
416
410
        self.assertSendSucceeds([], with_warning=True)
417
411
 
418
412
    def test_send_with_revision(self):
419
 
        self.assertSendSucceeds(['-r', 'revid:local'], revs=[b'local'])
 
413
        self.assertSendSucceeds(['-r', 'revid:local'], revs=['local'])
420
414
 
421
415
    def test_send_no_strict(self):
422
416
        self.assertSendSucceeds(['--no-strict'])
447
441
class TestBundleStrictWithoutChanges(TestSendStrictWithoutChanges):
448
442
 
449
443
    _default_command = ['bundle-revisions', '../parent']
450
 
 
451
 
 
452
 
class TestSmartServerSend(tests.TestCaseWithTransport):
453
 
 
454
 
    def test_send(self):
455
 
        self.setup_smart_server_with_call_log()
456
 
        t = self.make_branch_and_tree('branch')
457
 
        self.build_tree_contents([('branch/foo', b'thecontents')])
458
 
        t.add("foo")
459
 
        t.commit("message")
460
 
        local = t.controldir.sprout('local-branch').open_workingtree()
461
 
        self.build_tree_contents([('branch/foo', b'thenewcontents')])
462
 
        local.commit("anothermessage")
463
 
        self.reset_smart_call_log()
464
 
        out, err = self.run_bzr(
465
 
            ['send', '-o', 'x.diff', self.get_url('branch')], working_dir='local-branch')
466
 
        # This figure represent the amount of work to perform this use case. It
467
 
        # is entirely ok to reduce this number if a test fails due to rpc_count
468
 
        # being too low. If rpc_count increases, more network roundtrips have
469
 
        # become necessary for this use case. Please do not adjust this number
470
 
        # upwards without agreement from bzr's network support maintainers.
471
 
        self.assertLength(7, self.hpss_calls)
472
 
        self.assertLength(1, self.hpss_connections)
473
 
        self.assertThat(self.hpss_calls, ContainsNoVfsCalls)