~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

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

  • Committer: v.ladeuil+lp at free
  • Date: 2006-11-08 07:44:30 UTC
  • mfrom: (2123 +trunk)
  • mto: (2145.1.1 keepalive)
  • mto: This revision was merged to the branch mainline in revision 2146.
  • Revision ID: v.ladeuil+lp@free.fr-20061108074430-a9c08d4a475bd97f
Merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2006-2010 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
 
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')
 
38
        out,err = self.run_bzr("commit", "-m", "empty", retcode=3)
 
39
        self.assertEqual('', out)
 
40
        self.assertStartsWith(err, 'bzr: ERROR: no changes to commit.'
 
41
                                  ' use --unchanged to commit anyhow\n')
 
42
 
 
43
    def test_save_commit_message(self):
 
44
        """Failed commit should save the message in a file"""
 
45
        self.run_bzr("init")
 
46
        out,err = self.run_bzr("commit", "-m", "message", retcode=3)
 
47
        self.assertEqual('', out)
 
48
        self.assertStartsWith(err, 'bzr: ERROR: no changes to commit.'
 
49
                                  ' use --unchanged to commit anyhow\n'
 
50
                                  'Commit message saved. To reuse the message,'
 
51
                                  ' do\nbzr commit --file ')
 
52
        message_file = re.compile('bzr-commit-\S*').search(err).group()
 
53
        self.check_file_contents(message_file, 'message')
49
54
 
50
55
    def test_commit_success(self):
51
56
        """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])
 
57
        self.run_bzr("init")
 
58
        self.run_bzr("commit", "--unchanged", "-m", "message")
 
59
        self.assertEqual('', self.capture('unknowns'))
55
60
 
56
61
        # same for unicode messages
57
 
        self.run_bzr(["commit", "--unchanged", "-m", u'foo\xb5'])
58
 
        self.assertEqual('', self.run_bzr('unknowns')[0])
 
62
        self.run_bzr("commit", "--unchanged", "-m", u'foo\xb5')
 
63
        self.assertEqual('', self.capture('unknowns'))
59
64
 
60
65
    def test_commit_with_path(self):
61
66
        """Commit tree with path of root specified"""
62
 
        a_tree = self.make_branch_and_tree('a')
 
67
        self.run_bzr('init', 'a')
63
68
        self.build_tree(['a/a_file'])
64
 
        a_tree.add('a_file')
65
 
        self.run_bzr(['commit', '-m', 'first commit', 'a'])
 
69
        self.run_bzr('add', 'a/a_file')
 
70
        self.run_bzr('commit', '-m', 'first commit', 'a')
66
71
 
67
 
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
 
72
        self.run_bzr('branch', 'a', 'b')
68
73
        self.build_tree_contents([('b/a_file', 'changes in b')])
69
 
        self.run_bzr(['commit', '-m', 'first commit in b', 'b'])
 
74
        self.run_bzr('commit', '-m', 'first commit in b', 'b')
70
75
 
71
76
        self.build_tree_contents([('a/a_file', 'new contents')])
72
 
        self.run_bzr(['commit', '-m', 'change in a', 'a'])
 
77
        self.run_bzr('commit', '-m', 'change in a', 'a')
73
78
 
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'])
 
79
        os.chdir('b')
 
80
        self.run_bzr('merge', '../a', retcode=1) # will conflict
 
81
        os.chdir('..')
 
82
        self.run_bzr('resolved', 'b/a_file')
 
83
        self.run_bzr('commit', '-m', 'merge into b', 'b')
78
84
 
79
85
 
80
86
    def test_10_verbose_commit(self):
81
87
        """Add one file and examine verbose commit output"""
82
 
        tree = self.make_branch_and_tree('.')
 
88
        self.runbzr("init")
83
89
        self.build_tree(['hello.txt'])
84
 
        tree.add("hello.txt")
85
 
        out,err = self.run_bzr('commit -m added')
 
90
        self.runbzr("add hello.txt")
 
91
        out,err = self.run_bzr("commit", "-m", "added")
86
92
        self.assertEqual('', out)
87
 
        self.assertContainsRe(err, '^Committing to: .*\n'
88
 
                              'added hello.txt\n'
89
 
                              'Committed revision 1.\n$',)
 
93
        self.assertEqual('added hello.txt\n'
 
94
                         'Committed revision 1.\n',
 
95
                         err)
90
96
 
91
97
    def prepare_simple_history(self):
92
98
        """Prepare and return a working tree with one commit of one file"""
101
107
        # Verbose commit of modified file should say so
102
108
        wt = self.prepare_simple_history()
103
109
        self.build_tree_contents([('hello.txt', 'new contents')])
104
 
        out, err = self.run_bzr('commit -m modified')
 
110
        out, err = self.run_bzr("commit", "-m", "modified")
105
111
        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")
 
112
        self.assertEqual('modified hello.txt\n'
 
113
                         'Committed revision 2.\n',
 
114
                         err)
117
115
 
118
116
    def test_verbose_commit_renamed(self):
119
117
        # Verbose commit of renamed file should say so
120
118
        wt = self.prepare_simple_history()
121
119
        wt.rename_one('hello.txt', 'gutentag.txt')
122
 
        out, err = self.run_bzr('commit -m renamed')
 
120
        out, err = self.run_bzr("commit", "-m", "renamed")
123
121
        self.assertEqual('', out)
124
 
        self.assertContainsRe(err, '^Committing to: .*\n'
125
 
                              'renamed hello\.txt => gutentag\.txt\n'
126
 
                              'Committed revision 2\.$\n')
 
122
        self.assertEqual('renamed hello.txt => gutentag.txt\n'
 
123
                         'Committed revision 2.\n',
 
124
                         err)
127
125
 
128
126
    def test_verbose_commit_moved(self):
129
127
        # Verbose commit of file moved to new directory should say so
131
129
        os.mkdir('subdir')
132
130
        wt.add(['subdir'])
133
131
        wt.rename_one('hello.txt', 'subdir/hello.txt')
134
 
        out, err = self.run_bzr('commit -m renamed')
 
132
        out, err = self.run_bzr("commit", "-m", "renamed")
135
133
        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')))
 
134
        self.assertEqualDiff('added subdir\n'
 
135
                             'renamed hello.txt => subdir/hello.txt\n'
 
136
                             'Committed revision 2.\n',
 
137
                             err)
143
138
 
144
139
    def test_verbose_commit_with_unknown(self):
145
140
        """Unknown files should not be listed by default in verbose output"""
147
142
        wt = BzrDir.create_standalone_workingtree('.')
148
143
        self.build_tree(['hello.txt', 'extra.txt'])
149
144
        wt.add(['hello.txt'])
150
 
        out,err = self.run_bzr('commit -m added')
 
145
        out,err = self.run_bzr("commit", "-m", "added")
151
146
        self.assertEqual('', out)
152
 
        self.assertContainsRe(err, '^Committing to: .*\n'
153
 
                              'added hello\.txt\n'
154
 
                              'Committed revision 1\.\n$')
 
147
        self.assertEqual('added hello.txt\n'
 
148
                         'Committed revision 1.\n',
 
149
                         err)
155
150
 
156
151
    def test_verbose_commit_with_unchanged(self):
157
152
        """Unchanged files should not be listed by default in verbose output"""
158
 
        tree = self.make_branch_and_tree('.')
 
153
        self.runbzr("init")
159
154
        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')
 
155
        self.runbzr('add unchanged.txt')
 
156
        self.runbzr('commit -m unchanged unchanged.txt')
 
157
        self.runbzr("add hello.txt")
 
158
        out,err = self.run_bzr("commit", "-m", "added")
164
159
        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)
 
160
        self.assertEqual('added hello.txt\n'
 
161
                         'Committed revision 2.\n',
 
162
                         err)
199
163
 
200
164
    def test_commit_merge_reports_all_modified_files(self):
201
165
        # the commit command should show all the files that are shown by
234
198
            other_tree.rename_one('dirtorename', 'renameddir')
235
199
            other_tree.rename_one('dirtoreparent', 'renameddir/reparenteddir')
236
200
            other_tree.rename_one('filetorename', 'renamedfile')
237
 
            other_tree.rename_one('filetoreparent',
238
 
                                  'renameddir/reparentedfile')
 
201
            other_tree.rename_one('filetoreparent', 'renameddir/reparentedfile')
239
202
            other_tree.remove(['dirtoremove', 'filetoremove'])
240
203
            self.build_tree_contents([
241
 
                ('other/newdir/',),
 
204
                ('other/newdir/', ),
242
205
                ('other/filetomodify', 'new content'),
243
206
                ('other/newfile', 'new file content')])
244
207
            other_tree.add('newfile')
248
211
            other_tree.unlock()
249
212
        this_tree.merge_from_branch(other_tree.branch)
250
213
        os.chdir('this')
251
 
        out,err = self.run_bzr('commit -m added')
 
214
        out,err = self.run_bzr("commit", "-m", "added")
 
215
        os.chdir('..')
252
216
        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')))
 
217
        self.assertEqualDiff(
 
218
            'modified filetomodify\n'
 
219
            'added newdir\n'
 
220
            'added newfile\n'
 
221
            'renamed dirtorename => renameddir\n'
 
222
            'renamed dirtoreparent => renameddir/reparenteddir\n'
 
223
            'renamed filetoreparent => renameddir/reparentedfile\n'
 
224
            'renamed filetorename => renamedfile\n'
 
225
            'deleted dirtoremove\n'
 
226
            'deleted filetoremove\n'
 
227
            'Committed revision 2.\n',
 
228
            err)
267
229
 
268
230
    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.')
 
231
        self.runbzr("init")
 
232
        file('foo.c', 'wt').write('int main() {}')
 
233
        self.runbzr(['add', 'foo.c'])
 
234
        self.runbzr(["commit", "-m", ""] , retcode=3)
293
235
 
294
236
    def test_other_branch_commit(self):
295
237
        # this branch is to ensure consistent behaviour, whether we're run
296
238
        # 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'])
 
239
        os.mkdir('empty_branch')
 
240
        os.chdir('empty_branch')
 
241
        self.runbzr('init')
 
242
        os.mkdir('branch')
 
243
        os.chdir('branch')
 
244
        self.runbzr('init')
 
245
        file('foo.c', 'wt').write('int main() {}')
 
246
        file('bar.c', 'wt').write('int main() {}')
 
247
        os.chdir('..')
 
248
        self.runbzr(['add', 'branch/foo.c'])
 
249
        self.runbzr(['add', 'branch'])
303
250
        # 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')
 
251
        self.runbzr('commit -m newstuff branch/foo.c .', retcode=3)
 
252
        self.runbzr('commit -m newstuff branch/foo.c')
 
253
        self.runbzr('commit -m newstuff branch')
 
254
        self.runbzr('commit -m newstuff branch', retcode=3)
311
255
 
312
256
    def test_out_of_date_tree_commit(self):
313
257
        # check we get an error code and a clear message committing with an out
314
258
        # of date checkout
315
 
        tree = self.make_branch_and_tree('branch')
 
259
        self.make_branch_and_tree('branch')
316
260
        # make a checkout
317
 
        checkout = tree.branch.create_checkout('checkout', lightweight=True)
 
261
        self.runbzr('checkout --lightweight branch checkout')
318
262
        # commit to the original branch to make the checkout out of date
319
 
        tree.commit('message branch', allow_pointless=True)
 
263
        self.runbzr('commit --unchanged -m message branch')
320
264
        # now commit to the checkout should emit
321
265
        # ERROR: Out of date with the branch, 'bzr update' is suggested
322
 
        output = self.run_bzr('commit --unchanged -m checkout_message '
 
266
        output = self.runbzr('commit --unchanged -m checkout_message '
323
267
                             'checkout', retcode=3)
324
268
        self.assertEqual(output,
325
269
                         ('',
326
 
                          "bzr: ERROR: Working tree is out of date, please "
327
 
                          "run 'bzr update'.\n"))
 
270
                          "bzr: ERROR: Working tree is out of date, please run "
 
271
                          "'bzr update'.\n"))
328
272
 
329
273
    def test_local_commit_unbound(self):
330
274
        # a --local commit on an unbound branch is an error
331
275
        self.make_branch_and_tree('.')
332
 
        out, err = self.run_bzr('commit --local', retcode=3)
 
276
        out, err = self.run_bzr('commit', '--local', retcode=3)
333
277
        self.assertEqualDiff('', out)
334
278
        self.assertEqualDiff('bzr: ERROR: Cannot perform local-only commits '
335
279
                             'on unbound branches.\n', err)
337
281
    def test_commit_a_text_merge_in_a_checkout(self):
338
282
        # checkouts perform multiple actions in a transaction across bond
339
283
        # 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
 
284
        # past. This is a user story reported to fail in bug #43959 where 
341
285
        # a merge done in a checkout (using the update command) failed to
342
286
        # commit correctly.
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')
 
287
        self.run_bzr('init', 'trunk')
 
288
 
 
289
        self.run_bzr('checkout', 'trunk', 'u1')
 
290
        self.build_tree_contents([('u1/hosts', 'initial contents')])
 
291
        self.run_bzr('add', 'u1/hosts')
 
292
        self.run_bzr('commit', '-m', 'add hosts', 'u1')
 
293
 
 
294
        self.run_bzr('checkout', 'trunk', 'u2')
 
295
        self.build_tree_contents([('u2/hosts', 'altered in u2')])
 
296
        self.run_bzr('commit', '-m', 'checkin from u2', 'u2')
353
297
 
354
298
        # make an offline commits
355
 
        self.build_tree_contents([('u1/hosts', 'first offline change in u1\n')])
356
 
        self.run_bzr('commit -m checkin-offline --local u1')
 
299
        self.build_tree_contents([('u1/hosts', 'first offline change in u1')])
 
300
        self.run_bzr('commit', '-m', 'checkin offline', '--local', 'u1')
357
301
 
358
302
        # now try to pull in online work from u2, and then commit our offline
359
303
        # work as a merge
360
304
        # retcode 1 as we expect a text conflict
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')
 
305
        self.run_bzr('update', 'u1', retcode=1)
 
306
        self.run_bzr('resolved', 'u1/hosts')
372
307
        # add a text change here to represent resolving the merge conflicts in
373
308
        # favour of a new version of the file not identical to either the u1
374
309
        # version or the u2 version.
375
310
        self.build_tree_contents([('u1/hosts', 'merge resolution\n')])
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)
 
311
        self.run_bzr('commit', '-m', 'checkin merge of the offline work from u1', 'u1')
406
312
 
407
313
    def test_commit_respects_spec_for_removals(self):
408
314
        """Commit with a file spec should only commit removals that match"""
412
318
        t.commit('Create')
413
319
        t.remove(['file-a', 'dir-a/file-b'])
414
320
        os.chdir('dir-a')
415
 
        result = self.run_bzr('commit . -m removed-file-b')[1]
 
321
        result = self.run_bzr('commit', '.', '-m' 'removed file-b')[1]
416
322
        self.assertNotContainsRe(result, 'file-a')
417
323
        result = self.run_bzr('status')[0]
418
324
        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())