/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_commit.py

  • Committer: Matthew Fuller
  • Date: 2009-07-25 15:21:25 UTC
  • mto: (4772.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 4773.
  • Revision ID: fullermd@over-yonder.net-20090725152125-2mzil0setr85g0no
Adjust documentation in the user guide a bit to correspond to DWIM
revspecs.

This is untested, as I don't have the tools to build the docs.  It's
also really not as clean as it could be, and there are probably much
better ways to put this info in here.  But it's something.

Show diffs side-by-side

added added

removed removed

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