← 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: Robert Collins
  • Date: 2006-07-20 13:00:31 UTC
  • mto: (1852.9.1 Tree.compare().)
  • mto: This revision was merged to the branch mainline in revision 1890.
  • Revision ID: robertc@robertcollins.net-20060720130031-d26103a427ea10f3
Start tree implementation tests.

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