/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

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

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_commit.py
1
 
# Copyright (C) 2005, 2006 by Canonical Ltd
 
1
# Copyright (C) 2006-2010 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
    tests,
 
29
    )
25
30
from bzrlib.bzrdir import BzrDir
26
 
from bzrlib.errors import BzrCommandError
 
31
from bzrlib.tests import (
 
32
    probe_bad_non_ascii,
 
33
    TestSkipped,
 
34
    )
27
35
from bzrlib.tests.blackbox import ExternalBase
28
 
from bzrlib.workingtree import WorkingTree
29
36
 
30
37
 
31
38
class TestCommit(ExternalBase):
33
40
    def test_05_empty_commit(self):
34
41
        """Commit of tree with no versioned files should fail"""
35
42
        # If forced, it should succeed, but this is not tested here.
36
 
        self.run_bzr("init")
 
43
        self.make_branch_and_tree('.')
37
44
        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)
 
45
        out,err = self.run_bzr('commit -m empty', retcode=3)
 
46
        self.assertEqual('', out)
 
47
        self.assertContainsRe(err, 'bzr: ERROR: No changes to commit\.'
 
48
                                  ' Use --unchanged to commit anyhow.\n')
 
49
 
 
50
    def test_commit_success(self):
 
51
        """Successful commit should not leave behind a bzr-commit-* file"""
 
52
        self.make_branch_and_tree('.')
 
53
        self.run_bzr('commit --unchanged -m message')
 
54
        self.assertEqual('', self.run_bzr('unknowns')[0])
 
55
 
 
56
        # same for unicode messages
 
57
        self.run_bzr(["commit", "--unchanged", "-m", u'foo\xb5'])
 
58
        self.assertEqual('', self.run_bzr('unknowns')[0])
42
59
 
43
60
    def test_commit_with_path(self):
44
61
        """Commit tree with path of root specified"""
45
 
        self.run_bzr('init', 'a')
 
62
        a_tree = self.make_branch_and_tree('a')
46
63
        self.build_tree(['a/a_file'])
47
 
        self.run_bzr('add', 'a/a_file')
48
 
        self.run_bzr('commit', '-m', 'first commit', 'a')
 
64
        a_tree.add('a_file')
 
65
        self.run_bzr(['commit', '-m', 'first commit', 'a'])
49
66
 
50
 
        self.run_bzr('branch', 'a', 'b')
 
67
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
51
68
        self.build_tree_contents([('b/a_file', 'changes in b')])
52
 
        self.run_bzr('commit', '-m', 'first commit in b', 'b')
 
69
        self.run_bzr(['commit', '-m', 'first commit in b', 'b'])
53
70
 
54
71
        self.build_tree_contents([('a/a_file', 'new contents')])
55
 
        self.run_bzr('commit', '-m', 'change in a', 'a')
 
72
        self.run_bzr(['commit', '-m', 'change in a', 'a'])
56
73
 
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')
 
74
        b_tree.merge_from_branch(a_tree.branch)
 
75
        self.assertEqual(len(b_tree.conflicts()), 1)
 
76
        self.run_bzr('resolved b/a_file')
 
77
        self.run_bzr(['commit', '-m', 'merge into b', 'b'])
62
78
 
63
79
 
64
80
    def test_10_verbose_commit(self):
65
81
        """Add one file and examine verbose commit output"""
66
 
        self.runbzr("init")
 
82
        tree = self.make_branch_and_tree('.')
67
83
        self.build_tree(['hello.txt'])
68
 
        self.runbzr("add hello.txt")
69
 
        out,err = self.run_bzr("commit", "-m", "added")
 
84
        tree.add("hello.txt")
 
85
        out,err = self.run_bzr('commit -m added')
70
86
        self.assertEqual('', out)
71
 
        self.assertEqual('added hello.txt\n'
72
 
                         'Committed revision 1.\n',
73
 
                         err)
 
87
        self.assertContainsRe(err, '^Committing to: .*\n'
 
88
                              'added hello.txt\n'
 
89
                              'Committed revision 1.\n$',)
74
90
 
75
91
    def prepare_simple_history(self):
76
92
        """Prepare and return a working tree with one commit of one file"""
85
101
        # Verbose commit of modified file should say so
86
102
        wt = self.prepare_simple_history()
87
103
        self.build_tree_contents([('hello.txt', 'new contents')])
88
 
        out, err = self.run_bzr("commit", "-m", "modified")
 
104
        out, err = self.run_bzr('commit -m modified')
89
105
        self.assertEqual('', out)
90
 
        self.assertEqual('modified hello.txt\n'
91
 
                         'Committed revision 2.\n',
92
 
                         err)
 
106
        self.assertContainsRe(err, '^Committing to: .*\n'
 
107
                              'modified hello\.txt\n'
 
108
                              'Committed revision 2\.\n$')
 
109
 
 
110
    def test_warn_about_forgotten_commit_message(self):
 
111
        """Test that the lack of -m parameter is caught"""
 
112
        wt = self.make_branch_and_tree('.')
 
113
        self.build_tree(['one', 'two'])
 
114
        wt.add(['two'])
 
115
        out, err = self.run_bzr('commit -m one two')
 
116
        self.assertContainsRe(err, "The commit message is a file name")
93
117
 
94
118
    def test_verbose_commit_renamed(self):
95
119
        # Verbose commit of renamed file should say so
96
120
        wt = self.prepare_simple_history()
97
121
        wt.rename_one('hello.txt', 'gutentag.txt')
98
 
        out, err = self.run_bzr("commit", "-m", "renamed")
 
122
        out, err = self.run_bzr('commit -m renamed')
99
123
        self.assertEqual('', out)
100
 
        self.assertEqual('renamed hello.txt => gutentag.txt\n'
101
 
                         'Committed revision 2.\n',
102
 
                         err)
 
124
        self.assertContainsRe(err, '^Committing to: .*\n'
 
125
                              'renamed hello\.txt => gutentag\.txt\n'
 
126
                              'Committed revision 2\.$\n')
103
127
 
104
128
    def test_verbose_commit_moved(self):
105
129
        # Verbose commit of file moved to new directory should say so
107
131
        os.mkdir('subdir')
108
132
        wt.add(['subdir'])
109
133
        wt.rename_one('hello.txt', 'subdir/hello.txt')
110
 
        out, err = self.run_bzr("commit", "-m", "renamed")
 
134
        out, err = self.run_bzr('commit -m renamed')
111
135
        self.assertEqual('', out)
112
 
        self.assertEqualDiff('added subdir\n'
113
 
                             'renamed hello.txt => subdir/hello.txt\n'
114
 
                             'Committed revision 2.\n',
115
 
                             err)
 
136
        self.assertEqual(set([
 
137
            'Committing to: %s/' % osutils.getcwd(),
 
138
            'added subdir',
 
139
            'renamed hello.txt => subdir/hello.txt',
 
140
            'Committed revision 2.',
 
141
            '',
 
142
            ]), set(err.split('\n')))
116
143
 
117
144
    def test_verbose_commit_with_unknown(self):
118
145
        """Unknown files should not be listed by default in verbose output"""
120
147
        wt = BzrDir.create_standalone_workingtree('.')
121
148
        self.build_tree(['hello.txt', 'extra.txt'])
122
149
        wt.add(['hello.txt'])
123
 
        out,err = self.run_bzr("commit", "-m", "added")
 
150
        out,err = self.run_bzr('commit -m added')
124
151
        self.assertEqual('', out)
125
 
        self.assertEqual('added hello.txt\n'
126
 
                         'Committed revision 1.\n',
127
 
                         err)
 
152
        self.assertContainsRe(err, '^Committing to: .*\n'
 
153
                              'added hello\.txt\n'
 
154
                              'Committed revision 1\.\n$')
128
155
 
129
156
    def test_verbose_commit_with_unchanged(self):
130
157
        """Unchanged files should not be listed by default in verbose output"""
131
 
        self.runbzr("init")
 
158
        tree = self.make_branch_and_tree('.')
132
159
        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")
 
160
        tree.add('unchanged.txt')
 
161
        self.run_bzr('commit -m unchanged unchanged.txt')
 
162
        tree.add("hello.txt")
 
163
        out,err = self.run_bzr('commit -m added')
137
164
        self.assertEqual('', out)
138
 
        self.assertEqual('added hello.txt\n'
139
 
                         'Committed revision 2.\n',
140
 
                         err)
 
165
        self.assertContainsRe(err, '^Committing to: .*\n'
 
166
                              'added hello\.txt\n'
 
167
                              'Committed revision 2\.$\n')
 
168
 
 
169
    def test_verbose_commit_includes_master_location(self):
 
170
        """Location of master is displayed when committing to bound branch"""
 
171
        a_tree = self.make_branch_and_tree('a')
 
172
        self.build_tree(['a/b'])
 
173
        a_tree.add('b')
 
174
        a_tree.commit(message='Initial message')
 
175
 
 
176
        b_tree = a_tree.branch.create_checkout('b')
 
177
        expected = "%s/" % (osutils.abspath('a'), )
 
178
        out, err = self.run_bzr('commit -m blah --unchanged', working_dir='b')
 
179
        self.assertEqual(err, 'Committing to: %s\n'
 
180
                         'Committed revision 2.\n' % expected)
 
181
 
 
182
    def test_commit_sanitizes_CR_in_message(self):
 
183
        # See bug #433779, basically Emacs likes to pass '\r\n' style line
 
184
        # endings to 'bzr commit -m ""' which breaks because we don't allow
 
185
        # '\r' in commit messages. (Mostly because of issues where XML style
 
186
        # formats arbitrarily strip it out of the data while parsing.)
 
187
        # To make life easier for users, we just always translate '\r\n' =>
 
188
        # '\n'. And '\r' => '\n'.
 
189
        a_tree = self.make_branch_and_tree('a')
 
190
        self.build_tree(['a/b'])
 
191
        a_tree.add('b')
 
192
        self.run_bzr(['commit',
 
193
                      '-m', 'a string\r\n\r\nwith mixed\r\rendings\n'],
 
194
                     working_dir='a')
 
195
        rev_id = a_tree.branch.last_revision()
 
196
        rev = a_tree.branch.repository.get_revision(rev_id)
 
197
        self.assertEqualDiff('a string\n\nwith mixed\n\nendings\n',
 
198
                             rev.message)
141
199
 
142
200
    def test_commit_merge_reports_all_modified_files(self):
143
201
        # the commit command should show all the files that are shown by
176
234
            other_tree.rename_one('dirtorename', 'renameddir')
177
235
            other_tree.rename_one('dirtoreparent', 'renameddir/reparenteddir')
178
236
            other_tree.rename_one('filetorename', 'renamedfile')
179
 
            other_tree.rename_one('filetoreparent', 'renameddir/reparentedfile')
 
237
            other_tree.rename_one('filetoreparent',
 
238
                                  'renameddir/reparentedfile')
180
239
            other_tree.remove(['dirtoremove', 'filetoremove'])
181
240
            self.build_tree_contents([
182
 
                ('other/newdir/', ),
 
241
                ('other/newdir/',),
183
242
                ('other/filetomodify', 'new content'),
184
243
                ('other/newfile', 'new file content')])
185
244
            other_tree.add('newfile')
189
248
            other_tree.unlock()
190
249
        this_tree.merge_from_branch(other_tree.branch)
191
250
        os.chdir('this')
192
 
        out,err = self.run_bzr("commit", "-m", "added")
193
 
        os.chdir('..')
 
251
        out,err = self.run_bzr('commit -m added')
194
252
        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)
 
253
        self.assertEqual(set([
 
254
            'Committing to: %s/' % osutils.getcwd(),
 
255
            'modified filetomodify',
 
256
            'added newdir',
 
257
            'added newfile',
 
258
            'renamed dirtorename => renameddir',
 
259
            'renamed filetorename => renamedfile',
 
260
            'renamed dirtoreparent => renameddir/reparenteddir',
 
261
            'renamed filetoreparent => renameddir/reparentedfile',
 
262
            'deleted dirtoremove',
 
263
            'deleted filetoremove',
 
264
            'Committed revision 2.',
 
265
            ''
 
266
            ]), set(err.split('\n')))
207
267
 
208
268
    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)
 
269
        tree = self.make_branch_and_tree('.')
 
270
        self.build_tree_contents([('foo.c', 'int main() {}')])
 
271
        tree.add('foo.c')
 
272
        self.run_bzr('commit -m ""', retcode=3)
 
273
 
 
274
    def test_unsupported_encoding_commit_message(self):
 
275
        if sys.platform == 'win32':
 
276
            raise tests.TestNotApplicable('Win32 parses arguments directly'
 
277
                ' as Unicode, so we can\'t pass invalid non-ascii')
 
278
        tree = self.make_branch_and_tree('.')
 
279
        self.build_tree_contents([('foo.c', 'int main() {}')])
 
280
        tree.add('foo.c')
 
281
        # LANG env variable has no effect on Windows
 
282
        # but some characters anyway cannot be represented
 
283
        # in default user encoding
 
284
        char = probe_bad_non_ascii(osutils.get_user_encoding())
 
285
        if char is None:
 
286
            raise TestSkipped('Cannot find suitable non-ascii character'
 
287
                'for user_encoding (%s)' % osutils.get_user_encoding())
 
288
        out,err = self.run_bzr_subprocess('commit -m "%s"' % char,
 
289
                                          retcode=1,
 
290
                                          env_changes={'LANG': 'C'})
 
291
        self.assertContainsRe(err, r'bzrlib.errors.BzrError: Parameter.*is '
 
292
                                    'unsupported by the current encoding.')
213
293
 
214
294
    def test_other_branch_commit(self):
215
295
        # this branch is to ensure consistent behaviour, whether we're run
216
296
        # 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'])
 
297
        outer_tree = self.make_branch_and_tree('.')
 
298
        inner_tree = self.make_branch_and_tree('branch')
 
299
        self.build_tree_contents([
 
300
            ('branch/foo.c', 'int main() {}'),
 
301
            ('branch/bar.c', 'int main() {}')])
 
302
        inner_tree.add(['foo.c', 'bar.c'])
228
303
        # 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)
 
304
        self.run_bzr('commit -m newstuff branch/foo.c .', retcode=3)
 
305
        # can commit to branch - records foo.c only
 
306
        self.run_bzr('commit -m newstuff branch/foo.c')
 
307
        # can commit to branch - records bar.c
 
308
        self.run_bzr('commit -m newstuff branch')
 
309
        # No changes left
 
310
        self.run_bzr_error(["No changes to commit"], 'commit -m newstuff branch')
233
311
 
234
312
    def test_out_of_date_tree_commit(self):
235
313
        # check we get an error code and a clear message committing with an out
236
314
        # of date checkout
237
 
        self.make_branch_and_tree('branch')
 
315
        tree = self.make_branch_and_tree('branch')
238
316
        # make a checkout
239
 
        self.runbzr('checkout --lightweight branch checkout')
 
317
        checkout = tree.branch.create_checkout('checkout', lightweight=True)
240
318
        # commit to the original branch to make the checkout out of date
241
 
        self.runbzr('commit --unchanged -m message branch')
 
319
        tree.commit('message branch', allow_pointless=True)
242
320
        # now commit to the checkout should emit
243
321
        # ERROR: Out of date with the branch, 'bzr update' is suggested
244
 
        output = self.runbzr('commit --unchanged -m checkout_message '
 
322
        output = self.run_bzr('commit --unchanged -m checkout_message '
245
323
                             'checkout', retcode=3)
246
324
        self.assertEqual(output,
247
325
                         ('',
248
 
                          "bzr: ERROR: Working tree is out of date, please run "
249
 
                          "'bzr update'.\n"))
 
326
                          "bzr: ERROR: Working tree is out of date, please "
 
327
                          "run 'bzr update'.\n"))
250
328
 
251
329
    def test_local_commit_unbound(self):
252
330
        # a --local commit on an unbound branch is an error
253
331
        self.make_branch_and_tree('.')
254
 
        out, err = self.run_bzr('commit', '--local', retcode=3)
 
332
        out, err = self.run_bzr('commit --local', retcode=3)
255
333
        self.assertEqualDiff('', out)
256
334
        self.assertEqualDiff('bzr: ERROR: Cannot perform local-only commits '
257
335
                             'on unbound branches.\n', err)
259
337
    def test_commit_a_text_merge_in_a_checkout(self):
260
338
        # checkouts perform multiple actions in a transaction across bond
261
339
        # 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 
 
340
        # past. This is a user story reported to fail in bug #43959 where
263
341
        # a merge done in a checkout (using the update command) failed to
264
342
        # commit correctly.
265
 
        self.run_bzr('init', 'trunk')
266
 
 
267
 
        self.run_bzr('checkout', 'trunk', 'u1')
268
 
        self.build_tree_contents([('u1/hosts', 'initial contents')])
269
 
        self.run_bzr('add', 'u1/hosts')
270
 
        self.run_bzr('commit', '-m', 'add hosts', 'u1')
271
 
 
272
 
        self.run_bzr('checkout', 'trunk', 'u2')
273
 
        self.build_tree_contents([('u2/hosts', 'altered in u2')])
274
 
        self.run_bzr('commit', '-m', 'checkin from u2', 'u2')
 
343
        trunk = self.make_branch_and_tree('trunk')
 
344
 
 
345
        u1 = trunk.branch.create_checkout('u1')
 
346
        self.build_tree_contents([('u1/hosts', 'initial contents\n')])
 
347
        u1.add('hosts')
 
348
        self.run_bzr('commit -m add-hosts u1')
 
349
 
 
350
        u2 = trunk.branch.create_checkout('u2')
 
351
        self.build_tree_contents([('u2/hosts', 'altered in u2\n')])
 
352
        self.run_bzr('commit -m checkin-from-u2 u2')
275
353
 
276
354
        # make an offline commits
277
 
        self.build_tree_contents([('u1/hosts', 'first offline change in u1')])
278
 
        self.run_bzr('commit', '-m', 'checkin offline', '--local', 'u1')
 
355
        self.build_tree_contents([('u1/hosts', 'first offline change in u1\n')])
 
356
        self.run_bzr('commit -m checkin-offline --local u1')
279
357
 
280
358
        # now try to pull in online work from u2, and then commit our offline
281
359
        # work as a merge
282
360
        # retcode 1 as we expect a text conflict
283
 
        self.run_bzr('update', 'u1', retcode=1)
284
 
        self.run_bzr('resolved', 'u1/hosts')
 
361
        self.run_bzr('update u1', retcode=1)
 
362
        self.assertFileEqual('''\
 
363
<<<<<<< TREE
 
364
first offline change in u1
 
365
=======
 
366
altered in u2
 
367
>>>>>>> MERGE-SOURCE
 
368
''',
 
369
                             'u1/hosts')
 
370
 
 
371
        self.run_bzr('resolved u1/hosts')
285
372
        # add a text change here to represent resolving the merge conflicts in
286
373
        # favour of a new version of the file not identical to either the u1
287
374
        # version or the u2 version.
288
375
        self.build_tree_contents([('u1/hosts', 'merge resolution\n')])
289
 
        self.run_bzr('commit', '-m', 'checkin merge of the offline work from u1', 'u1')
 
376
        self.run_bzr('commit -m checkin-merge-of-the-offline-work-from-u1 u1')
 
377
 
 
378
    def test_commit_exclude_excludes_modified_files(self):
 
379
        """Commit -x foo should ignore changes to foo."""
 
380
        tree = self.make_branch_and_tree('.')
 
381
        self.build_tree(['a', 'b', 'c'])
 
382
        tree.smart_add(['.'])
 
383
        out, err = self.run_bzr(['commit', '-m', 'test', '-x', 'b'])
 
384
        self.assertFalse('added b' in out)
 
385
        self.assertFalse('added b' in err)
 
386
        # If b was excluded it will still be 'added' in status.
 
387
        out, err = self.run_bzr(['added'])
 
388
        self.assertEqual('b\n', out)
 
389
        self.assertEqual('', err)
 
390
 
 
391
    def test_commit_exclude_twice_uses_both_rules(self):
 
392
        """Commit -x foo -x bar should ignore changes to foo and bar."""
 
393
        tree = self.make_branch_and_tree('.')
 
394
        self.build_tree(['a', 'b', 'c'])
 
395
        tree.smart_add(['.'])
 
396
        out, err = self.run_bzr(['commit', '-m', 'test', '-x', 'b', '-x', 'c'])
 
397
        self.assertFalse('added b' in out)
 
398
        self.assertFalse('added c' in out)
 
399
        self.assertFalse('added b' in err)
 
400
        self.assertFalse('added c' in err)
 
401
        # If b was excluded it will still be 'added' in status.
 
402
        out, err = self.run_bzr(['added'])
 
403
        self.assertTrue('b\n' in out)
 
404
        self.assertTrue('c\n' in out)
 
405
        self.assertEqual('', err)
290
406
 
291
407
    def test_commit_respects_spec_for_removals(self):
292
408
        """Commit with a file spec should only commit removals that match"""
296
412
        t.commit('Create')
297
413
        t.remove(['file-a', 'dir-a/file-b'])
298
414
        os.chdir('dir-a')
299
 
        result = self.run_bzr('commit', '.', '-m' 'removed file-b')[1]
 
415
        result = self.run_bzr('commit . -m removed-file-b')[1]
300
416
        self.assertNotContainsRe(result, 'file-a')
301
417
        result = self.run_bzr('status')[0]
302
418
        self.assertContainsRe(result, 'removed:\n  file-a')
 
419
 
 
420
    def test_strict_commit(self):
 
421
        """Commit with --strict works if everything is known"""
 
422
        ignores._set_user_ignores([])
 
423
        tree = self.make_branch_and_tree('tree')
 
424
        self.build_tree(['tree/a'])
 
425
        tree.add('a')
 
426
        # A simple change should just work
 
427
        self.run_bzr('commit --strict -m adding-a',
 
428
                     working_dir='tree')
 
429
 
 
430
    def test_strict_commit_no_changes(self):
 
431
        """commit --strict gives "no changes" if there is nothing to commit"""
 
432
        tree = self.make_branch_and_tree('tree')
 
433
        self.build_tree(['tree/a'])
 
434
        tree.add('a')
 
435
        tree.commit('adding a')
 
436
 
 
437
        # With no changes, it should just be 'no changes'
 
438
        # Make sure that commit is failing because there is nothing to do
 
439
        self.run_bzr_error(['No changes to commit'],
 
440
                           'commit --strict -m no-changes',
 
441
                           working_dir='tree')
 
442
 
 
443
        # But --strict doesn't care if you supply --unchanged
 
444
        self.run_bzr('commit --strict --unchanged -m no-changes',
 
445
                     working_dir='tree')
 
446
 
 
447
    def test_strict_commit_unknown(self):
 
448
        """commit --strict fails if a file is unknown"""
 
449
        tree = self.make_branch_and_tree('tree')
 
450
        self.build_tree(['tree/a'])
 
451
        tree.add('a')
 
452
        tree.commit('adding a')
 
453
 
 
454
        # Add one file so there is a change, but forget the other
 
455
        self.build_tree(['tree/b', 'tree/c'])
 
456
        tree.add('b')
 
457
        self.run_bzr_error(['Commit refused because there are unknown files'],
 
458
                           'commit --strict -m add-b',
 
459
                           working_dir='tree')
 
460
 
 
461
        # --no-strict overrides --strict
 
462
        self.run_bzr('commit --strict -m add-b --no-strict',
 
463
                     working_dir='tree')
 
464
 
 
465
    def test_fixes_bug_output(self):
 
466
        """commit --fixes=lp:23452 succeeds without output."""
 
467
        tree = self.make_branch_and_tree('tree')
 
468
        self.build_tree(['tree/hello.txt'])
 
469
        tree.add('hello.txt')
 
470
        output, err = self.run_bzr(
 
471
            'commit -m hello --fixes=lp:23452 tree/hello.txt')
 
472
        self.assertEqual('', output)
 
473
        self.assertContainsRe(err, 'Committing to: .*\n'
 
474
                              'added hello\.txt\n'
 
475
                              'Committed revision 1\.\n')
 
476
 
 
477
    def test_no_bugs_no_properties(self):
 
478
        """If no bugs are fixed, the bugs property is not set.
 
479
 
 
480
        see https://beta.launchpad.net/bzr/+bug/109613
 
481
        """
 
482
        tree = self.make_branch_and_tree('tree')
 
483
        self.build_tree(['tree/hello.txt'])
 
484
        tree.add('hello.txt')
 
485
        self.run_bzr( 'commit -m hello tree/hello.txt')
 
486
        # Get the revision properties, ignoring the branch-nick property, which
 
487
        # we don't care about for this test.
 
488
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
489
        properties = dict(last_rev.properties)
 
490
        del properties['branch-nick']
 
491
        self.assertFalse('bugs' in properties)
 
492
 
 
493
    def test_fixes_bug_sets_property(self):
 
494
        """commit --fixes=lp:234 sets the lp:234 revprop to 'fixed'."""
 
495
        tree = self.make_branch_and_tree('tree')
 
496
        self.build_tree(['tree/hello.txt'])
 
497
        tree.add('hello.txt')
 
498
        self.run_bzr('commit -m hello --fixes=lp:234 tree/hello.txt')
 
499
 
 
500
        # Get the revision properties, ignoring the branch-nick property, which
 
501
        # we don't care about for this test.
 
502
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
503
        properties = dict(last_rev.properties)
 
504
        del properties['branch-nick']
 
505
 
 
506
        self.assertEqual({'bugs': 'https://launchpad.net/bugs/234 fixed'},
 
507
                         properties)
 
508
 
 
509
    def test_fixes_multiple_bugs_sets_properties(self):
 
510
        """--fixes can be used more than once to show that bugs are fixed."""
 
511
        tree = self.make_branch_and_tree('tree')
 
512
        self.build_tree(['tree/hello.txt'])
 
513
        tree.add('hello.txt')
 
514
        self.run_bzr('commit -m hello --fixes=lp:123 --fixes=lp:235'
 
515
                     ' tree/hello.txt')
 
516
 
 
517
        # Get the revision properties, ignoring the branch-nick property, which
 
518
        # we don't care about for this test.
 
519
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
520
        properties = dict(last_rev.properties)
 
521
        del properties['branch-nick']
 
522
 
 
523
        self.assertEqual(
 
524
            {'bugs': 'https://launchpad.net/bugs/123 fixed\n'
 
525
                     'https://launchpad.net/bugs/235 fixed'},
 
526
            properties)
 
527
 
 
528
    def test_fixes_bug_with_alternate_trackers(self):
 
529
        """--fixes can be used on a properly configured branch to mark bug
 
530
        fixes on multiple trackers.
 
531
        """
 
532
        tree = self.make_branch_and_tree('tree')
 
533
        tree.branch.get_config().set_user_option(
 
534
            'trac_twisted_url', 'http://twistedmatrix.com/trac')
 
535
        self.build_tree(['tree/hello.txt'])
 
536
        tree.add('hello.txt')
 
537
        self.run_bzr('commit -m hello --fixes=lp:123 --fixes=twisted:235 tree/')
 
538
 
 
539
        # Get the revision properties, ignoring the branch-nick property, which
 
540
        # we don't care about for this test.
 
541
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
542
        properties = dict(last_rev.properties)
 
543
        del properties['branch-nick']
 
544
 
 
545
        self.assertEqual(
 
546
            {'bugs': 'https://launchpad.net/bugs/123 fixed\n'
 
547
                     'http://twistedmatrix.com/trac/ticket/235 fixed'},
 
548
            properties)
 
549
 
 
550
    def test_fixes_unknown_bug_prefix(self):
 
551
        tree = self.make_branch_and_tree('tree')
 
552
        self.build_tree(['tree/hello.txt'])
 
553
        tree.add('hello.txt')
 
554
        self.run_bzr_error(
 
555
            ["Unrecognized bug %s. Commit refused." % 'xxx:123'],
 
556
            'commit -m add-b --fixes=xxx:123',
 
557
            working_dir='tree')
 
558
 
 
559
    def test_fixes_invalid_bug_number(self):
 
560
        tree = self.make_branch_and_tree('tree')
 
561
        self.build_tree(['tree/hello.txt'])
 
562
        tree.add('hello.txt')
 
563
        self.run_bzr_error(
 
564
            ["Did not understand bug identifier orange: Must be an integer. "
 
565
             "See \"bzr help bugs\" for more information on this feature.\n"
 
566
             "Commit refused."],
 
567
            'commit -m add-b --fixes=lp:orange',
 
568
            working_dir='tree')
 
569
 
 
570
    def test_fixes_invalid_argument(self):
 
571
        """Raise an appropriate error when the fixes argument isn't tag:id."""
 
572
        tree = self.make_branch_and_tree('tree')
 
573
        self.build_tree(['tree/hello.txt'])
 
574
        tree.add('hello.txt')
 
575
        self.run_bzr_error(
 
576
            [r"Invalid bug orange. Must be in the form of 'tracker:id'\. "
 
577
             r"See \"bzr help bugs\" for more information on this feature.\n"
 
578
             r"Commit refused\."],
 
579
            'commit -m add-b --fixes=orange',
 
580
            working_dir='tree')
 
581
 
 
582
    def test_no_author(self):
 
583
        """If the author is not specified, the author property is not set."""
 
584
        tree = self.make_branch_and_tree('tree')
 
585
        self.build_tree(['tree/hello.txt'])
 
586
        tree.add('hello.txt')
 
587
        self.run_bzr( 'commit -m hello tree/hello.txt')
 
588
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
589
        properties = last_rev.properties
 
590
        self.assertFalse('author' in properties)
 
591
 
 
592
    def test_author_sets_property(self):
 
593
        """commit --author='John Doe <jdoe@example.com>' sets the author
 
594
           revprop.
 
595
        """
 
596
        tree = self.make_branch_and_tree('tree')
 
597
        self.build_tree(['tree/hello.txt'])
 
598
        tree.add('hello.txt')
 
599
        self.run_bzr(["commit", '-m', 'hello',
 
600
                      '--author', u'John D\xf6 <jdoe@example.com>',
 
601
                     "tree/hello.txt"])
 
602
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
603
        properties = last_rev.properties
 
604
        self.assertEqual(u'John D\xf6 <jdoe@example.com>', properties['authors'])
 
605
 
 
606
    def test_author_no_email(self):
 
607
        """Author's name without an email address is allowed, too."""
 
608
        tree = self.make_branch_and_tree('tree')
 
609
        self.build_tree(['tree/hello.txt'])
 
610
        tree.add('hello.txt')
 
611
        out, err = self.run_bzr("commit -m hello --author='John Doe' "
 
612
                                "tree/hello.txt")
 
613
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
614
        properties = last_rev.properties
 
615
        self.assertEqual('John Doe', properties['authors'])
 
616
 
 
617
    def test_multiple_authors(self):
 
618
        """Multiple authors can be specyfied, and all are stored."""
 
619
        tree = self.make_branch_and_tree('tree')
 
620
        self.build_tree(['tree/hello.txt'])
 
621
        tree.add('hello.txt')
 
622
        out, err = self.run_bzr("commit -m hello --author='John Doe' "
 
623
                                "--author='Jane Rey' tree/hello.txt")
 
624
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
625
        properties = last_rev.properties
 
626
        self.assertEqual('John Doe\nJane Rey', properties['authors'])
 
627
 
 
628
    def test_commit_time(self):
 
629
        tree = self.make_branch_and_tree('tree')
 
630
        self.build_tree(['tree/hello.txt'])
 
631
        tree.add('hello.txt')
 
632
        out, err = self.run_bzr("commit -m hello "
 
633
            "--commit-time='2009-10-10 08:00:00 +0100' tree/hello.txt")
 
634
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
635
        self.assertEqual(
 
636
            'Sat 2009-10-10 08:00:00 +0100',
 
637
            osutils.format_date(last_rev.timestamp, last_rev.timezone))
 
638
        
 
639
    def test_commit_time_bad_time(self):
 
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 -m hello "
 
644
            "--commit-time='NOT A TIME' tree/hello.txt", retcode=3)
 
645
        self.assertStartsWith(
 
646
            err, "bzr: ERROR: Could not parse --commit-time:")
 
647
 
 
648
    def test_partial_commit_with_renames_in_tree(self):
 
649
        # this test illustrates bug #140419
 
650
        t = self.make_branch_and_tree('.')
 
651
        self.build_tree(['dir/', 'dir/a', 'test'])
 
652
        t.add(['dir/', 'dir/a', 'test'])
 
653
        t.commit('initial commit')
 
654
        # important part: file dir/a should change parent
 
655
        # and should appear before old parent
 
656
        # then during partial commit we have error
 
657
        # parent_id {dir-XXX} not in inventory
 
658
        t.rename_one('dir/a', 'a')
 
659
        self.build_tree_contents([('test', 'changes in test')])
 
660
        # partial commit
 
661
        out, err = self.run_bzr('commit test -m "partial commit"')
 
662
        self.assertEquals('', out)
 
663
        self.assertContainsRe(err, r'modified test\nCommitted revision 2.')
 
664
 
 
665
    def test_commit_readonly_checkout(self):
 
666
        # https://bugs.edge.launchpad.net/bzr/+bug/129701
 
667
        # "UnlockableTransport error trying to commit in checkout of readonly
 
668
        # branch"
 
669
        self.make_branch('master')
 
670
        master = BzrDir.open_from_transport(
 
671
            self.get_readonly_transport('master')).open_branch()
 
672
        master.create_checkout('checkout')
 
673
        out, err = self.run_bzr(['commit', '--unchanged', '-mfoo', 'checkout'],
 
674
            retcode=3)
 
675
        self.assertContainsRe(err,
 
676
            r'^bzr: ERROR: Cannot lock.*readonly transport')
 
677
 
 
678
    def setup_editor(self):
 
679
        # Test that commit template hooks work
 
680
        if sys.platform == "win32":
 
681
            f = file('fed.bat', 'w')
 
682
            f.write('@rem dummy fed')
 
683
            f.close()
 
684
            osutils.set_or_unset_env('BZR_EDITOR', "fed.bat")
 
685
        else:
 
686
            f = file('fed.sh', 'wb')
 
687
            f.write('#!/bin/sh\n')
 
688
            f.close()
 
689
            os.chmod('fed.sh', 0755)
 
690
            osutils.set_or_unset_env('BZR_EDITOR', "./fed.sh")
 
691
 
 
692
    def setup_commit_with_template(self):
 
693
        self.setup_editor()
 
694
        msgeditor.hooks.install_named_hook("commit_message_template",
 
695
                lambda commit_obj, msg: "save me some typing\n", None)
 
696
        tree = self.make_branch_and_tree('tree')
 
697
        self.build_tree(['tree/hello.txt'])
 
698
        tree.add('hello.txt')
 
699
        return tree
 
700
 
 
701
    def test_commit_hook_template_accepted(self):
 
702
        tree = self.setup_commit_with_template()
 
703
        out, err = self.run_bzr("commit tree/hello.txt", stdin="y\n")
 
704
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
705
        self.assertEqual('save me some typing\n', last_rev.message)
 
706
 
 
707
    def test_commit_hook_template_rejected(self):
 
708
        tree = self.setup_commit_with_template()
 
709
        expected = tree.last_revision()
 
710
        out, err = self.run_bzr_error(["empty commit message"],
 
711
            "commit tree/hello.txt", stdin="n\n")
 
712
        self.assertEqual(expected, tree.last_revision())