/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: Martin Pool
  • Date: 2007-10-03 08:06:44 UTC
  • mto: This revision was merged to the branch mainline in revision 2901.
  • Revision ID: mbp@sourcefrog.net-20071003080644-oivy0gkg98sex0ed
Avoid internal error tracebacks on failure to lock on readonly transport (#129701).

Add new LockFailed, which doesn't imply that we failed to get it because of
contention.  Raise this if we fail to create the pending or lock directories
because of Transport errors.

UnlockableTransport is not an internal error.

ReadOnlyLockError has a message which didn't match its name or usage; it's now
deprecated and callers are updated to use LockFailed which is more appropriate.

Add zero_ninetytwo deprecation symbol.

Unify assertMatchesRe with TestCase.assertContainsRe.

When the constructor is deprecated, just say that the class is deprecated, not
the __init__ method - this works better with applyDeprecated in tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_send.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 Canonical Ltd
2
2
# Authors: Aaron Bentley
3
3
#
4
4
# This program is free software; you can redistribute it and/or modify
13
13
#
14
14
# You should have received a copy of the GNU General Public License
15
15
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
 
 
18
 
 
19
 
import sys
20
 
from cStringIO import StringIO
 
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
17
 
 
18
 
 
19
import os
 
20
from StringIO import StringIO
21
21
 
22
22
from bzrlib import (
23
 
    branch,
24
 
    bzrdir,
 
23
    branch as _mod_branch,
25
24
    merge_directive,
26
 
    tests,
27
25
    )
28
26
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
54
 
 
55
 
 
56
 
class TestSendMixin(object):
57
 
 
58
 
    _default_command = ['send', '-o-']
59
 
    _default_wd = 'branch'
60
 
 
61
 
    def run_send(self, args, cmd=None, rc=0, wd=None, err_re=None):
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 = []
65
 
        return self.run_bzr(cmd + args, retcode=rc,
66
 
                            working_dir=wd,
67
 
                            error_regexes=err_re)
68
 
 
69
 
    def get_MD(self, args, cmd=None, wd='branch'):
70
 
        out = StringIO(self.run_send(args, cmd=cmd, wd=wd)[0])
71
 
        return merge_directive.MergeDirective.from_lines(out)
72
 
 
73
 
    def assertBundleContains(self, revs, args, cmd=None, wd='branch'):
74
 
        md = self.get_MD(args, cmd=cmd, wd=wd)
75
 
        br = serializer.read_bundle(StringIO(md.get_raw_bundle()))
76
 
        self.assertEqual(set(revs), set(r.revision_id for r in br.revisions))
77
 
 
78
 
 
79
 
class TestSend(tests.TestCaseWithTransport, TestSendMixin):
80
 
 
81
 
    def setUp(self):
82
 
        super(TestSend, self).setUp()
83
 
        grandparent_tree = bzrdir.BzrDir.create_standalone_workingtree(
84
 
            'grandparent')
 
27
from bzrlib.bzrdir import BzrDir
 
28
from bzrlib import tests
 
29
 
 
30
 
 
31
def read_bundle(fileobj):
 
32
    md = merge_directive.MergeDirective.from_lines(fileobj.readlines())
 
33
    return serializer.read_bundle(StringIO(md.get_raw_bundle()))
 
34
 
 
35
 
 
36
class TestSend(tests.TestCaseWithTransport):
 
37
 
 
38
    def make_trees(self):
 
39
        grandparent_tree = BzrDir.create_standalone_workingtree('grandparent')
85
40
        self.build_tree_contents([('grandparent/file1', 'grandparent')])
86
41
        grandparent_tree.add('file1')
87
 
        grandparent_tree.commit('initial commit', rev_id='rev1')
88
 
 
 
42
        grandparent_tree.commit('initial commit', rev_id='revision1')
89
43
        parent_bzrdir = grandparent_tree.bzrdir.sprout('parent')
90
44
        parent_tree = parent_bzrdir.open_workingtree()
91
 
        parent_tree.commit('next commit', rev_id='rev2')
92
 
 
 
45
        parent_tree.commit('next commit', rev_id='revision2')
93
46
        branch_tree = parent_tree.bzrdir.sprout('branch').open_workingtree()
94
47
        self.build_tree_contents([('branch/file1', 'branch')])
95
 
        branch_tree.commit('last commit', rev_id='rev3')
96
 
 
97
 
    def assertFormatIs(self, fmt_string, md):
98
 
        self.assertEqual(fmt_string, md.get_raw_bundle().splitlines()[0])
 
48
        branch_tree.commit('last commit', rev_id='revision3')
99
49
 
100
50
    def test_uses_parent(self):
101
51
        """Parent location is used as a basis by default"""
102
 
        errmsg = self.run_send([], rc=3, wd='grandparent')[1]
 
52
        self.make_trees()
 
53
        os.chdir('grandparent')
 
54
        errmsg = self.run_bzr('send -o-', retcode=3)[1]
103
55
        self.assertContainsRe(errmsg, 'No submit branch known or specified')
104
 
        stdout, stderr = self.run_send([])
105
 
        self.assertEqual(stderr.count('Using saved parent location'), 1)
106
 
        self.assertBundleContains(['rev3'], [])
 
56
        os.chdir('../branch')
 
57
        stdout, stderr = self.run_bzr('send -o-')
 
58
        self.assertEqual(stderr.count('Using saved location'), 1)
 
59
        br = read_bundle(StringIO(stdout))
 
60
        self.assertRevisions(br, ['revision3'])
107
61
 
108
62
    def test_bundle(self):
109
63
        """Bundle works like send, except -o is not required"""
110
 
        errmsg = self.run_send([], cmd=['bundle'], rc=3, wd='grandparent')[1]
 
64
        self.make_trees()
 
65
        os.chdir('grandparent')
 
66
        errmsg = self.run_bzr('bundle', retcode=3)[1]
111
67
        self.assertContainsRe(errmsg, 'No submit branch known or specified')
112
 
        stdout, stderr = self.run_send([], cmd=['bundle'])
113
 
        self.assertEqual(stderr.count('Using saved parent location'), 1)
114
 
        self.assertBundleContains(['rev3'], [], cmd=['bundle'])
 
68
        os.chdir('../branch')
 
69
        stdout, stderr = self.run_bzr('bundle')
 
70
        self.assertEqual(stderr.count('Using saved location'), 1)
 
71
        br = read_bundle(StringIO(stdout))
 
72
        self.assertRevisions(br, ['revision3'])
 
73
 
 
74
    def assertRevisions(self, bi, expected):
 
75
        self.assertEqual(set(r.revision_id for r in bi.revisions),
 
76
            set(expected))
115
77
 
116
78
    def test_uses_submit(self):
117
79
        """Submit location can be used and set"""
118
 
        self.assertBundleContains(['rev3'], [])
119
 
        self.assertBundleContains(['rev3', 'rev2'], ['../grandparent'])
 
80
        self.make_trees()
 
81
        os.chdir('branch')
 
82
        br = read_bundle(StringIO(self.run_bzr('send -o-')[0]))
 
83
        self.assertRevisions(br, ['revision3'])
 
84
        br = read_bundle(StringIO(self.run_bzr('send ../grandparent -o-')[0]))
 
85
        self.assertRevisions(br, ['revision3', 'revision2'])
120
86
        # submit location should be auto-remembered
121
 
        self.assertBundleContains(['rev3', 'rev2'], [])
122
 
 
123
 
        self.run_send(['../parent'])
124
 
        # We still point to ../grandparent
125
 
        self.assertBundleContains(['rev3', 'rev2'], [])
126
 
        # Remember parent now
127
 
        self.run_send(['../parent', '--remember'])
128
 
        # Now we point to parent
129
 
        self.assertBundleContains(['rev3'], [])
130
 
 
131
 
        err = self.run_send(['--remember'], rc=3)[1]
132
 
        self.assertContainsRe(err,
 
87
        br = read_bundle(StringIO(self.run_bzr('send -o-')[0]))
 
88
        self.assertRevisions(br, ['revision3', 'revision2'])
 
89
        self.run_bzr('send ../parent -o-')
 
90
        br = read_bundle(StringIO(self.run_bzr('send -o-')[0]))
 
91
        self.assertRevisions(br, ['revision3', 'revision2'])
 
92
        self.run_bzr('send ../parent --remember -o-')
 
93
        br = read_bundle(StringIO(self.run_bzr('send -o-')[0]))
 
94
        self.assertRevisions(br, ['revision3'])
 
95
        err = self.run_bzr('send --remember -o-', retcode=3)[1]
 
96
        self.assertContainsRe(err, 
133
97
                              '--remember requires a branch to be specified.')
134
98
 
135
99
    def test_revision_branch_interaction(self):
136
 
        self.assertBundleContains(['rev3', 'rev2'], ['../grandparent'])
137
 
        self.assertBundleContains(['rev2'], ['../grandparent', '-r-2'])
138
 
        self.assertBundleContains(['rev3', 'rev2'],
139
 
                                  ['../grandparent', '-r-2..-1'])
140
 
        md = self.get_MD(['-r-2..-1'])
141
 
        self.assertEqual('rev2', md.base_revision_id)
142
 
        self.assertEqual('rev3', md.revision_id)
 
100
        self.make_trees()
 
101
        os.chdir('branch')
 
102
        bi = read_bundle(StringIO(self.run_bzr('send ../grandparent -o-')[0]))
 
103
        self.assertRevisions(bi, ['revision3', 'revision2'])
 
104
        out = StringIO(self.run_bzr('send ../grandparent -r -2 -o-')[0])
 
105
        bi = read_bundle(out)
 
106
        self.assertRevisions(bi, ['revision2'])
 
107
        sio = StringIO(self.run_bzr('send -r -2..-1 -o-')[0])
 
108
        md = merge_directive.MergeDirective.from_lines(sio.readlines())
 
109
        self.assertEqual('revision2', md.base_revision_id)
 
110
        self.assertEqual('revision3', md.revision_id)
 
111
        sio.seek(0)
 
112
        bi = read_bundle(sio)
 
113
        self.assertRevisions(bi, ['revision2', 'revision3'])
 
114
        self.run_bzr('send ../grandparent -r -2..-1 -o-')
143
115
 
144
116
    def test_output(self):
145
117
        # check output for consistency
146
118
        # win32 stdout converts LF to CRLF,
147
119
        # which would break patch-based bundles
148
 
        self.assertBundleContains(['rev3'], [])
 
120
        self.make_trees()        
 
121
        os.chdir('branch')
 
122
        stdout = self.run_bzr_subprocess('send -o-')[0]
 
123
        br = read_bundle(StringIO(stdout))
 
124
        self.assertRevisions(br, ['revision3'])
149
125
 
150
126
    def test_no_common_ancestor(self):
151
127
        foo = self.make_branch_and_tree('foo')
152
128
        foo.commit('rev a')
153
129
        bar = self.make_branch_and_tree('bar')
154
130
        bar.commit('rev b')
155
 
        self.run_send(['--from', 'foo', '../bar'], wd='foo')
 
131
        os.chdir('foo')
 
132
        self.run_bzr('send ../bar -o-')
 
133
 
 
134
    def send_directive(self, args):
 
135
        sio = StringIO(self.run_bzr(['send', '-o-'] + args)[0])
 
136
        return merge_directive.MergeDirective.from_lines(sio.readlines())
156
137
 
157
138
    def test_content_options(self):
158
139
        """--no-patch and --no-bundle should work and be independant"""
159
 
        md = self.get_MD([])
160
 
        self.assertIsNot(None, md.bundle)
161
 
        self.assertIsNot(None, md.patch)
162
 
 
163
 
        md = self.get_MD(['--format=0.9'])
164
 
        self.assertIsNot(None, md.bundle)
165
 
        self.assertIsNot(None, md.patch)
166
 
 
167
 
        md = self.get_MD(['--no-patch'])
 
140
        self.make_trees()
 
141
        os.chdir('branch')
 
142
        md = self.send_directive([])
 
143
        self.assertIsNot(None, md.bundle)
 
144
        self.assertIsNot(None, md.patch)
 
145
 
 
146
        md = self.send_directive(['--format=0.9'])
 
147
        self.assertIsNot(None, md.bundle)
 
148
        self.assertIsNot(None, md.patch)
 
149
 
 
150
        md = self.send_directive(['--no-patch'])
168
151
        self.assertIsNot(None, md.bundle)
169
152
        self.assertIs(None, md.patch)
170
153
        self.run_bzr_error(['Format 0.9 does not permit bundle with no patch'],
171
 
                           ['send', '--no-patch', '--format=0.9', '-o-'],
172
 
                           working_dir='branch')
173
 
        md = self.get_MD(['--no-bundle', '.', '.'])
 
154
                      'send --no-patch --format=0.9 -o-')
 
155
 
 
156
        md = self.send_directive(['--no-bundle', '.', '.'])
174
157
        self.assertIs(None, md.bundle)
175
158
        self.assertIsNot(None, md.patch)
176
159
 
177
 
        md = self.get_MD(['--no-bundle', '--format=0.9', '../parent',
 
160
        md = self.send_directive(['--no-bundle', '--format=0.9', '../parent',
178
161
                                  '.'])
179
162
        self.assertIs(None, md.bundle)
180
163
        self.assertIsNot(None, md.patch)
181
164
 
182
 
        md = self.get_MD(['--no-bundle', '--no-patch', '.', '.'])
 
165
        md = self.send_directive(['--no-bundle', '--no-patch', '.', '.'])
183
166
        self.assertIs(None, md.bundle)
184
167
        self.assertIs(None, md.patch)
185
168
 
186
 
        md = self.get_MD(['--no-bundle', '--no-patch', '--format=0.9',
187
 
                          '../parent', '.'])
 
169
        md = self.send_directive(['--no-bundle', '--no-patch', '--format=0.9',
 
170
                                  '../parent', '.'])
188
171
        self.assertIs(None, md.bundle)
189
172
        self.assertIs(None, md.patch)
190
173
 
191
174
    def test_from_option(self):
 
175
        self.make_trees()
192
176
        self.run_bzr('send', retcode=3)
193
 
        md = self.get_MD(['--from', 'branch'])
194
 
        self.assertEqual('rev3', md.revision_id)
195
 
        md = self.get_MD(['-f', 'branch'])
196
 
        self.assertEqual('rev3', md.revision_id)
 
177
        md = self.send_directive(['--from', 'branch'])
 
178
        self.assertEqual('revision3', md.revision_id)
 
179
        md = self.send_directive(['-f', 'branch'])
 
180
        self.assertEqual('revision3', md.revision_id)
197
181
 
198
182
    def test_output_option(self):
 
183
        self.make_trees()
199
184
        stdout = self.run_bzr('send -f branch --output file1')[0]
200
185
        self.assertEqual('', stdout)
201
186
        md_file = open('file1', 'rb')
202
187
        self.addCleanup(md_file.close)
203
 
        self.assertContainsRe(md_file.read(), 'rev3')
 
188
        self.assertContainsRe(md_file.read(), 'revision3')
204
189
        stdout = self.run_bzr('send -f branch --output -')[0]
205
 
        self.assertContainsRe(stdout, 'rev3')
206
 
 
207
 
    def test_note_revisions(self):
208
 
        stderr = self.run_send([])[1]
209
 
        self.assertEndsWith(stderr, '\nBundling 1 revision(s).\n')
 
190
        self.assertContainsRe(stdout, 'revision3')
210
191
 
211
192
    def test_mailto_option(self):
212
 
        b = branch.Branch.open('branch')
213
 
        b.get_config().set_user_option('mail_client', 'editor')
214
 
        self.run_bzr_error(
215
 
            ('No mail-to address \\(--mail-to\\) or output \\(-o\\) specified',
216
 
            ), 'send -f branch')
217
 
        b.get_config().set_user_option('mail_client', 'bogus')
218
 
        self.run_send([])
 
193
        self.make_trees()
 
194
        branch = _mod_branch.Branch.open('branch')
 
195
        branch.get_config().set_user_option('mail_client', 'bogus')
 
196
        self.run_bzr_error(('No mail-to address specified',), 'send -f branch')
 
197
        self.run_bzr('send -f branch -o-')
219
198
        self.run_bzr_error(('Unknown mail client: bogus',),
220
199
                           'send -f branch --mail-to jrandom@example.org')
221
 
        b.get_config().set_user_option('submit_to', 'jrandom@example.org')
222
 
        self.run_bzr_error(('Unknown mail client: bogus',),
223
 
                           'send -f branch')
224
 
 
225
 
    def test_mailto_child_option(self):
226
 
        """Make sure that child_submit_to is used."""
227
 
        b = branch.Branch.open('branch')
228
 
        b.get_config().set_user_option('mail_client', 'bogus')
229
 
        parent = branch.Branch.open('parent')
230
 
        parent.get_config().set_user_option('child_submit_to',
231
 
                           'somebody@example.org')
 
200
        branch.get_config().set_user_option('submit_to', 'jrandom@example.org')
232
201
        self.run_bzr_error(('Unknown mail client: bogus',),
233
202
                           'send -f branch')
234
203
 
235
204
    def test_format(self):
236
 
        md = self.get_MD(['--format=4'])
 
205
        self.make_trees()
 
206
        s = StringIO(self.run_bzr('send -f branch -o- --format=4')[0])
 
207
        md = merge_directive.MergeDirective.from_lines(s.readlines())
237
208
        self.assertIs(merge_directive.MergeDirective2, md.__class__)
238
 
        self.assertFormatIs('# Bazaar revision bundle v4', md)
239
 
 
240
 
        md = self.get_MD(['--format=0.9'])
241
 
        self.assertFormatIs('# Bazaar revision bundle v0.9', md)
242
 
 
243
 
        md = self.get_MD(['--format=0.9'], cmd=['bundle'])
244
 
        self.assertFormatIs('# Bazaar revision bundle v0.9', md)
 
209
        s = StringIO(self.run_bzr('send -f branch -o- --format=0.9')[0])
 
210
        md = merge_directive.MergeDirective.from_lines(s.readlines())
 
211
        self.assertContainsRe(md.get_raw_bundle().splitlines()[0],
 
212
            '# Bazaar revision bundle v0.9')
 
213
        s = StringIO(self.run_bzr('bundle -f branch -o- --format=0.9')[0])
 
214
        md = merge_directive.MergeDirective.from_lines(s.readlines())
 
215
        self.assertContainsRe(md.get_raw_bundle().splitlines()[0],
 
216
            '# Bazaar revision bundle v0.9')
245
217
        self.assertIs(merge_directive.MergeDirective, md.__class__)
246
 
 
247
218
        self.run_bzr_error(['Bad value .* for option .format.'],
248
219
                            'send -f branch -o- --format=0.999')[0]
249
220
 
250
 
    def test_format_child_option(self):
251
 
        parent_config = branch.Branch.open('parent').get_config()
252
 
        parent_config.set_user_option('child_submit_format', '4')
253
 
        md = self.get_MD([])
254
 
        self.assertIs(merge_directive.MergeDirective2, md.__class__)
255
 
 
256
 
        parent_config.set_user_option('child_submit_format', '0.9')
257
 
        md = self.get_MD([])
258
 
        self.assertFormatIs('# Bazaar revision bundle v0.9', md)
259
 
 
260
 
        md = self.get_MD([], cmd=['bundle'])
261
 
        self.assertFormatIs('# Bazaar revision bundle v0.9', md)
262
 
        self.assertIs(merge_directive.MergeDirective, md.__class__)
263
 
 
264
 
        parent_config.set_user_option('child_submit_format', '0.999')
265
 
        self.run_bzr_error(["No such send format '0.999'"],
266
 
                            'send -f branch -o-')[0]
267
 
 
268
221
    def test_message_option(self):
 
222
        self.make_trees()
269
223
        self.run_bzr('send', retcode=3)
270
 
        md = self.get_MD([])
 
224
        md = self.send_directive(['--from', 'branch'])
271
225
        self.assertIs(None, md.message)
272
 
        md = self.get_MD(['-m', 'my message'])
 
226
        md = self.send_directive(['--from', 'branch', '-m', 'my message'])
273
227
        self.assertEqual('my message', md.message)
274
228
 
275
229
    def test_omitted_revision(self):
276
 
        md = self.get_MD(['-r-2..'])
277
 
        self.assertEqual('rev2', md.base_revision_id)
278
 
        self.assertEqual('rev3', md.revision_id)
279
 
        md = self.get_MD(['-r..3', '--from', 'branch', 'grandparent'], wd='.')
280
 
        self.assertEqual('rev1', md.base_revision_id)
281
 
        self.assertEqual('rev3', md.revision_id)
282
 
 
283
 
    def test_nonexistant_branch(self):
284
 
        self.vfs_transport_factory = memory.MemoryServer
285
 
        location = self.get_url('absentdir/')
286
 
        out, err = self.run_bzr(["send", "--from", location], retcode=3)
287
 
        self.assertEqual(out, '')
288
 
        self.assertEqual(err, 'bzr: ERROR: Not a branch: "%s".\n' % location)
289
 
 
290
 
 
291
 
class TestSendStrictMixin(TestSendMixin):
292
 
 
293
 
    def make_parent_and_local_branches(self):
294
 
        # Create a 'parent' branch as the base
295
 
        self.parent_tree = bzrdir.BzrDir.create_standalone_workingtree('parent')
296
 
        self.build_tree_contents([('parent/file', 'parent')])
297
 
        self.parent_tree.add('file')
298
 
        self.parent_tree.commit('first commit', rev_id='parent')
299
 
        # Branch 'local' from parent and do a change
300
 
        local_bzrdir = self.parent_tree.bzrdir.sprout('local')
301
 
        self.local_tree = local_bzrdir.open_workingtree()
302
 
        self.build_tree_contents([('local/file', 'local')])
303
 
        self.local_tree.commit('second commit', rev_id='local')
304
 
 
305
 
    _default_command = ['send', '-o-', '../parent']
306
 
    _default_wd = 'local'
307
 
    _default_sent_revs = ['local']
308
 
    _default_errors = ['Working tree ".*/local/" has uncommitted '
309
 
                       'changes \(See bzr status\)\.',]
310
 
    _default_additional_error = 'Use --no-strict to force the send.\n'
311
 
    _default_additional_warning = 'Uncommitted changes will not be sent.'
312
 
 
313
 
    def set_config_send_strict(self, 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)
318
 
 
319
 
    def assertSendFails(self, args):
320
 
        out, err = self.run_send(args, rc=3, err_re=self._default_errors)
321
 
        self.assertContainsRe(err, self._default_additional_error)
322
 
 
323
 
    def assertSendSucceeds(self, args, revs=None, with_warning=False):
324
 
        if with_warning:
325
 
            err_re = self._default_errors
326
 
        else:
327
 
            err_re = []
328
 
        if revs is None:
329
 
            revs = self._default_sent_revs
330
 
        out, err = self.run_send(args, err_re=err_re)
331
 
        bundling_revs = 'Bundling %d revision(s).\n' % len(revs)
332
 
        if with_warning:
333
 
            self.assertContainsRe(err, self._default_additional_warning)
334
 
            self.assertEndsWith(err, bundling_revs)
335
 
        else:
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()))
340
 
        self.assertEqual(set(revs), set(r.revision_id for r in br.revisions))
341
 
 
342
 
 
343
 
class TestSendStrictWithoutChanges(tests.TestCaseWithTransport,
344
 
                                   TestSendStrictMixin):
345
 
 
346
 
    def setUp(self):
347
 
        super(TestSendStrictWithoutChanges, self).setUp()
348
 
        self.make_parent_and_local_branches()
349
 
 
350
 
    def test_send_default(self):
351
 
        self.assertSendSucceeds([])
352
 
 
353
 
    def test_send_strict(self):
354
 
        self.assertSendSucceeds(['--strict'])
355
 
 
356
 
    def test_send_no_strict(self):
357
 
        self.assertSendSucceeds(['--no-strict'])
358
 
 
359
 
    def test_send_config_var_strict(self):
360
 
        self.set_config_send_strict('true')
361
 
        self.assertSendSucceeds([])
362
 
 
363
 
    def test_send_config_var_no_strict(self):
364
 
        self.set_config_send_strict('false')
365
 
        self.assertSendSucceeds([])
366
 
 
367
 
 
368
 
class TestSendStrictWithChanges(tests.TestCaseWithTransport,
369
 
                                   TestSendStrictMixin):
370
 
 
371
 
    _changes_type = None # Set by load_tests
372
 
 
373
 
    def setUp(self):
374
 
        super(TestSendStrictWithChanges, self).setUp()
375
 
        # load tests set _changes_types to the name of the method we want to
376
 
        # call now
377
 
        do_changes_func = getattr(self, self._changes_type)
378
 
        do_changes_func()
379
 
 
380
 
    def _uncommitted_changes(self):
381
 
        self.make_parent_and_local_branches()
382
 
        # Make a change without committing it
383
 
        self.build_tree_contents([('local/file', 'modified')])
384
 
 
385
 
    def _pending_merges(self):
386
 
        self.make_parent_and_local_branches()
387
 
        # Create 'other' branch containing a new file
388
 
        other_bzrdir = self.parent_tree.bzrdir.sprout('other')
389
 
        other_tree = other_bzrdir.open_workingtree()
390
 
        self.build_tree_contents([('other/other-file', 'other')])
391
 
        other_tree.add('other-file')
392
 
        other_tree.commit('other commit', rev_id='other')
393
 
        # Merge and revert, leaving a pending merge
394
 
        self.local_tree.merge_from_branch(other_tree.branch)
395
 
        self.local_tree.revert(filenames=['other-file'], backups=False)
396
 
 
397
 
    def _out_of_sync_trees(self):
398
 
        self.make_parent_and_local_branches()
399
 
        self.run_bzr(['checkout', '--lightweight', 'local', 'checkout'])
400
 
        # Make a change and commit it
401
 
        self.build_tree_contents([('local/file', 'modified in local')])
402
 
        self.local_tree.commit('modify file', rev_id='modified-in-local')
403
 
        # Exercise commands from the checkout directory
404
 
        self._default_wd = 'checkout'
405
 
        self._default_errors = ["Working tree is out of date, please run"
406
 
                                " 'bzr update'\.",]
407
 
        self._default_sent_revs = ['modified-in-local', 'local']
408
 
 
409
 
    def test_send_default(self):
410
 
        self.assertSendSucceeds([], with_warning=True)
411
 
 
412
 
    def test_send_with_revision(self):
413
 
        self.assertSendSucceeds(['-r', 'revid:local'], revs=['local'])
414
 
 
415
 
    def test_send_no_strict(self):
416
 
        self.assertSendSucceeds(['--no-strict'])
417
 
 
418
 
    def test_send_strict_with_changes(self):
419
 
        self.assertSendFails(['--strict'])
420
 
 
421
 
    def test_send_respect_config_var_strict(self):
422
 
        self.set_config_send_strict('true')
423
 
        self.assertSendFails([])
424
 
        self.assertSendSucceeds(['--no-strict'])
425
 
 
426
 
    def test_send_bogus_config_var_ignored(self):
427
 
        self.set_config_send_strict("I'm unsure")
428
 
        self.assertSendSucceeds([], with_warning=True)
429
 
 
430
 
    def test_send_no_strict_command_line_override_config(self):
431
 
        self.set_config_send_strict('true')
432
 
        self.assertSendFails([])
433
 
        self.assertSendSucceeds(['--no-strict'])
434
 
 
435
 
    def test_send_strict_command_line_override_config(self):
436
 
        self.set_config_send_strict('false')
437
 
        self.assertSendSucceeds([])
438
 
        self.assertSendFails(['--strict'])
439
 
 
440
 
 
441
 
class TestBundleStrictWithoutChanges(TestSendStrictWithoutChanges):
442
 
 
443
 
    _default_command = ['bundle-revisions', '../parent']
 
230
        self.make_trees()
 
231
        md = self.send_directive(['-r-2..', '--from', 'branch'])
 
232
        self.assertEqual('revision2', md.base_revision_id)
 
233
        self.assertEqual('revision3', md.revision_id)
 
234
        md = self.send_directive(['-r..3', '--from', 'branch',
 
235
                                 'grandparent'])
 
236
        self.assertEqual('revision1', md.base_revision_id)
 
237
        self.assertEqual('revision3', md.revision_id)