/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: Martin
  • Date: 2018-08-21 00:53:34 UTC
  • mto: This revision was merged to the branch mainline in revision 7074.
  • Revision ID: gzlist@googlemail.com-20180821005334-e1ogxakojyybpwib
Fix recursion check in C bencode implementation

Hard to get Cython to do the right thing but by inverting the
return code can use the standard except handling.

Avoid going through a Python call when encoding, which requires
the encode recursion check to work too.

Adjust tests to use a smaller limit to be more managable.

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
 
 
42
 
 
43
class TestCommit(TestCaseWithTransport):
40
44
 
41
45
    def test_05_empty_commit(self):
42
46
        """Commit of tree with no versioned files should fail"""
43
47
        # If forced, it should succeed, but this is not tested here.
44
48
        self.make_branch_and_tree('.')
45
49
        self.build_tree(['hello.txt'])
46
 
        out,err = self.run_bzr('commit -m empty', retcode=3)
 
50
        out, err = self.run_bzr('commit -m empty', retcode=3)
47
51
        self.assertEqual('', out)
48
 
        self.assertContainsRe(err, 'bzr: ERROR: No changes to commit\.'
49
 
                                  ' Use --unchanged to commit anyhow.\n')
 
52
        # Two ugly bits here.
 
53
        # 1) We really don't want 'aborting commit write group' anymore.
 
54
        # 2) brz: ERROR: is a really long line, so we wrap it with '\'
 
55
        self.assertThat(
 
56
            err,
 
57
            DocTestMatches("""\
 
58
Committing to: ...
 
59
brz: ERROR: No changes to commit.\
 
60
 Please 'brz add' the files you want to commit,\
 
61
 or use --unchanged to force an empty commit.
 
62
""", flags=doctest.ELLIPSIS|doctest.REPORT_UDIFF))
50
63
 
51
64
    def test_commit_success(self):
52
65
        """Successful commit should not leave behind a bzr-commit-* file"""
58
71
        self.run_bzr(["commit", "--unchanged", "-m", u'foo\xb5'])
59
72
        self.assertEqual('', self.run_bzr('unknowns')[0])
60
73
 
 
74
    def test_commit_lossy_native(self):
 
75
        """A --lossy option to commit is supported."""
 
76
        self.make_branch_and_tree('.')
 
77
        self.run_bzr('commit --lossy --unchanged -m message')
 
78
        self.assertEqual('', self.run_bzr('unknowns')[0])
 
79
 
 
80
    def test_commit_lossy_foreign(self):
 
81
        test_foreign.register_dummy_foreign_for_test(self)
 
82
        self.make_branch_and_tree('.',
 
83
            format=test_foreign.DummyForeignVcsDirFormat())
 
84
        self.run_bzr('commit --lossy --unchanged -m message')
 
85
        output = self.run_bzr('revision-info')[0]
 
86
        self.assertTrue(output.startswith('1 dummy-'))
 
87
 
61
88
    def test_commit_with_path(self):
62
89
        """Commit tree with path of root specified"""
63
90
        a_tree = self.make_branch_and_tree('a')
65
92
        a_tree.add('a_file')
66
93
        self.run_bzr(['commit', '-m', 'first commit', 'a'])
67
94
 
68
 
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
69
 
        self.build_tree_contents([('b/a_file', 'changes in b')])
 
95
        b_tree = a_tree.controldir.sprout('b').open_workingtree()
 
96
        self.build_tree_contents([('b/a_file', b'changes in b')])
70
97
        self.run_bzr(['commit', '-m', 'first commit in b', 'b'])
71
98
 
72
 
        self.build_tree_contents([('a/a_file', 'new contents')])
 
99
        self.build_tree_contents([('a/a_file', b'new contents')])
73
100
        self.run_bzr(['commit', '-m', 'change in a', 'a'])
74
101
 
75
102
        b_tree.merge_from_branch(a_tree.branch)
77
104
        self.run_bzr('resolved b/a_file')
78
105
        self.run_bzr(['commit', '-m', 'merge into b', 'b'])
79
106
 
80
 
 
81
107
    def test_10_verbose_commit(self):
82
108
        """Add one file and examine verbose commit output"""
83
109
        tree = self.make_branch_and_tree('.')
84
110
        self.build_tree(['hello.txt'])
85
111
        tree.add("hello.txt")
86
 
        out,err = self.run_bzr('commit -m added')
 
112
        out, err = self.run_bzr('commit -m added')
87
113
        self.assertEqual('', out)
88
114
        self.assertContainsRe(err, '^Committing to: .*\n'
89
115
                              'added hello.txt\n'
92
118
    def prepare_simple_history(self):
93
119
        """Prepare and return a working tree with one commit of one file"""
94
120
        # Commit with modified file should say so
95
 
        wt = BzrDir.create_standalone_workingtree('.')
 
121
        wt = ControlDir.create_standalone_workingtree('.')
96
122
        self.build_tree(['hello.txt', 'extra.txt'])
97
123
        wt.add(['hello.txt'])
98
124
        wt.commit(message='added')
101
127
    def test_verbose_commit_modified(self):
102
128
        # Verbose commit of modified file should say so
103
129
        wt = self.prepare_simple_history()
104
 
        self.build_tree_contents([('hello.txt', 'new contents')])
 
130
        self.build_tree_contents([('hello.txt', b'new contents')])
105
131
        out, err = self.run_bzr('commit -m modified')
106
132
        self.assertEqual('', out)
107
133
        self.assertContainsRe(err, '^Committing to: .*\n'
108
 
                              'modified hello\.txt\n'
109
 
                              'Committed revision 2\.\n$')
 
134
                              'modified hello\\.txt\n'
 
135
                              'Committed revision 2\\.\n$')
110
136
 
111
137
    def test_unicode_commit_message_is_filename(self):
112
138
        """Unicode commit message same as a filename (Bug #563646).
113
139
        """
 
140
        self.requireFeature(features.UnicodeFilenameFeature)
114
141
        file_name = u'\N{euro sign}'
115
142
        self.run_bzr(['init'])
116
 
        open(file_name, 'w').write('hello world')
 
143
        with open(file_name, 'w') as f:
 
144
            f.write('hello world')
117
145
        self.run_bzr(['add'])
118
146
        out, err = self.run_bzr(['commit', '-m', file_name])
119
147
        reflags = re.MULTILINE|re.DOTALL|re.UNICODE
120
148
        te = osutils.get_terminal_encoding()
121
 
        self.assertContainsRe(err.decode(te),
 
149
        self.assertContainsRe(err if PY3 else err.decode(te),
122
150
            u'The commit message is a file name:',
123
151
            flags=reflags)
124
152
 
129
157
        # by ui.text.show_warning
130
158
        default_get_terminal_enc = osutils.get_terminal_encoding
131
159
        try:
132
 
            osutils.get_terminal_encoding = lambda: 'ascii'
 
160
            osutils.get_terminal_encoding = lambda trace=None: 'ascii'
133
161
            file_name = u'foo\u1234'
134
 
            open(file_name, 'w').write('hello world')
 
162
            with open(file_name, 'w') as f:
 
163
                f.write('hello world')
135
164
            self.run_bzr(['add'])
136
165
            out, err = self.run_bzr(['commit', '-m', file_name])
137
166
            reflags = re.MULTILINE|re.DOTALL|re.UNICODE
138
167
            te = osutils.get_terminal_encoding()
139
 
            self.assertContainsRe(err.decode(te, 'replace'),
 
168
            self.assertContainsRe(err if PY3 else err.decode(te, 'replace'),
140
169
                u'The commit message is a file name:',
141
170
                flags=reflags)
142
171
        finally:
143
172
            osutils.get_terminal_encoding = default_get_terminal_enc
144
173
 
 
174
    def test_non_ascii_file_unversioned_utf8(self):
 
175
        self.requireFeature(features.UnicodeFilenameFeature)
 
176
        tree = self.make_branch_and_tree(".")
 
177
        self.build_tree(["f"])
 
178
        tree.add(["f"])
 
179
        out, err = self.run_bzr(["commit", "-m", "Wrong filename", u"\xa7"],
 
180
            encoding="utf-8", retcode=3)
 
181
        self.assertContainsRe(err, "(?m)not versioned: \"\xc2\xa7\"$")
 
182
 
 
183
    def test_non_ascii_file_unversioned_iso_8859_5(self):
 
184
        self.requireFeature(features.UnicodeFilenameFeature)
 
185
        tree = self.make_branch_and_tree(".")
 
186
        self.build_tree(["f"])
 
187
        tree.add(["f"])
 
188
        out, err = self.run_bzr(["commit", "-m", "Wrong filename", u"\xa7"],
 
189
            encoding="iso-8859-5", retcode=3)
 
190
        self.expectFailure("Error messages are always written as UTF-8",
 
191
            self.assertNotContainsString, err, "\xc2\xa7")
 
192
        self.assertContainsRe(err, "(?m)not versioned: \"\xfd\"$")
 
193
 
145
194
    def test_warn_about_forgotten_commit_message(self):
146
195
        """Test that the lack of -m parameter is caught"""
147
196
        wt = self.make_branch_and_tree('.')
157
206
        out, err = self.run_bzr('commit -m renamed')
158
207
        self.assertEqual('', out)
159
208
        self.assertContainsRe(err, '^Committing to: .*\n'
160
 
                              'renamed hello\.txt => gutentag\.txt\n'
161
 
                              'Committed revision 2\.$\n')
 
209
                              'renamed hello\\.txt => gutentag\\.txt\n'
 
210
                              'Committed revision 2\\.$\n')
162
211
 
163
212
    def test_verbose_commit_moved(self):
164
213
        # Verbose commit of file moved to new directory should say so
168
217
        wt.rename_one('hello.txt', 'subdir/hello.txt')
169
218
        out, err = self.run_bzr('commit -m renamed')
170
219
        self.assertEqual('', out)
171
 
        self.assertEqual(set([
 
220
        self.assertEqual({
172
221
            'Committing to: %s/' % osutils.getcwd(),
173
222
            'added subdir',
174
223
            'renamed hello.txt => subdir/hello.txt',
175
224
            'Committed revision 2.',
176
225
            '',
177
 
            ]), set(err.split('\n')))
 
226
            }, set(err.split('\n')))
178
227
 
179
228
    def test_verbose_commit_with_unknown(self):
180
229
        """Unknown files should not be listed by default in verbose output"""
181
230
        # Is that really the best policy?
182
 
        wt = BzrDir.create_standalone_workingtree('.')
 
231
        wt = ControlDir.create_standalone_workingtree('.')
183
232
        self.build_tree(['hello.txt', 'extra.txt'])
184
233
        wt.add(['hello.txt'])
185
 
        out,err = self.run_bzr('commit -m added')
 
234
        out, err = self.run_bzr('commit -m added')
186
235
        self.assertEqual('', out)
187
236
        self.assertContainsRe(err, '^Committing to: .*\n'
188
 
                              'added hello\.txt\n'
189
 
                              'Committed revision 1\.\n$')
 
237
                              'added hello\\.txt\n'
 
238
                              'Committed revision 1\\.\n$')
190
239
 
191
240
    def test_verbose_commit_with_unchanged(self):
192
241
        """Unchanged files should not be listed by default in verbose output"""
195
244
        tree.add('unchanged.txt')
196
245
        self.run_bzr('commit -m unchanged unchanged.txt')
197
246
        tree.add("hello.txt")
198
 
        out,err = self.run_bzr('commit -m added')
 
247
        out, err = self.run_bzr('commit -m added')
199
248
        self.assertEqual('', out)
200
249
        self.assertContainsRe(err, '^Committing to: .*\n'
201
 
                              'added hello\.txt\n'
202
 
                              'Committed revision 2\.$\n')
 
250
                              'added hello\\.txt\n'
 
251
                              'Committed revision 2\\.$\n')
203
252
 
204
253
    def test_verbose_commit_includes_master_location(self):
205
254
        """Location of master is displayed when committing to bound branch"""
216
265
 
217
266
    def test_commit_sanitizes_CR_in_message(self):
218
267
        # 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
 
268
        # endings to 'brz commit -m ""' which breaks because we don't allow
220
269
        # '\r' in commit messages. (Mostly because of issues where XML style
221
270
        # formats arbitrarily strip it out of the data while parsing.)
222
271
        # To make life easier for users, we just always translate '\r\n' =>
234
283
 
235
284
    def test_commit_merge_reports_all_modified_files(self):
236
285
        # 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
 
286
        # brz diff or brz status when committing, even when they were not
238
287
        # changed by the user but rather through doing a merge.
239
288
        this_tree = self.make_branch_and_tree('this')
240
289
        # we need a bunch of files and dirs, to perform one action on each.
261
310
            'filetoleave']
262
311
            )
263
312
        this_tree.commit('create_files')
264
 
        other_dir = this_tree.bzrdir.sprout('other')
 
313
        other_dir = this_tree.controldir.sprout('other')
265
314
        other_tree = other_dir.open_workingtree()
266
315
        other_tree.lock_write()
267
316
        # perform the needed actions on the files and dirs.
274
323
            other_tree.remove(['dirtoremove', 'filetoremove'])
275
324
            self.build_tree_contents([
276
325
                ('other/newdir/',),
277
 
                ('other/filetomodify', 'new content'),
278
 
                ('other/newfile', 'new file content')])
 
326
                ('other/filetomodify', b'new content'),
 
327
                ('other/newfile', b'new file content')])
279
328
            other_tree.add('newfile')
280
329
            other_tree.add('newdir/')
281
330
            other_tree.commit('modify all sample files and dirs.')
282
331
        finally:
283
332
            other_tree.unlock()
284
333
        this_tree.merge_from_branch(other_tree.branch)
285
 
        os.chdir('this')
286
 
        out,err = self.run_bzr('commit -m added')
 
334
        out, err = self.run_bzr('commit -m added', working_dir='this')
287
335
        self.assertEqual('', out)
288
 
        self.assertEqual(set([
289
 
            'Committing to: %s/' % osutils.getcwd(),
 
336
        self.assertEqual({
 
337
            'Committing to: %s/' % osutils.pathjoin(osutils.getcwd(), 'this'),
290
338
            'modified filetomodify',
291
339
            'added newdir',
292
340
            'added newfile',
298
346
            'deleted filetoremove',
299
347
            'Committed revision 2.',
300
348
            ''
301
 
            ]), set(err.split('\n')))
 
349
            }, set(err.split('\n')))
302
350
 
303
351
    def test_empty_commit_message(self):
304
352
        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.')
 
353
        self.build_tree_contents([('foo.c', b'int main() {}')])
 
354
        tree.add('foo.c')
 
355
        self.run_bzr('commit -m ""')
328
356
 
329
357
    def test_other_branch_commit(self):
330
358
        # this branch is to ensure consistent behaviour, whether we're run
332
360
        outer_tree = self.make_branch_and_tree('.')
333
361
        inner_tree = self.make_branch_and_tree('branch')
334
362
        self.build_tree_contents([
335
 
            ('branch/foo.c', 'int main() {}'),
336
 
            ('branch/bar.c', 'int main() {}')])
 
363
            ('branch/foo.c', b'int main() {}'),
 
364
            ('branch/bar.c', b'int main() {}')])
337
365
        inner_tree.add(['foo.c', 'bar.c'])
338
366
        # can't commit files in different trees; sane error
339
367
        self.run_bzr('commit -m newstuff branch/foo.c .', retcode=3)
353
381
        # commit to the original branch to make the checkout out of date
354
382
        tree.commit('message branch', allow_pointless=True)
355
383
        # now commit to the checkout should emit
356
 
        # ERROR: Out of date with the branch, 'bzr update' is suggested
 
384
        # ERROR: Out of date with the branch, 'brz update' is suggested
357
385
        output = self.run_bzr('commit --unchanged -m checkout_message '
358
386
                             'checkout', retcode=3)
359
387
        self.assertEqual(output,
360
388
                         ('',
361
 
                          "bzr: ERROR: Working tree is out of date, please "
362
 
                          "run 'bzr update'.\n"))
 
389
                          "brz: ERROR: Working tree is out of date, please "
 
390
                          "run 'brz update'.\n"))
363
391
 
364
392
    def test_local_commit_unbound(self):
365
393
        # a --local commit on an unbound branch is an error
366
394
        self.make_branch_and_tree('.')
367
395
        out, err = self.run_bzr('commit --local', retcode=3)
368
396
        self.assertEqualDiff('', out)
369
 
        self.assertEqualDiff('bzr: ERROR: Cannot perform local-only commits '
 
397
        self.assertEqualDiff('brz: ERROR: Cannot perform local-only commits '
370
398
                             'on unbound branches.\n', err)
371
399
 
372
400
    def test_commit_a_text_merge_in_a_checkout(self):
378
406
        trunk = self.make_branch_and_tree('trunk')
379
407
 
380
408
        u1 = trunk.branch.create_checkout('u1')
381
 
        self.build_tree_contents([('u1/hosts', 'initial contents\n')])
 
409
        self.build_tree_contents([('u1/hosts', b'initial contents\n')])
382
410
        u1.add('hosts')
383
411
        self.run_bzr('commit -m add-hosts u1')
384
412
 
385
413
        u2 = trunk.branch.create_checkout('u2')
386
 
        self.build_tree_contents([('u2/hosts', 'altered in u2\n')])
 
414
        self.build_tree_contents([('u2/hosts', b'altered in u2\n')])
387
415
        self.run_bzr('commit -m checkin-from-u2 u2')
388
416
 
389
417
        # make an offline commits
390
 
        self.build_tree_contents([('u1/hosts', 'first offline change in u1\n')])
 
418
        self.build_tree_contents([('u1/hosts', b'first offline change in u1\n')])
391
419
        self.run_bzr('commit -m checkin-offline --local u1')
392
420
 
393
421
        # now try to pull in online work from u2, and then commit our offline
394
422
        # work as a merge
395
423
        # retcode 1 as we expect a text conflict
396
424
        self.run_bzr('update u1', retcode=1)
397
 
        self.assertFileEqual('''\
 
425
        self.assertFileEqual(b'''\
398
426
<<<<<<< TREE
399
427
first offline change in u1
400
428
=======
407
435
        # add a text change here to represent resolving the merge conflicts in
408
436
        # favour of a new version of the file not identical to either the u1
409
437
        # version or the u2 version.
410
 
        self.build_tree_contents([('u1/hosts', 'merge resolution\n')])
 
438
        self.build_tree_contents([('u1/hosts', b'merge resolution\n')])
411
439
        self.run_bzr('commit -m checkin-merge-of-the-offline-work-from-u1 u1')
412
440
 
413
441
    def test_commit_exclude_excludes_modified_files(self):
446
474
        t.add(['file-a', 'dir-a', 'dir-a/file-b'])
447
475
        t.commit('Create')
448
476
        t.remove(['file-a', 'dir-a/file-b'])
449
 
        os.chdir('dir-a')
450
 
        result = self.run_bzr('commit . -m removed-file-b')[1]
 
477
        result = self.run_bzr('commit . -m removed-file-b',
 
478
                              working_dir='dir-a')[1]
451
479
        self.assertNotContainsRe(result, 'file-a')
452
 
        result = self.run_bzr('status')[0]
 
480
        result = self.run_bzr('status', working_dir='dir-a')[0]
453
481
        self.assertContainsRe(result, 'removed:\n  file-a')
454
482
 
455
483
    def test_strict_commit(self):
459
487
        self.build_tree(['tree/a'])
460
488
        tree.add('a')
461
489
        # A simple change should just work
462
 
        self.run_bzr('commit --strict -m adding-a',
463
 
                     working_dir='tree')
 
490
        self.run_bzr('commit --strict -m adding-a', working_dir='tree')
464
491
 
465
492
    def test_strict_commit_no_changes(self):
466
493
        """commit --strict gives "no changes" if there is nothing to commit"""
506
533
            'commit -m hello --fixes=lp:23452 tree/hello.txt')
507
534
        self.assertEqual('', output)
508
535
        self.assertContainsRe(err, 'Committing to: .*\n'
509
 
                              'added hello\.txt\n'
510
 
                              'Committed revision 1\.\n')
 
536
                              'added hello\\.txt\n'
 
537
                              'Committed revision 1\\.\n')
 
538
 
 
539
    def test_fixes_bug_unicode(self):
 
540
        """commit --fixes=lp:unicode succeeds without output."""
 
541
        tree = self.make_branch_and_tree('tree')
 
542
        self.build_tree(['tree/hello.txt'])
 
543
        tree.add('hello.txt')
 
544
        output, err = self.run_bzr(
 
545
            ['commit', '-m', 'hello',
 
546
             u'--fixes=generic:\u20ac', 'tree/hello.txt'],
 
547
            encoding='utf-8', retcode=3)
 
548
        self.assertEqual('', output)
 
549
        self.assertContainsRe(err,
 
550
            'brz: ERROR: Unrecognized bug generic:\xe2\x82\xac\\. Commit refused.\n')
511
551
 
512
552
    def test_no_bugs_no_properties(self):
513
553
        """If no bugs are fixed, the bugs property is not set.
517
557
        tree = self.make_branch_and_tree('tree')
518
558
        self.build_tree(['tree/hello.txt'])
519
559
        tree.add('hello.txt')
520
 
        self.run_bzr( 'commit -m hello tree/hello.txt')
 
560
        self.run_bzr('commit -m hello tree/hello.txt')
521
561
        # Get the revision properties, ignoring the branch-nick property, which
522
562
        # we don't care about for this test.
523
563
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
536
576
        # we don't care about for this test.
537
577
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
538
578
        properties = dict(last_rev.properties)
539
 
        del properties['branch-nick']
 
579
        del properties[u'branch-nick']
540
580
 
541
 
        self.assertEqual({'bugs': 'https://launchpad.net/bugs/234 fixed'},
 
581
        self.assertEqual({u'bugs': 'https://launchpad.net/bugs/234 fixed'},
542
582
                         properties)
543
583
 
544
584
    def test_fixes_multiple_bugs_sets_properties(self):
556
596
        del properties['branch-nick']
557
597
 
558
598
        self.assertEqual(
559
 
            {'bugs': 'https://launchpad.net/bugs/123 fixed\n'
 
599
            {u'bugs': 'https://launchpad.net/bugs/123 fixed\n'
560
600
                     'https://launchpad.net/bugs/235 fixed'},
561
601
            properties)
562
602
 
591
631
            'commit -m add-b --fixes=xxx:123',
592
632
            working_dir='tree')
593
633
 
 
634
    def test_fixes_bug_with_default_tracker(self):
 
635
        """commit --fixes=234 uses the default bug tracker."""
 
636
        tree = self.make_branch_and_tree('tree')
 
637
        self.build_tree(['tree/hello.txt'])
 
638
        tree.add('hello.txt')
 
639
        self.run_bzr_error(
 
640
            ["brz: ERROR: No tracker specified for bug 123. Use the form "
 
641
            "'tracker:id' or specify a default bug tracker using the "
 
642
            "`bugtracker` option.\n"
 
643
            "See \"brz help bugs\" for more information on this feature. "
 
644
            "Commit refused."],
 
645
            'commit -m add-b --fixes=123',
 
646
            working_dir='tree')
 
647
        tree.branch.get_config_stack().set("bugtracker", "lp")
 
648
        self.run_bzr('commit -m hello --fixes=234 tree/hello.txt')
 
649
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
650
        self.assertEqual('https://launchpad.net/bugs/234 fixed',
 
651
                         last_rev.properties['bugs'])
 
652
 
594
653
    def test_fixes_invalid_bug_number(self):
595
654
        tree = self.make_branch_and_tree('tree')
596
655
        self.build_tree(['tree/hello.txt'])
597
656
        tree.add('hello.txt')
598
657
        self.run_bzr_error(
599
658
            ["Did not understand bug identifier orange: Must be an integer. "
600
 
             "See \"bzr help bugs\" for more information on this feature.\n"
 
659
             "See \"brz help bugs\" for more information on this feature.\n"
601
660
             "Commit refused."],
602
661
            'commit -m add-b --fixes=lp:orange',
603
662
            working_dir='tree')
608
667
        self.build_tree(['tree/hello.txt'])
609
668
        tree.add('hello.txt')
610
669
        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',
 
670
            [r"Invalid bug orange:apples:bananas. Must be in the form of "
 
671
             r"'tracker:id'\. See \"brz help bugs\" for more information on "
 
672
             r"this feature.\nCommit refused\."],
 
673
            'commit -m add-b --fixes=orange:apples:bananas',
615
674
            working_dir='tree')
616
675
 
617
676
    def test_no_author(self):
678
737
        out, err = self.run_bzr("commit -m hello "
679
738
            "--commit-time='NOT A TIME' tree/hello.txt", retcode=3)
680
739
        self.assertStartsWith(
681
 
            err, "bzr: ERROR: Could not parse --commit-time:")
 
740
            err, "brz: ERROR: Could not parse --commit-time:")
 
741
 
 
742
    def test_commit_time_missing_tz(self):
 
743
        tree = self.make_branch_and_tree('tree')
 
744
        self.build_tree(['tree/hello.txt'])
 
745
        tree.add('hello.txt')
 
746
        out, err = self.run_bzr("commit -m hello "
 
747
            "--commit-time='2009-10-10 08:00:00' tree/hello.txt", retcode=3)
 
748
        self.assertStartsWith(
 
749
            err, "brz: ERROR: Could not parse --commit-time:")
 
750
        # Test that it is actually checking and does not simply crash with
 
751
        # some other exception
 
752
        self.assertContainsString(err, "missing a timezone offset")
682
753
 
683
754
    def test_partial_commit_with_renames_in_tree(self):
684
755
        # this test illustrates bug #140419
691
762
        # then during partial commit we have error
692
763
        # parent_id {dir-XXX} not in inventory
693
764
        t.rename_one('dir/a', 'a')
694
 
        self.build_tree_contents([('test', 'changes in test')])
 
765
        self.build_tree_contents([('test', b'changes in test')])
695
766
        # partial commit
696
767
        out, err = self.run_bzr('commit test -m "partial commit"')
697
 
        self.assertEquals('', out)
 
768
        self.assertEqual('', out)
698
769
        self.assertContainsRe(err, r'modified test\nCommitted revision 2.')
699
770
 
700
771
    def test_commit_readonly_checkout(self):
701
 
        # https://bugs.edge.launchpad.net/bzr/+bug/129701
 
772
        # https://bugs.launchpad.net/bzr/+bug/129701
702
773
        # "UnlockableTransport error trying to commit in checkout of readonly
703
774
        # branch"
704
775
        self.make_branch('master')
705
 
        master = BzrDir.open_from_transport(
 
776
        master = ControlDir.open_from_transport(
706
777
            self.get_readonly_transport('master')).open_branch()
707
778
        master.create_checkout('checkout')
708
779
        out, err = self.run_bzr(['commit', '--unchanged', '-mfoo', 'checkout'],
709
780
            retcode=3)
710
781
        self.assertContainsRe(err,
711
 
            r'^bzr: ERROR: Cannot lock.*readonly transport')
 
782
            r'^brz: ERROR: Cannot lock.*readonly transport')
712
783
 
713
784
    def setup_editor(self):
714
785
        # Test that commit template hooks work
715
786
        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")
 
787
            with open('fed.bat', 'w') as f:
 
788
                f.write('@rem dummy fed')
 
789
            self.overrideEnv('BRZ_EDITOR', "fed.bat")
720
790
        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")
 
791
            with open('fed.sh', 'wb') as f:
 
792
                f.write(b'#!/bin/sh\n')
 
793
            os.chmod('fed.sh', 0o755)
 
794
            self.overrideEnv('BRZ_EDITOR', "./fed.sh")
726
795
 
727
796
    def setup_commit_with_template(self):
728
797
        self.setup_editor()
733
802
        tree.add('hello.txt')
734
803
        return tree
735
804
 
 
805
    def test_edit_empty_message(self):
 
806
        tree = self.make_branch_and_tree('tree')
 
807
        self.setup_editor()
 
808
        self.build_tree(['tree/hello.txt'])
 
809
        tree.add('hello.txt')
 
810
        out, err = self.run_bzr("commit tree/hello.txt", retcode=3,
 
811
            stdin="y\n")
 
812
        self.assertContainsRe(err,
 
813
            "brz: ERROR: Empty commit message specified")
 
814
 
736
815
    def test_commit_hook_template_accepted(self):
737
816
        tree = self.setup_commit_with_template()
738
817
        out, err = self.run_bzr("commit tree/hello.txt", stdin="y\n")
742
821
    def test_commit_hook_template_rejected(self):
743
822
        tree = self.setup_commit_with_template()
744
823
        expected = tree.last_revision()
745
 
        out, err = self.run_bzr_error(["empty commit message"],
 
824
        out, err = self.run_bzr_error(["Empty commit message specified."
 
825
                  " Please specify a commit message with either"
 
826
                  " --message or --file or leave a blank message"
 
827
                  " with --message \"\"."],
746
828
            "commit tree/hello.txt", stdin="n\n")
747
829
        self.assertEqual(expected, tree.last_revision())
748
830
 
 
831
    def test_set_commit_message(self):
 
832
        msgeditor.hooks.install_named_hook("set_commit_message",
 
833
                lambda commit_obj, msg: "save me some typing\n", None)
 
834
        tree = self.make_branch_and_tree('tree')
 
835
        self.build_tree(['tree/hello.txt'])
 
836
        tree.add('hello.txt')
 
837
        out, err = self.run_bzr("commit tree/hello.txt")
 
838
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
839
        self.assertEqual('save me some typing\n', last_rev.message)
 
840
 
749
841
    def test_commit_without_username(self):
750
842
        """Ensure commit error if username is not set.
751
843
        """
752
844
        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')
 
845
        with open('foo/foo.txt', 'w') as f:
 
846
            f.write('hello')
 
847
        self.run_bzr(['add'], working_dir='foo')
 
848
        self.overrideEnv('EMAIL', None)
 
849
        self.overrideEnv('BRZ_EMAIL', None)
 
850
        # Also, make sure that it's not inferred from mailname.
 
851
        self.overrideAttr(config, '_auto_user_id',
 
852
            lambda: (None, None))
 
853
        self.run_bzr_error(
 
854
            ['Unable to determine your name'],
 
855
            ['commit', '-m', 'initial'], working_dir='foo')
 
856
 
 
857
    def test_commit_recursive_checkout(self):
 
858
        """Ensure that a commit to a recursive checkout fails cleanly.
 
859
        """
 
860
        self.run_bzr(['init', 'test_branch'])
 
861
        self.run_bzr(['checkout', 'test_branch', 'test_checkout'])
 
862
        self.run_bzr(['bind', '.'], working_dir='test_checkout') # bind to self
 
863
        with open('test_checkout/foo.txt', 'w') as f:
 
864
            f.write('hello')
 
865
        self.run_bzr(['add'], working_dir='test_checkout')
 
866
        out, err = self.run_bzr_error(
 
867
            ['Branch.*test_checkout.*appears to be bound to itself'],
 
868
            ['commit', '-m', 'addedfoo'], working_dir='test_checkout')
 
869
 
 
870
    def test_mv_dirs_non_ascii(self):
 
871
        """Move directory with non-ascii name and containing files.
 
872
 
 
873
        Regression test for bug 185211.
 
874
        """
 
875
        tree = self.make_branch_and_tree('.')
 
876
        self.build_tree([u'abc\xa7/', u'abc\xa7/foo'])
 
877
 
 
878
        tree.add([u'abc\xa7/', u'abc\xa7/foo'])
 
879
        tree.commit('checkin')
 
880
 
 
881
        tree.rename_one(u'abc\xa7', 'abc')
 
882
 
 
883
        self.run_bzr('ci -m "non-ascii mv"')
 
884
 
 
885
 
 
886
class TestSmartServerCommit(TestCaseWithTransport):
 
887
 
 
888
    def test_commit_to_lightweight(self):
 
889
        self.setup_smart_server_with_call_log()
 
890
        t = self.make_branch_and_tree('from')
 
891
        for count in range(9):
 
892
            t.commit(message='commit %d' % count)
 
893
        out, err = self.run_bzr(['checkout', '--lightweight', self.get_url('from'),
 
894
            'target'])
 
895
        self.reset_smart_call_log()
 
896
        self.build_tree(['target/afile'])
 
897
        self.run_bzr(['add', 'target/afile'])
 
898
        out, err = self.run_bzr(['commit', '-m', 'do something', 'target'])
 
899
        # This figure represent the amount of work to perform this use case. It
 
900
        # is entirely ok to reduce this number if a test fails due to rpc_count
 
901
        # being too low. If rpc_count increases, more network roundtrips have
 
902
        # become necessary for this use case. Please do not adjust this number
 
903
        # upwards without agreement from bzr's network support maintainers.
 
904
        self.assertLength(211, self.hpss_calls)
 
905
        self.assertLength(2, self.hpss_connections)
 
906
        self.expectFailure("commit still uses VFS calls",
 
907
            self.assertThat, self.hpss_calls, ContainsNoVfsCalls)