/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-02-18 01:57:45 UTC
  • mto: This revision was merged to the branch mainline in revision 7493.
  • Revision ID: jelmer@jelmer.uk-20200218015745-q2ss9tsk74h4nh61
drop use of future.

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 .. import (
 
35
    test_foreign,
 
36
    features,
 
37
    )
 
38
from .. import TestCaseWithTransport
 
39
from ..matchers import ContainsNoVfsCalls
 
40
from ..test_bedding import override_whoami
 
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
 
        reflags = re.MULTILINE|re.DOTALL|re.UNICODE
 
147
        reflags = re.MULTILINE | re.DOTALL | re.UNICODE
120
148
        te = osutils.get_terminal_encoding()
121
 
        self.assertContainsRe(err.decode(te),
122
 
            u'The commit message is a file name:',
123
 
            flags=reflags)
 
149
        self.assertContainsRe(err,
 
150
                              u'The commit message is a file name:',
 
151
                              flags=reflags)
124
152
 
125
153
        # Run same test with a filename that causes encode
126
154
        # error for the terminal encoding. We do this
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
 
            reflags = re.MULTILINE|re.DOTALL|re.UNICODE
 
166
            reflags = re.MULTILINE | re.DOTALL | re.UNICODE
138
167
            te = osutils.get_terminal_encoding()
139
 
            self.assertContainsRe(err.decode(te, 'replace'),
140
 
                u'The commit message is a file name:',
141
 
                flags=reflags)
 
168
            self.assertContainsRe(err,
 
169
                                  u'The commit message is a file name:',
 
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_raw(["commit", "-m", "Wrong filename", u"\xa7"],
 
180
                                    encoding="utf-8", retcode=3)
 
181
        self.assertContainsRe(err, b"(?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_raw(["commit", "-m", "Wrong filename", u"\xa7"],
 
189
                                    encoding="iso-8859-5", retcode=3)
 
190
        self.assertNotContainsString(err, b"\xc2\xa7")
 
191
        self.assertContainsRe(err, b"(?m)not versioned: \"\xfd\"$")
 
192
 
145
193
    def test_warn_about_forgotten_commit_message(self):
146
194
        """Test that the lack of -m parameter is caught"""
147
195
        wt = self.make_branch_and_tree('.')
157
205
        out, err = self.run_bzr('commit -m renamed')
158
206
        self.assertEqual('', out)
159
207
        self.assertContainsRe(err, '^Committing to: .*\n'
160
 
                              'renamed hello\.txt => gutentag\.txt\n'
161
 
                              'Committed revision 2\.$\n')
 
208
                              'renamed hello\\.txt => gutentag\\.txt\n'
 
209
                              'Committed revision 2\\.$\n')
162
210
 
163
211
    def test_verbose_commit_moved(self):
164
212
        # Verbose commit of file moved to new directory should say so
168
216
        wt.rename_one('hello.txt', 'subdir/hello.txt')
169
217
        out, err = self.run_bzr('commit -m renamed')
170
218
        self.assertEqual('', out)
171
 
        self.assertEqual(set([
 
219
        self.assertEqual({
172
220
            'Committing to: %s/' % osutils.getcwd(),
173
221
            'added subdir',
174
222
            'renamed hello.txt => subdir/hello.txt',
175
223
            'Committed revision 2.',
176
224
            '',
177
 
            ]), set(err.split('\n')))
 
225
            }, set(err.split('\n')))
178
226
 
179
227
    def test_verbose_commit_with_unknown(self):
180
228
        """Unknown files should not be listed by default in verbose output"""
181
229
        # Is that really the best policy?
182
 
        wt = BzrDir.create_standalone_workingtree('.')
 
230
        wt = ControlDir.create_standalone_workingtree('.')
183
231
        self.build_tree(['hello.txt', 'extra.txt'])
184
232
        wt.add(['hello.txt'])
185
 
        out,err = self.run_bzr('commit -m added')
 
233
        out, err = self.run_bzr('commit -m added')
186
234
        self.assertEqual('', out)
187
235
        self.assertContainsRe(err, '^Committing to: .*\n'
188
 
                              'added hello\.txt\n'
189
 
                              'Committed revision 1\.\n$')
 
236
                              'added hello\\.txt\n'
 
237
                              'Committed revision 1\\.\n$')
190
238
 
191
239
    def test_verbose_commit_with_unchanged(self):
192
240
        """Unchanged files should not be listed by default in verbose output"""
195
243
        tree.add('unchanged.txt')
196
244
        self.run_bzr('commit -m unchanged unchanged.txt')
197
245
        tree.add("hello.txt")
198
 
        out,err = self.run_bzr('commit -m added')
 
246
        out, err = self.run_bzr('commit -m added')
199
247
        self.assertEqual('', out)
200
248
        self.assertContainsRe(err, '^Committing to: .*\n'
201
 
                              'added hello\.txt\n'
202
 
                              'Committed revision 2\.$\n')
 
249
                              'added hello\\.txt\n'
 
250
                              'Committed revision 2\\.$\n')
203
251
 
204
252
    def test_verbose_commit_includes_master_location(self):
205
253
        """Location of master is displayed when committing to bound branch"""
216
264
 
217
265
    def test_commit_sanitizes_CR_in_message(self):
218
266
        # 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
 
267
        # endings to 'brz commit -m ""' which breaks because we don't allow
220
268
        # '\r' in commit messages. (Mostly because of issues where XML style
221
269
        # formats arbitrarily strip it out of the data while parsing.)
222
270
        # To make life easier for users, we just always translate '\r\n' =>
234
282
 
235
283
    def test_commit_merge_reports_all_modified_files(self):
236
284
        # 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
 
285
        # brz diff or brz status when committing, even when they were not
238
286
        # changed by the user but rather through doing a merge.
239
287
        this_tree = self.make_branch_and_tree('this')
240
288
        # we need a bunch of files and dirs, to perform one action on each.
261
309
            'filetoleave']
262
310
            )
263
311
        this_tree.commit('create_files')
264
 
        other_dir = this_tree.bzrdir.sprout('other')
 
312
        other_dir = this_tree.controldir.sprout('other')
265
313
        other_tree = other_dir.open_workingtree()
266
 
        other_tree.lock_write()
267
 
        # perform the needed actions on the files and dirs.
268
 
        try:
 
314
        with other_tree.lock_write():
 
315
            # perform the needed actions on the files and dirs.
269
316
            other_tree.rename_one('dirtorename', 'renameddir')
270
317
            other_tree.rename_one('dirtoreparent', 'renameddir/reparenteddir')
271
318
            other_tree.rename_one('filetorename', 'renamedfile')
274
321
            other_tree.remove(['dirtoremove', 'filetoremove'])
275
322
            self.build_tree_contents([
276
323
                ('other/newdir/',),
277
 
                ('other/filetomodify', 'new content'),
278
 
                ('other/newfile', 'new file content')])
 
324
                ('other/filetomodify', b'new content'),
 
325
                ('other/newfile', b'new file content')])
279
326
            other_tree.add('newfile')
280
327
            other_tree.add('newdir/')
281
328
            other_tree.commit('modify all sample files and dirs.')
282
 
        finally:
283
 
            other_tree.unlock()
284
329
        this_tree.merge_from_branch(other_tree.branch)
285
 
        os.chdir('this')
286
 
        out,err = self.run_bzr('commit -m added')
 
330
        out, err = self.run_bzr('commit -m added', working_dir='this')
287
331
        self.assertEqual('', out)
288
 
        self.assertEqual(set([
289
 
            'Committing to: %s/' % osutils.getcwd(),
 
332
        self.assertEqual({
 
333
            'Committing to: %s/' % osutils.pathjoin(osutils.getcwd(), 'this'),
290
334
            'modified filetomodify',
291
335
            'added newdir',
292
336
            'added newfile',
298
342
            'deleted filetoremove',
299
343
            'Committed revision 2.',
300
344
            ''
301
 
            ]), set(err.split('\n')))
 
345
            }, set(err.split('\n')))
302
346
 
303
347
    def test_empty_commit_message(self):
304
348
        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.')
 
349
        self.build_tree_contents([('foo.c', b'int main() {}')])
 
350
        tree.add('foo.c')
 
351
        self.run_bzr('commit -m ""')
328
352
 
329
353
    def test_other_branch_commit(self):
330
354
        # this branch is to ensure consistent behaviour, whether we're run
332
356
        outer_tree = self.make_branch_and_tree('.')
333
357
        inner_tree = self.make_branch_and_tree('branch')
334
358
        self.build_tree_contents([
335
 
            ('branch/foo.c', 'int main() {}'),
336
 
            ('branch/bar.c', 'int main() {}')])
 
359
            ('branch/foo.c', b'int main() {}'),
 
360
            ('branch/bar.c', b'int main() {}')])
337
361
        inner_tree.add(['foo.c', 'bar.c'])
338
362
        # can't commit files in different trees; sane error
339
363
        self.run_bzr('commit -m newstuff branch/foo.c .', retcode=3)
342
366
        # can commit to branch - records bar.c
343
367
        self.run_bzr('commit -m newstuff branch')
344
368
        # No changes left
345
 
        self.run_bzr_error(["No changes to commit"], 'commit -m newstuff branch')
 
369
        self.run_bzr_error(["No changes to commit"],
 
370
                           'commit -m newstuff branch')
346
371
 
347
372
    def test_out_of_date_tree_commit(self):
348
373
        # check we get an error code and a clear message committing with an out
353
378
        # commit to the original branch to make the checkout out of date
354
379
        tree.commit('message branch', allow_pointless=True)
355
380
        # now commit to the checkout should emit
356
 
        # ERROR: Out of date with the branch, 'bzr update' is suggested
 
381
        # ERROR: Out of date with the branch, 'brz update' is suggested
357
382
        output = self.run_bzr('commit --unchanged -m checkout_message '
358
 
                             'checkout', retcode=3)
 
383
                              'checkout', retcode=3)
359
384
        self.assertEqual(output,
360
385
                         ('',
361
 
                          "bzr: ERROR: Working tree is out of date, please "
362
 
                          "run 'bzr update'.\n"))
 
386
                          "brz: ERROR: Working tree is out of date, please "
 
387
                          "run 'brz update'.\n"))
363
388
 
364
389
    def test_local_commit_unbound(self):
365
390
        # a --local commit on an unbound branch is an error
366
391
        self.make_branch_and_tree('.')
367
392
        out, err = self.run_bzr('commit --local', retcode=3)
368
393
        self.assertEqualDiff('', out)
369
 
        self.assertEqualDiff('bzr: ERROR: Cannot perform local-only commits '
 
394
        self.assertEqualDiff('brz: ERROR: Cannot perform local-only commits '
370
395
                             'on unbound branches.\n', err)
371
396
 
372
397
    def test_commit_a_text_merge_in_a_checkout(self):
378
403
        trunk = self.make_branch_and_tree('trunk')
379
404
 
380
405
        u1 = trunk.branch.create_checkout('u1')
381
 
        self.build_tree_contents([('u1/hosts', 'initial contents\n')])
 
406
        self.build_tree_contents([('u1/hosts', b'initial contents\n')])
382
407
        u1.add('hosts')
383
408
        self.run_bzr('commit -m add-hosts u1')
384
409
 
385
410
        u2 = trunk.branch.create_checkout('u2')
386
 
        self.build_tree_contents([('u2/hosts', 'altered in u2\n')])
 
411
        self.build_tree_contents([('u2/hosts', b'altered in u2\n')])
387
412
        self.run_bzr('commit -m checkin-from-u2 u2')
388
413
 
389
414
        # make an offline commits
390
 
        self.build_tree_contents([('u1/hosts', 'first offline change in u1\n')])
 
415
        self.build_tree_contents(
 
416
            [('u1/hosts', b'first offline change in u1\n')])
391
417
        self.run_bzr('commit -m checkin-offline --local u1')
392
418
 
393
419
        # now try to pull in online work from u2, and then commit our offline
394
420
        # work as a merge
395
421
        # retcode 1 as we expect a text conflict
396
422
        self.run_bzr('update u1', retcode=1)
397
 
        self.assertFileEqual('''\
 
423
        self.assertFileEqual(b'''\
398
424
<<<<<<< TREE
399
425
first offline change in u1
400
426
=======
407
433
        # add a text change here to represent resolving the merge conflicts in
408
434
        # favour of a new version of the file not identical to either the u1
409
435
        # version or the u2 version.
410
 
        self.build_tree_contents([('u1/hosts', 'merge resolution\n')])
 
436
        self.build_tree_contents([('u1/hosts', b'merge resolution\n')])
411
437
        self.run_bzr('commit -m checkin-merge-of-the-offline-work-from-u1 u1')
412
438
 
413
439
    def test_commit_exclude_excludes_modified_files(self):
446
472
        t.add(['file-a', 'dir-a', 'dir-a/file-b'])
447
473
        t.commit('Create')
448
474
        t.remove(['file-a', 'dir-a/file-b'])
449
 
        os.chdir('dir-a')
450
 
        result = self.run_bzr('commit . -m removed-file-b')[1]
 
475
        result = self.run_bzr('commit . -m removed-file-b',
 
476
                              working_dir='dir-a')[1]
451
477
        self.assertNotContainsRe(result, 'file-a')
452
 
        result = self.run_bzr('status')[0]
 
478
        result = self.run_bzr('status', working_dir='dir-a')[0]
453
479
        self.assertContainsRe(result, 'removed:\n  file-a')
454
480
 
455
481
    def test_strict_commit(self):
459
485
        self.build_tree(['tree/a'])
460
486
        tree.add('a')
461
487
        # A simple change should just work
462
 
        self.run_bzr('commit --strict -m adding-a',
463
 
                     working_dir='tree')
 
488
        self.run_bzr('commit --strict -m adding-a', working_dir='tree')
464
489
 
465
490
    def test_strict_commit_no_changes(self):
466
491
        """commit --strict gives "no changes" if there is nothing to commit"""
506
531
            'commit -m hello --fixes=lp:23452 tree/hello.txt')
507
532
        self.assertEqual('', output)
508
533
        self.assertContainsRe(err, 'Committing to: .*\n'
509
 
                              'added hello\.txt\n'
510
 
                              'Committed revision 1\.\n')
 
534
                              'added hello\\.txt\n'
 
535
                              'Committed revision 1\\.\n')
 
536
 
 
537
    def test_fixes_bug_unicode(self):
 
538
        """commit --fixes=lp:unicode succeeds without output."""
 
539
        tree = self.make_branch_and_tree('tree')
 
540
        self.build_tree(['tree/hello.txt'])
 
541
        tree.add('hello.txt')
 
542
        output, err = self.run_bzr_raw(
 
543
            ['commit', '-m', 'hello',
 
544
             u'--fixes=generic:\u20ac', 'tree/hello.txt'],
 
545
            encoding='utf-8', retcode=3)
 
546
        self.assertEqual(b'', output)
 
547
        self.assertContainsRe(err,
 
548
                              b'brz: ERROR: Unrecognized bug generic:\xe2\x82\xac\\. Commit refused.\n')
511
549
 
512
550
    def test_no_bugs_no_properties(self):
513
551
        """If no bugs are fixed, the bugs property is not set.
517
555
        tree = self.make_branch_and_tree('tree')
518
556
        self.build_tree(['tree/hello.txt'])
519
557
        tree.add('hello.txt')
520
 
        self.run_bzr( 'commit -m hello tree/hello.txt')
 
558
        self.run_bzr('commit -m hello tree/hello.txt')
521
559
        # Get the revision properties, ignoring the branch-nick property, which
522
560
        # we don't care about for this test.
523
561
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
525
563
        del properties['branch-nick']
526
564
        self.assertFalse('bugs' in properties)
527
565
 
 
566
    def test_bugs_sets_property(self):
 
567
        """commit --bugs=lp:234 sets the lp:234 revprop to 'related'."""
 
568
        tree = self.make_branch_and_tree('tree')
 
569
        self.build_tree(['tree/hello.txt'])
 
570
        tree.add('hello.txt')
 
571
        self.run_bzr('commit -m hello --bugs=lp:234 tree/hello.txt')
 
572
 
 
573
        # Get the revision properties, ignoring the branch-nick property, which
 
574
        # we don't care about for this test.
 
575
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
576
        properties = dict(last_rev.properties)
 
577
        del properties[u'branch-nick']
 
578
 
 
579
        self.assertEqual({u'bugs': 'https://launchpad.net/bugs/234 related'},
 
580
                         properties)
 
581
 
528
582
    def test_fixes_bug_sets_property(self):
529
583
        """commit --fixes=lp:234 sets the lp:234 revprop to 'fixed'."""
530
584
        tree = self.make_branch_and_tree('tree')
536
590
        # we don't care about for this test.
537
591
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
538
592
        properties = dict(last_rev.properties)
539
 
        del properties['branch-nick']
 
593
        del properties[u'branch-nick']
540
594
 
541
 
        self.assertEqual({'bugs': 'https://launchpad.net/bugs/234 fixed'},
 
595
        self.assertEqual({u'bugs': 'https://launchpad.net/bugs/234 fixed'},
542
596
                         properties)
543
597
 
544
598
    def test_fixes_multiple_bugs_sets_properties(self):
556
610
        del properties['branch-nick']
557
611
 
558
612
        self.assertEqual(
559
 
            {'bugs': 'https://launchpad.net/bugs/123 fixed\n'
560
 
                     'https://launchpad.net/bugs/235 fixed'},
 
613
            {u'bugs': 'https://launchpad.net/bugs/123 fixed\n'
 
614
             'https://launchpad.net/bugs/235 fixed'},
561
615
            properties)
562
616
 
563
617
    def test_fixes_bug_with_alternate_trackers(self):
569
623
            'trac_twisted_url', 'http://twistedmatrix.com/trac')
570
624
        self.build_tree(['tree/hello.txt'])
571
625
        tree.add('hello.txt')
572
 
        self.run_bzr('commit -m hello --fixes=lp:123 --fixes=twisted:235 tree/')
 
626
        self.run_bzr(
 
627
            'commit -m hello --fixes=lp:123 --fixes=twisted:235 tree/')
573
628
 
574
629
        # Get the revision properties, ignoring the branch-nick property, which
575
630
        # we don't care about for this test.
591
646
            'commit -m add-b --fixes=xxx:123',
592
647
            working_dir='tree')
593
648
 
 
649
    def test_fixes_bug_with_default_tracker(self):
 
650
        """commit --fixes=234 uses the default bug tracker."""
 
651
        tree = self.make_branch_and_tree('tree')
 
652
        self.build_tree(['tree/hello.txt'])
 
653
        tree.add('hello.txt')
 
654
        self.run_bzr_error(
 
655
            ["brz: ERROR: No tracker specified for bug 123. Use the form "
 
656
             "'tracker:id' or specify a default bug tracker using the "
 
657
             "`bugtracker` option.\n"
 
658
             "See \"brz help bugs\" for more information on this feature. "
 
659
             "Commit refused."],
 
660
            'commit -m add-b --fixes=123',
 
661
            working_dir='tree')
 
662
        tree.branch.get_config_stack().set("bugtracker", "lp")
 
663
        self.run_bzr('commit -m hello --fixes=234 tree/hello.txt')
 
664
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
665
        self.assertEqual('https://launchpad.net/bugs/234 fixed',
 
666
                         last_rev.properties['bugs'])
 
667
 
594
668
    def test_fixes_invalid_bug_number(self):
595
669
        tree = self.make_branch_and_tree('tree')
596
670
        self.build_tree(['tree/hello.txt'])
597
671
        tree.add('hello.txt')
598
672
        self.run_bzr_error(
599
673
            ["Did not understand bug identifier orange: Must be an integer. "
600
 
             "See \"bzr help bugs\" for more information on this feature.\n"
 
674
             "See \"brz help bugs\" for more information on this feature.\n"
601
675
             "Commit refused."],
602
676
            'commit -m add-b --fixes=lp:orange',
603
677
            working_dir='tree')
608
682
        self.build_tree(['tree/hello.txt'])
609
683
        tree.add('hello.txt')
610
684
        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',
 
685
            [r"Invalid bug orange:apples:bananas. Must be in the form of "
 
686
             r"'tracker:id'\. See \"brz help bugs\" for more information on "
 
687
             r"this feature.\nCommit refused\."],
 
688
            'commit -m add-b --fixes=orange:apples:bananas',
615
689
            working_dir='tree')
616
690
 
617
691
    def test_no_author(self):
619
693
        tree = self.make_branch_and_tree('tree')
620
694
        self.build_tree(['tree/hello.txt'])
621
695
        tree.add('hello.txt')
622
 
        self.run_bzr( 'commit -m hello tree/hello.txt')
 
696
        self.run_bzr('commit -m hello tree/hello.txt')
623
697
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
624
698
        properties = last_rev.properties
625
699
        self.assertFalse('author' in properties)
633
707
        tree.add('hello.txt')
634
708
        self.run_bzr(["commit", '-m', 'hello',
635
709
                      '--author', u'John D\xf6 <jdoe@example.com>',
636
 
                     "tree/hello.txt"])
 
710
                      "tree/hello.txt"])
637
711
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
638
712
        properties = last_rev.properties
639
 
        self.assertEqual(u'John D\xf6 <jdoe@example.com>', properties['authors'])
 
713
        self.assertEqual(u'John D\xf6 <jdoe@example.com>',
 
714
                         properties['authors'])
640
715
 
641
716
    def test_author_no_email(self):
642
717
        """Author's name without an email address is allowed, too."""
665
740
        self.build_tree(['tree/hello.txt'])
666
741
        tree.add('hello.txt')
667
742
        out, err = self.run_bzr("commit -m hello "
668
 
            "--commit-time='2009-10-10 08:00:00 +0100' tree/hello.txt")
 
743
                                "--commit-time='2009-10-10 08:00:00 +0100' tree/hello.txt")
669
744
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
670
745
        self.assertEqual(
671
746
            'Sat 2009-10-10 08:00:00 +0100',
672
747
            osutils.format_date(last_rev.timestamp, last_rev.timezone))
673
 
        
 
748
 
674
749
    def test_commit_time_bad_time(self):
675
750
        tree = self.make_branch_and_tree('tree')
676
751
        self.build_tree(['tree/hello.txt'])
677
752
        tree.add('hello.txt')
678
753
        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:")
 
754
                                "--commit-time='NOT A TIME' tree/hello.txt", retcode=3)
 
755
        self.assertStartsWith(
 
756
            err, "brz: ERROR: Could not parse --commit-time:")
 
757
 
 
758
    def test_commit_time_missing_tz(self):
 
759
        tree = self.make_branch_and_tree('tree')
 
760
        self.build_tree(['tree/hello.txt'])
 
761
        tree.add('hello.txt')
 
762
        out, err = self.run_bzr("commit -m hello "
 
763
                                "--commit-time='2009-10-10 08:00:00' tree/hello.txt", retcode=3)
 
764
        self.assertStartsWith(
 
765
            err, "brz: ERROR: Could not parse --commit-time:")
 
766
        # Test that it is actually checking and does not simply crash with
 
767
        # some other exception
 
768
        self.assertContainsString(err, "missing a timezone offset")
682
769
 
683
770
    def test_partial_commit_with_renames_in_tree(self):
684
771
        # this test illustrates bug #140419
691
778
        # then during partial commit we have error
692
779
        # parent_id {dir-XXX} not in inventory
693
780
        t.rename_one('dir/a', 'a')
694
 
        self.build_tree_contents([('test', 'changes in test')])
 
781
        self.build_tree_contents([('test', b'changes in test')])
695
782
        # partial commit
696
783
        out, err = self.run_bzr('commit test -m "partial commit"')
697
 
        self.assertEquals('', out)
 
784
        self.assertEqual('', out)
698
785
        self.assertContainsRe(err, r'modified test\nCommitted revision 2.')
699
786
 
700
787
    def test_commit_readonly_checkout(self):
701
 
        # https://bugs.edge.launchpad.net/bzr/+bug/129701
 
788
        # https://bugs.launchpad.net/bzr/+bug/129701
702
789
        # "UnlockableTransport error trying to commit in checkout of readonly
703
790
        # branch"
704
791
        self.make_branch('master')
705
 
        master = BzrDir.open_from_transport(
 
792
        master = ControlDir.open_from_transport(
706
793
            self.get_readonly_transport('master')).open_branch()
707
794
        master.create_checkout('checkout')
708
795
        out, err = self.run_bzr(['commit', '--unchanged', '-mfoo', 'checkout'],
709
 
            retcode=3)
 
796
                                retcode=3)
710
797
        self.assertContainsRe(err,
711
 
            r'^bzr: ERROR: Cannot lock.*readonly transport')
 
798
                              r'^brz: ERROR: Cannot lock.*readonly transport')
712
799
 
713
800
    def setup_editor(self):
714
801
        # Test that commit template hooks work
715
802
        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")
 
803
            with open('fed.bat', 'w') as f:
 
804
                f.write('@rem dummy fed')
 
805
            self.overrideEnv('BRZ_EDITOR', "fed.bat")
720
806
        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")
 
807
            with open('fed.sh', 'wb') as f:
 
808
                f.write(b'#!/bin/sh\n')
 
809
            os.chmod('fed.sh', 0o755)
 
810
            self.overrideEnv('BRZ_EDITOR', "./fed.sh")
726
811
 
727
812
    def setup_commit_with_template(self):
728
813
        self.setup_editor()
729
814
        msgeditor.hooks.install_named_hook("commit_message_template",
730
 
                lambda commit_obj, msg: "save me some typing\n", None)
 
815
                                           lambda commit_obj, msg: "save me some typing\n", None)
731
816
        tree = self.make_branch_and_tree('tree')
732
817
        self.build_tree(['tree/hello.txt'])
733
818
        tree.add('hello.txt')
734
819
        return tree
735
820
 
 
821
    def test_edit_empty_message(self):
 
822
        tree = self.make_branch_and_tree('tree')
 
823
        self.setup_editor()
 
824
        self.build_tree(['tree/hello.txt'])
 
825
        tree.add('hello.txt')
 
826
        out, err = self.run_bzr("commit tree/hello.txt", retcode=3,
 
827
                                stdin="y\n")
 
828
        self.assertContainsRe(err,
 
829
                              "brz: ERROR: Empty commit message specified")
 
830
 
736
831
    def test_commit_hook_template_accepted(self):
737
832
        tree = self.setup_commit_with_template()
738
833
        out, err = self.run_bzr("commit tree/hello.txt", stdin="y\n")
742
837
    def test_commit_hook_template_rejected(self):
743
838
        tree = self.setup_commit_with_template()
744
839
        expected = tree.last_revision()
745
 
        out, err = self.run_bzr_error(["empty commit message"],
746
 
            "commit tree/hello.txt", stdin="n\n")
 
840
        out, err = self.run_bzr_error(["Empty commit message specified."
 
841
                                       " Please specify a commit message with either"
 
842
                                       " --message or --file or leave a blank message"
 
843
                                       " with --message \"\"."],
 
844
                                      "commit tree/hello.txt", stdin="n\n")
747
845
        self.assertEqual(expected, tree.last_revision())
748
846
 
 
847
    def test_set_commit_message(self):
 
848
        msgeditor.hooks.install_named_hook("set_commit_message",
 
849
                                           lambda commit_obj, msg: "save me some typing\n", None)
 
850
        tree = self.make_branch_and_tree('tree')
 
851
        self.build_tree(['tree/hello.txt'])
 
852
        tree.add('hello.txt')
 
853
        out, err = self.run_bzr("commit tree/hello.txt")
 
854
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
855
        self.assertEqual('save me some typing\n', last_rev.message)
 
856
 
749
857
    def test_commit_without_username(self):
750
858
        """Ensure commit error if username is not set.
751
859
        """
752
860
        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')
 
861
        with open('foo/foo.txt', 'w') as f:
 
862
            f.write('hello')
 
863
        self.run_bzr(['add'], working_dir='foo')
 
864
        override_whoami(self)
 
865
        self.run_bzr_error(
 
866
            ['Unable to determine your name'],
 
867
            ['commit', '-m', 'initial'], working_dir='foo')
 
868
 
 
869
    def test_commit_recursive_checkout(self):
 
870
        """Ensure that a commit to a recursive checkout fails cleanly.
 
871
        """
 
872
        self.run_bzr(['init', 'test_branch'])
 
873
        self.run_bzr(['checkout', 'test_branch', 'test_checkout'])
 
874
        # bind to self
 
875
        self.run_bzr(['bind', '.'], working_dir='test_checkout')
 
876
        with open('test_checkout/foo.txt', 'w') as f:
 
877
            f.write('hello')
 
878
        self.run_bzr(['add'], working_dir='test_checkout')
 
879
        out, err = self.run_bzr_error(
 
880
            ['Branch.*test_checkout.*appears to be bound to itself'],
 
881
            ['commit', '-m', 'addedfoo'], working_dir='test_checkout')
 
882
 
 
883
    def test_mv_dirs_non_ascii(self):
 
884
        """Move directory with non-ascii name and containing files.
 
885
 
 
886
        Regression test for bug 185211.
 
887
        """
 
888
        tree = self.make_branch_and_tree('.')
 
889
        self.build_tree([u'abc\xa7/', u'abc\xa7/foo'])
 
890
 
 
891
        tree.add([u'abc\xa7/', u'abc\xa7/foo'])
 
892
        tree.commit('checkin')
 
893
 
 
894
        tree.rename_one(u'abc\xa7', 'abc')
 
895
 
 
896
        self.run_bzr('ci -m "non-ascii mv"')
 
897
 
 
898
 
 
899
class TestSmartServerCommit(TestCaseWithTransport):
 
900
 
 
901
    def test_commit_to_lightweight(self):
 
902
        self.setup_smart_server_with_call_log()
 
903
        t = self.make_branch_and_tree('from')
 
904
        for count in range(9):
 
905
            t.commit(message='commit %d' % count)
 
906
        out, err = self.run_bzr(['checkout', '--lightweight', self.get_url('from'),
 
907
                                 'target'])
 
908
        self.reset_smart_call_log()
 
909
        self.build_tree(['target/afile'])
 
910
        self.run_bzr(['add', 'target/afile'])
 
911
        out, err = self.run_bzr(['commit', '-m', 'do something', 'target'])
 
912
        # This figure represent the amount of work to perform this use case. It
 
913
        # is entirely ok to reduce this number if a test fails due to rpc_count
 
914
        # being too low. If rpc_count increases, more network roundtrips have
 
915
        # become necessary for this use case. Please do not adjust this number
 
916
        # upwards without agreement from bzr's network support maintainers.
 
917
        self.assertLength(211, self.hpss_calls)
 
918
        self.assertLength(2, self.hpss_connections)
 
919
        self.expectFailure("commit still uses VFS calls",
 
920
                           self.assertThat, self.hpss_calls, ContainsNoVfsCalls)