~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-05-29 15:57:16 UTC
  • mfrom: (3427.5.9 dep_warnings)
  • Revision ID: pqm@pqm.ubuntu.com-20080529155716-0w3kic8lioa63231
(jam) Enable Deprecation Warnings when running -Werror and when
        running selftest

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
import bzrlib
 
24
from bzrlib import (
 
25
    osutils,
 
26
    ignores,
 
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])
 
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
 
39
78
 
40
79
    def test_10_verbose_commit(self):
41
80
        """Add one file and examine verbose commit output"""
42
 
        self.runbzr("init")
 
81
        tree = self.make_branch_and_tree('.')
43
82
        self.build_tree(['hello.txt'])
44
 
        self.runbzr("add hello.txt")
45
 
        out,err = self.run_bzr("commit", "-m", "added")
 
83
        tree.add("hello.txt")
 
84
        out,err = self.run_bzr('commit -m added')
46
85
        self.assertEqual('', out)
47
 
        self.assertEqual('added hello.txt\n'
48
 
                         'Committed revision 1.\n',
49
 
                         err)
 
86
        self.assertContainsRe(err, '^Committing to: .*\n'
 
87
                              'added hello.txt\n'
 
88
                              'Committed revision 1.\n$',)
50
89
 
51
90
    def prepare_simple_history(self):
52
91
        """Prepare and return a working tree with one commit of one file"""
61
100
        # Verbose commit of modified file should say so
62
101
        wt = self.prepare_simple_history()
63
102
        self.build_tree_contents([('hello.txt', 'new contents')])
64
 
        out, err = self.run_bzr("commit", "-m", "modified")
 
103
        out, err = self.run_bzr('commit -m modified')
65
104
        self.assertEqual('', out)
66
 
        self.assertEqual('modified hello.txt\n'
67
 
                         'Committed revision 2.\n',
68
 
                         err)
 
105
        self.assertContainsRe(err, '^Committing to: .*\n'
 
106
                              'modified hello\.txt\n'
 
107
                              'Committed revision 2\.\n$')
69
108
 
70
109
    def test_verbose_commit_renamed(self):
71
110
        # Verbose commit of renamed file should say so
72
111
        wt = self.prepare_simple_history()
73
112
        wt.rename_one('hello.txt', 'gutentag.txt')
74
 
        out, err = self.run_bzr("commit", "-m", "renamed")
 
113
        out, err = self.run_bzr('commit -m renamed')
75
114
        self.assertEqual('', out)
76
 
        self.assertEqual('renamed gutentag.txt\n'
77
 
                         'Committed revision 2.\n',
78
 
                         err)
 
115
        self.assertContainsRe(err, '^Committing to: .*\n'
 
116
                              'renamed hello\.txt => gutentag\.txt\n'
 
117
                              'Committed revision 2\.$\n')
79
118
 
80
119
    def test_verbose_commit_moved(self):
81
120
        # Verbose commit of file moved to new directory should say so
83
122
        os.mkdir('subdir')
84
123
        wt.add(['subdir'])
85
124
        wt.rename_one('hello.txt', 'subdir/hello.txt')
86
 
        out, err = self.run_bzr("commit", "-m", "renamed")
 
125
        out, err = self.run_bzr('commit -m renamed')
87
126
        self.assertEqual('', out)
88
 
        self.assertEqualDiff('added subdir\n'
89
 
                             'renamed subdir/hello.txt\n'
90
 
                             'Committed revision 2.\n',
91
 
                             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$')
92
131
 
93
132
    def test_verbose_commit_with_unknown(self):
94
133
        """Unknown files should not be listed by default in verbose output"""
96
135
        wt = BzrDir.create_standalone_workingtree('.')
97
136
        self.build_tree(['hello.txt', 'extra.txt'])
98
137
        wt.add(['hello.txt'])
99
 
        out,err = self.run_bzr("commit", "-m", "added")
 
138
        out,err = self.run_bzr('commit -m added')
100
139
        self.assertEqual('', out)
101
 
        self.assertEqual('added hello.txt\n'
102
 
                         'Committed revision 1.\n',
103
 
                         err)
 
140
        self.assertContainsRe(err, '^Committing to: .*\n'
 
141
                              'added hello\.txt\n'
 
142
                              'Committed revision 1\.\n$')
104
143
 
105
 
    def test_16_verbose_commit_with_unchanged(self):
 
144
    def test_verbose_commit_with_unchanged(self):
106
145
        """Unchanged files should not be listed by default in verbose output"""
107
 
        self.runbzr("init")
 
146
        tree = self.make_branch_and_tree('.')
108
147
        self.build_tree(['hello.txt', 'unchanged.txt'])
109
 
        self.runbzr('add unchanged.txt')
110
 
        self.runbzr('commit -m unchanged unchanged.txt')
111
 
        self.runbzr("add hello.txt")
112
 
        out,err = self.run_bzr("commit", "-m", "added")
113
 
        self.assertEqual('', out)
114
 
        self.assertEqual('added hello.txt\n'
115
 
                         'Committed revision 2.\n',
116
 
                         err)
 
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')
 
152
        self.assertEqual('', out)
 
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)
 
169
 
 
170
    def test_commit_merge_reports_all_modified_files(self):
 
171
        # the commit command should show all the files that are shown by
 
172
        # bzr diff or bzr status when committing, even when they were not
 
173
        # changed by the user but rather through doing a merge.
 
174
        this_tree = self.make_branch_and_tree('this')
 
175
        # we need a bunch of files and dirs, to perform one action on each.
 
176
        self.build_tree([
 
177
            'this/dirtorename/',
 
178
            'this/dirtoreparent/',
 
179
            'this/dirtoleave/',
 
180
            'this/dirtoremove/',
 
181
            'this/filetoreparent',
 
182
            'this/filetorename',
 
183
            'this/filetomodify',
 
184
            'this/filetoremove',
 
185
            'this/filetoleave']
 
186
            )
 
187
        this_tree.add([
 
188
            'dirtorename',
 
189
            'dirtoreparent',
 
190
            'dirtoleave',
 
191
            'dirtoremove',
 
192
            'filetoreparent',
 
193
            'filetorename',
 
194
            'filetomodify',
 
195
            'filetoremove',
 
196
            'filetoleave']
 
197
            )
 
198
        this_tree.commit('create_files')
 
199
        other_dir = this_tree.bzrdir.sprout('other')
 
200
        other_tree = other_dir.open_workingtree()
 
201
        other_tree.lock_write()
 
202
        # perform the needed actions on the files and dirs.
 
203
        try:
 
204
            other_tree.rename_one('dirtorename', 'renameddir')
 
205
            other_tree.rename_one('dirtoreparent', 'renameddir/reparenteddir')
 
206
            other_tree.rename_one('filetorename', 'renamedfile')
 
207
            other_tree.rename_one('filetoreparent',
 
208
                                  'renameddir/reparentedfile')
 
209
            other_tree.remove(['dirtoremove', 'filetoremove'])
 
210
            self.build_tree_contents([
 
211
                ('other/newdir/',),
 
212
                ('other/filetomodify', 'new content'),
 
213
                ('other/newfile', 'new file content')])
 
214
            other_tree.add('newfile')
 
215
            other_tree.add('newdir/')
 
216
            other_tree.commit('modify all sample files and dirs.')
 
217
        finally:
 
218
            other_tree.unlock()
 
219
        this_tree.merge_from_branch(other_tree.branch)
 
220
        os.chdir('this')
 
221
        out,err = self.run_bzr('commit -m added')
 
222
        self.assertEqual('', out)
 
223
        expected = '%s/' % (osutils.getcwd(), )
 
224
        self.assertEqualDiff(
 
225
            'Committing to: %s\n'
 
226
            'modified filetomodify\n'
 
227
            'added newdir\n'
 
228
            'added newfile\n'
 
229
            'renamed dirtorename => renameddir\n'
 
230
            'renamed filetorename => renamedfile\n'
 
231
            'renamed dirtoreparent => renameddir/reparenteddir\n'
 
232
            'renamed filetoreparent => renameddir/reparentedfile\n'
 
233
            'deleted dirtoremove\n'
 
234
            'deleted filetoremove\n'
 
235
            'Committed revision 2.\n' % (expected, ),
 
236
            err)
117
237
 
118
238
    def test_empty_commit_message(self):
119
 
        self.runbzr("init")
120
 
        file('foo.c', 'wt').write('int main() {}')
121
 
        self.runbzr(['add', 'foo.c'])
122
 
        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.')
123
260
 
124
261
    def test_other_branch_commit(self):
125
262
        # this branch is to ensure consistent behaviour, whether we're run
126
263
        # inside a branch, or not.
127
 
        os.mkdir('empty_branch')
128
 
        os.chdir('empty_branch')
129
 
        self.runbzr('init')
130
 
        os.mkdir('branch')
131
 
        os.chdir('branch')
132
 
        self.runbzr('init')
133
 
        file('foo.c', 'wt').write('int main() {}')
134
 
        file('bar.c', 'wt').write('int main() {}')
135
 
        os.chdir('..')
136
 
        self.runbzr(['add', 'branch/foo.c'])
137
 
        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')
138
271
        # can't commit files in different trees; sane error
139
 
        self.runbzr('commit -m newstuff branch/foo.c .', retcode=3)
140
 
        self.runbzr('commit -m newstuff branch/foo.c')
141
 
        self.runbzr('commit -m newstuff branch')
142
 
        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)
143
276
 
144
277
    def test_out_of_date_tree_commit(self):
145
278
        # check we get an error code and a clear message committing with an out
146
279
        # of date checkout
147
 
        self.make_branch_and_tree('branch')
 
280
        tree = self.make_branch_and_tree('branch')
148
281
        # make a checkout
149
 
        self.runbzr('checkout --lightweight branch checkout')
 
282
        checkout = tree.branch.create_checkout('checkout', lightweight=True)
150
283
        # commit to the original branch to make the checkout out of date
151
 
        self.runbzr('commit --unchanged -m message branch')
 
284
        tree.commit('message branch', allow_pointless=True)
152
285
        # now commit to the checkout should emit
153
286
        # ERROR: Out of date with the branch, 'bzr update' is suggested
154
 
        output = self.runbzr('commit --unchanged -m checkout_message '
 
287
        output = self.run_bzr('commit --unchanged -m checkout_message '
155
288
                             'checkout', retcode=3)
156
289
        self.assertEqual(output,
157
290
                         ('',
158
 
                          "bzr: ERROR: Working tree is out of date, please run "
159
 
                          "'bzr update'.\n"))
 
291
                          "bzr: ERROR: Working tree is out of date, please "
 
292
                          "run 'bzr update'.\n"))
160
293
 
161
294
    def test_local_commit_unbound(self):
162
295
        # a --local commit on an unbound branch is an error
163
296
        self.make_branch_and_tree('.')
164
 
        out, err = self.run_bzr('commit', '--local', retcode=3)
 
297
        out, err = self.run_bzr('commit --local', retcode=3)
165
298
        self.assertEqualDiff('', out)
166
299
        self.assertEqualDiff('bzr: ERROR: Cannot perform local-only commits '
167
300
                             'on unbound branches.\n', err)
 
301
 
 
302
    def test_commit_a_text_merge_in_a_checkout(self):
 
303
        # checkouts perform multiple actions in a transaction across bond
 
304
        # branches and their master, and have been observed to fail in the
 
305
        # past. This is a user story reported to fail in bug #43959 where 
 
306
        # a merge done in a checkout (using the update command) failed to
 
307
        # commit correctly.
 
308
        trunk = self.make_branch_and_tree('trunk')
 
309
 
 
310
        u1 = trunk.branch.create_checkout('u1')
 
311
        self.build_tree_contents([('u1/hosts', 'initial contents')])
 
312
        u1.add('hosts')
 
313
        self.run_bzr('commit -m add-hosts u1')
 
314
 
 
315
        u2 = trunk.branch.create_checkout('u2')
 
316
        self.build_tree_contents([('u2/hosts', 'altered in u2')])
 
317
        self.run_bzr('commit -m checkin-from-u2 u2')
 
318
 
 
319
        # make an offline commits
 
320
        self.build_tree_contents([('u1/hosts', 'first offline change in u1')])
 
321
        self.run_bzr('commit -m checkin-offline --local u1')
 
322
 
 
323
        # now try to pull in online work from u2, and then commit our offline
 
324
        # work as a merge
 
325
        # retcode 1 as we expect a text conflict
 
326
        self.run_bzr('update u1', retcode=1)
 
327
        self.run_bzr('resolved u1/hosts')
 
328
        # add a text change here to represent resolving the merge conflicts in
 
329
        # favour of a new version of the file not identical to either the u1
 
330
        # version or the u2 version.
 
331
        self.build_tree_contents([('u1/hosts', 'merge resolution\n')])
 
332
        self.run_bzr('commit -m checkin-merge-of-the-offline-work-from-u1 u1')
 
333
 
 
334
    def test_commit_respects_spec_for_removals(self):
 
335
        """Commit with a file spec should only commit removals that match"""
 
336
        t = self.make_branch_and_tree('.')
 
337
        self.build_tree(['file-a', 'dir-a/', 'dir-a/file-b'])
 
338
        t.add(['file-a', 'dir-a', 'dir-a/file-b'])
 
339
        t.commit('Create')
 
340
        t.remove(['file-a', 'dir-a/file-b'])
 
341
        os.chdir('dir-a')
 
342
        result = self.run_bzr('commit . -m removed-file-b')[1]
 
343
        self.assertNotContainsRe(result, 'file-a')
 
344
        result = self.run_bzr('status')[0]
 
345
        self.assertContainsRe(result, 'removed:\n  file-a')
 
346
 
 
347
    def test_strict_commit(self):
 
348
        """Commit with --strict works if everything is known"""
 
349
        ignores._set_user_ignores([])
 
350
        tree = self.make_branch_and_tree('tree')
 
351
        self.build_tree(['tree/a'])
 
352
        tree.add('a')
 
353
        # A simple change should just work
 
354
        self.run_bzr('commit --strict -m adding-a',
 
355
                     working_dir='tree')
 
356
 
 
357
    def test_strict_commit_no_changes(self):
 
358
        """commit --strict gives "no changes" if there is nothing to commit"""
 
359
        tree = self.make_branch_and_tree('tree')
 
360
        self.build_tree(['tree/a'])
 
361
        tree.add('a')
 
362
        tree.commit('adding a')
 
363
 
 
364
        # With no changes, it should just be 'no changes'
 
365
        # Make sure that commit is failing because there is nothing to do
 
366
        self.run_bzr_error(['no changes to commit'],
 
367
                           'commit --strict -m no-changes',
 
368
                           working_dir='tree')
 
369
 
 
370
        # But --strict doesn't care if you supply --unchanged
 
371
        self.run_bzr('commit --strict --unchanged -m no-changes',
 
372
                     working_dir='tree')
 
373
 
 
374
    def test_strict_commit_unknown(self):
 
375
        """commit --strict fails if a file is unknown"""
 
376
        tree = self.make_branch_and_tree('tree')
 
377
        self.build_tree(['tree/a'])
 
378
        tree.add('a')
 
379
        tree.commit('adding a')
 
380
 
 
381
        # Add one file so there is a change, but forget the other
 
382
        self.build_tree(['tree/b', 'tree/c'])
 
383
        tree.add('b')
 
384
        self.run_bzr_error(['Commit refused because there are unknown files'],
 
385
                           'commit --strict -m add-b',
 
386
                           working_dir='tree')
 
387
 
 
388
        # --no-strict overrides --strict
 
389
        self.run_bzr('commit --strict -m add-b --no-strict',
 
390
                     working_dir='tree')
 
391
 
 
392
    def test_fixes_bug_output(self):
 
393
        """commit --fixes=lp:23452 succeeds without output."""
 
394
        tree = self.make_branch_and_tree('tree')
 
395
        self.build_tree(['tree/hello.txt'])
 
396
        tree.add('hello.txt')
 
397
        output, err = self.run_bzr(
 
398
            'commit -m hello --fixes=lp:23452 tree/hello.txt')
 
399
        self.assertEqual('', output)
 
400
        self.assertContainsRe(err, 'Committing to: .*\n'
 
401
                              'added hello\.txt\n'
 
402
                              'Committed revision 1\.\n')
 
403
 
 
404
    def test_no_bugs_no_properties(self):
 
405
        """If no bugs are fixed, the bugs property is not set.
 
406
 
 
407
        see https://beta.launchpad.net/bzr/+bug/109613
 
408
        """
 
409
        tree = self.make_branch_and_tree('tree')
 
410
        self.build_tree(['tree/hello.txt'])
 
411
        tree.add('hello.txt')
 
412
        self.run_bzr( 'commit -m hello tree/hello.txt')
 
413
        # Get the revision properties, ignoring the branch-nick property, which
 
414
        # we don't care about for this test.
 
415
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
416
        properties = dict(last_rev.properties)
 
417
        del properties['branch-nick']
 
418
        self.assertFalse('bugs' in properties)
 
419
 
 
420
    def test_fixes_bug_sets_property(self):
 
421
        """commit --fixes=lp:234 sets the lp:234 revprop to 'fixed'."""
 
422
        tree = self.make_branch_and_tree('tree')
 
423
        self.build_tree(['tree/hello.txt'])
 
424
        tree.add('hello.txt')
 
425
        self.run_bzr('commit -m hello --fixes=lp:234 tree/hello.txt')
 
426
 
 
427
        # Get the revision properties, ignoring the branch-nick property, which
 
428
        # we don't care about for this test.
 
429
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
430
        properties = dict(last_rev.properties)
 
431
        del properties['branch-nick']
 
432
 
 
433
        self.assertEqual({'bugs': 'https://launchpad.net/bugs/234 fixed'},
 
434
                         properties)
 
435
 
 
436
    def test_fixes_multiple_bugs_sets_properties(self):
 
437
        """--fixes can be used more than once to show that bugs are fixed."""
 
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 --fixes=lp:123 --fixes=lp:235'
 
442
                     ' tree/hello.txt')
 
443
 
 
444
        # Get the revision properties, ignoring the branch-nick property, which
 
445
        # we don't care about for this test.
 
446
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
447
        properties = dict(last_rev.properties)
 
448
        del properties['branch-nick']
 
449
 
 
450
        self.assertEqual(
 
451
            {'bugs': 'https://launchpad.net/bugs/123 fixed\n'
 
452
                     'https://launchpad.net/bugs/235 fixed'},
 
453
            properties)
 
454
 
 
455
    def test_fixes_bug_with_alternate_trackers(self):
 
456
        """--fixes can be used on a properly configured branch to mark bug
 
457
        fixes on multiple trackers.
 
458
        """
 
459
        tree = self.make_branch_and_tree('tree')
 
460
        tree.branch.get_config().set_user_option(
 
461
            'trac_twisted_url', 'http://twistedmatrix.com/trac')
 
462
        self.build_tree(['tree/hello.txt'])
 
463
        tree.add('hello.txt')
 
464
        self.run_bzr('commit -m hello --fixes=lp:123 --fixes=twisted:235 tree/')
 
465
 
 
466
        # Get the revision properties, ignoring the branch-nick property, which
 
467
        # we don't care about for this test.
 
468
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
469
        properties = dict(last_rev.properties)
 
470
        del properties['branch-nick']
 
471
 
 
472
        self.assertEqual(
 
473
            {'bugs': 'https://launchpad.net/bugs/123 fixed\n'
 
474
                     'http://twistedmatrix.com/trac/ticket/235 fixed'},
 
475
            properties)
 
476
 
 
477
    def test_fixes_unknown_bug_prefix(self):
 
478
        tree = self.make_branch_and_tree('tree')
 
479
        self.build_tree(['tree/hello.txt'])
 
480
        tree.add('hello.txt')
 
481
        self.run_bzr_error(
 
482
            ["Unrecognized bug %s. Commit refused." % 'xxx:123'],
 
483
            'commit -m add-b --fixes=xxx:123',
 
484
            working_dir='tree')
 
485
 
 
486
    def test_fixes_invalid_bug_number(self):
 
487
        tree = self.make_branch_and_tree('tree')
 
488
        self.build_tree(['tree/hello.txt'])
 
489
        tree.add('hello.txt')
 
490
        self.run_bzr_error(
 
491
            ["Invalid bug identifier for %s. Commit refused." % 'lp:orange'],
 
492
            'commit -m add-b --fixes=lp:orange',
 
493
            working_dir='tree')
 
494
 
 
495
    def test_fixes_invalid_argument(self):
 
496
        """Raise an appropriate error when the fixes argument isn't tag:id."""
 
497
        tree = self.make_branch_and_tree('tree')
 
498
        self.build_tree(['tree/hello.txt'])
 
499
        tree.add('hello.txt')
 
500
        self.run_bzr_error(
 
501
            [r"Invalid bug orange. Must be in the form of 'tag:id'\. "
 
502
             r"Commit refused\."],
 
503
            'commit -m add-b --fixes=orange',
 
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')