← 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: Ian Clatworthy
  • Date: 2009-01-19 02:24:15 UTC
  • mto: This revision was merged to the branch mainline in revision 3944.
  • Revision ID: ian.clatworthy@canonical.com-20090119022415-mo0mcfeiexfktgwt
apply jam's log --short fix (Ian Clatworthy)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_commit.py
1
 
# Copyright (C) 2005, 2006 by Canonical Ltd
2
 
 
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
 
 
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
18
"""Tests for the commit CLI of bzr."""
19
19
 
20
20
import os
21
 
import re
22
21
import sys
23
22
 
24
 
from bzrlib.branch import Branch
 
23
from bzrlib import (
 
24
    osutils,
 
25
    ignores,
 
26
    msgeditor,
 
27
    osutils,
 
28
    )
25
29
from bzrlib.bzrdir import BzrDir
26
 
from bzrlib.errors import BzrCommandError
 
30
from bzrlib.tests import (
 
31
    probe_bad_non_ascii,
 
32
    TestSkipped,
 
33
    )
27
34
from bzrlib.tests.blackbox import ExternalBase
28
 
from bzrlib.workingtree import WorkingTree
29
35
 
30
36
 
31
37
class TestCommit(ExternalBase):
33
39
    def test_05_empty_commit(self):
34
40
        """Commit of tree with no versioned files should fail"""
35
41
        # If forced, it should succeed, but this is not tested here.
36
 
        self.runbzr("init")
 
42
        self.make_branch_and_tree('.')
37
43
        self.build_tree(['hello.txt'])
38
 
        self.runbzr("commit -m empty", retcode=3)
 
44
        out,err = self.run_bzr('commit -m empty', retcode=3)
 
45
        self.assertEqual('', out)
 
46
        self.assertContainsRe(err, 'bzr: ERROR: no changes to commit\.'
 
47
                                  ' use --unchanged to commit anyhow\n')
 
48
 
 
49
    def test_commit_success(self):
 
50
        """Successful commit should not leave behind a bzr-commit-* file"""
 
51
        self.make_branch_and_tree('.')
 
52
        self.run_bzr('commit --unchanged -m message')
 
53
        self.assertEqual('', self.run_bzr('unknowns')[0])
 
54
 
 
55
        # same for unicode messages
 
56
        self.run_bzr(["commit", "--unchanged", "-m", u'foo\xb5'])
 
57
        self.assertEqual('', self.run_bzr('unknowns')[0])
39
58
 
40
59
    def test_commit_with_path(self):
41
60
        """Commit tree with path of root specified"""
42
 
        self.run_bzr('init', 'a')
 
61
        a_tree = self.make_branch_and_tree('a')
43
62
        self.build_tree(['a/a_file'])
44
 
        self.run_bzr('add', 'a/a_file')
45
 
        self.run_bzr('commit', '-m', 'first commit', 'a')
 
63
        a_tree.add('a_file')
 
64
        self.run_bzr(['commit', '-m', 'first commit', 'a'])
46
65
 
47
 
        self.run_bzr('branch', 'a', 'b')
 
66
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
48
67
        self.build_tree_contents([('b/a_file', 'changes in b')])
49
 
        self.run_bzr('commit', '-m', 'first commit in b', 'b')
 
68
        self.run_bzr(['commit', '-m', 'first commit in b', 'b'])
50
69
 
51
70
        self.build_tree_contents([('a/a_file', 'new contents')])
52
 
        self.run_bzr('commit', '-m', 'change in a', 'a')
 
71
        self.run_bzr(['commit', '-m', 'change in a', 'a'])
53
72
 
54
 
        os.chdir('b')
55
 
        self.run_bzr('merge', '../a', retcode=1) # will conflict
56
 
        os.chdir('..')
57
 
        self.run_bzr('resolved', 'b/a_file')
58
 
        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'])
59
77
 
60
78
 
61
79
    def test_10_verbose_commit(self):
62
80
        """Add one file and examine verbose commit output"""
63
 
        self.runbzr("init")
 
81
        tree = self.make_branch_and_tree('.')
64
82
        self.build_tree(['hello.txt'])
65
 
        self.runbzr("add hello.txt")
66
 
        out,err = self.run_bzr("commit", "-m", "added")
 
83
        tree.add("hello.txt")
 
84
        out,err = self.run_bzr('commit -m added')
67
85
        self.assertEqual('', out)
68
 
        self.assertEqual('added hello.txt\n'
69
 
                         'Committed revision 1.\n',
70
 
                         err)
 
86
        self.assertContainsRe(err, '^Committing to: .*\n'
 
87
                              'added hello.txt\n'
 
88
                              'Committed revision 1.\n$',)
71
89
 
72
90
    def prepare_simple_history(self):
73
91
        """Prepare and return a working tree with one commit of one file"""
82
100
        # Verbose commit of modified file should say so
83
101
        wt = self.prepare_simple_history()
84
102
        self.build_tree_contents([('hello.txt', 'new contents')])
85
 
        out, err = self.run_bzr("commit", "-m", "modified")
 
103
        out, err = self.run_bzr('commit -m modified')
86
104
        self.assertEqual('', out)
87
 
        self.assertEqual('modified hello.txt\n'
88
 
                         'Committed revision 2.\n',
89
 
                         err)
 
105
        self.assertContainsRe(err, '^Committing to: .*\n'
 
106
                              'modified hello\.txt\n'
 
107
                              'Committed revision 2\.\n$')
90
108
 
91
109
    def test_verbose_commit_renamed(self):
92
110
        # Verbose commit of renamed file should say so
93
111
        wt = self.prepare_simple_history()
94
112
        wt.rename_one('hello.txt', 'gutentag.txt')
95
 
        out, err = self.run_bzr("commit", "-m", "renamed")
 
113
        out, err = self.run_bzr('commit -m renamed')
96
114
        self.assertEqual('', out)
97
 
        self.assertEqual('renamed hello.txt => gutentag.txt\n'
98
 
                         'Committed revision 2.\n',
99
 
                         err)
 
115
        self.assertContainsRe(err, '^Committing to: .*\n'
 
116
                              'renamed hello\.txt => gutentag\.txt\n'
 
117
                              'Committed revision 2\.$\n')
100
118
 
101
119
    def test_verbose_commit_moved(self):
102
120
        # Verbose commit of file moved to new directory should say so
104
122
        os.mkdir('subdir')
105
123
        wt.add(['subdir'])
106
124
        wt.rename_one('hello.txt', 'subdir/hello.txt')
107
 
        out, err = self.run_bzr("commit", "-m", "renamed")
 
125
        out, err = self.run_bzr('commit -m renamed')
108
126
        self.assertEqual('', out)
109
 
        self.assertEqualDiff('added subdir\n'
110
 
                             'renamed hello.txt => subdir/hello.txt\n'
111
 
                             'Committed revision 2.\n',
112
 
                             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$')
113
131
 
114
132
    def test_verbose_commit_with_unknown(self):
115
133
        """Unknown files should not be listed by default in verbose output"""
117
135
        wt = BzrDir.create_standalone_workingtree('.')
118
136
        self.build_tree(['hello.txt', 'extra.txt'])
119
137
        wt.add(['hello.txt'])
120
 
        out,err = self.run_bzr("commit", "-m", "added")
 
138
        out,err = self.run_bzr('commit -m added')
121
139
        self.assertEqual('', out)
122
 
        self.assertEqual('added hello.txt\n'
123
 
                         'Committed revision 1.\n',
124
 
                         err)
 
140
        self.assertContainsRe(err, '^Committing to: .*\n'
 
141
                              'added hello\.txt\n'
 
142
                              'Committed revision 1\.\n$')
125
143
 
126
144
    def test_verbose_commit_with_unchanged(self):
127
145
        """Unchanged files should not be listed by default in verbose output"""
128
 
        self.runbzr("init")
 
146
        tree = self.make_branch_and_tree('.')
129
147
        self.build_tree(['hello.txt', 'unchanged.txt'])
130
 
        self.runbzr('add unchanged.txt')
131
 
        self.runbzr('commit -m unchanged unchanged.txt')
132
 
        self.runbzr("add hello.txt")
133
 
        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')
134
152
        self.assertEqual('', out)
135
 
        self.assertEqual('added hello.txt\n'
136
 
                         'Committed revision 2.\n',
137
 
                         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)
138
169
 
139
170
    def test_commit_merge_reports_all_modified_files(self):
140
171
        # the commit command should show all the files that are shown by
173
204
            other_tree.rename_one('dirtorename', 'renameddir')
174
205
            other_tree.rename_one('dirtoreparent', 'renameddir/reparenteddir')
175
206
            other_tree.rename_one('filetorename', 'renamedfile')
176
 
            other_tree.rename_one('filetoreparent', 'renameddir/reparentedfile')
 
207
            other_tree.rename_one('filetoreparent',
 
208
                                  'renameddir/reparentedfile')
177
209
            other_tree.remove(['dirtoremove', 'filetoremove'])
178
210
            self.build_tree_contents([
179
 
                ('other/newdir/', ),
 
211
                ('other/newdir/',),
180
212
                ('other/filetomodify', 'new content'),
181
213
                ('other/newfile', 'new file content')])
182
214
            other_tree.add('newfile')
184
216
            other_tree.commit('modify all sample files and dirs.')
185
217
        finally:
186
218
            other_tree.unlock()
187
 
        self.merge(other_tree.branch, this_tree)
 
219
        this_tree.merge_from_branch(other_tree.branch)
188
220
        os.chdir('this')
189
 
        out,err = self.run_bzr("commit", "-m", "added")
190
 
        os.chdir('..')
 
221
        out,err = self.run_bzr('commit -m added')
191
222
        self.assertEqual('', out)
 
223
        expected = '%s/' % (osutils.getcwd(), )
192
224
        self.assertEqualDiff(
 
225
            'Committing to: %s\n'
193
226
            'modified filetomodify\n'
194
227
            'added newdir\n'
195
228
            'added newfile\n'
196
229
            'renamed dirtorename => renameddir\n'
 
230
            'renamed filetorename => renamedfile\n'
197
231
            'renamed dirtoreparent => renameddir/reparenteddir\n'
198
232
            'renamed filetoreparent => renameddir/reparentedfile\n'
199
 
            'renamed filetorename => renamedfile\n'
200
233
            'deleted dirtoremove\n'
201
234
            'deleted filetoremove\n'
202
 
            'Committed revision 2.\n',
 
235
            'Committed revision 2.\n' % (expected, ),
203
236
            err)
204
237
 
205
238
    def test_empty_commit_message(self):
206
 
        self.runbzr("init")
207
 
        file('foo.c', 'wt').write('int main() {}')
208
 
        self.runbzr(['add', 'foo.c'])
209
 
        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(osutils.get_user_encoding())
 
252
        if char is None:
 
253
            raise TestSkipped('Cannot find suitable non-ascii character'
 
254
                'for user_encoding (%s)' % osutils.get_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.')
210
260
 
211
261
    def test_other_branch_commit(self):
212
262
        # this branch is to ensure consistent behaviour, whether we're run
213
263
        # inside a branch, or not.
214
 
        os.mkdir('empty_branch')
215
 
        os.chdir('empty_branch')
216
 
        self.runbzr('init')
217
 
        os.mkdir('branch')
218
 
        os.chdir('branch')
219
 
        self.runbzr('init')
220
 
        file('foo.c', 'wt').write('int main() {}')
221
 
        file('bar.c', 'wt').write('int main() {}')
222
 
        os.chdir('..')
223
 
        self.runbzr(['add', 'branch/foo.c'])
224
 
        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')
225
271
        # can't commit files in different trees; sane error
226
 
        self.runbzr('commit -m newstuff branch/foo.c .', retcode=3)
227
 
        self.runbzr('commit -m newstuff branch/foo.c')
228
 
        self.runbzr('commit -m newstuff branch')
229
 
        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)
230
276
 
231
277
    def test_out_of_date_tree_commit(self):
232
278
        # check we get an error code and a clear message committing with an out
233
279
        # of date checkout
234
 
        self.make_branch_and_tree('branch')
 
280
        tree = self.make_branch_and_tree('branch')
235
281
        # make a checkout
236
 
        self.runbzr('checkout --lightweight branch checkout')
 
282
        checkout = tree.branch.create_checkout('checkout', lightweight=True)
237
283
        # commit to the original branch to make the checkout out of date
238
 
        self.runbzr('commit --unchanged -m message branch')
 
284
        tree.commit('message branch', allow_pointless=True)
239
285
        # now commit to the checkout should emit
240
286
        # ERROR: Out of date with the branch, 'bzr update' is suggested
241
 
        output = self.runbzr('commit --unchanged -m checkout_message '
 
287
        output = self.run_bzr('commit --unchanged -m checkout_message '
242
288
                             'checkout', retcode=3)
243
289
        self.assertEqual(output,
244
290
                         ('',
245
 
                          "bzr: ERROR: Working tree is out of date, please run "
246
 
                          "'bzr update'.\n"))
 
291
                          "bzr: ERROR: Working tree is out of date, please "
 
292
                          "run 'bzr update'.\n"))
247
293
 
248
294
    def test_local_commit_unbound(self):
249
295
        # a --local commit on an unbound branch is an error
250
296
        self.make_branch_and_tree('.')
251
 
        out, err = self.run_bzr('commit', '--local', retcode=3)
 
297
        out, err = self.run_bzr('commit --local', retcode=3)
252
298
        self.assertEqualDiff('', out)
253
299
        self.assertEqualDiff('bzr: ERROR: Cannot perform local-only commits '
254
300
                             'on unbound branches.\n', err)
259
305
        # past. This is a user story reported to fail in bug #43959 where 
260
306
        # a merge done in a checkout (using the update command) failed to
261
307
        # commit correctly.
262
 
        self.run_bzr('init', 'trunk')
 
308
        trunk = self.make_branch_and_tree('trunk')
263
309
 
264
 
        self.run_bzr('checkout', 'trunk', 'u1')
 
310
        u1 = trunk.branch.create_checkout('u1')
265
311
        self.build_tree_contents([('u1/hosts', 'initial contents')])
266
 
        self.run_bzr('add', 'u1/hosts')
267
 
        self.run_bzr('commit', '-m', 'add hosts', 'u1')
 
312
        u1.add('hosts')
 
313
        self.run_bzr('commit -m add-hosts u1')
268
314
 
269
 
        self.run_bzr('checkout', 'trunk', 'u2')
 
315
        u2 = trunk.branch.create_checkout('u2')
270
316
        self.build_tree_contents([('u2/hosts', 'altered in u2')])
271
 
        self.run_bzr('commit', '-m', 'checkin from u2', 'u2')
 
317
        self.run_bzr('commit -m checkin-from-u2 u2')
272
318
 
273
319
        # make an offline commits
274
320
        self.build_tree_contents([('u1/hosts', 'first offline change in u1')])
275
 
        self.run_bzr('commit', '-m', 'checkin offline', '--local', 'u1')
 
321
        self.run_bzr('commit -m checkin-offline --local u1')
276
322
 
277
323
        # now try to pull in online work from u2, and then commit our offline
278
324
        # work as a merge
279
325
        # retcode 1 as we expect a text conflict
280
 
        self.run_bzr('update', 'u1', retcode=1)
281
 
        self.run_bzr('resolved', 'u1/hosts')
 
326
        self.run_bzr('update u1', retcode=1)
 
327
        self.run_bzr('resolved u1/hosts')
282
328
        # add a text change here to represent resolving the merge conflicts in
283
329
        # favour of a new version of the file not identical to either the u1
284
330
        # version or the u2 version.
285
331
        self.build_tree_contents([('u1/hosts', 'merge resolution\n')])
286
 
        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')
 
333
 
 
334
    def test_commit_exclude_excludes_modified_files(self):
 
335
        """Commit -x foo should ignore changes to foo."""
 
336
        tree = self.make_branch_and_tree('.')
 
337
        self.build_tree(['a', 'b', 'c'])
 
338
        tree.smart_add(['.'])
 
339
        out, err = self.run_bzr(['commit', '-m', 'test', '-x', 'b'])
 
340
        self.assertFalse('added b' in out)
 
341
        self.assertFalse('added b' in err)
 
342
        # If b was excluded it will still be 'added' in status.
 
343
        out, err = self.run_bzr(['added'])
 
344
        self.assertEqual('b\n', out)
 
345
        self.assertEqual('', err)
 
346
 
 
347
    def test_commit_exclude_twice_uses_both_rules(self):
 
348
        """Commit -x foo -x bar should ignore changes to foo and bar."""
 
349
        tree = self.make_branch_and_tree('.')
 
350
        self.build_tree(['a', 'b', 'c'])
 
351
        tree.smart_add(['.'])
 
352
        out, err = self.run_bzr(['commit', '-m', 'test', '-x', 'b', '-x', 'c'])
 
353
        self.assertFalse('added b' in out)
 
354
        self.assertFalse('added c' in out)
 
355
        self.assertFalse('added b' in err)
 
356
        self.assertFalse('added c' in err)
 
357
        # If b was excluded it will still be 'added' in status.
 
358
        out, err = self.run_bzr(['added'])
 
359
        self.assertTrue('b\n' in out)
 
360
        self.assertTrue('c\n' in out)
 
361
        self.assertEqual('', err)
 
362
 
 
363
    def test_commit_respects_spec_for_removals(self):
 
364
        """Commit with a file spec should only commit removals that match"""
 
365
        t = self.make_branch_and_tree('.')
 
366
        self.build_tree(['file-a', 'dir-a/', 'dir-a/file-b'])
 
367
        t.add(['file-a', 'dir-a', 'dir-a/file-b'])
 
368
        t.commit('Create')
 
369
        t.remove(['file-a', 'dir-a/file-b'])
 
370
        os.chdir('dir-a')
 
371
        result = self.run_bzr('commit . -m removed-file-b')[1]
 
372
        self.assertNotContainsRe(result, 'file-a')
 
373
        result = self.run_bzr('status')[0]
 
374
        self.assertContainsRe(result, 'removed:\n  file-a')
 
375
 
 
376
    def test_strict_commit(self):
 
377
        """Commit with --strict works if everything is known"""
 
378
        ignores._set_user_ignores([])
 
379
        tree = self.make_branch_and_tree('tree')
 
380
        self.build_tree(['tree/a'])
 
381
        tree.add('a')
 
382
        # A simple change should just work
 
383
        self.run_bzr('commit --strict -m adding-a',
 
384
                     working_dir='tree')
 
385
 
 
386
    def test_strict_commit_no_changes(self):
 
387
        """commit --strict gives "no changes" if there is nothing to commit"""
 
388
        tree = self.make_branch_and_tree('tree')
 
389
        self.build_tree(['tree/a'])
 
390
        tree.add('a')
 
391
        tree.commit('adding a')
 
392
 
 
393
        # With no changes, it should just be 'no changes'
 
394
        # Make sure that commit is failing because there is nothing to do
 
395
        self.run_bzr_error(['no changes to commit'],
 
396
                           'commit --strict -m no-changes',
 
397
                           working_dir='tree')
 
398
 
 
399
        # But --strict doesn't care if you supply --unchanged
 
400
        self.run_bzr('commit --strict --unchanged -m no-changes',
 
401
                     working_dir='tree')
 
402
 
 
403
    def test_strict_commit_unknown(self):
 
404
        """commit --strict fails if a file is unknown"""
 
405
        tree = self.make_branch_and_tree('tree')
 
406
        self.build_tree(['tree/a'])
 
407
        tree.add('a')
 
408
        tree.commit('adding a')
 
409
 
 
410
        # Add one file so there is a change, but forget the other
 
411
        self.build_tree(['tree/b', 'tree/c'])
 
412
        tree.add('b')
 
413
        self.run_bzr_error(['Commit refused because there are unknown files'],
 
414
                           'commit --strict -m add-b',
 
415
                           working_dir='tree')
 
416
 
 
417
        # --no-strict overrides --strict
 
418
        self.run_bzr('commit --strict -m add-b --no-strict',
 
419
                     working_dir='tree')
 
420
 
 
421
    def test_fixes_bug_output(self):
 
422
        """commit --fixes=lp:23452 succeeds without output."""
 
423
        tree = self.make_branch_and_tree('tree')
 
424
        self.build_tree(['tree/hello.txt'])
 
425
        tree.add('hello.txt')
 
426
        output, err = self.run_bzr(
 
427
            'commit -m hello --fixes=lp:23452 tree/hello.txt')
 
428
        self.assertEqual('', output)
 
429
        self.assertContainsRe(err, 'Committing to: .*\n'
 
430
                              'added hello\.txt\n'
 
431
                              'Committed revision 1\.\n')
 
432
 
 
433
    def test_no_bugs_no_properties(self):
 
434
        """If no bugs are fixed, the bugs property is not set.
 
435
 
 
436
        see https://beta.launchpad.net/bzr/+bug/109613
 
437
        """
 
438
        tree = self.make_branch_and_tree('tree')
 
439
        self.build_tree(['tree/hello.txt'])
 
440
        tree.add('hello.txt')
 
441
        self.run_bzr( 'commit -m hello tree/hello.txt')
 
442
        # Get the revision properties, ignoring the branch-nick property, which
 
443
        # we don't care about for this test.
 
444
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
445
        properties = dict(last_rev.properties)
 
446
        del properties['branch-nick']
 
447
        self.assertFalse('bugs' in properties)
 
448
 
 
449
    def test_fixes_bug_sets_property(self):
 
450
        """commit --fixes=lp:234 sets the lp:234 revprop to 'fixed'."""
 
451
        tree = self.make_branch_and_tree('tree')
 
452
        self.build_tree(['tree/hello.txt'])
 
453
        tree.add('hello.txt')
 
454
        self.run_bzr('commit -m hello --fixes=lp:234 tree/hello.txt')
 
455
 
 
456
        # Get the revision properties, ignoring the branch-nick property, which
 
457
        # we don't care about for this test.
 
458
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
459
        properties = dict(last_rev.properties)
 
460
        del properties['branch-nick']
 
461
 
 
462
        self.assertEqual({'bugs': 'https://launchpad.net/bugs/234 fixed'},
 
463
                         properties)
 
464
 
 
465
    def test_fixes_multiple_bugs_sets_properties(self):
 
466
        """--fixes can be used more than once to show that bugs are fixed."""
 
467
        tree = self.make_branch_and_tree('tree')
 
468
        self.build_tree(['tree/hello.txt'])
 
469
        tree.add('hello.txt')
 
470
        self.run_bzr('commit -m hello --fixes=lp:123 --fixes=lp:235'
 
471
                     ' tree/hello.txt')
 
472
 
 
473
        # Get the revision properties, ignoring the branch-nick property, which
 
474
        # we don't care about for this test.
 
475
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
476
        properties = dict(last_rev.properties)
 
477
        del properties['branch-nick']
 
478
 
 
479
        self.assertEqual(
 
480
            {'bugs': 'https://launchpad.net/bugs/123 fixed\n'
 
481
                     'https://launchpad.net/bugs/235 fixed'},
 
482
            properties)
 
483
 
 
484
    def test_fixes_bug_with_alternate_trackers(self):
 
485
        """--fixes can be used on a properly configured branch to mark bug
 
486
        fixes on multiple trackers.
 
487
        """
 
488
        tree = self.make_branch_and_tree('tree')
 
489
        tree.branch.get_config().set_user_option(
 
490
            'trac_twisted_url', 'http://twistedmatrix.com/trac')
 
491
        self.build_tree(['tree/hello.txt'])
 
492
        tree.add('hello.txt')
 
493
        self.run_bzr('commit -m hello --fixes=lp:123 --fixes=twisted:235 tree/')
 
494
 
 
495
        # Get the revision properties, ignoring the branch-nick property, which
 
496
        # we don't care about for this test.
 
497
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
498
        properties = dict(last_rev.properties)
 
499
        del properties['branch-nick']
 
500
 
 
501
        self.assertEqual(
 
502
            {'bugs': 'https://launchpad.net/bugs/123 fixed\n'
 
503
                     'http://twistedmatrix.com/trac/ticket/235 fixed'},
 
504
            properties)
 
505
 
 
506
    def test_fixes_unknown_bug_prefix(self):
 
507
        tree = self.make_branch_and_tree('tree')
 
508
        self.build_tree(['tree/hello.txt'])
 
509
        tree.add('hello.txt')
 
510
        self.run_bzr_error(
 
511
            ["Unrecognized bug %s. Commit refused." % 'xxx:123'],
 
512
            'commit -m add-b --fixes=xxx:123',
 
513
            working_dir='tree')
 
514
 
 
515
    def test_fixes_invalid_bug_number(self):
 
516
        tree = self.make_branch_and_tree('tree')
 
517
        self.build_tree(['tree/hello.txt'])
 
518
        tree.add('hello.txt')
 
519
        self.run_bzr_error(
 
520
            ["Invalid bug identifier for %s. Commit refused." % 'lp:orange'],
 
521
            'commit -m add-b --fixes=lp:orange',
 
522
            working_dir='tree')
 
523
 
 
524
    def test_fixes_invalid_argument(self):
 
525
        """Raise an appropriate error when the fixes argument isn't tag:id."""
 
526
        tree = self.make_branch_and_tree('tree')
 
527
        self.build_tree(['tree/hello.txt'])
 
528
        tree.add('hello.txt')
 
529
        self.run_bzr_error(
 
530
            [r"Invalid bug orange. Must be in the form of 'tag:id'\. "
 
531
             r"Commit refused\."],
 
532
            'commit -m add-b --fixes=orange',
 
533
            working_dir='tree')
 
534
 
 
535
    def test_no_author(self):
 
536
        """If the author is not specified, the author property is not set."""
 
537
        tree = self.make_branch_and_tree('tree')
 
538
        self.build_tree(['tree/hello.txt'])
 
539
        tree.add('hello.txt')
 
540
        self.run_bzr( 'commit -m hello tree/hello.txt')
 
541
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
542
        properties = last_rev.properties
 
543
        self.assertFalse('author' in properties)
 
544
 
 
545
    def test_author_sets_property(self):
 
546
        """commit --author='John Doe <jdoe@example.com>' sets the author
 
547
           revprop.
 
548
        """
 
549
        tree = self.make_branch_and_tree('tree')
 
550
        self.build_tree(['tree/hello.txt'])
 
551
        tree.add('hello.txt')
 
552
        self.run_bzr(["commit", '-m', 'hello',
 
553
                      '--author', u'John D\xf6 <jdoe@example.com>',
 
554
                     "tree/hello.txt"])
 
555
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
556
        properties = last_rev.properties
 
557
        self.assertEqual(u'John D\xf6 <jdoe@example.com>', properties['author'])
 
558
 
 
559
    def test_author_no_email(self):
 
560
        """Author's name without an email address is allowed, too."""
 
561
        tree = self.make_branch_and_tree('tree')
 
562
        self.build_tree(['tree/hello.txt'])
 
563
        tree.add('hello.txt')
 
564
        out, err = self.run_bzr("commit -m hello --author='John Doe' "
 
565
                                "tree/hello.txt")
 
566
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
567
        properties = last_rev.properties
 
568
        self.assertEqual('John Doe', properties['author'])
 
569
 
 
570
    def test_partial_commit_with_renames_in_tree(self):
 
571
        # this test illustrates bug #140419
 
572
        t = self.make_branch_and_tree('.')
 
573
        self.build_tree(['dir/', 'dir/a', 'test'])
 
574
        t.add(['dir/', 'dir/a', 'test'])
 
575
        t.commit('initial commit')
 
576
        # important part: file dir/a should change parent
 
577
        # and should appear before old parent
 
578
        # then during partial commit we have error
 
579
        # parent_id {dir-XXX} not in inventory
 
580
        t.rename_one('dir/a', 'a')
 
581
        self.build_tree_contents([('test', 'changes in test')])
 
582
        # partial commit
 
583
        out, err = self.run_bzr('commit test -m "partial commit"')
 
584
        self.assertEquals('', out)
 
585
        self.assertContainsRe(err, r'modified test\nCommitted revision 2.')
 
586
 
 
587
    def test_commit_readonly_checkout(self):
 
588
        # https://bugs.edge.launchpad.net/bzr/+bug/129701
 
589
        # "UnlockableTransport error trying to commit in checkout of readonly
 
590
        # branch"
 
591
        self.make_branch('master')
 
592
        master = BzrDir.open_from_transport(
 
593
            self.get_readonly_transport('master')).open_branch()
 
594
        master.create_checkout('checkout')
 
595
        out, err = self.run_bzr(['commit', '--unchanged', '-mfoo', 'checkout'],
 
596
            retcode=3)
 
597
        self.assertContainsRe(err,
 
598
            r'^bzr: ERROR: Cannot lock.*readonly transport')
 
599
 
 
600
    def test_commit_hook_template(self):
 
601
        # Test that commit template hooks work
 
602
        def restoreDefaults():
 
603
            msgeditor.hooks['commit_message_template'] = []
 
604
            osutils.set_or_unset_env('BZR_EDITOR', default_editor)
 
605
        if sys.platform == "win32":
 
606
            f = file('fed.bat', 'w')
 
607
            f.write('@rem dummy fed')
 
608
            f.close()
 
609
            default_editor = osutils.set_or_unset_env('BZR_EDITOR', "fed.bat")
 
610
        else:
 
611
            f = file('fed.sh', 'wb')
 
612
            f.write('#!/bin/sh\n')
 
613
            f.close()
 
614
            os.chmod('fed.sh', 0755)
 
615
            default_editor = osutils.set_or_unset_env('BZR_EDITOR', "./fed.sh")
 
616
        self.addCleanup(restoreDefaults)
 
617
        msgeditor.hooks.install_named_hook("commit_message_template",
 
618
                lambda commit_obj, msg: "save me some typing\n", None)
 
619
        tree = self.make_branch_and_tree('tree')
 
620
        self.build_tree(['tree/hello.txt'])
 
621
        tree.add('hello.txt')
 
622
        out, err = self.run_bzr("commit tree/hello.txt")
 
623
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
624
        self.assertEqual('save me some typing\n', last_rev.message)