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

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-02-11 04:02:41 UTC
  • mfrom: (5017.2.2 tariff)
  • Revision ID: pqm@pqm.ubuntu.com-20100211040241-w6n021dz0uus341n
(mbp) add import-tariff tests

Show diffs side-by-side

added added

removed removed

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