~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

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

  • Committer: Andrew Bennetts
  • Date: 2009-10-26 06:44:40 UTC
  • mfrom: (4634.77.9 2.0)
  • mto: This revision was merged to the branch mainline in revision 4770.
  • Revision ID: andrew.bennetts@canonical.com-20091026064440-06u7tpg7l6sjkh8h
Merge lp:bzr/2.0 into lp:bzr.

Show diffs side-by-side

added added

removed removed

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