← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

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

  • Committer: Aaron Bentley
  • Date: 2007-03-09 21:46:40 UTC
  • mto: (2323.6.9 0.15-integration)
  • mto: This revision was merged to the branch mainline in revision 2330.
  • Revision ID: abentley@panoramicfeedback.com-20070309214640-nnxk7g37bygoz50c
Add (set|get)_public_branch

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_commit.py
1
 
# Copyright (C) 2005, 2006, 2007, 2009 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
18
"""Tests for the commit CLI of bzr."""
19
19
 
20
20
import os
 
21
import re
21
22
import sys
22
23
 
23
24
from bzrlib import (
24
 
    osutils,
25
25
    ignores,
26
 
    msgeditor,
27
 
    osutils,
28
26
    )
 
27
from bzrlib.branch import Branch
29
28
from bzrlib.bzrdir import BzrDir
30
 
from bzrlib.tests import (
31
 
    probe_bad_non_ascii,
32
 
    TestSkipped,
33
 
    )
 
29
from bzrlib.errors import BzrCommandError
34
30
from bzrlib.tests.blackbox import ExternalBase
 
31
from bzrlib.workingtree import WorkingTree
35
32
 
36
33
 
37
34
class TestCommit(ExternalBase):
39
36
    def test_05_empty_commit(self):
40
37
        """Commit of tree with no versioned files should fail"""
41
38
        # If forced, it should succeed, but this is not tested here.
42
 
        self.make_branch_and_tree('.')
 
39
        self.run_bzr("init")
43
40
        self.build_tree(['hello.txt'])
44
 
        out,err = self.run_bzr('commit -m empty', retcode=3)
 
41
        out,err = self.run_bzr("commit", "-m", "empty", retcode=3)
45
42
        self.assertEqual('', out)
46
 
        self.assertContainsRe(err, 'bzr: ERROR: No changes to commit\.'
47
 
                                  ' Use --unchanged to commit anyhow.\n')
 
43
        self.assertStartsWith(err, 'bzr: ERROR: no changes to commit.'
 
44
                                  ' use --unchanged to commit anyhow\n')
48
45
 
49
46
    def test_commit_success(self):
50
47
        """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])
 
48
        self.run_bzr("init")
 
49
        self.run_bzr("commit", "--unchanged", "-m", "message")
 
50
        self.assertEqual('', self.capture('unknowns'))
54
51
 
55
52
        # same for unicode messages
56
 
        self.run_bzr(["commit", "--unchanged", "-m", u'foo\xb5'])
57
 
        self.assertEqual('', self.run_bzr('unknowns')[0])
 
53
        self.run_bzr("commit", "--unchanged", "-m", u'foo\xb5')
 
54
        self.assertEqual('', self.capture('unknowns'))
58
55
 
59
56
    def test_commit_with_path(self):
60
57
        """Commit tree with path of root specified"""
61
 
        a_tree = self.make_branch_and_tree('a')
 
58
        self.run_bzr('init', 'a')
62
59
        self.build_tree(['a/a_file'])
63
 
        a_tree.add('a_file')
64
 
        self.run_bzr(['commit', '-m', 'first commit', 'a'])
 
60
        self.run_bzr('add', 'a/a_file')
 
61
        self.run_bzr('commit', '-m', 'first commit', 'a')
65
62
 
66
 
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
 
63
        self.run_bzr('branch', 'a', 'b')
67
64
        self.build_tree_contents([('b/a_file', 'changes in b')])
68
 
        self.run_bzr(['commit', '-m', 'first commit in b', 'b'])
 
65
        self.run_bzr('commit', '-m', 'first commit in b', 'b')
69
66
 
70
67
        self.build_tree_contents([('a/a_file', 'new contents')])
71
 
        self.run_bzr(['commit', '-m', 'change in a', 'a'])
 
68
        self.run_bzr('commit', '-m', 'change in a', 'a')
72
69
 
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'])
 
70
        os.chdir('b')
 
71
        self.run_bzr('merge', '../a', retcode=1) # will conflict
 
72
        os.chdir('..')
 
73
        self.run_bzr('resolved', 'b/a_file')
 
74
        self.run_bzr('commit', '-m', 'merge into b', 'b')
77
75
 
78
76
 
79
77
    def test_10_verbose_commit(self):
80
78
        """Add one file and examine verbose commit output"""
81
 
        tree = self.make_branch_and_tree('.')
 
79
        self.runbzr("init")
82
80
        self.build_tree(['hello.txt'])
83
 
        tree.add("hello.txt")
84
 
        out,err = self.run_bzr('commit -m added')
 
81
        self.runbzr("add hello.txt")
 
82
        out,err = self.run_bzr("commit", "-m", "added")
85
83
        self.assertEqual('', out)
86
 
        self.assertContainsRe(err, '^Committing to: .*\n'
87
 
                              'added hello.txt\n'
88
 
                              'Committed revision 1.\n$',)
 
84
        self.assertEqual('added hello.txt\n'
 
85
                         'Committed revision 1.\n',
 
86
                         err)
89
87
 
90
88
    def prepare_simple_history(self):
91
89
        """Prepare and return a working tree with one commit of one file"""
100
98
        # Verbose commit of modified file should say so
101
99
        wt = self.prepare_simple_history()
102
100
        self.build_tree_contents([('hello.txt', 'new contents')])
103
 
        out, err = self.run_bzr('commit -m modified')
 
101
        out, err = self.run_bzr("commit", "-m", "modified")
104
102
        self.assertEqual('', out)
105
 
        self.assertContainsRe(err, '^Committing to: .*\n'
106
 
                              'modified hello\.txt\n'
107
 
                              'Committed revision 2\.\n$')
 
103
        self.assertEqual('modified hello.txt\n'
 
104
                         'Committed revision 2.\n',
 
105
                         err)
108
106
 
109
107
    def test_verbose_commit_renamed(self):
110
108
        # Verbose commit of renamed file should say so
111
109
        wt = self.prepare_simple_history()
112
110
        wt.rename_one('hello.txt', 'gutentag.txt')
113
 
        out, err = self.run_bzr('commit -m renamed')
 
111
        out, err = self.run_bzr("commit", "-m", "renamed")
114
112
        self.assertEqual('', out)
115
 
        self.assertContainsRe(err, '^Committing to: .*\n'
116
 
                              'renamed hello\.txt => gutentag\.txt\n'
117
 
                              'Committed revision 2\.$\n')
 
113
        self.assertEqual('renamed hello.txt => gutentag.txt\n'
 
114
                         'Committed revision 2.\n',
 
115
                         err)
118
116
 
119
117
    def test_verbose_commit_moved(self):
120
118
        # Verbose commit of file moved to new directory should say so
122
120
        os.mkdir('subdir')
123
121
        wt.add(['subdir'])
124
122
        wt.rename_one('hello.txt', 'subdir/hello.txt')
125
 
        out, err = self.run_bzr('commit -m renamed')
 
123
        out, err = self.run_bzr("commit", "-m", "renamed")
126
124
        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')))
 
125
        self.assertEqualDiff('added subdir\n'
 
126
                             'renamed hello.txt => subdir/hello.txt\n'
 
127
                             'Committed revision 2.\n',
 
128
                             err)
134
129
 
135
130
    def test_verbose_commit_with_unknown(self):
136
131
        """Unknown files should not be listed by default in verbose output"""
138
133
        wt = BzrDir.create_standalone_workingtree('.')
139
134
        self.build_tree(['hello.txt', 'extra.txt'])
140
135
        wt.add(['hello.txt'])
141
 
        out,err = self.run_bzr('commit -m added')
 
136
        out,err = self.run_bzr("commit", "-m", "added")
142
137
        self.assertEqual('', out)
143
 
        self.assertContainsRe(err, '^Committing to: .*\n'
144
 
                              'added hello\.txt\n'
145
 
                              'Committed revision 1\.\n$')
 
138
        self.assertEqual('added hello.txt\n'
 
139
                         'Committed revision 1.\n',
 
140
                         err)
146
141
 
147
142
    def test_verbose_commit_with_unchanged(self):
148
143
        """Unchanged files should not be listed by default in verbose output"""
149
 
        tree = self.make_branch_and_tree('.')
 
144
        self.runbzr("init")
150
145
        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')
 
146
        self.runbzr('add unchanged.txt')
 
147
        self.runbzr('commit -m unchanged unchanged.txt')
 
148
        self.runbzr("add hello.txt")
 
149
        out,err = self.run_bzr("commit", "-m", "added")
155
150
        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)
 
151
        self.assertEqual('added hello.txt\n'
 
152
                         'Committed revision 2.\n',
 
153
                         err)
172
154
 
173
155
    def test_commit_merge_reports_all_modified_files(self):
174
156
        # the commit command should show all the files that are shown by
207
189
            other_tree.rename_one('dirtorename', 'renameddir')
208
190
            other_tree.rename_one('dirtoreparent', 'renameddir/reparenteddir')
209
191
            other_tree.rename_one('filetorename', 'renamedfile')
210
 
            other_tree.rename_one('filetoreparent',
211
 
                                  'renameddir/reparentedfile')
 
192
            other_tree.rename_one('filetoreparent', 'renameddir/reparentedfile')
212
193
            other_tree.remove(['dirtoremove', 'filetoremove'])
213
194
            self.build_tree_contents([
214
 
                ('other/newdir/',),
 
195
                ('other/newdir/', ),
215
196
                ('other/filetomodify', 'new content'),
216
197
                ('other/newfile', 'new file content')])
217
198
            other_tree.add('newfile')
221
202
            other_tree.unlock()
222
203
        this_tree.merge_from_branch(other_tree.branch)
223
204
        os.chdir('this')
224
 
        out,err = self.run_bzr('commit -m added')
 
205
        out,err = self.run_bzr("commit", "-m", "added")
 
206
        os.chdir('..')
225
207
        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')))
 
208
        self.assertEqualDiff(
 
209
            'modified filetomodify\n'
 
210
            'added newdir\n'
 
211
            'added newfile\n'
 
212
            'renamed dirtorename => renameddir\n'
 
213
            'renamed dirtoreparent => renameddir/reparenteddir\n'
 
214
            'renamed filetoreparent => renameddir/reparentedfile\n'
 
215
            'renamed filetorename => renamedfile\n'
 
216
            'deleted dirtoremove\n'
 
217
            'deleted filetoremove\n'
 
218
            'Committed revision 2.\n',
 
219
            err)
240
220
 
241
221
    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.')
 
222
        self.runbzr("init")
 
223
        file('foo.c', 'wt').write('int main() {}')
 
224
        self.runbzr(['add', 'foo.c'])
 
225
        self.runbzr(["commit", "-m", ""] , retcode=3)
267
226
 
268
227
    def test_other_branch_commit(self):
269
228
        # this branch is to ensure consistent behaviour, whether we're run
270
229
        # 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')
 
230
        os.mkdir('empty_branch')
 
231
        os.chdir('empty_branch')
 
232
        self.runbzr('init')
 
233
        os.mkdir('branch')
 
234
        os.chdir('branch')
 
235
        self.runbzr('init')
 
236
        file('foo.c', 'wt').write('int main() {}')
 
237
        file('bar.c', 'wt').write('int main() {}')
 
238
        os.chdir('..')
 
239
        self.runbzr(['add', 'branch/foo.c'])
 
240
        self.runbzr(['add', 'branch'])
278
241
        # 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)
 
242
        self.runbzr('commit -m newstuff branch/foo.c .', retcode=3)
 
243
        self.runbzr('commit -m newstuff branch/foo.c')
 
244
        self.runbzr('commit -m newstuff branch')
 
245
        self.runbzr('commit -m newstuff branch', retcode=3)
283
246
 
284
247
    def test_out_of_date_tree_commit(self):
285
248
        # check we get an error code and a clear message committing with an out
286
249
        # of date checkout
287
 
        tree = self.make_branch_and_tree('branch')
 
250
        self.make_branch_and_tree('branch')
288
251
        # make a checkout
289
 
        checkout = tree.branch.create_checkout('checkout', lightweight=True)
 
252
        self.runbzr('checkout --lightweight branch checkout')
290
253
        # commit to the original branch to make the checkout out of date
291
 
        tree.commit('message branch', allow_pointless=True)
 
254
        self.runbzr('commit --unchanged -m message branch')
292
255
        # now commit to the checkout should emit
293
256
        # ERROR: Out of date with the branch, 'bzr update' is suggested
294
 
        output = self.run_bzr('commit --unchanged -m checkout_message '
 
257
        output = self.runbzr('commit --unchanged -m checkout_message '
295
258
                             'checkout', retcode=3)
296
259
        self.assertEqual(output,
297
260
                         ('',
298
 
                          "bzr: ERROR: Working tree is out of date, please "
299
 
                          "run 'bzr update'.\n"))
 
261
                          "bzr: ERROR: Working tree is out of date, please run "
 
262
                          "'bzr update'.\n"))
300
263
 
301
264
    def test_local_commit_unbound(self):
302
265
        # a --local commit on an unbound branch is an error
303
266
        self.make_branch_and_tree('.')
304
 
        out, err = self.run_bzr('commit --local', retcode=3)
 
267
        out, err = self.run_bzr('commit', '--local', retcode=3)
305
268
        self.assertEqualDiff('', out)
306
269
        self.assertEqualDiff('bzr: ERROR: Cannot perform local-only commits '
307
270
                             'on unbound branches.\n', err)
309
272
    def test_commit_a_text_merge_in_a_checkout(self):
310
273
        # checkouts perform multiple actions in a transaction across bond
311
274
        # 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
 
275
        # past. This is a user story reported to fail in bug #43959 where 
313
276
        # a merge done in a checkout (using the update command) failed to
314
277
        # commit correctly.
315
 
        trunk = self.make_branch_and_tree('trunk')
 
278
        self.run_bzr('init', 'trunk')
316
279
 
317
 
        u1 = trunk.branch.create_checkout('u1')
 
280
        self.run_bzr('checkout', 'trunk', 'u1')
318
281
        self.build_tree_contents([('u1/hosts', 'initial contents')])
319
 
        u1.add('hosts')
320
 
        self.run_bzr('commit -m add-hosts u1')
 
282
        self.run_bzr('add', 'u1/hosts')
 
283
        self.run_bzr('commit', '-m', 'add hosts', 'u1')
321
284
 
322
 
        u2 = trunk.branch.create_checkout('u2')
 
285
        self.run_bzr('checkout', 'trunk', 'u2')
323
286
        self.build_tree_contents([('u2/hosts', 'altered in u2')])
324
 
        self.run_bzr('commit -m checkin-from-u2 u2')
 
287
        self.run_bzr('commit', '-m', 'checkin from u2', 'u2')
325
288
 
326
289
        # make an offline commits
327
290
        self.build_tree_contents([('u1/hosts', 'first offline change in u1')])
328
 
        self.run_bzr('commit -m checkin-offline --local u1')
 
291
        self.run_bzr('commit', '-m', 'checkin offline', '--local', 'u1')
329
292
 
330
293
        # now try to pull in online work from u2, and then commit our offline
331
294
        # work as a merge
332
295
        # retcode 1 as we expect a text conflict
333
 
        self.run_bzr('update u1', retcode=1)
334
 
        self.run_bzr('resolved u1/hosts')
 
296
        self.run_bzr('update', 'u1', retcode=1)
 
297
        self.run_bzr('resolved', 'u1/hosts')
335
298
        # add a text change here to represent resolving the merge conflicts in
336
299
        # favour of a new version of the file not identical to either the u1
337
300
        # version or the u2 version.
338
301
        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)
 
302
        self.run_bzr('commit', '-m', 'checkin merge of the offline work from u1', 'u1')
369
303
 
370
304
    def test_commit_respects_spec_for_removals(self):
371
305
        """Commit with a file spec should only commit removals that match"""
375
309
        t.commit('Create')
376
310
        t.remove(['file-a', 'dir-a/file-b'])
377
311
        os.chdir('dir-a')
378
 
        result = self.run_bzr('commit . -m removed-file-b')[1]
 
312
        result = self.run_bzr('commit', '.', '-m' 'removed file-b')[1]
379
313
        self.assertNotContainsRe(result, 'file-a')
380
314
        result = self.run_bzr('status')[0]
381
315
        self.assertContainsRe(result, 'removed:\n  file-a')
387
321
        self.build_tree(['tree/a'])
388
322
        tree.add('a')
389
323
        # A simple change should just work
390
 
        self.run_bzr('commit --strict -m adding-a',
 
324
        self.run_bzr('commit', '--strict', '-m', 'adding a',
391
325
                     working_dir='tree')
392
326
 
393
327
    def test_strict_commit_no_changes(self):
399
333
 
400
334
        # With no changes, it should just be 'no changes'
401
335
        # 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',
 
336
        self.run_bzr_error(['no changes to commit'],
 
337
                           'commit', '--strict', '-m', 'no changes',
404
338
                           working_dir='tree')
405
339
 
406
340
        # But --strict doesn't care if you supply --unchanged
407
 
        self.run_bzr('commit --strict --unchanged -m no-changes',
 
341
        self.run_bzr('commit', '--strict', '--unchanged', '-m', 'no changes',
408
342
                     working_dir='tree')
409
343
 
410
344
    def test_strict_commit_unknown(self):
418
352
        self.build_tree(['tree/b', 'tree/c'])
419
353
        tree.add('b')
420
354
        self.run_bzr_error(['Commit refused because there are unknown files'],
421
 
                           'commit --strict -m add-b',
 
355
                           'commit', '--strict', '-m', 'add b',
422
356
                           working_dir='tree')
423
357
 
424
358
        # --no-strict overrides --strict
425
 
        self.run_bzr('commit --strict -m add-b --no-strict',
 
359
        self.run_bzr('commit', '--strict', '-m', 'add b', '--no-strict',
426
360
                     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)