← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

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

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

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_commit.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
18
18
"""Tests for the commit CLI of bzr."""
19
19
 
20
20
import os
21
 
import re
22
21
import sys
23
22
 
 
23
import bzrlib
24
24
from bzrlib import (
 
25
    osutils,
25
26
    ignores,
 
27
    osutils,
26
28
    )
27
 
from bzrlib.branch import Branch
28
29
from bzrlib.bzrdir import BzrDir
29
 
from bzrlib.errors import BzrCommandError
 
30
from bzrlib.tests import (
 
31
    probe_bad_non_ascii,
 
32
    TestSkipped,
 
33
    )
30
34
from bzrlib.tests.blackbox import ExternalBase
31
 
from bzrlib.workingtree import WorkingTree
32
35
 
33
36
 
34
37
class TestCommit(ExternalBase):
36
39
    def test_05_empty_commit(self):
37
40
        """Commit of tree with no versioned files should fail"""
38
41
        # If forced, it should succeed, but this is not tested here.
39
 
        self.run_bzr("init")
 
42
        self.make_branch_and_tree('.')
40
43
        self.build_tree(['hello.txt'])
41
 
        out,err = self.run_bzr("commit", "-m", "empty", retcode=3)
 
44
        out,err = self.run_bzr('commit -m empty', retcode=3)
42
45
        self.assertEqual('', out)
43
 
        self.assertStartsWith(err, 'bzr: ERROR: no changes to commit.'
 
46
        self.assertContainsRe(err, 'bzr: ERROR: no changes to commit\.'
44
47
                                  ' use --unchanged to commit anyhow\n')
45
48
 
46
49
    def test_commit_success(self):
47
50
        """Successful commit should not leave behind a bzr-commit-* file"""
48
 
        self.run_bzr("init")
49
 
        self.run_bzr("commit", "--unchanged", "-m", "message")
50
 
        self.assertEqual('', self.capture('unknowns'))
 
51
        self.make_branch_and_tree('.')
 
52
        self.run_bzr('commit --unchanged -m message')
 
53
        self.assertEqual('', self.run_bzr('unknowns')[0])
51
54
 
52
55
        # same for unicode messages
53
 
        self.run_bzr("commit", "--unchanged", "-m", u'foo\xb5')
54
 
        self.assertEqual('', self.capture('unknowns'))
 
56
        self.run_bzr(["commit", "--unchanged", "-m", u'foo\xb5'])
 
57
        self.assertEqual('', self.run_bzr('unknowns')[0])
55
58
 
56
59
    def test_commit_with_path(self):
57
60
        """Commit tree with path of root specified"""
58
 
        self.run_bzr('init', 'a')
 
61
        a_tree = self.make_branch_and_tree('a')
59
62
        self.build_tree(['a/a_file'])
60
 
        self.run_bzr('add', 'a/a_file')
61
 
        self.run_bzr('commit', '-m', 'first commit', 'a')
 
63
        a_tree.add('a_file')
 
64
        self.run_bzr(['commit', '-m', 'first commit', 'a'])
62
65
 
63
 
        self.run_bzr('branch', 'a', 'b')
 
66
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
64
67
        self.build_tree_contents([('b/a_file', 'changes in b')])
65
 
        self.run_bzr('commit', '-m', 'first commit in b', 'b')
 
68
        self.run_bzr(['commit', '-m', 'first commit in b', 'b'])
66
69
 
67
70
        self.build_tree_contents([('a/a_file', 'new contents')])
68
 
        self.run_bzr('commit', '-m', 'change in a', 'a')
 
71
        self.run_bzr(['commit', '-m', 'change in a', 'a'])
69
72
 
70
 
        os.chdir('b')
71
 
        self.run_bzr('merge', '../a', retcode=1) # will conflict
72
 
        os.chdir('..')
73
 
        self.run_bzr('resolved', 'b/a_file')
74
 
        self.run_bzr('commit', '-m', 'merge into b', 'b')
 
73
        b_tree.merge_from_branch(a_tree.branch)
 
74
        self.assertEqual(len(b_tree.conflicts()), 1)
 
75
        self.run_bzr('resolved b/a_file')
 
76
        self.run_bzr(['commit', '-m', 'merge into b', 'b'])
75
77
 
76
78
 
77
79
    def test_10_verbose_commit(self):
78
80
        """Add one file and examine verbose commit output"""
79
 
        self.runbzr("init")
 
81
        tree = self.make_branch_and_tree('.')
80
82
        self.build_tree(['hello.txt'])
81
 
        self.runbzr("add hello.txt")
82
 
        out,err = self.run_bzr("commit", "-m", "added")
 
83
        tree.add("hello.txt")
 
84
        out,err = self.run_bzr('commit -m added')
83
85
        self.assertEqual('', out)
84
 
        self.assertEqual('added hello.txt\n'
85
 
                         'Committed revision 1.\n',
86
 
                         err)
 
86
        self.assertContainsRe(err, '^Committing to: .*\n'
 
87
                              'added hello.txt\n'
 
88
                              'Committed revision 1.\n$',)
87
89
 
88
90
    def prepare_simple_history(self):
89
91
        """Prepare and return a working tree with one commit of one file"""
98
100
        # Verbose commit of modified file should say so
99
101
        wt = self.prepare_simple_history()
100
102
        self.build_tree_contents([('hello.txt', 'new contents')])
101
 
        out, err = self.run_bzr("commit", "-m", "modified")
 
103
        out, err = self.run_bzr('commit -m modified')
102
104
        self.assertEqual('', out)
103
 
        self.assertEqual('modified hello.txt\n'
104
 
                         'Committed revision 2.\n',
105
 
                         err)
 
105
        self.assertContainsRe(err, '^Committing to: .*\n'
 
106
                              'modified hello\.txt\n'
 
107
                              'Committed revision 2\.\n$')
106
108
 
107
109
    def test_verbose_commit_renamed(self):
108
110
        # Verbose commit of renamed file should say so
109
111
        wt = self.prepare_simple_history()
110
112
        wt.rename_one('hello.txt', 'gutentag.txt')
111
 
        out, err = self.run_bzr("commit", "-m", "renamed")
 
113
        out, err = self.run_bzr('commit -m renamed')
112
114
        self.assertEqual('', out)
113
 
        self.assertEqual('renamed hello.txt => gutentag.txt\n'
114
 
                         'Committed revision 2.\n',
115
 
                         err)
 
115
        self.assertContainsRe(err, '^Committing to: .*\n'
 
116
                              'renamed hello\.txt => gutentag\.txt\n'
 
117
                              'Committed revision 2\.$\n')
116
118
 
117
119
    def test_verbose_commit_moved(self):
118
120
        # Verbose commit of file moved to new directory should say so
120
122
        os.mkdir('subdir')
121
123
        wt.add(['subdir'])
122
124
        wt.rename_one('hello.txt', 'subdir/hello.txt')
123
 
        out, err = self.run_bzr("commit", "-m", "renamed")
 
125
        out, err = self.run_bzr('commit -m renamed')
124
126
        self.assertEqual('', out)
125
 
        self.assertEqualDiff('added subdir\n'
126
 
                             'renamed hello.txt => subdir/hello.txt\n'
127
 
                             'Committed revision 2.\n',
128
 
                             err)
 
127
        self.assertContainsRe(err, '^Committing to: .*\n'
 
128
                              'added subdir\n'
 
129
                              'renamed hello\.txt => subdir/hello\.txt\n'
 
130
                              'Committed revision 2\.\n$')
129
131
 
130
132
    def test_verbose_commit_with_unknown(self):
131
133
        """Unknown files should not be listed by default in verbose output"""
133
135
        wt = BzrDir.create_standalone_workingtree('.')
134
136
        self.build_tree(['hello.txt', 'extra.txt'])
135
137
        wt.add(['hello.txt'])
136
 
        out,err = self.run_bzr("commit", "-m", "added")
 
138
        out,err = self.run_bzr('commit -m added')
137
139
        self.assertEqual('', out)
138
 
        self.assertEqual('added hello.txt\n'
139
 
                         'Committed revision 1.\n',
140
 
                         err)
 
140
        self.assertContainsRe(err, '^Committing to: .*\n'
 
141
                              'added hello\.txt\n'
 
142
                              'Committed revision 1\.\n$')
141
143
 
142
144
    def test_verbose_commit_with_unchanged(self):
143
145
        """Unchanged files should not be listed by default in verbose output"""
144
 
        self.runbzr("init")
 
146
        tree = self.make_branch_and_tree('.')
145
147
        self.build_tree(['hello.txt', 'unchanged.txt'])
146
 
        self.runbzr('add unchanged.txt')
147
 
        self.runbzr('commit -m unchanged unchanged.txt')
148
 
        self.runbzr("add hello.txt")
149
 
        out,err = self.run_bzr("commit", "-m", "added")
 
148
        tree.add('unchanged.txt')
 
149
        self.run_bzr('commit -m unchanged unchanged.txt')
 
150
        tree.add("hello.txt")
 
151
        out,err = self.run_bzr('commit -m added')
150
152
        self.assertEqual('', out)
151
 
        self.assertEqual('added hello.txt\n'
152
 
                         'Committed revision 2.\n',
153
 
                         err)
 
153
        self.assertContainsRe(err, '^Committing to: .*\n'
 
154
                              'added hello\.txt\n'
 
155
                              'Committed revision 2\.$\n')
 
156
 
 
157
    def test_verbose_commit_includes_master_location(self):
 
158
        """Location of master is displayed when committing to bound branch"""
 
159
        a_tree = self.make_branch_and_tree('a')
 
160
        self.build_tree(['a/b'])
 
161
        a_tree.add('b')
 
162
        a_tree.commit(message='Initial message')
 
163
 
 
164
        b_tree = a_tree.branch.create_checkout('b')
 
165
        expected = "%s/" % (osutils.abspath('a'), )
 
166
        out, err = self.run_bzr('commit -m blah --unchanged', working_dir='b')
 
167
        self.assertEqual(err, 'Committing to: %s\n'
 
168
                         'Committed revision 2.\n' % expected)
154
169
 
155
170
    def test_commit_merge_reports_all_modified_files(self):
156
171
        # the commit command should show all the files that are shown by
189
204
            other_tree.rename_one('dirtorename', 'renameddir')
190
205
            other_tree.rename_one('dirtoreparent', 'renameddir/reparenteddir')
191
206
            other_tree.rename_one('filetorename', 'renamedfile')
192
 
            other_tree.rename_one('filetoreparent', 'renameddir/reparentedfile')
 
207
            other_tree.rename_one('filetoreparent',
 
208
                                  'renameddir/reparentedfile')
193
209
            other_tree.remove(['dirtoremove', 'filetoremove'])
194
210
            self.build_tree_contents([
195
 
                ('other/newdir/', ),
 
211
                ('other/newdir/',),
196
212
                ('other/filetomodify', 'new content'),
197
213
                ('other/newfile', 'new file content')])
198
214
            other_tree.add('newfile')
202
218
            other_tree.unlock()
203
219
        this_tree.merge_from_branch(other_tree.branch)
204
220
        os.chdir('this')
205
 
        out,err = self.run_bzr("commit", "-m", "added")
206
 
        os.chdir('..')
 
221
        out,err = self.run_bzr('commit -m added')
207
222
        self.assertEqual('', out)
 
223
        expected = '%s/' % (osutils.getcwd(), )
208
224
        self.assertEqualDiff(
 
225
            'Committing to: %s\n'
209
226
            'modified filetomodify\n'
210
227
            'added newdir\n'
211
228
            'added newfile\n'
212
229
            'renamed dirtorename => renameddir\n'
 
230
            'renamed filetorename => renamedfile\n'
213
231
            'renamed dirtoreparent => renameddir/reparenteddir\n'
214
232
            'renamed filetoreparent => renameddir/reparentedfile\n'
215
 
            'renamed filetorename => renamedfile\n'
216
233
            'deleted dirtoremove\n'
217
234
            'deleted filetoremove\n'
218
 
            'Committed revision 2.\n',
 
235
            'Committed revision 2.\n' % (expected, ),
219
236
            err)
220
237
 
221
238
    def test_empty_commit_message(self):
222
 
        self.runbzr("init")
223
 
        file('foo.c', 'wt').write('int main() {}')
224
 
        self.runbzr(['add', 'foo.c'])
225
 
        self.runbzr(["commit", "-m", ""] , retcode=3)
 
239
        tree = self.make_branch_and_tree('.')
 
240
        self.build_tree_contents([('foo.c', 'int main() {}')])
 
241
        tree.add('foo.c')
 
242
        self.run_bzr('commit -m ""', retcode=3)
 
243
 
 
244
    def test_unsupported_encoding_commit_message(self):
 
245
        tree = self.make_branch_and_tree('.')
 
246
        self.build_tree_contents([('foo.c', 'int main() {}')])
 
247
        tree.add('foo.c')
 
248
        # LANG env variable has no effect on Windows
 
249
        # but some characters anyway cannot be represented
 
250
        # in default user encoding
 
251
        char = probe_bad_non_ascii(bzrlib.user_encoding)
 
252
        if char is None:
 
253
            raise TestSkipped('Cannot find suitable non-ascii character'
 
254
                'for user_encoding (%s)' % bzrlib.user_encoding)
 
255
        out,err = self.run_bzr_subprocess('commit -m "%s"' % char,
 
256
                                          retcode=1,
 
257
                                          env_changes={'LANG': 'C'})
 
258
        self.assertContainsRe(err, r'bzrlib.errors.BzrError: Parameter.*is '
 
259
                                    'unsupported by the current encoding.')
226
260
 
227
261
    def test_other_branch_commit(self):
228
262
        # this branch is to ensure consistent behaviour, whether we're run
229
263
        # inside a branch, or not.
230
 
        os.mkdir('empty_branch')
231
 
        os.chdir('empty_branch')
232
 
        self.runbzr('init')
233
 
        os.mkdir('branch')
234
 
        os.chdir('branch')
235
 
        self.runbzr('init')
236
 
        file('foo.c', 'wt').write('int main() {}')
237
 
        file('bar.c', 'wt').write('int main() {}')
238
 
        os.chdir('..')
239
 
        self.runbzr(['add', 'branch/foo.c'])
240
 
        self.runbzr(['add', 'branch'])
 
264
        outer_tree = self.make_branch_and_tree('.')
 
265
        inner_tree = self.make_branch_and_tree('branch')
 
266
        self.build_tree_contents([
 
267
            ('branch/foo.c', 'int main() {}'),
 
268
            ('branch/bar.c', 'int main() {}')])
 
269
        inner_tree.add('foo.c')
 
270
        inner_tree.add('bar.c')
241
271
        # can't commit files in different trees; sane error
242
 
        self.runbzr('commit -m newstuff branch/foo.c .', retcode=3)
243
 
        self.runbzr('commit -m newstuff branch/foo.c')
244
 
        self.runbzr('commit -m newstuff branch')
245
 
        self.runbzr('commit -m newstuff branch', retcode=3)
 
272
        self.run_bzr('commit -m newstuff branch/foo.c .', retcode=3)
 
273
        self.run_bzr('commit -m newstuff branch/foo.c')
 
274
        self.run_bzr('commit -m newstuff branch')
 
275
        self.run_bzr('commit -m newstuff branch', retcode=3)
246
276
 
247
277
    def test_out_of_date_tree_commit(self):
248
278
        # check we get an error code and a clear message committing with an out
249
279
        # of date checkout
250
 
        self.make_branch_and_tree('branch')
 
280
        tree = self.make_branch_and_tree('branch')
251
281
        # make a checkout
252
 
        self.runbzr('checkout --lightweight branch checkout')
 
282
        checkout = tree.branch.create_checkout('checkout', lightweight=True)
253
283
        # commit to the original branch to make the checkout out of date
254
 
        self.runbzr('commit --unchanged -m message branch')
 
284
        tree.commit('message branch', allow_pointless=True)
255
285
        # now commit to the checkout should emit
256
286
        # ERROR: Out of date with the branch, 'bzr update' is suggested
257
 
        output = self.runbzr('commit --unchanged -m checkout_message '
 
287
        output = self.run_bzr('commit --unchanged -m checkout_message '
258
288
                             'checkout', retcode=3)
259
289
        self.assertEqual(output,
260
290
                         ('',
261
 
                          "bzr: ERROR: Working tree is out of date, please run "
262
 
                          "'bzr update'.\n"))
 
291
                          "bzr: ERROR: Working tree is out of date, please "
 
292
                          "run 'bzr update'.\n"))
263
293
 
264
294
    def test_local_commit_unbound(self):
265
295
        # a --local commit on an unbound branch is an error
266
296
        self.make_branch_and_tree('.')
267
 
        out, err = self.run_bzr('commit', '--local', retcode=3)
 
297
        out, err = self.run_bzr('commit --local', retcode=3)
268
298
        self.assertEqualDiff('', out)
269
299
        self.assertEqualDiff('bzr: ERROR: Cannot perform local-only commits '
270
300
                             'on unbound branches.\n', err)
275
305
        # past. This is a user story reported to fail in bug #43959 where 
276
306
        # a merge done in a checkout (using the update command) failed to
277
307
        # commit correctly.
278
 
        self.run_bzr('init', 'trunk')
 
308
        trunk = self.make_branch_and_tree('trunk')
279
309
 
280
 
        self.run_bzr('checkout', 'trunk', 'u1')
 
310
        u1 = trunk.branch.create_checkout('u1')
281
311
        self.build_tree_contents([('u1/hosts', 'initial contents')])
282
 
        self.run_bzr('add', 'u1/hosts')
283
 
        self.run_bzr('commit', '-m', 'add hosts', 'u1')
 
312
        u1.add('hosts')
 
313
        self.run_bzr('commit -m add-hosts u1')
284
314
 
285
 
        self.run_bzr('checkout', 'trunk', 'u2')
 
315
        u2 = trunk.branch.create_checkout('u2')
286
316
        self.build_tree_contents([('u2/hosts', 'altered in u2')])
287
 
        self.run_bzr('commit', '-m', 'checkin from u2', 'u2')
 
317
        self.run_bzr('commit -m checkin-from-u2 u2')
288
318
 
289
319
        # make an offline commits
290
320
        self.build_tree_contents([('u1/hosts', 'first offline change in u1')])
291
 
        self.run_bzr('commit', '-m', 'checkin offline', '--local', 'u1')
 
321
        self.run_bzr('commit -m checkin-offline --local u1')
292
322
 
293
323
        # now try to pull in online work from u2, and then commit our offline
294
324
        # work as a merge
295
325
        # retcode 1 as we expect a text conflict
296
 
        self.run_bzr('update', 'u1', retcode=1)
297
 
        self.run_bzr('resolved', 'u1/hosts')
 
326
        self.run_bzr('update u1', retcode=1)
 
327
        self.run_bzr('resolved u1/hosts')
298
328
        # add a text change here to represent resolving the merge conflicts in
299
329
        # favour of a new version of the file not identical to either the u1
300
330
        # version or the u2 version.
301
331
        self.build_tree_contents([('u1/hosts', 'merge resolution\n')])
302
 
        self.run_bzr('commit', '-m', 'checkin merge of the offline work from u1', 'u1')
 
332
        self.run_bzr('commit -m checkin-merge-of-the-offline-work-from-u1 u1')
303
333
 
304
334
    def test_commit_respects_spec_for_removals(self):
305
335
        """Commit with a file spec should only commit removals that match"""
309
339
        t.commit('Create')
310
340
        t.remove(['file-a', 'dir-a/file-b'])
311
341
        os.chdir('dir-a')
312
 
        result = self.run_bzr('commit', '.', '-m' 'removed file-b')[1]
 
342
        result = self.run_bzr('commit . -m removed-file-b')[1]
313
343
        self.assertNotContainsRe(result, 'file-a')
314
344
        result = self.run_bzr('status')[0]
315
345
        self.assertContainsRe(result, 'removed:\n  file-a')
321
351
        self.build_tree(['tree/a'])
322
352
        tree.add('a')
323
353
        # A simple change should just work
324
 
        self.run_bzr('commit', '--strict', '-m', 'adding a',
 
354
        self.run_bzr('commit --strict -m adding-a',
325
355
                     working_dir='tree')
326
356
 
327
357
    def test_strict_commit_no_changes(self):
334
364
        # With no changes, it should just be 'no changes'
335
365
        # Make sure that commit is failing because there is nothing to do
336
366
        self.run_bzr_error(['no changes to commit'],
337
 
                           'commit', '--strict', '-m', 'no changes',
 
367
                           'commit --strict -m no-changes',
338
368
                           working_dir='tree')
339
369
 
340
370
        # But --strict doesn't care if you supply --unchanged
341
 
        self.run_bzr('commit', '--strict', '--unchanged', '-m', 'no changes',
 
371
        self.run_bzr('commit --strict --unchanged -m no-changes',
342
372
                     working_dir='tree')
343
373
 
344
374
    def test_strict_commit_unknown(self):
352
382
        self.build_tree(['tree/b', 'tree/c'])
353
383
        tree.add('b')
354
384
        self.run_bzr_error(['Commit refused because there are unknown files'],
355
 
                           'commit', '--strict', '-m', 'add b',
 
385
                           'commit --strict -m add-b',
356
386
                           working_dir='tree')
357
387
 
358
388
        # --no-strict overrides --strict
359
 
        self.run_bzr('commit', '--strict', '-m', 'add b', '--no-strict',
 
389
        self.run_bzr('commit --strict -m add-b --no-strict',
360
390
                     working_dir='tree')
361
391
 
362
392
    def test_fixes_bug_output(self):
365
395
        self.build_tree(['tree/hello.txt'])
366
396
        tree.add('hello.txt')
367
397
        output, err = self.run_bzr(
368
 
            'commit', '-m', 'hello', '--fixes=lp:23452', 'tree/hello.txt')
 
398
            'commit -m hello --fixes=lp:23452 tree/hello.txt')
369
399
        self.assertEqual('', output)
370
 
        self.assertEqual('added hello.txt\nCommitted revision 1.\n', err)
 
400
        self.assertContainsRe(err, 'Committing to: .*\n'
 
401
                              'added hello\.txt\n'
 
402
                              'Committed revision 1\.\n')
371
403
 
372
404
    def test_no_bugs_no_properties(self):
373
405
        """If no bugs are fixed, the bugs property is not set.
377
409
        tree = self.make_branch_and_tree('tree')
378
410
        self.build_tree(['tree/hello.txt'])
379
411
        tree.add('hello.txt')
380
 
        self.run_bzr( 'commit', '-m', 'hello', 'tree/hello.txt')
 
412
        self.run_bzr( 'commit -m hello tree/hello.txt')
381
413
        # Get the revision properties, ignoring the branch-nick property, which
382
414
        # we don't care about for this test.
383
415
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
390
422
        tree = self.make_branch_and_tree('tree')
391
423
        self.build_tree(['tree/hello.txt'])
392
424
        tree.add('hello.txt')
393
 
        self.run_bzr(
394
 
            'commit', '-m', 'hello', '--fixes=lp:234', 'tree/hello.txt')
 
425
        self.run_bzr('commit -m hello --fixes=lp:234 tree/hello.txt')
395
426
 
396
427
        # Get the revision properties, ignoring the branch-nick property, which
397
428
        # we don't care about for this test.
407
438
        tree = self.make_branch_and_tree('tree')
408
439
        self.build_tree(['tree/hello.txt'])
409
440
        tree.add('hello.txt')
410
 
        self.run_bzr(
411
 
            'commit', '-m', 'hello', '--fixes=lp:123', '--fixes=lp:235',
412
 
            'tree/hello.txt')
 
441
        self.run_bzr('commit -m hello --fixes=lp:123 --fixes=lp:235'
 
442
                     ' tree/hello.txt')
413
443
 
414
444
        # Get the revision properties, ignoring the branch-nick property, which
415
445
        # we don't care about for this test.
431
461
            'trac_twisted_url', 'http://twistedmatrix.com/trac')
432
462
        self.build_tree(['tree/hello.txt'])
433
463
        tree.add('hello.txt')
434
 
        self.run_bzr(
435
 
            'commit', '-m', 'hello', '--fixes=lp:123',
436
 
            '--fixes=twisted:235', 'tree/')
 
464
        self.run_bzr('commit -m hello --fixes=lp:123 --fixes=twisted:235 tree/')
437
465
 
438
466
        # Get the revision properties, ignoring the branch-nick property, which
439
467
        # we don't care about for this test.
452
480
        tree.add('hello.txt')
453
481
        self.run_bzr_error(
454
482
            ["Unrecognized bug %s. Commit refused." % 'xxx:123'],
455
 
            'commit', '-m', 'add b', '--fixes=xxx:123',
 
483
            'commit -m add-b --fixes=xxx:123',
456
484
            working_dir='tree')
457
485
 
458
486
    def test_fixes_invalid_bug_number(self):
461
489
        tree.add('hello.txt')
462
490
        self.run_bzr_error(
463
491
            ["Invalid bug identifier for %s. Commit refused." % 'lp:orange'],
464
 
            'commit', '-m', 'add b', '--fixes=lp:orange',
 
492
            'commit -m add-b --fixes=lp:orange',
465
493
            working_dir='tree')
466
494
 
467
495
    def test_fixes_invalid_argument(self):
472
500
        self.run_bzr_error(
473
501
            [r"Invalid bug orange. Must be in the form of 'tag:id'\. "
474
502
             r"Commit refused\."],
475
 
            'commit', '-m', 'add b', '--fixes=orange',
 
503
            'commit -m add-b --fixes=orange',
476
504
            working_dir='tree')
 
505
 
 
506
    def test_no_author(self):
 
507
        """If the author is not specified, the author property is not set."""
 
508
        tree = self.make_branch_and_tree('tree')
 
509
        self.build_tree(['tree/hello.txt'])
 
510
        tree.add('hello.txt')
 
511
        self.run_bzr( 'commit -m hello tree/hello.txt')
 
512
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
513
        properties = last_rev.properties
 
514
        self.assertFalse('author' in properties)
 
515
 
 
516
    def test_author_sets_property(self):
 
517
        """commit --author='John Doe <jdoe@example.com>' sets the author
 
518
           revprop.
 
519
        """
 
520
        tree = self.make_branch_and_tree('tree')
 
521
        self.build_tree(['tree/hello.txt'])
 
522
        tree.add('hello.txt')
 
523
        self.run_bzr(["commit", '-m', 'hello',
 
524
                      '--author', u'John D\xf6 <jdoe@example.com>',
 
525
                     "tree/hello.txt"])
 
526
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
527
        properties = last_rev.properties
 
528
        self.assertEqual(u'John D\xf6 <jdoe@example.com>', properties['author'])
 
529
 
 
530
    def test_author_no_email(self):
 
531
        """Author's name without an email address is allowed, too."""
 
532
        tree = self.make_branch_and_tree('tree')
 
533
        self.build_tree(['tree/hello.txt'])
 
534
        tree.add('hello.txt')
 
535
        out, err = self.run_bzr("commit -m hello --author='John Doe' "
 
536
                                "tree/hello.txt")
 
537
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
538
        properties = last_rev.properties
 
539
        self.assertEqual('John Doe', properties['author'])
 
540
 
 
541
    def test_partial_commit_with_renames_in_tree(self):
 
542
        # this test illustrates bug #140419
 
543
        t = self.make_branch_and_tree('.')
 
544
        self.build_tree(['dir/', 'dir/a', 'test'])
 
545
        t.add(['dir/', 'dir/a', 'test'])
 
546
        t.commit('initial commit')
 
547
        # important part: file dir/a should change parent
 
548
        # and should appear before old parent
 
549
        # then during partial commit we have error
 
550
        # parent_id {dir-XXX} not in inventory
 
551
        t.rename_one('dir/a', 'a')
 
552
        self.build_tree_contents([('test', 'changes in test')])
 
553
        # partial commit
 
554
        out, err = self.run_bzr('commit test -m "partial commit"')
 
555
        self.assertEquals('', out)
 
556
        self.assertContainsRe(err, r'modified test\nCommitted revision 2.')
 
557
 
 
558
    def test_commit_readonly_checkout(self):
 
559
        # https://bugs.edge.launchpad.net/bzr/+bug/129701
 
560
        # "UnlockableTransport error trying to commit in checkout of readonly
 
561
        # branch"
 
562
        self.make_branch('master')
 
563
        master = BzrDir.open_from_transport(
 
564
            self.get_readonly_transport('master')).open_branch()
 
565
        master.create_checkout('checkout')
 
566
        out, err = self.run_bzr(['commit', '--unchanged', '-mfoo', 'checkout'],
 
567
            retcode=3)
 
568
        self.assertContainsRe(err,
 
569
            r'^bzr: ERROR: Cannot lock.*readonly transport')