/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: 2018-11-16 23:19:12 UTC
  • mfrom: (7180 work)
  • mto: This revision was merged to the branch mainline in revision 7294.
  • Revision ID: jelmer@jelmer.uk-20181116231912-e043vpq22bdkxa6q
Merge trunk.

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