/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: 2019-07-12 01:01:45 UTC
  • mto: This revision was merged to the branch mainline in revision 7375.
  • Revision ID: jelmer@jelmer.uk-20190712010145-m7224qumb8w068zw
https://launchpad.net/bugs/1836238
Fix importing from remote git repositories.

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