~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

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

  • Committer: Martin Packman
  • Date: 2011-12-13 17:10:47 UTC
  • mto: This revision was merged to the branch mainline in revision 6367.
  • Revision ID: martin.packman@canonical.com-20111213171047-esvi1kyfbuehmhrm
Minor tweaks including normalising _fs_enc value

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