~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

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

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2011-05-04 12:10:51 UTC
  • mfrom: (5819.1.4 777007-developer-doc)
  • Revision ID: pqm@pqm.ubuntu.com-20110504121051-aovlsmqiivjmc4fc
(jelmer) Small fixes to developer documentation. (Jonathan Riddell)

Show diffs side-by-side

added added

removed removed

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