~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

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

  • Committer: Jelmer Vernooij
  • Date: 2011-08-19 22:34:02 UTC
  • mto: This revision was merged to the branch mainline in revision 6089.
  • Revision ID: jelmer@samba.org-20110819223402-wjywqb0fa1xxx522
Use get_transport_from_{url,path} in more places.

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_warn_about_forgotten_commit_message(self):
 
171
        """Test that the lack of -m parameter is caught"""
 
172
        wt = self.make_branch_and_tree('.')
 
173
        self.build_tree(['one', 'two'])
 
174
        wt.add(['two'])
 
175
        out, err = self.run_bzr('commit -m one two')
 
176
        self.assertContainsRe(err, "The commit message is a file name")
106
177
 
107
178
    def test_verbose_commit_renamed(self):
108
179
        # Verbose commit of renamed file should say so
109
180
        wt = self.prepare_simple_history()
110
181
        wt.rename_one('hello.txt', 'gutentag.txt')
111
 
        out, err = self.run_bzr("commit", "-m", "renamed")
 
182
        out, err = self.run_bzr('commit -m renamed')
112
183
        self.assertEqual('', out)
113
 
        self.assertEqual('renamed hello.txt => gutentag.txt\n'
114
 
                         'Committed revision 2.\n',
115
 
                         err)
 
184
        self.assertContainsRe(err, '^Committing to: .*\n'
 
185
                              'renamed hello\.txt => gutentag\.txt\n'
 
186
                              'Committed revision 2\.$\n')
116
187
 
117
188
    def test_verbose_commit_moved(self):
118
189
        # Verbose commit of file moved to new directory should say so
120
191
        os.mkdir('subdir')
121
192
        wt.add(['subdir'])
122
193
        wt.rename_one('hello.txt', 'subdir/hello.txt')
123
 
        out, err = self.run_bzr("commit", "-m", "renamed")
 
194
        out, err = self.run_bzr('commit -m renamed')
124
195
        self.assertEqual('', out)
125
 
        self.assertEqualDiff('added subdir\n'
126
 
                             'renamed hello.txt => subdir/hello.txt\n'
127
 
                             'Committed revision 2.\n',
128
 
                             err)
 
196
        self.assertEqual(set([
 
197
            'Committing to: %s/' % osutils.getcwd(),
 
198
            'added subdir',
 
199
            'renamed hello.txt => subdir/hello.txt',
 
200
            'Committed revision 2.',
 
201
            '',
 
202
            ]), set(err.split('\n')))
129
203
 
130
204
    def test_verbose_commit_with_unknown(self):
131
205
        """Unknown files should not be listed by default in verbose output"""
133
207
        wt = BzrDir.create_standalone_workingtree('.')
134
208
        self.build_tree(['hello.txt', 'extra.txt'])
135
209
        wt.add(['hello.txt'])
136
 
        out,err = self.run_bzr("commit", "-m", "added")
 
210
        out,err = self.run_bzr('commit -m added')
137
211
        self.assertEqual('', out)
138
 
        self.assertEqual('added hello.txt\n'
139
 
                         'Committed revision 1.\n',
140
 
                         err)
 
212
        self.assertContainsRe(err, '^Committing to: .*\n'
 
213
                              'added hello\.txt\n'
 
214
                              'Committed revision 1\.\n$')
141
215
 
142
216
    def test_verbose_commit_with_unchanged(self):
143
217
        """Unchanged files should not be listed by default in verbose output"""
144
 
        self.runbzr("init")
 
218
        tree = self.make_branch_and_tree('.')
145
219
        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")
 
220
        tree.add('unchanged.txt')
 
221
        self.run_bzr('commit -m unchanged unchanged.txt')
 
222
        tree.add("hello.txt")
 
223
        out,err = self.run_bzr('commit -m added')
150
224
        self.assertEqual('', out)
151
 
        self.assertEqual('added hello.txt\n'
152
 
                         'Committed revision 2.\n',
153
 
                         err)
 
225
        self.assertContainsRe(err, '^Committing to: .*\n'
 
226
                              'added hello\.txt\n'
 
227
                              'Committed revision 2\.$\n')
 
228
 
 
229
    def test_verbose_commit_includes_master_location(self):
 
230
        """Location of master is displayed when committing to bound branch"""
 
231
        a_tree = self.make_branch_and_tree('a')
 
232
        self.build_tree(['a/b'])
 
233
        a_tree.add('b')
 
234
        a_tree.commit(message='Initial message')
 
235
 
 
236
        b_tree = a_tree.branch.create_checkout('b')
 
237
        expected = "%s/" % (osutils.abspath('a'), )
 
238
        out, err = self.run_bzr('commit -m blah --unchanged', working_dir='b')
 
239
        self.assertEqual(err, 'Committing to: %s\n'
 
240
                         'Committed revision 2.\n' % expected)
 
241
 
 
242
    def test_commit_sanitizes_CR_in_message(self):
 
243
        # See bug #433779, basically Emacs likes to pass '\r\n' style line
 
244
        # endings to 'bzr commit -m ""' which breaks because we don't allow
 
245
        # '\r' in commit messages. (Mostly because of issues where XML style
 
246
        # formats arbitrarily strip it out of the data while parsing.)
 
247
        # To make life easier for users, we just always translate '\r\n' =>
 
248
        # '\n'. And '\r' => '\n'.
 
249
        a_tree = self.make_branch_and_tree('a')
 
250
        self.build_tree(['a/b'])
 
251
        a_tree.add('b')
 
252
        self.run_bzr(['commit',
 
253
                      '-m', 'a string\r\n\r\nwith mixed\r\rendings\n'],
 
254
                     working_dir='a')
 
255
        rev_id = a_tree.branch.last_revision()
 
256
        rev = a_tree.branch.repository.get_revision(rev_id)
 
257
        self.assertEqualDiff('a string\n\nwith mixed\n\nendings\n',
 
258
                             rev.message)
154
259
 
155
260
    def test_commit_merge_reports_all_modified_files(self):
156
261
        # the commit command should show all the files that are shown by
189
294
            other_tree.rename_one('dirtorename', 'renameddir')
190
295
            other_tree.rename_one('dirtoreparent', 'renameddir/reparenteddir')
191
296
            other_tree.rename_one('filetorename', 'renamedfile')
192
 
            other_tree.rename_one('filetoreparent', 'renameddir/reparentedfile')
 
297
            other_tree.rename_one('filetoreparent',
 
298
                                  'renameddir/reparentedfile')
193
299
            other_tree.remove(['dirtoremove', 'filetoremove'])
194
300
            self.build_tree_contents([
195
 
                ('other/newdir/', ),
 
301
                ('other/newdir/',),
196
302
                ('other/filetomodify', 'new content'),
197
303
                ('other/newfile', 'new file content')])
198
304
            other_tree.add('newfile')
202
308
            other_tree.unlock()
203
309
        this_tree.merge_from_branch(other_tree.branch)
204
310
        os.chdir('this')
205
 
        out,err = self.run_bzr("commit", "-m", "added")
206
 
        os.chdir('..')
 
311
        out,err = self.run_bzr('commit -m added')
207
312
        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)
 
313
        self.assertEqual(set([
 
314
            'Committing to: %s/' % osutils.getcwd(),
 
315
            'modified filetomodify',
 
316
            'added newdir',
 
317
            'added newfile',
 
318
            'renamed dirtorename => renameddir',
 
319
            'renamed filetorename => renamedfile',
 
320
            'renamed dirtoreparent => renameddir/reparenteddir',
 
321
            'renamed filetoreparent => renameddir/reparentedfile',
 
322
            'deleted dirtoremove',
 
323
            'deleted filetoremove',
 
324
            'Committed revision 2.',
 
325
            ''
 
326
            ]), set(err.split('\n')))
220
327
 
221
328
    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)
 
329
        tree = self.make_branch_and_tree('.')
 
330
        self.build_tree_contents([('foo.c', 'int main() {}')])
 
331
        tree.add('foo.c')
 
332
        self.run_bzr('commit -m ""')
226
333
 
227
334
    def test_other_branch_commit(self):
228
335
        # this branch is to ensure consistent behaviour, whether we're run
229
336
        # 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'])
 
337
        outer_tree = self.make_branch_and_tree('.')
 
338
        inner_tree = self.make_branch_and_tree('branch')
 
339
        self.build_tree_contents([
 
340
            ('branch/foo.c', 'int main() {}'),
 
341
            ('branch/bar.c', 'int main() {}')])
 
342
        inner_tree.add(['foo.c', 'bar.c'])
241
343
        # 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)
 
344
        self.run_bzr('commit -m newstuff branch/foo.c .', retcode=3)
 
345
        # can commit to branch - records foo.c only
 
346
        self.run_bzr('commit -m newstuff branch/foo.c')
 
347
        # can commit to branch - records bar.c
 
348
        self.run_bzr('commit -m newstuff branch')
 
349
        # No changes left
 
350
        self.run_bzr_error(["No changes to commit"], 'commit -m newstuff branch')
246
351
 
247
352
    def test_out_of_date_tree_commit(self):
248
353
        # check we get an error code and a clear message committing with an out
249
354
        # of date checkout
250
 
        self.make_branch_and_tree('branch')
 
355
        tree = self.make_branch_and_tree('branch')
251
356
        # make a checkout
252
 
        self.runbzr('checkout --lightweight branch checkout')
 
357
        checkout = tree.branch.create_checkout('checkout', lightweight=True)
253
358
        # commit to the original branch to make the checkout out of date
254
 
        self.runbzr('commit --unchanged -m message branch')
 
359
        tree.commit('message branch', allow_pointless=True)
255
360
        # now commit to the checkout should emit
256
361
        # ERROR: Out of date with the branch, 'bzr update' is suggested
257
 
        output = self.runbzr('commit --unchanged -m checkout_message '
 
362
        output = self.run_bzr('commit --unchanged -m checkout_message '
258
363
                             'checkout', retcode=3)
259
364
        self.assertEqual(output,
260
365
                         ('',
261
 
                          "bzr: ERROR: Working tree is out of date, please run "
262
 
                          "'bzr update'.\n"))
 
366
                          "bzr: ERROR: Working tree is out of date, please "
 
367
                          "run 'bzr update'.\n"))
263
368
 
264
369
    def test_local_commit_unbound(self):
265
370
        # a --local commit on an unbound branch is an error
266
371
        self.make_branch_and_tree('.')
267
 
        out, err = self.run_bzr('commit', '--local', retcode=3)
 
372
        out, err = self.run_bzr('commit --local', retcode=3)
268
373
        self.assertEqualDiff('', out)
269
374
        self.assertEqualDiff('bzr: ERROR: Cannot perform local-only commits '
270
375
                             'on unbound branches.\n', err)
272
377
    def test_commit_a_text_merge_in_a_checkout(self):
273
378
        # checkouts perform multiple actions in a transaction across bond
274
379
        # 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 
 
380
        # past. This is a user story reported to fail in bug #43959 where
276
381
        # a merge done in a checkout (using the update command) failed to
277
382
        # 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')
 
383
        trunk = self.make_branch_and_tree('trunk')
 
384
 
 
385
        u1 = trunk.branch.create_checkout('u1')
 
386
        self.build_tree_contents([('u1/hosts', 'initial contents\n')])
 
387
        u1.add('hosts')
 
388
        self.run_bzr('commit -m add-hosts u1')
 
389
 
 
390
        u2 = trunk.branch.create_checkout('u2')
 
391
        self.build_tree_contents([('u2/hosts', 'altered in u2\n')])
 
392
        self.run_bzr('commit -m checkin-from-u2 u2')
288
393
 
289
394
        # 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')
 
395
        self.build_tree_contents([('u1/hosts', 'first offline change in u1\n')])
 
396
        self.run_bzr('commit -m checkin-offline --local u1')
292
397
 
293
398
        # now try to pull in online work from u2, and then commit our offline
294
399
        # work as a merge
295
400
        # retcode 1 as we expect a text conflict
296
 
        self.run_bzr('update', 'u1', retcode=1)
297
 
        self.run_bzr('resolved', 'u1/hosts')
 
401
        self.run_bzr('update u1', retcode=1)
 
402
        self.assertFileEqual('''\
 
403
<<<<<<< TREE
 
404
first offline change in u1
 
405
=======
 
406
altered in u2
 
407
>>>>>>> MERGE-SOURCE
 
408
''',
 
409
                             'u1/hosts')
 
410
 
 
411
        self.run_bzr('resolved u1/hosts')
298
412
        # add a text change here to represent resolving the merge conflicts in
299
413
        # favour of a new version of the file not identical to either the u1
300
414
        # version or the u2 version.
301
415
        self.build_tree_contents([('u1/hosts', 'merge resolution\n')])
302
 
        self.run_bzr('commit', '-m', 'checkin merge of the offline work from u1', 'u1')
 
416
        self.run_bzr('commit -m checkin-merge-of-the-offline-work-from-u1 u1')
 
417
 
 
418
    def test_commit_exclude_excludes_modified_files(self):
 
419
        """Commit -x foo should ignore changes to foo."""
 
420
        tree = self.make_branch_and_tree('.')
 
421
        self.build_tree(['a', 'b', 'c'])
 
422
        tree.smart_add(['.'])
 
423
        out, err = self.run_bzr(['commit', '-m', 'test', '-x', 'b'])
 
424
        self.assertFalse('added b' in out)
 
425
        self.assertFalse('added b' in err)
 
426
        # If b was excluded it will still be 'added' in status.
 
427
        out, err = self.run_bzr(['added'])
 
428
        self.assertEqual('b\n', out)
 
429
        self.assertEqual('', err)
 
430
 
 
431
    def test_commit_exclude_twice_uses_both_rules(self):
 
432
        """Commit -x foo -x bar should ignore changes to foo and bar."""
 
433
        tree = self.make_branch_and_tree('.')
 
434
        self.build_tree(['a', 'b', 'c'])
 
435
        tree.smart_add(['.'])
 
436
        out, err = self.run_bzr(['commit', '-m', 'test', '-x', 'b', '-x', 'c'])
 
437
        self.assertFalse('added b' in out)
 
438
        self.assertFalse('added c' in out)
 
439
        self.assertFalse('added b' in err)
 
440
        self.assertFalse('added c' in err)
 
441
        # If b was excluded it will still be 'added' in status.
 
442
        out, err = self.run_bzr(['added'])
 
443
        self.assertTrue('b\n' in out)
 
444
        self.assertTrue('c\n' in out)
 
445
        self.assertEqual('', err)
303
446
 
304
447
    def test_commit_respects_spec_for_removals(self):
305
448
        """Commit with a file spec should only commit removals that match"""
309
452
        t.commit('Create')
310
453
        t.remove(['file-a', 'dir-a/file-b'])
311
454
        os.chdir('dir-a')
312
 
        result = self.run_bzr('commit', '.', '-m' 'removed file-b')[1]
 
455
        result = self.run_bzr('commit . -m removed-file-b')[1]
313
456
        self.assertNotContainsRe(result, 'file-a')
314
457
        result = self.run_bzr('status')[0]
315
458
        self.assertContainsRe(result, 'removed:\n  file-a')
321
464
        self.build_tree(['tree/a'])
322
465
        tree.add('a')
323
466
        # A simple change should just work
324
 
        self.run_bzr('commit', '--strict', '-m', 'adding a',
 
467
        self.run_bzr('commit --strict -m adding-a',
325
468
                     working_dir='tree')
326
469
 
327
470
    def test_strict_commit_no_changes(self):
333
476
 
334
477
        # With no changes, it should just be 'no changes'
335
478
        # 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',
 
479
        self.run_bzr_error(['No changes to commit'],
 
480
                           'commit --strict -m no-changes',
338
481
                           working_dir='tree')
339
482
 
340
483
        # But --strict doesn't care if you supply --unchanged
341
 
        self.run_bzr('commit', '--strict', '--unchanged', '-m', 'no changes',
 
484
        self.run_bzr('commit --strict --unchanged -m no-changes',
342
485
                     working_dir='tree')
343
486
 
344
487
    def test_strict_commit_unknown(self):
352
495
        self.build_tree(['tree/b', 'tree/c'])
353
496
        tree.add('b')
354
497
        self.run_bzr_error(['Commit refused because there are unknown files'],
355
 
                           'commit', '--strict', '-m', 'add b',
 
498
                           'commit --strict -m add-b',
356
499
                           working_dir='tree')
357
500
 
358
501
        # --no-strict overrides --strict
359
 
        self.run_bzr('commit', '--strict', '-m', 'add b', '--no-strict',
 
502
        self.run_bzr('commit --strict -m add-b --no-strict',
360
503
                     working_dir='tree')
 
504
 
 
505
    def test_fixes_bug_output(self):
 
506
        """commit --fixes=lp:23452 succeeds without output."""
 
507
        tree = self.make_branch_and_tree('tree')
 
508
        self.build_tree(['tree/hello.txt'])
 
509
        tree.add('hello.txt')
 
510
        output, err = self.run_bzr(
 
511
            'commit -m hello --fixes=lp:23452 tree/hello.txt')
 
512
        self.assertEqual('', output)
 
513
        self.assertContainsRe(err, 'Committing to: .*\n'
 
514
                              'added hello\.txt\n'
 
515
                              'Committed revision 1\.\n')
 
516
 
 
517
    def test_no_bugs_no_properties(self):
 
518
        """If no bugs are fixed, the bugs property is not set.
 
519
 
 
520
        see https://beta.launchpad.net/bzr/+bug/109613
 
521
        """
 
522
        tree = self.make_branch_and_tree('tree')
 
523
        self.build_tree(['tree/hello.txt'])
 
524
        tree.add('hello.txt')
 
525
        self.run_bzr( 'commit -m hello tree/hello.txt')
 
526
        # Get the revision properties, ignoring the branch-nick property, which
 
527
        # we don't care about for this test.
 
528
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
529
        properties = dict(last_rev.properties)
 
530
        del properties['branch-nick']
 
531
        self.assertFalse('bugs' in properties)
 
532
 
 
533
    def test_fixes_bug_sets_property(self):
 
534
        """commit --fixes=lp:234 sets the lp:234 revprop to 'fixed'."""
 
535
        tree = self.make_branch_and_tree('tree')
 
536
        self.build_tree(['tree/hello.txt'])
 
537
        tree.add('hello.txt')
 
538
        self.run_bzr('commit -m hello --fixes=lp:234 tree/hello.txt')
 
539
 
 
540
        # Get the revision properties, ignoring the branch-nick property, which
 
541
        # we don't care about for this test.
 
542
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
543
        properties = dict(last_rev.properties)
 
544
        del properties['branch-nick']
 
545
 
 
546
        self.assertEqual({'bugs': 'https://launchpad.net/bugs/234 fixed'},
 
547
                         properties)
 
548
 
 
549
    def test_fixes_multiple_bugs_sets_properties(self):
 
550
        """--fixes can be used more than once to show that bugs are fixed."""
 
551
        tree = self.make_branch_and_tree('tree')
 
552
        self.build_tree(['tree/hello.txt'])
 
553
        tree.add('hello.txt')
 
554
        self.run_bzr('commit -m hello --fixes=lp:123 --fixes=lp:235'
 
555
                     ' tree/hello.txt')
 
556
 
 
557
        # Get the revision properties, ignoring the branch-nick property, which
 
558
        # we don't care about for this test.
 
559
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
560
        properties = dict(last_rev.properties)
 
561
        del properties['branch-nick']
 
562
 
 
563
        self.assertEqual(
 
564
            {'bugs': 'https://launchpad.net/bugs/123 fixed\n'
 
565
                     'https://launchpad.net/bugs/235 fixed'},
 
566
            properties)
 
567
 
 
568
    def test_fixes_bug_with_alternate_trackers(self):
 
569
        """--fixes can be used on a properly configured branch to mark bug
 
570
        fixes on multiple trackers.
 
571
        """
 
572
        tree = self.make_branch_and_tree('tree')
 
573
        tree.branch.get_config().set_user_option(
 
574
            'trac_twisted_url', 'http://twistedmatrix.com/trac')
 
575
        self.build_tree(['tree/hello.txt'])
 
576
        tree.add('hello.txt')
 
577
        self.run_bzr('commit -m hello --fixes=lp:123 --fixes=twisted:235 tree/')
 
578
 
 
579
        # Get the revision properties, ignoring the branch-nick property, which
 
580
        # we don't care about for this test.
 
581
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
582
        properties = dict(last_rev.properties)
 
583
        del properties['branch-nick']
 
584
 
 
585
        self.assertEqual(
 
586
            {'bugs': 'https://launchpad.net/bugs/123 fixed\n'
 
587
                     'http://twistedmatrix.com/trac/ticket/235 fixed'},
 
588
            properties)
 
589
 
 
590
    def test_fixes_unknown_bug_prefix(self):
 
591
        tree = self.make_branch_and_tree('tree')
 
592
        self.build_tree(['tree/hello.txt'])
 
593
        tree.add('hello.txt')
 
594
        self.run_bzr_error(
 
595
            ["Unrecognized bug %s. Commit refused." % 'xxx:123'],
 
596
            'commit -m add-b --fixes=xxx:123',
 
597
            working_dir='tree')
 
598
 
 
599
    def test_fixes_invalid_bug_number(self):
 
600
        tree = self.make_branch_and_tree('tree')
 
601
        self.build_tree(['tree/hello.txt'])
 
602
        tree.add('hello.txt')
 
603
        self.run_bzr_error(
 
604
            ["Did not understand bug identifier orange: Must be an integer. "
 
605
             "See \"bzr help bugs\" for more information on this feature.\n"
 
606
             "Commit refused."],
 
607
            'commit -m add-b --fixes=lp:orange',
 
608
            working_dir='tree')
 
609
 
 
610
    def test_fixes_invalid_argument(self):
 
611
        """Raise an appropriate error when the fixes argument isn't tag:id."""
 
612
        tree = self.make_branch_and_tree('tree')
 
613
        self.build_tree(['tree/hello.txt'])
 
614
        tree.add('hello.txt')
 
615
        self.run_bzr_error(
 
616
            [r"Invalid bug orange. Must be in the form of 'tracker:id'\. "
 
617
             r"See \"bzr help bugs\" for more information on this feature.\n"
 
618
             r"Commit refused\."],
 
619
            'commit -m add-b --fixes=orange',
 
620
            working_dir='tree')
 
621
 
 
622
    def test_no_author(self):
 
623
        """If the author is not specified, the author property is not set."""
 
624
        tree = self.make_branch_and_tree('tree')
 
625
        self.build_tree(['tree/hello.txt'])
 
626
        tree.add('hello.txt')
 
627
        self.run_bzr( 'commit -m hello tree/hello.txt')
 
628
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
629
        properties = last_rev.properties
 
630
        self.assertFalse('author' in properties)
 
631
 
 
632
    def test_author_sets_property(self):
 
633
        """commit --author='John Doe <jdoe@example.com>' sets the author
 
634
           revprop.
 
635
        """
 
636
        tree = self.make_branch_and_tree('tree')
 
637
        self.build_tree(['tree/hello.txt'])
 
638
        tree.add('hello.txt')
 
639
        self.run_bzr(["commit", '-m', 'hello',
 
640
                      '--author', u'John D\xf6 <jdoe@example.com>',
 
641
                     "tree/hello.txt"])
 
642
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
643
        properties = last_rev.properties
 
644
        self.assertEqual(u'John D\xf6 <jdoe@example.com>', properties['authors'])
 
645
 
 
646
    def test_author_no_email(self):
 
647
        """Author's name without an email address is allowed, too."""
 
648
        tree = self.make_branch_and_tree('tree')
 
649
        self.build_tree(['tree/hello.txt'])
 
650
        tree.add('hello.txt')
 
651
        out, err = self.run_bzr("commit -m hello --author='John Doe' "
 
652
                                "tree/hello.txt")
 
653
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
654
        properties = last_rev.properties
 
655
        self.assertEqual('John Doe', properties['authors'])
 
656
 
 
657
    def test_multiple_authors(self):
 
658
        """Multiple authors can be specyfied, and all are stored."""
 
659
        tree = self.make_branch_and_tree('tree')
 
660
        self.build_tree(['tree/hello.txt'])
 
661
        tree.add('hello.txt')
 
662
        out, err = self.run_bzr("commit -m hello --author='John Doe' "
 
663
                                "--author='Jane Rey' tree/hello.txt")
 
664
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
665
        properties = last_rev.properties
 
666
        self.assertEqual('John Doe\nJane Rey', properties['authors'])
 
667
 
 
668
    def test_commit_time(self):
 
669
        tree = self.make_branch_and_tree('tree')
 
670
        self.build_tree(['tree/hello.txt'])
 
671
        tree.add('hello.txt')
 
672
        out, err = self.run_bzr("commit -m hello "
 
673
            "--commit-time='2009-10-10 08:00:00 +0100' tree/hello.txt")
 
674
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
675
        self.assertEqual(
 
676
            'Sat 2009-10-10 08:00:00 +0100',
 
677
            osutils.format_date(last_rev.timestamp, last_rev.timezone))
 
678
        
 
679
    def test_commit_time_bad_time(self):
 
680
        tree = self.make_branch_and_tree('tree')
 
681
        self.build_tree(['tree/hello.txt'])
 
682
        tree.add('hello.txt')
 
683
        out, err = self.run_bzr("commit -m hello "
 
684
            "--commit-time='NOT A TIME' tree/hello.txt", retcode=3)
 
685
        self.assertStartsWith(
 
686
            err, "bzr: ERROR: Could not parse --commit-time:")
 
687
 
 
688
    def test_partial_commit_with_renames_in_tree(self):
 
689
        # this test illustrates bug #140419
 
690
        t = self.make_branch_and_tree('.')
 
691
        self.build_tree(['dir/', 'dir/a', 'test'])
 
692
        t.add(['dir/', 'dir/a', 'test'])
 
693
        t.commit('initial commit')
 
694
        # important part: file dir/a should change parent
 
695
        # and should appear before old parent
 
696
        # then during partial commit we have error
 
697
        # parent_id {dir-XXX} not in inventory
 
698
        t.rename_one('dir/a', 'a')
 
699
        self.build_tree_contents([('test', 'changes in test')])
 
700
        # partial commit
 
701
        out, err = self.run_bzr('commit test -m "partial commit"')
 
702
        self.assertEquals('', out)
 
703
        self.assertContainsRe(err, r'modified test\nCommitted revision 2.')
 
704
 
 
705
    def test_commit_readonly_checkout(self):
 
706
        # https://bugs.launchpad.net/bzr/+bug/129701
 
707
        # "UnlockableTransport error trying to commit in checkout of readonly
 
708
        # branch"
 
709
        self.make_branch('master')
 
710
        master = BzrDir.open_from_transport(
 
711
            self.get_readonly_transport('master')).open_branch()
 
712
        master.create_checkout('checkout')
 
713
        out, err = self.run_bzr(['commit', '--unchanged', '-mfoo', 'checkout'],
 
714
            retcode=3)
 
715
        self.assertContainsRe(err,
 
716
            r'^bzr: ERROR: Cannot lock.*readonly transport')
 
717
 
 
718
    def setup_editor(self):
 
719
        # Test that commit template hooks work
 
720
        if sys.platform == "win32":
 
721
            f = file('fed.bat', 'w')
 
722
            f.write('@rem dummy fed')
 
723
            f.close()
 
724
            self.overrideEnv('BZR_EDITOR', "fed.bat")
 
725
        else:
 
726
            f = file('fed.sh', 'wb')
 
727
            f.write('#!/bin/sh\n')
 
728
            f.close()
 
729
            os.chmod('fed.sh', 0755)
 
730
            self.overrideEnv('BZR_EDITOR', "./fed.sh")
 
731
 
 
732
    def setup_commit_with_template(self):
 
733
        self.setup_editor()
 
734
        msgeditor.hooks.install_named_hook("commit_message_template",
 
735
                lambda commit_obj, msg: "save me some typing\n", None)
 
736
        tree = self.make_branch_and_tree('tree')
 
737
        self.build_tree(['tree/hello.txt'])
 
738
        tree.add('hello.txt')
 
739
        return tree
 
740
 
 
741
    def test_edit_empty_message(self):
 
742
        tree = self.make_branch_and_tree('tree')
 
743
        self.setup_editor()
 
744
        self.build_tree(['tree/hello.txt'])
 
745
        tree.add('hello.txt')
 
746
        out, err = self.run_bzr("commit tree/hello.txt", retcode=3,
 
747
            stdin="y\n")
 
748
        self.assertContainsRe(err,
 
749
            "bzr: ERROR: Empty commit message specified")
 
750
 
 
751
    def test_commit_hook_template_accepted(self):
 
752
        tree = self.setup_commit_with_template()
 
753
        out, err = self.run_bzr("commit tree/hello.txt", stdin="y\n")
 
754
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
755
        self.assertEqual('save me some typing\n', last_rev.message)
 
756
 
 
757
    def test_commit_hook_template_rejected(self):
 
758
        tree = self.setup_commit_with_template()
 
759
        expected = tree.last_revision()
 
760
        out, err = self.run_bzr_error(["Empty commit message specified."
 
761
                  " Please specify a commit message with either"
 
762
                  " --message or --file or leave a blank message"
 
763
                  " with --message \"\"."],
 
764
            "commit tree/hello.txt", stdin="n\n")
 
765
        self.assertEqual(expected, tree.last_revision())
 
766
 
 
767
    def test_set_commit_message(self):
 
768
        msgeditor.hooks.install_named_hook("set_commit_message",
 
769
                lambda commit_obj, msg: "save me some typing\n", None)
 
770
        tree = self.make_branch_and_tree('tree')
 
771
        self.build_tree(['tree/hello.txt'])
 
772
        tree.add('hello.txt')
 
773
        out, err = self.run_bzr("commit tree/hello.txt")
 
774
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
775
        self.assertEqual('save me some typing\n', last_rev.message)
 
776
 
 
777
    def test_commit_without_username(self):
 
778
        """Ensure commit error if username is not set.
 
779
        """
 
780
        self.run_bzr(['init', 'foo'])
 
781
        os.chdir('foo')
 
782
        open('foo.txt', 'w').write('hello')
 
783
        self.run_bzr(['add'])
 
784
        self.overrideEnv('EMAIL', None)
 
785
        self.overrideEnv('BZR_EMAIL', None)
 
786
        # Also, make sure that it's not inferred from mailname.
 
787
        self.overrideAttr(config, '_auto_user_id',
 
788
            lambda: (None, None))
 
789
        out, err = self.run_bzr(['commit', '-m', 'initial'], 3)
 
790
        self.assertContainsRe(err, 'Unable to determine your name')
 
791
 
 
792
    def test_commit_recursive_checkout(self):
 
793
        """Ensure that a commit to a recursive checkout fails cleanly.
 
794
        """
 
795
        self.run_bzr(['init', 'test_branch'])
 
796
        self.run_bzr(['checkout', 'test_branch', 'test_checkout'])
 
797
        os.chdir('test_checkout')
 
798
        self.run_bzr(['bind', '.']) # bind to self
 
799
        open('foo.txt', 'w').write('hello')
 
800
        self.run_bzr(['add'])
 
801
        out, err = self.run_bzr(['commit', '-m', 'addedfoo'], 3)
 
802
        self.assertEqual(out, '')
 
803
        self.assertContainsRe(err,
 
804
            'Branch.*test_checkout.*appears to be bound to itself')