/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

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

  • Committer: Robert Collins
  • Date: 2010-05-21 04:27:11 UTC
  • mto: This revision was merged to the branch mainline in revision 5248.
  • Revision ID: robertc@robertcollins.net-20100521042711-gt6x2vojrm4flnc9
Allow setting new proposals as approved immediately.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_commit.py
1
 
# Copyright (C) 2006-2012, 2016 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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
17
17
 
18
18
"""Tests for the commit CLI of bzr."""
19
19
 
20
 
import doctest
21
20
import os
22
21
import re
23
22
import sys
24
23
 
25
 
from testtools.matchers import DocTestMatches
26
 
 
27
 
from ... import (
28
 
    config,
 
24
from bzrlib import (
29
25
    osutils,
30
26
    ignores,
31
27
    msgeditor,
32
 
    )
33
 
from ...controldir import ControlDir
34
 
from ...sixish import PY3
35
 
from .. import (
36
 
    test_foreign,
37
 
    features,
38
 
    )
39
 
from .. import TestCaseWithTransport
40
 
from ..matchers import ContainsNoVfsCalls
41
 
from ..test_bedding import override_whoami
42
 
 
43
 
 
44
 
class TestCommit(TestCaseWithTransport):
 
28
    osutils,
 
29
    tests,
 
30
    )
 
31
from bzrlib.bzrdir import BzrDir
 
32
from bzrlib.tests import (
 
33
    probe_bad_non_ascii,
 
34
    TestSkipped,
 
35
    )
 
36
from bzrlib.tests.blackbox import ExternalBase
 
37
 
 
38
 
 
39
class TestCommit(ExternalBase):
45
40
 
46
41
    def test_05_empty_commit(self):
47
42
        """Commit of tree with no versioned files should fail"""
48
43
        # If forced, it should succeed, but this is not tested here.
49
44
        self.make_branch_and_tree('.')
50
45
        self.build_tree(['hello.txt'])
51
 
        out, err = self.run_bzr('commit -m empty', retcode=3)
 
46
        out,err = self.run_bzr('commit -m empty', retcode=3)
52
47
        self.assertEqual('', out)
53
 
        # Two ugly bits here.
54
 
        # 1) We really don't want 'aborting commit write group' anymore.
55
 
        # 2) brz: ERROR: is a really long line, so we wrap it with '\'
56
 
        self.assertThat(
57
 
            err,
58
 
            DocTestMatches("""\
59
 
Committing to: ...
60
 
brz: ERROR: No changes to commit.\
61
 
 Please 'brz add' the files you want to commit,\
62
 
 or use --unchanged to force an empty commit.
63
 
""", flags=doctest.ELLIPSIS | doctest.REPORT_UDIFF))
 
48
        self.assertContainsRe(err, 'bzr: ERROR: No changes to commit\.'
 
49
                                  ' Use --unchanged to commit anyhow.\n')
64
50
 
65
51
    def test_commit_success(self):
66
52
        """Successful commit should not leave behind a bzr-commit-* file"""
72
58
        self.run_bzr(["commit", "--unchanged", "-m", u'foo\xb5'])
73
59
        self.assertEqual('', self.run_bzr('unknowns')[0])
74
60
 
75
 
    def test_commit_lossy_native(self):
76
 
        """A --lossy option to commit is supported."""
77
 
        self.make_branch_and_tree('.')
78
 
        self.run_bzr('commit --lossy --unchanged -m message')
79
 
        self.assertEqual('', self.run_bzr('unknowns')[0])
80
 
 
81
 
    def test_commit_lossy_foreign(self):
82
 
        test_foreign.register_dummy_foreign_for_test(self)
83
 
        self.make_branch_and_tree('.',
84
 
                                  format=test_foreign.DummyForeignVcsDirFormat())
85
 
        self.run_bzr('commit --lossy --unchanged -m message')
86
 
        output = self.run_bzr('revision-info')[0]
87
 
        self.assertTrue(output.startswith('1 dummy-'))
88
 
 
89
61
    def test_commit_with_path(self):
90
62
        """Commit tree with path of root specified"""
91
63
        a_tree = self.make_branch_and_tree('a')
93
65
        a_tree.add('a_file')
94
66
        self.run_bzr(['commit', '-m', 'first commit', 'a'])
95
67
 
96
 
        b_tree = a_tree.controldir.sprout('b').open_workingtree()
97
 
        self.build_tree_contents([('b/a_file', b'changes in b')])
 
68
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
 
69
        self.build_tree_contents([('b/a_file', 'changes in b')])
98
70
        self.run_bzr(['commit', '-m', 'first commit in b', 'b'])
99
71
 
100
 
        self.build_tree_contents([('a/a_file', b'new contents')])
 
72
        self.build_tree_contents([('a/a_file', 'new contents')])
101
73
        self.run_bzr(['commit', '-m', 'change in a', 'a'])
102
74
 
103
75
        b_tree.merge_from_branch(a_tree.branch)
105
77
        self.run_bzr('resolved b/a_file')
106
78
        self.run_bzr(['commit', '-m', 'merge into b', 'b'])
107
79
 
 
80
 
108
81
    def test_10_verbose_commit(self):
109
82
        """Add one file and examine verbose commit output"""
110
83
        tree = self.make_branch_and_tree('.')
111
84
        self.build_tree(['hello.txt'])
112
85
        tree.add("hello.txt")
113
 
        out, err = self.run_bzr('commit -m added')
 
86
        out,err = self.run_bzr('commit -m added')
114
87
        self.assertEqual('', out)
115
88
        self.assertContainsRe(err, '^Committing to: .*\n'
116
89
                              'added hello.txt\n'
119
92
    def prepare_simple_history(self):
120
93
        """Prepare and return a working tree with one commit of one file"""
121
94
        # Commit with modified file should say so
122
 
        wt = ControlDir.create_standalone_workingtree('.')
 
95
        wt = BzrDir.create_standalone_workingtree('.')
123
96
        self.build_tree(['hello.txt', 'extra.txt'])
124
97
        wt.add(['hello.txt'])
125
98
        wt.commit(message='added')
128
101
    def test_verbose_commit_modified(self):
129
102
        # Verbose commit of modified file should say so
130
103
        wt = self.prepare_simple_history()
131
 
        self.build_tree_contents([('hello.txt', b'new contents')])
 
104
        self.build_tree_contents([('hello.txt', 'new contents')])
132
105
        out, err = self.run_bzr('commit -m modified')
133
106
        self.assertEqual('', out)
134
107
        self.assertContainsRe(err, '^Committing to: .*\n'
135
 
                              'modified hello\\.txt\n'
136
 
                              'Committed revision 2\\.\n$')
 
108
                              'modified hello\.txt\n'
 
109
                              'Committed revision 2\.\n$')
137
110
 
138
111
    def test_unicode_commit_message_is_filename(self):
139
112
        """Unicode commit message same as a filename (Bug #563646).
140
113
        """
141
 
        self.requireFeature(features.UnicodeFilenameFeature)
142
114
        file_name = u'\N{euro sign}'
143
115
        self.run_bzr(['init'])
144
 
        with open(file_name, 'w') as f:
145
 
            f.write('hello world')
 
116
        open(file_name, 'w').write('hello world')
146
117
        self.run_bzr(['add'])
147
118
        out, err = self.run_bzr(['commit', '-m', file_name])
148
 
        reflags = re.MULTILINE | re.DOTALL | re.UNICODE
 
119
        reflags = re.MULTILINE|re.DOTALL|re.UNICODE
149
120
        te = osutils.get_terminal_encoding()
150
 
        self.assertContainsRe(err if PY3 else err.decode(te),
151
 
                              u'The commit message is a file name:',
152
 
                              flags=reflags)
 
121
        self.assertContainsRe(err.decode(te),
 
122
            u'The commit message is a file name:',
 
123
            flags=reflags)
153
124
 
154
125
        # Run same test with a filename that causes encode
155
126
        # error for the terminal encoding. We do this
158
129
        # by ui.text.show_warning
159
130
        default_get_terminal_enc = osutils.get_terminal_encoding
160
131
        try:
161
 
            osutils.get_terminal_encoding = lambda trace=None: 'ascii'
 
132
            osutils.get_terminal_encoding = lambda: 'ascii'
162
133
            file_name = u'foo\u1234'
163
 
            with open(file_name, 'w') as f:
164
 
                f.write('hello world')
 
134
            open(file_name, 'w').write('hello world')
165
135
            self.run_bzr(['add'])
166
136
            out, err = self.run_bzr(['commit', '-m', file_name])
167
 
            reflags = re.MULTILINE | re.DOTALL | re.UNICODE
 
137
            reflags = re.MULTILINE|re.DOTALL|re.UNICODE
168
138
            te = osutils.get_terminal_encoding()
169
 
            self.assertContainsRe(err if PY3 else err.decode(te, 'replace'),
170
 
                                  u'The commit message is a file name:',
171
 
                                  flags=reflags)
 
139
            self.assertContainsRe(err.decode(te, 'replace'),
 
140
                u'The commit message is a file name:',
 
141
                flags=reflags)
172
142
        finally:
173
143
            osutils.get_terminal_encoding = default_get_terminal_enc
174
144
 
175
 
    def test_non_ascii_file_unversioned_utf8(self):
176
 
        self.requireFeature(features.UnicodeFilenameFeature)
177
 
        tree = self.make_branch_and_tree(".")
178
 
        self.build_tree(["f"])
179
 
        tree.add(["f"])
180
 
        out, err = self.run_bzr_raw(["commit", "-m", "Wrong filename", u"\xa7"],
181
 
                                    encoding="utf-8", retcode=3)
182
 
        self.assertContainsRe(err, b"(?m)not versioned: \"\xc2\xa7\"$")
183
 
 
184
 
    def test_non_ascii_file_unversioned_iso_8859_5(self):
185
 
        self.requireFeature(features.UnicodeFilenameFeature)
186
 
        tree = self.make_branch_and_tree(".")
187
 
        self.build_tree(["f"])
188
 
        tree.add(["f"])
189
 
        out, err = self.run_bzr_raw(["commit", "-m", "Wrong filename", u"\xa7"],
190
 
                                    encoding="iso-8859-5", retcode=3)
191
 
        if not PY3:
192
 
            self.expectFailure("Error messages are always written as UTF-8",
193
 
                               self.assertNotContainsString, err, b"\xc2\xa7")
194
 
        else:
195
 
            self.assertNotContainsString(err, b"\xc2\xa7")
196
 
        self.assertContainsRe(err, b"(?m)not versioned: \"\xfd\"$")
197
 
 
198
145
    def test_warn_about_forgotten_commit_message(self):
199
146
        """Test that the lack of -m parameter is caught"""
200
147
        wt = self.make_branch_and_tree('.')
210
157
        out, err = self.run_bzr('commit -m renamed')
211
158
        self.assertEqual('', out)
212
159
        self.assertContainsRe(err, '^Committing to: .*\n'
213
 
                              'renamed hello\\.txt => gutentag\\.txt\n'
214
 
                              'Committed revision 2\\.$\n')
 
160
                              'renamed hello\.txt => gutentag\.txt\n'
 
161
                              'Committed revision 2\.$\n')
215
162
 
216
163
    def test_verbose_commit_moved(self):
217
164
        # Verbose commit of file moved to new directory should say so
221
168
        wt.rename_one('hello.txt', 'subdir/hello.txt')
222
169
        out, err = self.run_bzr('commit -m renamed')
223
170
        self.assertEqual('', out)
224
 
        self.assertEqual({
 
171
        self.assertEqual(set([
225
172
            'Committing to: %s/' % osutils.getcwd(),
226
173
            'added subdir',
227
174
            'renamed hello.txt => subdir/hello.txt',
228
175
            'Committed revision 2.',
229
176
            '',
230
 
            }, set(err.split('\n')))
 
177
            ]), set(err.split('\n')))
231
178
 
232
179
    def test_verbose_commit_with_unknown(self):
233
180
        """Unknown files should not be listed by default in verbose output"""
234
181
        # Is that really the best policy?
235
 
        wt = ControlDir.create_standalone_workingtree('.')
 
182
        wt = BzrDir.create_standalone_workingtree('.')
236
183
        self.build_tree(['hello.txt', 'extra.txt'])
237
184
        wt.add(['hello.txt'])
238
 
        out, err = self.run_bzr('commit -m added')
 
185
        out,err = self.run_bzr('commit -m added')
239
186
        self.assertEqual('', out)
240
187
        self.assertContainsRe(err, '^Committing to: .*\n'
241
 
                              'added hello\\.txt\n'
242
 
                              'Committed revision 1\\.\n$')
 
188
                              'added hello\.txt\n'
 
189
                              'Committed revision 1\.\n$')
243
190
 
244
191
    def test_verbose_commit_with_unchanged(self):
245
192
        """Unchanged files should not be listed by default in verbose output"""
248
195
        tree.add('unchanged.txt')
249
196
        self.run_bzr('commit -m unchanged unchanged.txt')
250
197
        tree.add("hello.txt")
251
 
        out, err = self.run_bzr('commit -m added')
 
198
        out,err = self.run_bzr('commit -m added')
252
199
        self.assertEqual('', out)
253
200
        self.assertContainsRe(err, '^Committing to: .*\n'
254
 
                              'added hello\\.txt\n'
255
 
                              'Committed revision 2\\.$\n')
 
201
                              'added hello\.txt\n'
 
202
                              'Committed revision 2\.$\n')
256
203
 
257
204
    def test_verbose_commit_includes_master_location(self):
258
205
        """Location of master is displayed when committing to bound branch"""
269
216
 
270
217
    def test_commit_sanitizes_CR_in_message(self):
271
218
        # See bug #433779, basically Emacs likes to pass '\r\n' style line
272
 
        # endings to 'brz commit -m ""' which breaks because we don't allow
 
219
        # endings to 'bzr commit -m ""' which breaks because we don't allow
273
220
        # '\r' in commit messages. (Mostly because of issues where XML style
274
221
        # formats arbitrarily strip it out of the data while parsing.)
275
222
        # To make life easier for users, we just always translate '\r\n' =>
287
234
 
288
235
    def test_commit_merge_reports_all_modified_files(self):
289
236
        # the commit command should show all the files that are shown by
290
 
        # brz diff or brz status when committing, even when they were not
 
237
        # bzr diff or bzr status when committing, even when they were not
291
238
        # changed by the user but rather through doing a merge.
292
239
        this_tree = self.make_branch_and_tree('this')
293
240
        # we need a bunch of files and dirs, to perform one action on each.
314
261
            'filetoleave']
315
262
            )
316
263
        this_tree.commit('create_files')
317
 
        other_dir = this_tree.controldir.sprout('other')
 
264
        other_dir = this_tree.bzrdir.sprout('other')
318
265
        other_tree = other_dir.open_workingtree()
319
 
        with other_tree.lock_write():
320
 
            # perform the needed actions on the files and dirs.
 
266
        other_tree.lock_write()
 
267
        # perform the needed actions on the files and dirs.
 
268
        try:
321
269
            other_tree.rename_one('dirtorename', 'renameddir')
322
270
            other_tree.rename_one('dirtoreparent', 'renameddir/reparenteddir')
323
271
            other_tree.rename_one('filetorename', 'renamedfile')
326
274
            other_tree.remove(['dirtoremove', 'filetoremove'])
327
275
            self.build_tree_contents([
328
276
                ('other/newdir/',),
329
 
                ('other/filetomodify', b'new content'),
330
 
                ('other/newfile', b'new file content')])
 
277
                ('other/filetomodify', 'new content'),
 
278
                ('other/newfile', 'new file content')])
331
279
            other_tree.add('newfile')
332
280
            other_tree.add('newdir/')
333
281
            other_tree.commit('modify all sample files and dirs.')
 
282
        finally:
 
283
            other_tree.unlock()
334
284
        this_tree.merge_from_branch(other_tree.branch)
335
 
        out, err = self.run_bzr('commit -m added', working_dir='this')
 
285
        os.chdir('this')
 
286
        out,err = self.run_bzr('commit -m added')
336
287
        self.assertEqual('', out)
337
 
        self.assertEqual({
338
 
            'Committing to: %s/' % osutils.pathjoin(osutils.getcwd(), 'this'),
 
288
        self.assertEqual(set([
 
289
            'Committing to: %s/' % osutils.getcwd(),
339
290
            'modified filetomodify',
340
291
            'added newdir',
341
292
            'added newfile',
347
298
            'deleted filetoremove',
348
299
            'Committed revision 2.',
349
300
            ''
350
 
            }, set(err.split('\n')))
 
301
            ]), set(err.split('\n')))
351
302
 
352
303
    def test_empty_commit_message(self):
353
304
        tree = self.make_branch_and_tree('.')
354
 
        self.build_tree_contents([('foo.c', b'int main() {}')])
355
 
        tree.add('foo.c')
356
 
        self.run_bzr('commit -m ""')
 
305
        self.build_tree_contents([('foo.c', 'int main() {}')])
 
306
        tree.add('foo.c')
 
307
        self.run_bzr('commit -m ""', retcode=3)
 
308
 
 
309
    def test_unsupported_encoding_commit_message(self):
 
310
        if sys.platform == 'win32':
 
311
            raise tests.TestNotApplicable('Win32 parses arguments directly'
 
312
                ' as Unicode, so we can\'t pass invalid non-ascii')
 
313
        tree = self.make_branch_and_tree('.')
 
314
        self.build_tree_contents([('foo.c', 'int main() {}')])
 
315
        tree.add('foo.c')
 
316
        # LANG env variable has no effect on Windows
 
317
        # but some characters anyway cannot be represented
 
318
        # in default user encoding
 
319
        char = probe_bad_non_ascii(osutils.get_user_encoding())
 
320
        if char is None:
 
321
            raise TestSkipped('Cannot find suitable non-ascii character'
 
322
                'for user_encoding (%s)' % osutils.get_user_encoding())
 
323
        out,err = self.run_bzr_subprocess('commit -m "%s"' % char,
 
324
                                          retcode=1,
 
325
                                          env_changes={'LANG': 'C'})
 
326
        self.assertContainsRe(err, r'bzrlib.errors.BzrError: Parameter.*is '
 
327
                                    'unsupported by the current encoding.')
357
328
 
358
329
    def test_other_branch_commit(self):
359
330
        # this branch is to ensure consistent behaviour, whether we're run
361
332
        outer_tree = self.make_branch_and_tree('.')
362
333
        inner_tree = self.make_branch_and_tree('branch')
363
334
        self.build_tree_contents([
364
 
            ('branch/foo.c', b'int main() {}'),
365
 
            ('branch/bar.c', b'int main() {}')])
 
335
            ('branch/foo.c', 'int main() {}'),
 
336
            ('branch/bar.c', 'int main() {}')])
366
337
        inner_tree.add(['foo.c', 'bar.c'])
367
338
        # can't commit files in different trees; sane error
368
339
        self.run_bzr('commit -m newstuff branch/foo.c .', retcode=3)
371
342
        # can commit to branch - records bar.c
372
343
        self.run_bzr('commit -m newstuff branch')
373
344
        # No changes left
374
 
        self.run_bzr_error(["No changes to commit"],
375
 
                           'commit -m newstuff branch')
 
345
        self.run_bzr_error(["No changes to commit"], 'commit -m newstuff branch')
376
346
 
377
347
    def test_out_of_date_tree_commit(self):
378
348
        # check we get an error code and a clear message committing with an out
383
353
        # commit to the original branch to make the checkout out of date
384
354
        tree.commit('message branch', allow_pointless=True)
385
355
        # now commit to the checkout should emit
386
 
        # ERROR: Out of date with the branch, 'brz update' is suggested
 
356
        # ERROR: Out of date with the branch, 'bzr update' is suggested
387
357
        output = self.run_bzr('commit --unchanged -m checkout_message '
388
 
                              'checkout', retcode=3)
 
358
                             'checkout', retcode=3)
389
359
        self.assertEqual(output,
390
360
                         ('',
391
 
                          "brz: ERROR: Working tree is out of date, please "
392
 
                          "run 'brz update'.\n"))
 
361
                          "bzr: ERROR: Working tree is out of date, please "
 
362
                          "run 'bzr update'.\n"))
393
363
 
394
364
    def test_local_commit_unbound(self):
395
365
        # a --local commit on an unbound branch is an error
396
366
        self.make_branch_and_tree('.')
397
367
        out, err = self.run_bzr('commit --local', retcode=3)
398
368
        self.assertEqualDiff('', out)
399
 
        self.assertEqualDiff('brz: ERROR: Cannot perform local-only commits '
 
369
        self.assertEqualDiff('bzr: ERROR: Cannot perform local-only commits '
400
370
                             'on unbound branches.\n', err)
401
371
 
402
372
    def test_commit_a_text_merge_in_a_checkout(self):
408
378
        trunk = self.make_branch_and_tree('trunk')
409
379
 
410
380
        u1 = trunk.branch.create_checkout('u1')
411
 
        self.build_tree_contents([('u1/hosts', b'initial contents\n')])
 
381
        self.build_tree_contents([('u1/hosts', 'initial contents\n')])
412
382
        u1.add('hosts')
413
383
        self.run_bzr('commit -m add-hosts u1')
414
384
 
415
385
        u2 = trunk.branch.create_checkout('u2')
416
 
        self.build_tree_contents([('u2/hosts', b'altered in u2\n')])
 
386
        self.build_tree_contents([('u2/hosts', 'altered in u2\n')])
417
387
        self.run_bzr('commit -m checkin-from-u2 u2')
418
388
 
419
389
        # make an offline commits
420
 
        self.build_tree_contents(
421
 
            [('u1/hosts', b'first offline change in u1\n')])
 
390
        self.build_tree_contents([('u1/hosts', 'first offline change in u1\n')])
422
391
        self.run_bzr('commit -m checkin-offline --local u1')
423
392
 
424
393
        # now try to pull in online work from u2, and then commit our offline
425
394
        # work as a merge
426
395
        # retcode 1 as we expect a text conflict
427
396
        self.run_bzr('update u1', retcode=1)
428
 
        self.assertFileEqual(b'''\
 
397
        self.assertFileEqual('''\
429
398
<<<<<<< TREE
430
399
first offline change in u1
431
400
=======
438
407
        # add a text change here to represent resolving the merge conflicts in
439
408
        # favour of a new version of the file not identical to either the u1
440
409
        # version or the u2 version.
441
 
        self.build_tree_contents([('u1/hosts', b'merge resolution\n')])
 
410
        self.build_tree_contents([('u1/hosts', 'merge resolution\n')])
442
411
        self.run_bzr('commit -m checkin-merge-of-the-offline-work-from-u1 u1')
443
412
 
444
413
    def test_commit_exclude_excludes_modified_files(self):
477
446
        t.add(['file-a', 'dir-a', 'dir-a/file-b'])
478
447
        t.commit('Create')
479
448
        t.remove(['file-a', 'dir-a/file-b'])
480
 
        result = self.run_bzr('commit . -m removed-file-b',
481
 
                              working_dir='dir-a')[1]
 
449
        os.chdir('dir-a')
 
450
        result = self.run_bzr('commit . -m removed-file-b')[1]
482
451
        self.assertNotContainsRe(result, 'file-a')
483
 
        result = self.run_bzr('status', working_dir='dir-a')[0]
 
452
        result = self.run_bzr('status')[0]
484
453
        self.assertContainsRe(result, 'removed:\n  file-a')
485
454
 
486
455
    def test_strict_commit(self):
490
459
        self.build_tree(['tree/a'])
491
460
        tree.add('a')
492
461
        # A simple change should just work
493
 
        self.run_bzr('commit --strict -m adding-a', working_dir='tree')
 
462
        self.run_bzr('commit --strict -m adding-a',
 
463
                     working_dir='tree')
494
464
 
495
465
    def test_strict_commit_no_changes(self):
496
466
        """commit --strict gives "no changes" if there is nothing to commit"""
536
506
            'commit -m hello --fixes=lp:23452 tree/hello.txt')
537
507
        self.assertEqual('', output)
538
508
        self.assertContainsRe(err, 'Committing to: .*\n'
539
 
                              'added hello\\.txt\n'
540
 
                              'Committed revision 1\\.\n')
541
 
 
542
 
    def test_fixes_bug_unicode(self):
543
 
        """commit --fixes=lp:unicode succeeds without output."""
544
 
        tree = self.make_branch_and_tree('tree')
545
 
        self.build_tree(['tree/hello.txt'])
546
 
        tree.add('hello.txt')
547
 
        output, err = self.run_bzr_raw(
548
 
            ['commit', '-m', 'hello',
549
 
             u'--fixes=generic:\u20ac', 'tree/hello.txt'],
550
 
            encoding='utf-8', retcode=3)
551
 
        self.assertEqual(b'', output)
552
 
        self.assertContainsRe(err,
553
 
                              b'brz: ERROR: Unrecognized bug generic:\xe2\x82\xac\\. Commit refused.\n')
 
509
                              'added hello\.txt\n'
 
510
                              'Committed revision 1\.\n')
554
511
 
555
512
    def test_no_bugs_no_properties(self):
556
513
        """If no bugs are fixed, the bugs property is not set.
560
517
        tree = self.make_branch_and_tree('tree')
561
518
        self.build_tree(['tree/hello.txt'])
562
519
        tree.add('hello.txt')
563
 
        self.run_bzr('commit -m hello tree/hello.txt')
 
520
        self.run_bzr( 'commit -m hello tree/hello.txt')
564
521
        # Get the revision properties, ignoring the branch-nick property, which
565
522
        # we don't care about for this test.
566
523
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
568
525
        del properties['branch-nick']
569
526
        self.assertFalse('bugs' in properties)
570
527
 
571
 
    def test_bugs_sets_property(self):
572
 
        """commit --bugs=lp:234 sets the lp:234 revprop to 'related'."""
573
 
        tree = self.make_branch_and_tree('tree')
574
 
        self.build_tree(['tree/hello.txt'])
575
 
        tree.add('hello.txt')
576
 
        self.run_bzr('commit -m hello --bugs=lp:234 tree/hello.txt')
577
 
 
578
 
        # Get the revision properties, ignoring the branch-nick property, which
579
 
        # we don't care about for this test.
580
 
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
581
 
        properties = dict(last_rev.properties)
582
 
        del properties[u'branch-nick']
583
 
 
584
 
        self.assertEqual({u'bugs': 'https://launchpad.net/bugs/234 related'},
585
 
                         properties)
586
 
 
587
528
    def test_fixes_bug_sets_property(self):
588
529
        """commit --fixes=lp:234 sets the lp:234 revprop to 'fixed'."""
589
530
        tree = self.make_branch_and_tree('tree')
595
536
        # we don't care about for this test.
596
537
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
597
538
        properties = dict(last_rev.properties)
598
 
        del properties[u'branch-nick']
 
539
        del properties['branch-nick']
599
540
 
600
 
        self.assertEqual({u'bugs': 'https://launchpad.net/bugs/234 fixed'},
 
541
        self.assertEqual({'bugs': 'https://launchpad.net/bugs/234 fixed'},
601
542
                         properties)
602
543
 
603
544
    def test_fixes_multiple_bugs_sets_properties(self):
615
556
        del properties['branch-nick']
616
557
 
617
558
        self.assertEqual(
618
 
            {u'bugs': 'https://launchpad.net/bugs/123 fixed\n'
619
 
             'https://launchpad.net/bugs/235 fixed'},
 
559
            {'bugs': 'https://launchpad.net/bugs/123 fixed\n'
 
560
                     'https://launchpad.net/bugs/235 fixed'},
620
561
            properties)
621
562
 
622
563
    def test_fixes_bug_with_alternate_trackers(self):
628
569
            'trac_twisted_url', 'http://twistedmatrix.com/trac')
629
570
        self.build_tree(['tree/hello.txt'])
630
571
        tree.add('hello.txt')
631
 
        self.run_bzr(
632
 
            'commit -m hello --fixes=lp:123 --fixes=twisted:235 tree/')
 
572
        self.run_bzr('commit -m hello --fixes=lp:123 --fixes=twisted:235 tree/')
633
573
 
634
574
        # Get the revision properties, ignoring the branch-nick property, which
635
575
        # we don't care about for this test.
651
591
            'commit -m add-b --fixes=xxx:123',
652
592
            working_dir='tree')
653
593
 
654
 
    def test_fixes_bug_with_default_tracker(self):
655
 
        """commit --fixes=234 uses the default bug tracker."""
656
 
        tree = self.make_branch_and_tree('tree')
657
 
        self.build_tree(['tree/hello.txt'])
658
 
        tree.add('hello.txt')
659
 
        self.run_bzr_error(
660
 
            ["brz: ERROR: No tracker specified for bug 123. Use the form "
661
 
             "'tracker:id' or specify a default bug tracker using the "
662
 
             "`bugtracker` option.\n"
663
 
             "See \"brz help bugs\" for more information on this feature. "
664
 
             "Commit refused."],
665
 
            'commit -m add-b --fixes=123',
666
 
            working_dir='tree')
667
 
        tree.branch.get_config_stack().set("bugtracker", "lp")
668
 
        self.run_bzr('commit -m hello --fixes=234 tree/hello.txt')
669
 
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
670
 
        self.assertEqual('https://launchpad.net/bugs/234 fixed',
671
 
                         last_rev.properties['bugs'])
672
 
 
673
594
    def test_fixes_invalid_bug_number(self):
674
595
        tree = self.make_branch_and_tree('tree')
675
596
        self.build_tree(['tree/hello.txt'])
676
597
        tree.add('hello.txt')
677
598
        self.run_bzr_error(
678
599
            ["Did not understand bug identifier orange: Must be an integer. "
679
 
             "See \"brz help bugs\" for more information on this feature.\n"
 
600
             "See \"bzr help bugs\" for more information on this feature.\n"
680
601
             "Commit refused."],
681
602
            'commit -m add-b --fixes=lp:orange',
682
603
            working_dir='tree')
687
608
        self.build_tree(['tree/hello.txt'])
688
609
        tree.add('hello.txt')
689
610
        self.run_bzr_error(
690
 
            [r"Invalid bug orange:apples:bananas. Must be in the form of "
691
 
             r"'tracker:id'\. See \"brz help bugs\" for more information on "
692
 
             r"this feature.\nCommit refused\."],
693
 
            'commit -m add-b --fixes=orange:apples:bananas',
 
611
            [r"Invalid bug orange. Must be in the form of 'tracker:id'\. "
 
612
             r"See \"bzr help bugs\" for more information on this feature.\n"
 
613
             r"Commit refused\."],
 
614
            'commit -m add-b --fixes=orange',
694
615
            working_dir='tree')
695
616
 
696
617
    def test_no_author(self):
698
619
        tree = self.make_branch_and_tree('tree')
699
620
        self.build_tree(['tree/hello.txt'])
700
621
        tree.add('hello.txt')
701
 
        self.run_bzr('commit -m hello tree/hello.txt')
 
622
        self.run_bzr( 'commit -m hello tree/hello.txt')
702
623
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
703
624
        properties = last_rev.properties
704
625
        self.assertFalse('author' in properties)
712
633
        tree.add('hello.txt')
713
634
        self.run_bzr(["commit", '-m', 'hello',
714
635
                      '--author', u'John D\xf6 <jdoe@example.com>',
715
 
                      "tree/hello.txt"])
 
636
                     "tree/hello.txt"])
716
637
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
717
638
        properties = last_rev.properties
718
 
        self.assertEqual(u'John D\xf6 <jdoe@example.com>',
719
 
                         properties['authors'])
 
639
        self.assertEqual(u'John D\xf6 <jdoe@example.com>', properties['authors'])
720
640
 
721
641
    def test_author_no_email(self):
722
642
        """Author's name without an email address is allowed, too."""
745
665
        self.build_tree(['tree/hello.txt'])
746
666
        tree.add('hello.txt')
747
667
        out, err = self.run_bzr("commit -m hello "
748
 
                                "--commit-time='2009-10-10 08:00:00 +0100' tree/hello.txt")
 
668
            "--commit-time='2009-10-10 08:00:00 +0100' tree/hello.txt")
749
669
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
750
670
        self.assertEqual(
751
671
            'Sat 2009-10-10 08:00:00 +0100',
752
672
            osutils.format_date(last_rev.timestamp, last_rev.timezone))
753
 
 
 
673
        
754
674
    def test_commit_time_bad_time(self):
755
675
        tree = self.make_branch_and_tree('tree')
756
676
        self.build_tree(['tree/hello.txt'])
757
677
        tree.add('hello.txt')
758
678
        out, err = self.run_bzr("commit -m hello "
759
 
                                "--commit-time='NOT A TIME' tree/hello.txt", retcode=3)
760
 
        self.assertStartsWith(
761
 
            err, "brz: ERROR: Could not parse --commit-time:")
762
 
 
763
 
    def test_commit_time_missing_tz(self):
764
 
        tree = self.make_branch_and_tree('tree')
765
 
        self.build_tree(['tree/hello.txt'])
766
 
        tree.add('hello.txt')
767
 
        out, err = self.run_bzr("commit -m hello "
768
 
                                "--commit-time='2009-10-10 08:00:00' tree/hello.txt", retcode=3)
769
 
        self.assertStartsWith(
770
 
            err, "brz: ERROR: Could not parse --commit-time:")
771
 
        # Test that it is actually checking and does not simply crash with
772
 
        # some other exception
773
 
        self.assertContainsString(err, "missing a timezone offset")
 
679
            "--commit-time='NOT A TIME' tree/hello.txt", retcode=3)
 
680
        self.assertStartsWith(
 
681
            err, "bzr: ERROR: Could not parse --commit-time:")
774
682
 
775
683
    def test_partial_commit_with_renames_in_tree(self):
776
684
        # this test illustrates bug #140419
783
691
        # then during partial commit we have error
784
692
        # parent_id {dir-XXX} not in inventory
785
693
        t.rename_one('dir/a', 'a')
786
 
        self.build_tree_contents([('test', b'changes in test')])
 
694
        self.build_tree_contents([('test', 'changes in test')])
787
695
        # partial commit
788
696
        out, err = self.run_bzr('commit test -m "partial commit"')
789
 
        self.assertEqual('', out)
 
697
        self.assertEquals('', out)
790
698
        self.assertContainsRe(err, r'modified test\nCommitted revision 2.')
791
699
 
792
700
    def test_commit_readonly_checkout(self):
794
702
        # "UnlockableTransport error trying to commit in checkout of readonly
795
703
        # branch"
796
704
        self.make_branch('master')
797
 
        master = ControlDir.open_from_transport(
 
705
        master = BzrDir.open_from_transport(
798
706
            self.get_readonly_transport('master')).open_branch()
799
707
        master.create_checkout('checkout')
800
708
        out, err = self.run_bzr(['commit', '--unchanged', '-mfoo', 'checkout'],
801
 
                                retcode=3)
 
709
            retcode=3)
802
710
        self.assertContainsRe(err,
803
 
                              r'^brz: ERROR: Cannot lock.*readonly transport')
 
711
            r'^bzr: ERROR: Cannot lock.*readonly transport')
804
712
 
805
713
    def setup_editor(self):
806
714
        # Test that commit template hooks work
807
715
        if sys.platform == "win32":
808
 
            with open('fed.bat', 'w') as f:
809
 
                f.write('@rem dummy fed')
810
 
            self.overrideEnv('BRZ_EDITOR', "fed.bat")
 
716
            f = file('fed.bat', 'w')
 
717
            f.write('@rem dummy fed')
 
718
            f.close()
 
719
            osutils.set_or_unset_env('BZR_EDITOR', "fed.bat")
811
720
        else:
812
 
            with open('fed.sh', 'wb') as f:
813
 
                f.write(b'#!/bin/sh\n')
814
 
            os.chmod('fed.sh', 0o755)
815
 
            self.overrideEnv('BRZ_EDITOR', "./fed.sh")
 
721
            f = file('fed.sh', 'wb')
 
722
            f.write('#!/bin/sh\n')
 
723
            f.close()
 
724
            os.chmod('fed.sh', 0755)
 
725
            osutils.set_or_unset_env('BZR_EDITOR', "./fed.sh")
816
726
 
817
727
    def setup_commit_with_template(self):
818
728
        self.setup_editor()
819
729
        msgeditor.hooks.install_named_hook("commit_message_template",
820
 
                                           lambda commit_obj, msg: "save me some typing\n", None)
 
730
                lambda commit_obj, msg: "save me some typing\n", None)
821
731
        tree = self.make_branch_and_tree('tree')
822
732
        self.build_tree(['tree/hello.txt'])
823
733
        tree.add('hello.txt')
824
734
        return tree
825
735
 
826
 
    def test_edit_empty_message(self):
827
 
        tree = self.make_branch_and_tree('tree')
828
 
        self.setup_editor()
829
 
        self.build_tree(['tree/hello.txt'])
830
 
        tree.add('hello.txt')
831
 
        out, err = self.run_bzr("commit tree/hello.txt", retcode=3,
832
 
                                stdin="y\n")
833
 
        self.assertContainsRe(err,
834
 
                              "brz: ERROR: Empty commit message specified")
835
 
 
836
736
    def test_commit_hook_template_accepted(self):
837
737
        tree = self.setup_commit_with_template()
838
738
        out, err = self.run_bzr("commit tree/hello.txt", stdin="y\n")
842
742
    def test_commit_hook_template_rejected(self):
843
743
        tree = self.setup_commit_with_template()
844
744
        expected = tree.last_revision()
845
 
        out, err = self.run_bzr_error(["Empty commit message specified."
846
 
                                       " Please specify a commit message with either"
847
 
                                       " --message or --file or leave a blank message"
848
 
                                       " with --message \"\"."],
849
 
                                      "commit tree/hello.txt", stdin="n\n")
 
745
        out, err = self.run_bzr_error(["empty commit message"],
 
746
            "commit tree/hello.txt", stdin="n\n")
850
747
        self.assertEqual(expected, tree.last_revision())
851
748
 
852
 
    def test_set_commit_message(self):
853
 
        msgeditor.hooks.install_named_hook("set_commit_message",
854
 
                                           lambda commit_obj, msg: "save me some typing\n", None)
855
 
        tree = self.make_branch_and_tree('tree')
856
 
        self.build_tree(['tree/hello.txt'])
857
 
        tree.add('hello.txt')
858
 
        out, err = self.run_bzr("commit tree/hello.txt")
859
 
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
860
 
        self.assertEqual('save me some typing\n', last_rev.message)
861
 
 
862
749
    def test_commit_without_username(self):
863
750
        """Ensure commit error if username is not set.
864
751
        """
865
752
        self.run_bzr(['init', 'foo'])
866
 
        with open('foo/foo.txt', 'w') as f:
867
 
            f.write('hello')
868
 
        self.run_bzr(['add'], working_dir='foo')
869
 
        override_whoami(self)
870
 
        self.run_bzr_error(
871
 
            ['Unable to determine your name'],
872
 
            ['commit', '-m', 'initial'], working_dir='foo')
873
 
 
874
 
    def test_commit_recursive_checkout(self):
875
 
        """Ensure that a commit to a recursive checkout fails cleanly.
876
 
        """
877
 
        self.run_bzr(['init', 'test_branch'])
878
 
        self.run_bzr(['checkout', 'test_branch', 'test_checkout'])
879
 
        # bind to self
880
 
        self.run_bzr(['bind', '.'], working_dir='test_checkout')
881
 
        with open('test_checkout/foo.txt', 'w') as f:
882
 
            f.write('hello')
883
 
        self.run_bzr(['add'], working_dir='test_checkout')
884
 
        out, err = self.run_bzr_error(
885
 
            ['Branch.*test_checkout.*appears to be bound to itself'],
886
 
            ['commit', '-m', 'addedfoo'], working_dir='test_checkout')
887
 
 
888
 
    def test_mv_dirs_non_ascii(self):
889
 
        """Move directory with non-ascii name and containing files.
890
 
 
891
 
        Regression test for bug 185211.
892
 
        """
893
 
        tree = self.make_branch_and_tree('.')
894
 
        self.build_tree([u'abc\xa7/', u'abc\xa7/foo'])
895
 
 
896
 
        tree.add([u'abc\xa7/', u'abc\xa7/foo'])
897
 
        tree.commit('checkin')
898
 
 
899
 
        tree.rename_one(u'abc\xa7', 'abc')
900
 
 
901
 
        self.run_bzr('ci -m "non-ascii mv"')
902
 
 
903
 
 
904
 
class TestSmartServerCommit(TestCaseWithTransport):
905
 
 
906
 
    def test_commit_to_lightweight(self):
907
 
        self.setup_smart_server_with_call_log()
908
 
        t = self.make_branch_and_tree('from')
909
 
        for count in range(9):
910
 
            t.commit(message='commit %d' % count)
911
 
        out, err = self.run_bzr(['checkout', '--lightweight', self.get_url('from'),
912
 
                                 'target'])
913
 
        self.reset_smart_call_log()
914
 
        self.build_tree(['target/afile'])
915
 
        self.run_bzr(['add', 'target/afile'])
916
 
        out, err = self.run_bzr(['commit', '-m', 'do something', 'target'])
917
 
        # This figure represent the amount of work to perform this use case. It
918
 
        # is entirely ok to reduce this number if a test fails due to rpc_count
919
 
        # being too low. If rpc_count increases, more network roundtrips have
920
 
        # become necessary for this use case. Please do not adjust this number
921
 
        # upwards without agreement from bzr's network support maintainers.
922
 
        self.assertLength(211, self.hpss_calls)
923
 
        self.assertLength(2, self.hpss_connections)
924
 
        self.expectFailure("commit still uses VFS calls",
925
 
                           self.assertThat, self.hpss_calls, ContainsNoVfsCalls)
 
753
        os.chdir('foo')
 
754
        open('foo.txt', 'w').write('hello')
 
755
        self.run_bzr(['add'])
 
756
        osutils.set_or_unset_env('EMAIL', None)
 
757
        osutils.set_or_unset_env('BZR_EMAIL', None)
 
758
        out, err = self.run_bzr(['commit', '-m', 'initial'], 3)
 
759
        self.assertContainsRe(err, 'Unable to determine your name')