/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 breezy/tests/blackbox/test_commit.py

  • Committer: Jelmer Vernooij
  • Date: 2020-04-05 19:11:34 UTC
  • mto: (7490.7.16 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200405191134-0aebh8ikiwygxma5
Populate the .gitignore file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/blackbox/test_commit.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2012, 2016 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
20
21
import os
21
22
import re
22
23
import sys
23
24
 
24
 
from bzrlib import (
 
25
from testtools.matchers import DocTestMatches
 
26
 
 
27
from ... import (
 
28
    config,
25
29
    osutils,
26
30
    ignores,
27
31
    msgeditor,
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):
 
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):
40
45
 
41
46
    def test_05_empty_commit(self):
42
47
        """Commit of tree with no versioned files should fail"""
43
48
        # If forced, it should succeed, but this is not tested here.
44
49
        self.make_branch_and_tree('.')
45
50
        self.build_tree(['hello.txt'])
46
 
        out,err = self.run_bzr('commit -m empty', retcode=3)
 
51
        out, err = self.run_bzr('commit -m empty', retcode=3)
47
52
        self.assertEqual('', out)
48
 
        self.assertContainsRe(err, 'bzr: ERROR: No changes to commit\.'
49
 
                                  ' Use --unchanged to commit anyhow.\n')
 
53
        # Two ugly bits here.
 
54
        # 1) We really don't want 'aborting commit write group' anymore.
 
55
        # 2) 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))
50
64
 
51
65
    def test_commit_success(self):
52
66
        """Successful commit should not leave behind a bzr-commit-* file"""
58
72
        self.run_bzr(["commit", "--unchanged", "-m", u'foo\xb5'])
59
73
        self.assertEqual('', self.run_bzr('unknowns')[0])
60
74
 
 
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
 
61
89
    def test_commit_with_path(self):
62
90
        """Commit tree with path of root specified"""
63
91
        a_tree = self.make_branch_and_tree('a')
65
93
        a_tree.add('a_file')
66
94
        self.run_bzr(['commit', '-m', 'first commit', 'a'])
67
95
 
68
 
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
69
 
        self.build_tree_contents([('b/a_file', 'changes in b')])
 
96
        b_tree = a_tree.controldir.sprout('b').open_workingtree()
 
97
        self.build_tree_contents([('b/a_file', b'changes in b')])
70
98
        self.run_bzr(['commit', '-m', 'first commit in b', 'b'])
71
99
 
72
 
        self.build_tree_contents([('a/a_file', 'new contents')])
 
100
        self.build_tree_contents([('a/a_file', b'new contents')])
73
101
        self.run_bzr(['commit', '-m', 'change in a', 'a'])
74
102
 
75
103
        b_tree.merge_from_branch(a_tree.branch)
77
105
        self.run_bzr('resolved b/a_file')
78
106
        self.run_bzr(['commit', '-m', 'merge into b', 'b'])
79
107
 
80
 
 
81
108
    def test_10_verbose_commit(self):
82
109
        """Add one file and examine verbose commit output"""
83
110
        tree = self.make_branch_and_tree('.')
84
111
        self.build_tree(['hello.txt'])
85
112
        tree.add("hello.txt")
86
 
        out,err = self.run_bzr('commit -m added')
 
113
        out, err = self.run_bzr('commit -m added')
87
114
        self.assertEqual('', out)
88
115
        self.assertContainsRe(err, '^Committing to: .*\n'
89
116
                              'added hello.txt\n'
92
119
    def prepare_simple_history(self):
93
120
        """Prepare and return a working tree with one commit of one file"""
94
121
        # Commit with modified file should say so
95
 
        wt = BzrDir.create_standalone_workingtree('.')
 
122
        wt = ControlDir.create_standalone_workingtree('.')
96
123
        self.build_tree(['hello.txt', 'extra.txt'])
97
124
        wt.add(['hello.txt'])
98
125
        wt.commit(message='added')
101
128
    def test_verbose_commit_modified(self):
102
129
        # Verbose commit of modified file should say so
103
130
        wt = self.prepare_simple_history()
104
 
        self.build_tree_contents([('hello.txt', 'new contents')])
 
131
        self.build_tree_contents([('hello.txt', b'new contents')])
105
132
        out, err = self.run_bzr('commit -m modified')
106
133
        self.assertEqual('', out)
107
134
        self.assertContainsRe(err, '^Committing to: .*\n'
108
 
                              'modified hello\.txt\n'
109
 
                              'Committed revision 2\.\n$')
 
135
                              'modified hello\\.txt\n'
 
136
                              'Committed revision 2\\.\n$')
110
137
 
111
138
    def test_unicode_commit_message_is_filename(self):
112
139
        """Unicode commit message same as a filename (Bug #563646).
113
140
        """
 
141
        self.requireFeature(features.UnicodeFilenameFeature)
114
142
        file_name = u'\N{euro sign}'
115
143
        self.run_bzr(['init'])
116
 
        open(file_name, 'w').write('hello world')
 
144
        with open(file_name, 'w') as f:
 
145
            f.write('hello world')
117
146
        self.run_bzr(['add'])
118
147
        out, err = self.run_bzr(['commit', '-m', file_name])
119
 
        reflags = re.MULTILINE|re.DOTALL|re.UNICODE
 
148
        reflags = re.MULTILINE | re.DOTALL | re.UNICODE
120
149
        te = osutils.get_terminal_encoding()
121
 
        self.assertContainsRe(err.decode(te),
122
 
            u'The commit message is a file name:',
123
 
            flags=reflags)
 
150
        self.assertContainsRe(err if PY3 else err.decode(te),
 
151
                              u'The commit message is a file name:',
 
152
                              flags=reflags)
124
153
 
125
154
        # Run same test with a filename that causes encode
126
155
        # error for the terminal encoding. We do this
129
158
        # by ui.text.show_warning
130
159
        default_get_terminal_enc = osutils.get_terminal_encoding
131
160
        try:
132
 
            osutils.get_terminal_encoding = lambda: 'ascii'
 
161
            osutils.get_terminal_encoding = lambda trace=None: 'ascii'
133
162
            file_name = u'foo\u1234'
134
 
            open(file_name, 'w').write('hello world')
 
163
            with open(file_name, 'w') as f:
 
164
                f.write('hello world')
135
165
            self.run_bzr(['add'])
136
166
            out, err = self.run_bzr(['commit', '-m', file_name])
137
 
            reflags = re.MULTILINE|re.DOTALL|re.UNICODE
 
167
            reflags = re.MULTILINE | re.DOTALL | re.UNICODE
138
168
            te = osutils.get_terminal_encoding()
139
 
            self.assertContainsRe(err.decode(te, 'replace'),
140
 
                u'The commit message is a file name:',
141
 
                flags=reflags)
 
169
            self.assertContainsRe(err if PY3 else err.decode(te, 'replace'),
 
170
                                  u'The commit message is a file name:',
 
171
                                  flags=reflags)
142
172
        finally:
143
173
            osutils.get_terminal_encoding = default_get_terminal_enc
144
174
 
 
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
 
145
198
    def test_warn_about_forgotten_commit_message(self):
146
199
        """Test that the lack of -m parameter is caught"""
147
200
        wt = self.make_branch_and_tree('.')
157
210
        out, err = self.run_bzr('commit -m renamed')
158
211
        self.assertEqual('', out)
159
212
        self.assertContainsRe(err, '^Committing to: .*\n'
160
 
                              'renamed hello\.txt => gutentag\.txt\n'
161
 
                              'Committed revision 2\.$\n')
 
213
                              'renamed hello\\.txt => gutentag\\.txt\n'
 
214
                              'Committed revision 2\\.$\n')
162
215
 
163
216
    def test_verbose_commit_moved(self):
164
217
        # Verbose commit of file moved to new directory should say so
168
221
        wt.rename_one('hello.txt', 'subdir/hello.txt')
169
222
        out, err = self.run_bzr('commit -m renamed')
170
223
        self.assertEqual('', out)
171
 
        self.assertEqual(set([
 
224
        self.assertEqual({
172
225
            'Committing to: %s/' % osutils.getcwd(),
173
226
            'added subdir',
174
227
            'renamed hello.txt => subdir/hello.txt',
175
228
            'Committed revision 2.',
176
229
            '',
177
 
            ]), set(err.split('\n')))
 
230
            }, set(err.split('\n')))
178
231
 
179
232
    def test_verbose_commit_with_unknown(self):
180
233
        """Unknown files should not be listed by default in verbose output"""
181
234
        # Is that really the best policy?
182
 
        wt = BzrDir.create_standalone_workingtree('.')
 
235
        wt = ControlDir.create_standalone_workingtree('.')
183
236
        self.build_tree(['hello.txt', 'extra.txt'])
184
237
        wt.add(['hello.txt'])
185
 
        out,err = self.run_bzr('commit -m added')
 
238
        out, err = self.run_bzr('commit -m added')
186
239
        self.assertEqual('', out)
187
240
        self.assertContainsRe(err, '^Committing to: .*\n'
188
 
                              'added hello\.txt\n'
189
 
                              'Committed revision 1\.\n$')
 
241
                              'added hello\\.txt\n'
 
242
                              'Committed revision 1\\.\n$')
190
243
 
191
244
    def test_verbose_commit_with_unchanged(self):
192
245
        """Unchanged files should not be listed by default in verbose output"""
195
248
        tree.add('unchanged.txt')
196
249
        self.run_bzr('commit -m unchanged unchanged.txt')
197
250
        tree.add("hello.txt")
198
 
        out,err = self.run_bzr('commit -m added')
 
251
        out, err = self.run_bzr('commit -m added')
199
252
        self.assertEqual('', out)
200
253
        self.assertContainsRe(err, '^Committing to: .*\n'
201
 
                              'added hello\.txt\n'
202
 
                              'Committed revision 2\.$\n')
 
254
                              'added hello\\.txt\n'
 
255
                              'Committed revision 2\\.$\n')
203
256
 
204
257
    def test_verbose_commit_includes_master_location(self):
205
258
        """Location of master is displayed when committing to bound branch"""
216
269
 
217
270
    def test_commit_sanitizes_CR_in_message(self):
218
271
        # See bug #433779, basically Emacs likes to pass '\r\n' style line
219
 
        # endings to 'bzr commit -m ""' which breaks because we don't allow
 
272
        # endings to 'brz commit -m ""' which breaks because we don't allow
220
273
        # '\r' in commit messages. (Mostly because of issues where XML style
221
274
        # formats arbitrarily strip it out of the data while parsing.)
222
275
        # To make life easier for users, we just always translate '\r\n' =>
234
287
 
235
288
    def test_commit_merge_reports_all_modified_files(self):
236
289
        # the commit command should show all the files that are shown by
237
 
        # bzr diff or bzr status when committing, even when they were not
 
290
        # brz diff or brz status when committing, even when they were not
238
291
        # changed by the user but rather through doing a merge.
239
292
        this_tree = self.make_branch_and_tree('this')
240
293
        # we need a bunch of files and dirs, to perform one action on each.
261
314
            'filetoleave']
262
315
            )
263
316
        this_tree.commit('create_files')
264
 
        other_dir = this_tree.bzrdir.sprout('other')
 
317
        other_dir = this_tree.controldir.sprout('other')
265
318
        other_tree = other_dir.open_workingtree()
266
 
        other_tree.lock_write()
267
 
        # perform the needed actions on the files and dirs.
268
 
        try:
 
319
        with other_tree.lock_write():
 
320
            # perform the needed actions on the files and dirs.
269
321
            other_tree.rename_one('dirtorename', 'renameddir')
270
322
            other_tree.rename_one('dirtoreparent', 'renameddir/reparenteddir')
271
323
            other_tree.rename_one('filetorename', 'renamedfile')
274
326
            other_tree.remove(['dirtoremove', 'filetoremove'])
275
327
            self.build_tree_contents([
276
328
                ('other/newdir/',),
277
 
                ('other/filetomodify', 'new content'),
278
 
                ('other/newfile', 'new file content')])
 
329
                ('other/filetomodify', b'new content'),
 
330
                ('other/newfile', b'new file content')])
279
331
            other_tree.add('newfile')
280
332
            other_tree.add('newdir/')
281
333
            other_tree.commit('modify all sample files and dirs.')
282
 
        finally:
283
 
            other_tree.unlock()
284
334
        this_tree.merge_from_branch(other_tree.branch)
285
 
        os.chdir('this')
286
 
        out,err = self.run_bzr('commit -m added')
 
335
        out, err = self.run_bzr('commit -m added', working_dir='this')
287
336
        self.assertEqual('', out)
288
 
        self.assertEqual(set([
289
 
            'Committing to: %s/' % osutils.getcwd(),
 
337
        self.assertEqual({
 
338
            'Committing to: %s/' % osutils.pathjoin(osutils.getcwd(), 'this'),
290
339
            'modified filetomodify',
291
340
            'added newdir',
292
341
            'added newfile',
298
347
            'deleted filetoremove',
299
348
            'Committed revision 2.',
300
349
            ''
301
 
            ]), set(err.split('\n')))
 
350
            }, set(err.split('\n')))
302
351
 
303
352
    def test_empty_commit_message(self):
304
353
        tree = self.make_branch_and_tree('.')
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.')
 
354
        self.build_tree_contents([('foo.c', b'int main() {}')])
 
355
        tree.add('foo.c')
 
356
        self.run_bzr('commit -m ""')
328
357
 
329
358
    def test_other_branch_commit(self):
330
359
        # this branch is to ensure consistent behaviour, whether we're run
332
361
        outer_tree = self.make_branch_and_tree('.')
333
362
        inner_tree = self.make_branch_and_tree('branch')
334
363
        self.build_tree_contents([
335
 
            ('branch/foo.c', 'int main() {}'),
336
 
            ('branch/bar.c', 'int main() {}')])
 
364
            ('branch/foo.c', b'int main() {}'),
 
365
            ('branch/bar.c', b'int main() {}')])
337
366
        inner_tree.add(['foo.c', 'bar.c'])
338
367
        # can't commit files in different trees; sane error
339
368
        self.run_bzr('commit -m newstuff branch/foo.c .', retcode=3)
342
371
        # can commit to branch - records bar.c
343
372
        self.run_bzr('commit -m newstuff branch')
344
373
        # No changes left
345
 
        self.run_bzr_error(["No changes to commit"], 'commit -m newstuff branch')
 
374
        self.run_bzr_error(["No changes to commit"],
 
375
                           'commit -m newstuff branch')
346
376
 
347
377
    def test_out_of_date_tree_commit(self):
348
378
        # check we get an error code and a clear message committing with an out
353
383
        # commit to the original branch to make the checkout out of date
354
384
        tree.commit('message branch', allow_pointless=True)
355
385
        # now commit to the checkout should emit
356
 
        # ERROR: Out of date with the branch, 'bzr update' is suggested
 
386
        # ERROR: Out of date with the branch, 'brz update' is suggested
357
387
        output = self.run_bzr('commit --unchanged -m checkout_message '
358
 
                             'checkout', retcode=3)
 
388
                              'checkout', retcode=3)
359
389
        self.assertEqual(output,
360
390
                         ('',
361
 
                          "bzr: ERROR: Working tree is out of date, please "
362
 
                          "run 'bzr update'.\n"))
 
391
                          "brz: ERROR: Working tree is out of date, please "
 
392
                          "run 'brz update'.\n"))
363
393
 
364
394
    def test_local_commit_unbound(self):
365
395
        # a --local commit on an unbound branch is an error
366
396
        self.make_branch_and_tree('.')
367
397
        out, err = self.run_bzr('commit --local', retcode=3)
368
398
        self.assertEqualDiff('', out)
369
 
        self.assertEqualDiff('bzr: ERROR: Cannot perform local-only commits '
 
399
        self.assertEqualDiff('brz: ERROR: Cannot perform local-only commits '
370
400
                             'on unbound branches.\n', err)
371
401
 
372
402
    def test_commit_a_text_merge_in_a_checkout(self):
378
408
        trunk = self.make_branch_and_tree('trunk')
379
409
 
380
410
        u1 = trunk.branch.create_checkout('u1')
381
 
        self.build_tree_contents([('u1/hosts', 'initial contents\n')])
 
411
        self.build_tree_contents([('u1/hosts', b'initial contents\n')])
382
412
        u1.add('hosts')
383
413
        self.run_bzr('commit -m add-hosts u1')
384
414
 
385
415
        u2 = trunk.branch.create_checkout('u2')
386
 
        self.build_tree_contents([('u2/hosts', 'altered in u2\n')])
 
416
        self.build_tree_contents([('u2/hosts', b'altered in u2\n')])
387
417
        self.run_bzr('commit -m checkin-from-u2 u2')
388
418
 
389
419
        # make an offline commits
390
 
        self.build_tree_contents([('u1/hosts', 'first offline change in u1\n')])
 
420
        self.build_tree_contents(
 
421
            [('u1/hosts', b'first offline change in u1\n')])
391
422
        self.run_bzr('commit -m checkin-offline --local u1')
392
423
 
393
424
        # now try to pull in online work from u2, and then commit our offline
394
425
        # work as a merge
395
426
        # retcode 1 as we expect a text conflict
396
427
        self.run_bzr('update u1', retcode=1)
397
 
        self.assertFileEqual('''\
 
428
        self.assertFileEqual(b'''\
398
429
<<<<<<< TREE
399
430
first offline change in u1
400
431
=======
407
438
        # add a text change here to represent resolving the merge conflicts in
408
439
        # favour of a new version of the file not identical to either the u1
409
440
        # version or the u2 version.
410
 
        self.build_tree_contents([('u1/hosts', 'merge resolution\n')])
 
441
        self.build_tree_contents([('u1/hosts', b'merge resolution\n')])
411
442
        self.run_bzr('commit -m checkin-merge-of-the-offline-work-from-u1 u1')
412
443
 
413
444
    def test_commit_exclude_excludes_modified_files(self):
446
477
        t.add(['file-a', 'dir-a', 'dir-a/file-b'])
447
478
        t.commit('Create')
448
479
        t.remove(['file-a', 'dir-a/file-b'])
449
 
        os.chdir('dir-a')
450
 
        result = self.run_bzr('commit . -m removed-file-b')[1]
 
480
        result = self.run_bzr('commit . -m removed-file-b',
 
481
                              working_dir='dir-a')[1]
451
482
        self.assertNotContainsRe(result, 'file-a')
452
 
        result = self.run_bzr('status')[0]
 
483
        result = self.run_bzr('status', working_dir='dir-a')[0]
453
484
        self.assertContainsRe(result, 'removed:\n  file-a')
454
485
 
455
486
    def test_strict_commit(self):
459
490
        self.build_tree(['tree/a'])
460
491
        tree.add('a')
461
492
        # A simple change should just work
462
 
        self.run_bzr('commit --strict -m adding-a',
463
 
                     working_dir='tree')
 
493
        self.run_bzr('commit --strict -m adding-a', working_dir='tree')
464
494
 
465
495
    def test_strict_commit_no_changes(self):
466
496
        """commit --strict gives "no changes" if there is nothing to commit"""
506
536
            'commit -m hello --fixes=lp:23452 tree/hello.txt')
507
537
        self.assertEqual('', output)
508
538
        self.assertContainsRe(err, 'Committing to: .*\n'
509
 
                              'added hello\.txt\n'
510
 
                              'Committed revision 1\.\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')
511
554
 
512
555
    def test_no_bugs_no_properties(self):
513
556
        """If no bugs are fixed, the bugs property is not set.
517
560
        tree = self.make_branch_and_tree('tree')
518
561
        self.build_tree(['tree/hello.txt'])
519
562
        tree.add('hello.txt')
520
 
        self.run_bzr( 'commit -m hello tree/hello.txt')
 
563
        self.run_bzr('commit -m hello tree/hello.txt')
521
564
        # Get the revision properties, ignoring the branch-nick property, which
522
565
        # we don't care about for this test.
523
566
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
525
568
        del properties['branch-nick']
526
569
        self.assertFalse('bugs' in properties)
527
570
 
 
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
 
528
587
    def test_fixes_bug_sets_property(self):
529
588
        """commit --fixes=lp:234 sets the lp:234 revprop to 'fixed'."""
530
589
        tree = self.make_branch_and_tree('tree')
536
595
        # we don't care about for this test.
537
596
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
538
597
        properties = dict(last_rev.properties)
539
 
        del properties['branch-nick']
 
598
        del properties[u'branch-nick']
540
599
 
541
 
        self.assertEqual({'bugs': 'https://launchpad.net/bugs/234 fixed'},
 
600
        self.assertEqual({u'bugs': 'https://launchpad.net/bugs/234 fixed'},
542
601
                         properties)
543
602
 
544
603
    def test_fixes_multiple_bugs_sets_properties(self):
556
615
        del properties['branch-nick']
557
616
 
558
617
        self.assertEqual(
559
 
            {'bugs': 'https://launchpad.net/bugs/123 fixed\n'
560
 
                     'https://launchpad.net/bugs/235 fixed'},
 
618
            {u'bugs': 'https://launchpad.net/bugs/123 fixed\n'
 
619
             'https://launchpad.net/bugs/235 fixed'},
561
620
            properties)
562
621
 
563
622
    def test_fixes_bug_with_alternate_trackers(self):
569
628
            'trac_twisted_url', 'http://twistedmatrix.com/trac')
570
629
        self.build_tree(['tree/hello.txt'])
571
630
        tree.add('hello.txt')
572
 
        self.run_bzr('commit -m hello --fixes=lp:123 --fixes=twisted:235 tree/')
 
631
        self.run_bzr(
 
632
            'commit -m hello --fixes=lp:123 --fixes=twisted:235 tree/')
573
633
 
574
634
        # Get the revision properties, ignoring the branch-nick property, which
575
635
        # we don't care about for this test.
591
651
            'commit -m add-b --fixes=xxx:123',
592
652
            working_dir='tree')
593
653
 
 
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
 
594
673
    def test_fixes_invalid_bug_number(self):
595
674
        tree = self.make_branch_and_tree('tree')
596
675
        self.build_tree(['tree/hello.txt'])
597
676
        tree.add('hello.txt')
598
677
        self.run_bzr_error(
599
678
            ["Did not understand bug identifier orange: Must be an integer. "
600
 
             "See \"bzr help bugs\" for more information on this feature.\n"
 
679
             "See \"brz help bugs\" for more information on this feature.\n"
601
680
             "Commit refused."],
602
681
            'commit -m add-b --fixes=lp:orange',
603
682
            working_dir='tree')
608
687
        self.build_tree(['tree/hello.txt'])
609
688
        tree.add('hello.txt')
610
689
        self.run_bzr_error(
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',
 
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',
615
694
            working_dir='tree')
616
695
 
617
696
    def test_no_author(self):
619
698
        tree = self.make_branch_and_tree('tree')
620
699
        self.build_tree(['tree/hello.txt'])
621
700
        tree.add('hello.txt')
622
 
        self.run_bzr( 'commit -m hello tree/hello.txt')
 
701
        self.run_bzr('commit -m hello tree/hello.txt')
623
702
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
624
703
        properties = last_rev.properties
625
704
        self.assertFalse('author' in properties)
633
712
        tree.add('hello.txt')
634
713
        self.run_bzr(["commit", '-m', 'hello',
635
714
                      '--author', u'John D\xf6 <jdoe@example.com>',
636
 
                     "tree/hello.txt"])
 
715
                      "tree/hello.txt"])
637
716
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
638
717
        properties = last_rev.properties
639
 
        self.assertEqual(u'John D\xf6 <jdoe@example.com>', properties['authors'])
 
718
        self.assertEqual(u'John D\xf6 <jdoe@example.com>',
 
719
                         properties['authors'])
640
720
 
641
721
    def test_author_no_email(self):
642
722
        """Author's name without an email address is allowed, too."""
665
745
        self.build_tree(['tree/hello.txt'])
666
746
        tree.add('hello.txt')
667
747
        out, err = self.run_bzr("commit -m hello "
668
 
            "--commit-time='2009-10-10 08:00:00 +0100' tree/hello.txt")
 
748
                                "--commit-time='2009-10-10 08:00:00 +0100' tree/hello.txt")
669
749
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
670
750
        self.assertEqual(
671
751
            'Sat 2009-10-10 08:00:00 +0100',
672
752
            osutils.format_date(last_rev.timestamp, last_rev.timezone))
673
 
        
 
753
 
674
754
    def test_commit_time_bad_time(self):
675
755
        tree = self.make_branch_and_tree('tree')
676
756
        self.build_tree(['tree/hello.txt'])
677
757
        tree.add('hello.txt')
678
758
        out, err = self.run_bzr("commit -m hello "
679
 
            "--commit-time='NOT A TIME' tree/hello.txt", retcode=3)
680
 
        self.assertStartsWith(
681
 
            err, "bzr: ERROR: Could not parse --commit-time:")
 
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")
682
774
 
683
775
    def test_partial_commit_with_renames_in_tree(self):
684
776
        # this test illustrates bug #140419
691
783
        # then during partial commit we have error
692
784
        # parent_id {dir-XXX} not in inventory
693
785
        t.rename_one('dir/a', 'a')
694
 
        self.build_tree_contents([('test', 'changes in test')])
 
786
        self.build_tree_contents([('test', b'changes in test')])
695
787
        # partial commit
696
788
        out, err = self.run_bzr('commit test -m "partial commit"')
697
 
        self.assertEquals('', out)
 
789
        self.assertEqual('', out)
698
790
        self.assertContainsRe(err, r'modified test\nCommitted revision 2.')
699
791
 
700
792
    def test_commit_readonly_checkout(self):
701
 
        # https://bugs.edge.launchpad.net/bzr/+bug/129701
 
793
        # https://bugs.launchpad.net/bzr/+bug/129701
702
794
        # "UnlockableTransport error trying to commit in checkout of readonly
703
795
        # branch"
704
796
        self.make_branch('master')
705
 
        master = BzrDir.open_from_transport(
 
797
        master = ControlDir.open_from_transport(
706
798
            self.get_readonly_transport('master')).open_branch()
707
799
        master.create_checkout('checkout')
708
800
        out, err = self.run_bzr(['commit', '--unchanged', '-mfoo', 'checkout'],
709
 
            retcode=3)
 
801
                                retcode=3)
710
802
        self.assertContainsRe(err,
711
 
            r'^bzr: ERROR: Cannot lock.*readonly transport')
 
803
                              r'^brz: ERROR: Cannot lock.*readonly transport')
712
804
 
713
805
    def setup_editor(self):
714
806
        # Test that commit template hooks work
715
807
        if sys.platform == "win32":
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")
 
808
            with open('fed.bat', 'w') as f:
 
809
                f.write('@rem dummy fed')
 
810
            self.overrideEnv('BRZ_EDITOR', "fed.bat")
720
811
        else:
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")
 
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")
726
816
 
727
817
    def setup_commit_with_template(self):
728
818
        self.setup_editor()
729
819
        msgeditor.hooks.install_named_hook("commit_message_template",
730
 
                lambda commit_obj, msg: "save me some typing\n", None)
 
820
                                           lambda commit_obj, msg: "save me some typing\n", None)
731
821
        tree = self.make_branch_and_tree('tree')
732
822
        self.build_tree(['tree/hello.txt'])
733
823
        tree.add('hello.txt')
734
824
        return tree
735
825
 
 
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
 
736
836
    def test_commit_hook_template_accepted(self):
737
837
        tree = self.setup_commit_with_template()
738
838
        out, err = self.run_bzr("commit tree/hello.txt", stdin="y\n")
742
842
    def test_commit_hook_template_rejected(self):
743
843
        tree = self.setup_commit_with_template()
744
844
        expected = tree.last_revision()
745
 
        out, err = self.run_bzr_error(["empty commit message"],
746
 
            "commit tree/hello.txt", stdin="n\n")
 
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")
747
850
        self.assertEqual(expected, tree.last_revision())
748
851
 
 
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
 
749
862
    def test_commit_without_username(self):
750
863
        """Ensure commit error if username is not set.
751
864
        """
752
865
        self.run_bzr(['init', 'foo'])
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')
 
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)