/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: Alexander Belchenko
  • Date: 2006-06-29 08:41:31 UTC
  • mto: (1860.1.1 win32.installer)
  • mto: This revision was merged to the branch mainline in revision 1906.
  • Revision ID: bialix@ukr.net-20060629084131-3ea4d44e3204e36f
win32 installer for bzr.dev.0.9

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
2
 
#
 
1
# Copyright (C) 2005, 2006 by Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
#
 
12
 
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
18
"""Tests for the commit CLI of bzr."""
19
19
 
20
 
import doctest
21
20
import os
22
21
import re
23
22
import sys
24
23
 
25
 
from testtools.matchers import DocTestMatches
26
 
 
27
 
from ... import (
28
 
    config,
29
 
    osutils,
30
 
    ignores,
31
 
    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):
 
24
from bzrlib.branch import Branch
 
25
from bzrlib.bzrdir import BzrDir
 
26
from bzrlib.errors import BzrCommandError
 
27
from bzrlib.tests.blackbox import ExternalBase
 
28
from bzrlib.workingtree import WorkingTree
 
29
 
 
30
 
 
31
class TestCommit(ExternalBase):
45
32
 
46
33
    def test_05_empty_commit(self):
47
34
        """Commit of tree with no versioned files should fail"""
48
35
        # If forced, it should succeed, but this is not tested here.
49
 
        self.make_branch_and_tree('.')
 
36
        self.run_bzr("init")
50
37
        self.build_tree(['hello.txt'])
51
 
        out, err = self.run_bzr('commit -m empty', retcode=3)
52
 
        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))
64
 
 
65
 
    def test_commit_success(self):
66
 
        """Successful commit should not leave behind a bzr-commit-* file"""
67
 
        self.make_branch_and_tree('.')
68
 
        self.run_bzr('commit --unchanged -m message')
69
 
        self.assertEqual('', self.run_bzr('unknowns')[0])
70
 
 
71
 
        # same for unicode messages
72
 
        self.run_bzr(["commit", "--unchanged", "-m", u'foo\xb5'])
73
 
        self.assertEqual('', self.run_bzr('unknowns')[0])
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-'))
 
38
        result = self.run_bzr("commit", "-m", "empty", retcode=3)
 
39
        self.assertEqual(('', 'bzr: ERROR: no changes to commit.'
 
40
                              ' use --unchanged to commit anyhow\n'),
 
41
                         result)
88
42
 
89
43
    def test_commit_with_path(self):
90
44
        """Commit tree with path of root specified"""
91
 
        a_tree = self.make_branch_and_tree('a')
 
45
        self.run_bzr('init', 'a')
92
46
        self.build_tree(['a/a_file'])
93
 
        a_tree.add('a_file')
94
 
        self.run_bzr(['commit', '-m', 'first commit', 'a'])
95
 
 
96
 
        b_tree = a_tree.controldir.sprout('b').open_workingtree()
97
 
        self.build_tree_contents([('b/a_file', b'changes in b')])
98
 
        self.run_bzr(['commit', '-m', 'first commit in b', 'b'])
99
 
 
100
 
        self.build_tree_contents([('a/a_file', b'new contents')])
101
 
        self.run_bzr(['commit', '-m', 'change in a', 'a'])
102
 
 
103
 
        b_tree.merge_from_branch(a_tree.branch)
104
 
        self.assertEqual(len(b_tree.conflicts()), 1)
105
 
        self.run_bzr('resolved b/a_file')
106
 
        self.run_bzr(['commit', '-m', 'merge into b', 'b'])
 
47
        self.run_bzr('add', 'a/a_file')
 
48
        self.run_bzr('commit', '-m', 'first commit', 'a')
 
49
 
 
50
        self.run_bzr('branch', 'a', 'b')
 
51
        self.build_tree_contents([('b/a_file', 'changes in b')])
 
52
        self.run_bzr('commit', '-m', 'first commit in b', 'b')
 
53
 
 
54
        self.build_tree_contents([('a/a_file', 'new contents')])
 
55
        self.run_bzr('commit', '-m', 'change in a', 'a')
 
56
 
 
57
        os.chdir('b')
 
58
        self.run_bzr('merge', '../a', retcode=1) # will conflict
 
59
        os.chdir('..')
 
60
        self.run_bzr('resolved', 'b/a_file')
 
61
        self.run_bzr('commit', '-m', 'merge into b', 'b')
 
62
 
107
63
 
108
64
    def test_10_verbose_commit(self):
109
65
        """Add one file and examine verbose commit output"""
110
 
        tree = self.make_branch_and_tree('.')
 
66
        self.runbzr("init")
111
67
        self.build_tree(['hello.txt'])
112
 
        tree.add("hello.txt")
113
 
        out, err = self.run_bzr('commit -m added')
 
68
        self.runbzr("add hello.txt")
 
69
        out,err = self.run_bzr("commit", "-m", "added")
114
70
        self.assertEqual('', out)
115
 
        self.assertContainsRe(err, '^Committing to: .*\n'
116
 
                              'added hello.txt\n'
117
 
                              'Committed revision 1.\n$',)
 
71
        self.assertEqual('added hello.txt\n'
 
72
                         'Committed revision 1.\n',
 
73
                         err)
118
74
 
119
75
    def prepare_simple_history(self):
120
76
        """Prepare and return a working tree with one commit of one file"""
121
77
        # Commit with modified file should say so
122
 
        wt = ControlDir.create_standalone_workingtree('.')
 
78
        wt = BzrDir.create_standalone_workingtree('.')
123
79
        self.build_tree(['hello.txt', 'extra.txt'])
124
80
        wt.add(['hello.txt'])
125
81
        wt.commit(message='added')
128
84
    def test_verbose_commit_modified(self):
129
85
        # Verbose commit of modified file should say so
130
86
        wt = self.prepare_simple_history()
131
 
        self.build_tree_contents([('hello.txt', b'new contents')])
132
 
        out, err = self.run_bzr('commit -m modified')
 
87
        self.build_tree_contents([('hello.txt', 'new contents')])
 
88
        out, err = self.run_bzr("commit", "-m", "modified")
133
89
        self.assertEqual('', out)
134
 
        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\"$")
197
 
 
198
 
    def test_warn_about_forgotten_commit_message(self):
199
 
        """Test that the lack of -m parameter is caught"""
200
 
        wt = self.make_branch_and_tree('.')
201
 
        self.build_tree(['one', 'two'])
202
 
        wt.add(['two'])
203
 
        out, err = self.run_bzr('commit -m one two')
204
 
        self.assertContainsRe(err, "The commit message is a file name")
 
90
        self.assertEqual('modified hello.txt\n'
 
91
                         'Committed revision 2.\n',
 
92
                         err)
205
93
 
206
94
    def test_verbose_commit_renamed(self):
207
95
        # Verbose commit of renamed file should say so
208
96
        wt = self.prepare_simple_history()
209
97
        wt.rename_one('hello.txt', 'gutentag.txt')
210
 
        out, err = self.run_bzr('commit -m renamed')
 
98
        out, err = self.run_bzr("commit", "-m", "renamed")
211
99
        self.assertEqual('', out)
212
 
        self.assertContainsRe(err, '^Committing to: .*\n'
213
 
                              'renamed hello\\.txt => gutentag\\.txt\n'
214
 
                              'Committed revision 2\\.$\n')
 
100
        self.assertEqual('renamed hello.txt => gutentag.txt\n'
 
101
                         'Committed revision 2.\n',
 
102
                         err)
215
103
 
216
104
    def test_verbose_commit_moved(self):
217
105
        # Verbose commit of file moved to new directory should say so
219
107
        os.mkdir('subdir')
220
108
        wt.add(['subdir'])
221
109
        wt.rename_one('hello.txt', 'subdir/hello.txt')
222
 
        out, err = self.run_bzr('commit -m renamed')
 
110
        out, err = self.run_bzr("commit", "-m", "renamed")
223
111
        self.assertEqual('', out)
224
 
        self.assertEqual({
225
 
            'Committing to: %s/' % osutils.getcwd(),
226
 
            'added subdir',
227
 
            'renamed hello.txt => subdir/hello.txt',
228
 
            'Committed revision 2.',
229
 
            '',
230
 
            }, set(err.split('\n')))
 
112
        self.assertEqualDiff('added subdir\n'
 
113
                             'renamed hello.txt => subdir/hello.txt\n'
 
114
                             'Committed revision 2.\n',
 
115
                             err)
231
116
 
232
117
    def test_verbose_commit_with_unknown(self):
233
118
        """Unknown files should not be listed by default in verbose output"""
234
119
        # Is that really the best policy?
235
 
        wt = ControlDir.create_standalone_workingtree('.')
 
120
        wt = BzrDir.create_standalone_workingtree('.')
236
121
        self.build_tree(['hello.txt', 'extra.txt'])
237
122
        wt.add(['hello.txt'])
238
 
        out, err = self.run_bzr('commit -m added')
 
123
        out,err = self.run_bzr("commit", "-m", "added")
239
124
        self.assertEqual('', out)
240
 
        self.assertContainsRe(err, '^Committing to: .*\n'
241
 
                              'added hello\\.txt\n'
242
 
                              'Committed revision 1\\.\n$')
 
125
        self.assertEqual('added hello.txt\n'
 
126
                         'Committed revision 1.\n',
 
127
                         err)
243
128
 
244
129
    def test_verbose_commit_with_unchanged(self):
245
130
        """Unchanged files should not be listed by default in verbose output"""
246
 
        tree = self.make_branch_and_tree('.')
 
131
        self.runbzr("init")
247
132
        self.build_tree(['hello.txt', 'unchanged.txt'])
248
 
        tree.add('unchanged.txt')
249
 
        self.run_bzr('commit -m unchanged unchanged.txt')
250
 
        tree.add("hello.txt")
251
 
        out, err = self.run_bzr('commit -m added')
 
133
        self.runbzr('add unchanged.txt')
 
134
        self.runbzr('commit -m unchanged unchanged.txt')
 
135
        self.runbzr("add hello.txt")
 
136
        out,err = self.run_bzr("commit", "-m", "added")
252
137
        self.assertEqual('', out)
253
 
        self.assertContainsRe(err, '^Committing to: .*\n'
254
 
                              'added hello\\.txt\n'
255
 
                              'Committed revision 2\\.$\n')
256
 
 
257
 
    def test_verbose_commit_includes_master_location(self):
258
 
        """Location of master is displayed when committing to bound branch"""
259
 
        a_tree = self.make_branch_and_tree('a')
260
 
        self.build_tree(['a/b'])
261
 
        a_tree.add('b')
262
 
        a_tree.commit(message='Initial message')
263
 
 
264
 
        b_tree = a_tree.branch.create_checkout('b')
265
 
        expected = "%s/" % (osutils.abspath('a'), )
266
 
        out, err = self.run_bzr('commit -m blah --unchanged', working_dir='b')
267
 
        self.assertEqual(err, 'Committing to: %s\n'
268
 
                         'Committed revision 2.\n' % expected)
269
 
 
270
 
    def test_commit_sanitizes_CR_in_message(self):
271
 
        # 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
273
 
        # '\r' in commit messages. (Mostly because of issues where XML style
274
 
        # formats arbitrarily strip it out of the data while parsing.)
275
 
        # To make life easier for users, we just always translate '\r\n' =>
276
 
        # '\n'. And '\r' => '\n'.
277
 
        a_tree = self.make_branch_and_tree('a')
278
 
        self.build_tree(['a/b'])
279
 
        a_tree.add('b')
280
 
        self.run_bzr(['commit',
281
 
                      '-m', 'a string\r\n\r\nwith mixed\r\rendings\n'],
282
 
                     working_dir='a')
283
 
        rev_id = a_tree.branch.last_revision()
284
 
        rev = a_tree.branch.repository.get_revision(rev_id)
285
 
        self.assertEqualDiff('a string\n\nwith mixed\n\nendings\n',
286
 
                             rev.message)
 
138
        self.assertEqual('added hello.txt\n'
 
139
                         'Committed revision 2.\n',
 
140
                         err)
287
141
 
288
142
    def test_commit_merge_reports_all_modified_files(self):
289
143
        # 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
 
144
        # bzr diff or bzr status when committing, even when they were not
291
145
        # changed by the user but rather through doing a merge.
292
146
        this_tree = self.make_branch_and_tree('this')
293
147
        # we need a bunch of files and dirs, to perform one action on each.
314
168
            'filetoleave']
315
169
            )
316
170
        this_tree.commit('create_files')
317
 
        other_dir = this_tree.controldir.sprout('other')
 
171
        other_dir = this_tree.bzrdir.sprout('other')
318
172
        other_tree = other_dir.open_workingtree()
319
 
        with other_tree.lock_write():
320
 
            # perform the needed actions on the files and dirs.
 
173
        other_tree.lock_write()
 
174
        # perform the needed actions on the files and dirs.
 
175
        try:
321
176
            other_tree.rename_one('dirtorename', 'renameddir')
322
177
            other_tree.rename_one('dirtoreparent', 'renameddir/reparenteddir')
323
178
            other_tree.rename_one('filetorename', 'renamedfile')
324
 
            other_tree.rename_one('filetoreparent',
325
 
                                  'renameddir/reparentedfile')
 
179
            other_tree.rename_one('filetoreparent', 'renameddir/reparentedfile')
326
180
            other_tree.remove(['dirtoremove', 'filetoremove'])
327
181
            self.build_tree_contents([
328
 
                ('other/newdir/',),
329
 
                ('other/filetomodify', b'new content'),
330
 
                ('other/newfile', b'new file content')])
 
182
                ('other/newdir/', ),
 
183
                ('other/filetomodify', 'new content'),
 
184
                ('other/newfile', 'new file content')])
331
185
            other_tree.add('newfile')
332
186
            other_tree.add('newdir/')
333
187
            other_tree.commit('modify all sample files and dirs.')
334
 
        this_tree.merge_from_branch(other_tree.branch)
335
 
        out, err = self.run_bzr('commit -m added', working_dir='this')
 
188
        finally:
 
189
            other_tree.unlock()
 
190
        self.merge(other_tree.branch, this_tree)
 
191
        os.chdir('this')
 
192
        out,err = self.run_bzr("commit", "-m", "added")
 
193
        os.chdir('..')
336
194
        self.assertEqual('', out)
337
 
        self.assertEqual({
338
 
            'Committing to: %s/' % osutils.pathjoin(osutils.getcwd(), 'this'),
339
 
            'modified filetomodify',
340
 
            'added newdir',
341
 
            'added newfile',
342
 
            'renamed dirtorename => renameddir',
343
 
            'renamed filetorename => renamedfile',
344
 
            'renamed dirtoreparent => renameddir/reparenteddir',
345
 
            'renamed filetoreparent => renameddir/reparentedfile',
346
 
            'deleted dirtoremove',
347
 
            'deleted filetoremove',
348
 
            'Committed revision 2.',
349
 
            ''
350
 
            }, set(err.split('\n')))
 
195
        self.assertEqualDiff(
 
196
            'modified filetomodify\n'
 
197
            'added newdir\n'
 
198
            'added newfile\n'
 
199
            'renamed dirtorename => renameddir\n'
 
200
            'renamed dirtoreparent => renameddir/reparenteddir\n'
 
201
            'renamed filetoreparent => renameddir/reparentedfile\n'
 
202
            'renamed filetorename => renamedfile\n'
 
203
            'deleted dirtoremove\n'
 
204
            'deleted filetoremove\n'
 
205
            'Committed revision 2.\n',
 
206
            err)
351
207
 
352
208
    def test_empty_commit_message(self):
353
 
        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 ""')
 
209
        self.runbzr("init")
 
210
        file('foo.c', 'wt').write('int main() {}')
 
211
        self.runbzr(['add', 'foo.c'])
 
212
        self.runbzr(["commit", "-m", ""] , retcode=3)
357
213
 
358
214
    def test_other_branch_commit(self):
359
215
        # this branch is to ensure consistent behaviour, whether we're run
360
216
        # inside a branch, or not.
361
 
        outer_tree = self.make_branch_and_tree('.')
362
 
        inner_tree = self.make_branch_and_tree('branch')
363
 
        self.build_tree_contents([
364
 
            ('branch/foo.c', b'int main() {}'),
365
 
            ('branch/bar.c', b'int main() {}')])
366
 
        inner_tree.add(['foo.c', 'bar.c'])
 
217
        os.mkdir('empty_branch')
 
218
        os.chdir('empty_branch')
 
219
        self.runbzr('init')
 
220
        os.mkdir('branch')
 
221
        os.chdir('branch')
 
222
        self.runbzr('init')
 
223
        file('foo.c', 'wt').write('int main() {}')
 
224
        file('bar.c', 'wt').write('int main() {}')
 
225
        os.chdir('..')
 
226
        self.runbzr(['add', 'branch/foo.c'])
 
227
        self.runbzr(['add', 'branch'])
367
228
        # can't commit files in different trees; sane error
368
 
        self.run_bzr('commit -m newstuff branch/foo.c .', retcode=3)
369
 
        # can commit to branch - records foo.c only
370
 
        self.run_bzr('commit -m newstuff branch/foo.c')
371
 
        # can commit to branch - records bar.c
372
 
        self.run_bzr('commit -m newstuff branch')
373
 
        # No changes left
374
 
        self.run_bzr_error(["No changes to commit"],
375
 
                           'commit -m newstuff branch')
 
229
        self.runbzr('commit -m newstuff branch/foo.c .', retcode=3)
 
230
        self.runbzr('commit -m newstuff branch/foo.c')
 
231
        self.runbzr('commit -m newstuff branch')
 
232
        self.runbzr('commit -m newstuff branch', retcode=3)
376
233
 
377
234
    def test_out_of_date_tree_commit(self):
378
235
        # check we get an error code and a clear message committing with an out
379
236
        # of date checkout
380
 
        tree = self.make_branch_and_tree('branch')
 
237
        self.make_branch_and_tree('branch')
381
238
        # make a checkout
382
 
        checkout = tree.branch.create_checkout('checkout', lightweight=True)
 
239
        self.runbzr('checkout --lightweight branch checkout')
383
240
        # commit to the original branch to make the checkout out of date
384
 
        tree.commit('message branch', allow_pointless=True)
 
241
        self.runbzr('commit --unchanged -m message branch')
385
242
        # now commit to the checkout should emit
386
 
        # ERROR: Out of date with the branch, 'brz update' is suggested
387
 
        output = self.run_bzr('commit --unchanged -m checkout_message '
388
 
                              'checkout', retcode=3)
 
243
        # ERROR: Out of date with the branch, 'bzr update' is suggested
 
244
        output = self.runbzr('commit --unchanged -m checkout_message '
 
245
                             'checkout', retcode=3)
389
246
        self.assertEqual(output,
390
247
                         ('',
391
 
                          "brz: ERROR: Working tree is out of date, please "
392
 
                          "run 'brz update'.\n"))
 
248
                          "bzr: ERROR: Working tree is out of date, please run "
 
249
                          "'bzr update'.\n"))
393
250
 
394
251
    def test_local_commit_unbound(self):
395
252
        # a --local commit on an unbound branch is an error
396
253
        self.make_branch_and_tree('.')
397
 
        out, err = self.run_bzr('commit --local', retcode=3)
 
254
        out, err = self.run_bzr('commit', '--local', retcode=3)
398
255
        self.assertEqualDiff('', out)
399
 
        self.assertEqualDiff('brz: ERROR: Cannot perform local-only commits '
 
256
        self.assertEqualDiff('bzr: ERROR: Cannot perform local-only commits '
400
257
                             'on unbound branches.\n', err)
401
258
 
402
259
    def test_commit_a_text_merge_in_a_checkout(self):
403
260
        # checkouts perform multiple actions in a transaction across bond
404
261
        # branches and their master, and have been observed to fail in the
405
 
        # past. This is a user story reported to fail in bug #43959 where
 
262
        # past. This is a user story reported to fail in bug #43959 where 
406
263
        # a merge done in a checkout (using the update command) failed to
407
264
        # commit correctly.
408
 
        trunk = self.make_branch_and_tree('trunk')
409
 
 
410
 
        u1 = trunk.branch.create_checkout('u1')
411
 
        self.build_tree_contents([('u1/hosts', b'initial contents\n')])
412
 
        u1.add('hosts')
413
 
        self.run_bzr('commit -m add-hosts u1')
414
 
 
415
 
        u2 = trunk.branch.create_checkout('u2')
416
 
        self.build_tree_contents([('u2/hosts', b'altered in u2\n')])
417
 
        self.run_bzr('commit -m checkin-from-u2 u2')
 
265
        self.run_bzr('init', 'trunk')
 
266
 
 
267
        self.run_bzr('checkout', 'trunk', 'u1')
 
268
        self.build_tree_contents([('u1/hosts', 'initial contents')])
 
269
        self.run_bzr('add', 'u1/hosts')
 
270
        self.run_bzr('commit', '-m', 'add hosts', 'u1')
 
271
 
 
272
        self.run_bzr('checkout', 'trunk', 'u2')
 
273
        self.build_tree_contents([('u2/hosts', 'altered in u2')])
 
274
        self.run_bzr('commit', '-m', 'checkin from u2', 'u2')
418
275
 
419
276
        # make an offline commits
420
 
        self.build_tree_contents(
421
 
            [('u1/hosts', b'first offline change in u1\n')])
422
 
        self.run_bzr('commit -m checkin-offline --local u1')
 
277
        self.build_tree_contents([('u1/hosts', 'first offline change in u1')])
 
278
        self.run_bzr('commit', '-m', 'checkin offline', '--local', 'u1')
423
279
 
424
280
        # now try to pull in online work from u2, and then commit our offline
425
281
        # work as a merge
426
282
        # retcode 1 as we expect a text conflict
427
 
        self.run_bzr('update u1', retcode=1)
428
 
        self.assertFileEqual(b'''\
429
 
<<<<<<< TREE
430
 
first offline change in u1
431
 
=======
432
 
altered in u2
433
 
>>>>>>> MERGE-SOURCE
434
 
''',
435
 
                             'u1/hosts')
436
 
 
437
 
        self.run_bzr('resolved u1/hosts')
 
283
        self.run_bzr('update', 'u1', retcode=1)
 
284
        self.run_bzr('resolved', 'u1/hosts')
438
285
        # add a text change here to represent resolving the merge conflicts in
439
286
        # favour of a new version of the file not identical to either the u1
440
287
        # version or the u2 version.
441
 
        self.build_tree_contents([('u1/hosts', b'merge resolution\n')])
442
 
        self.run_bzr('commit -m checkin-merge-of-the-offline-work-from-u1 u1')
443
 
 
444
 
    def test_commit_exclude_excludes_modified_files(self):
445
 
        """Commit -x foo should ignore changes to foo."""
446
 
        tree = self.make_branch_and_tree('.')
447
 
        self.build_tree(['a', 'b', 'c'])
448
 
        tree.smart_add(['.'])
449
 
        out, err = self.run_bzr(['commit', '-m', 'test', '-x', 'b'])
450
 
        self.assertFalse('added b' in out)
451
 
        self.assertFalse('added b' in err)
452
 
        # If b was excluded it will still be 'added' in status.
453
 
        out, err = self.run_bzr(['added'])
454
 
        self.assertEqual('b\n', out)
455
 
        self.assertEqual('', err)
456
 
 
457
 
    def test_commit_exclude_twice_uses_both_rules(self):
458
 
        """Commit -x foo -x bar should ignore changes to foo and bar."""
459
 
        tree = self.make_branch_and_tree('.')
460
 
        self.build_tree(['a', 'b', 'c'])
461
 
        tree.smart_add(['.'])
462
 
        out, err = self.run_bzr(['commit', '-m', 'test', '-x', 'b', '-x', 'c'])
463
 
        self.assertFalse('added b' in out)
464
 
        self.assertFalse('added c' in out)
465
 
        self.assertFalse('added b' in err)
466
 
        self.assertFalse('added c' in err)
467
 
        # If b was excluded it will still be 'added' in status.
468
 
        out, err = self.run_bzr(['added'])
469
 
        self.assertTrue('b\n' in out)
470
 
        self.assertTrue('c\n' in out)
471
 
        self.assertEqual('', err)
472
 
 
473
 
    def test_commit_respects_spec_for_removals(self):
474
 
        """Commit with a file spec should only commit removals that match"""
475
 
        t = self.make_branch_and_tree('.')
476
 
        self.build_tree(['file-a', 'dir-a/', 'dir-a/file-b'])
477
 
        t.add(['file-a', 'dir-a', 'dir-a/file-b'])
478
 
        t.commit('Create')
479
 
        t.remove(['file-a', 'dir-a/file-b'])
480
 
        result = self.run_bzr('commit . -m removed-file-b',
481
 
                              working_dir='dir-a')[1]
482
 
        self.assertNotContainsRe(result, 'file-a')
483
 
        result = self.run_bzr('status', working_dir='dir-a')[0]
484
 
        self.assertContainsRe(result, 'removed:\n  file-a')
485
 
 
486
 
    def test_strict_commit(self):
487
 
        """Commit with --strict works if everything is known"""
488
 
        ignores._set_user_ignores([])
489
 
        tree = self.make_branch_and_tree('tree')
490
 
        self.build_tree(['tree/a'])
491
 
        tree.add('a')
492
 
        # A simple change should just work
493
 
        self.run_bzr('commit --strict -m adding-a', working_dir='tree')
494
 
 
495
 
    def test_strict_commit_no_changes(self):
496
 
        """commit --strict gives "no changes" if there is nothing to commit"""
497
 
        tree = self.make_branch_and_tree('tree')
498
 
        self.build_tree(['tree/a'])
499
 
        tree.add('a')
500
 
        tree.commit('adding a')
501
 
 
502
 
        # With no changes, it should just be 'no changes'
503
 
        # Make sure that commit is failing because there is nothing to do
504
 
        self.run_bzr_error(['No changes to commit'],
505
 
                           'commit --strict -m no-changes',
506
 
                           working_dir='tree')
507
 
 
508
 
        # But --strict doesn't care if you supply --unchanged
509
 
        self.run_bzr('commit --strict --unchanged -m no-changes',
510
 
                     working_dir='tree')
511
 
 
512
 
    def test_strict_commit_unknown(self):
513
 
        """commit --strict fails if a file is unknown"""
514
 
        tree = self.make_branch_and_tree('tree')
515
 
        self.build_tree(['tree/a'])
516
 
        tree.add('a')
517
 
        tree.commit('adding a')
518
 
 
519
 
        # Add one file so there is a change, but forget the other
520
 
        self.build_tree(['tree/b', 'tree/c'])
521
 
        tree.add('b')
522
 
        self.run_bzr_error(['Commit refused because there are unknown files'],
523
 
                           'commit --strict -m add-b',
524
 
                           working_dir='tree')
525
 
 
526
 
        # --no-strict overrides --strict
527
 
        self.run_bzr('commit --strict -m add-b --no-strict',
528
 
                     working_dir='tree')
529
 
 
530
 
    def test_fixes_bug_output(self):
531
 
        """commit --fixes=lp:23452 succeeds without output."""
532
 
        tree = self.make_branch_and_tree('tree')
533
 
        self.build_tree(['tree/hello.txt'])
534
 
        tree.add('hello.txt')
535
 
        output, err = self.run_bzr(
536
 
            'commit -m hello --fixes=lp:23452 tree/hello.txt')
537
 
        self.assertEqual('', output)
538
 
        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')
554
 
 
555
 
    def test_no_bugs_no_properties(self):
556
 
        """If no bugs are fixed, the bugs property is not set.
557
 
 
558
 
        see https://beta.launchpad.net/bzr/+bug/109613
559
 
        """
560
 
        tree = self.make_branch_and_tree('tree')
561
 
        self.build_tree(['tree/hello.txt'])
562
 
        tree.add('hello.txt')
563
 
        self.run_bzr('commit -m hello tree/hello.txt')
564
 
        # Get the revision properties, ignoring the branch-nick property, which
565
 
        # we don't care about for this test.
566
 
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
567
 
        properties = dict(last_rev.properties)
568
 
        del properties['branch-nick']
569
 
        self.assertFalse('bugs' in properties)
570
 
 
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
 
    def test_fixes_bug_sets_property(self):
588
 
        """commit --fixes=lp:234 sets the lp:234 revprop to 'fixed'."""
589
 
        tree = self.make_branch_and_tree('tree')
590
 
        self.build_tree(['tree/hello.txt'])
591
 
        tree.add('hello.txt')
592
 
        self.run_bzr('commit -m hello --fixes=lp:234 tree/hello.txt')
593
 
 
594
 
        # Get the revision properties, ignoring the branch-nick property, which
595
 
        # we don't care about for this test.
596
 
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
597
 
        properties = dict(last_rev.properties)
598
 
        del properties[u'branch-nick']
599
 
 
600
 
        self.assertEqual({u'bugs': 'https://launchpad.net/bugs/234 fixed'},
601
 
                         properties)
602
 
 
603
 
    def test_fixes_multiple_bugs_sets_properties(self):
604
 
        """--fixes can be used more than once to show that bugs are fixed."""
605
 
        tree = self.make_branch_and_tree('tree')
606
 
        self.build_tree(['tree/hello.txt'])
607
 
        tree.add('hello.txt')
608
 
        self.run_bzr('commit -m hello --fixes=lp:123 --fixes=lp:235'
609
 
                     ' tree/hello.txt')
610
 
 
611
 
        # Get the revision properties, ignoring the branch-nick property, which
612
 
        # we don't care about for this test.
613
 
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
614
 
        properties = dict(last_rev.properties)
615
 
        del properties['branch-nick']
616
 
 
617
 
        self.assertEqual(
618
 
            {u'bugs': 'https://launchpad.net/bugs/123 fixed\n'
619
 
             'https://launchpad.net/bugs/235 fixed'},
620
 
            properties)
621
 
 
622
 
    def test_fixes_bug_with_alternate_trackers(self):
623
 
        """--fixes can be used on a properly configured branch to mark bug
624
 
        fixes on multiple trackers.
625
 
        """
626
 
        tree = self.make_branch_and_tree('tree')
627
 
        tree.branch.get_config().set_user_option(
628
 
            'trac_twisted_url', 'http://twistedmatrix.com/trac')
629
 
        self.build_tree(['tree/hello.txt'])
630
 
        tree.add('hello.txt')
631
 
        self.run_bzr(
632
 
            'commit -m hello --fixes=lp:123 --fixes=twisted:235 tree/')
633
 
 
634
 
        # Get the revision properties, ignoring the branch-nick property, which
635
 
        # we don't care about for this test.
636
 
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
637
 
        properties = dict(last_rev.properties)
638
 
        del properties['branch-nick']
639
 
 
640
 
        self.assertEqual(
641
 
            {'bugs': 'https://launchpad.net/bugs/123 fixed\n'
642
 
                     'http://twistedmatrix.com/trac/ticket/235 fixed'},
643
 
            properties)
644
 
 
645
 
    def test_fixes_unknown_bug_prefix(self):
646
 
        tree = self.make_branch_and_tree('tree')
647
 
        self.build_tree(['tree/hello.txt'])
648
 
        tree.add('hello.txt')
649
 
        self.run_bzr_error(
650
 
            ["Unrecognized bug %s. Commit refused." % 'xxx:123'],
651
 
            'commit -m add-b --fixes=xxx:123',
652
 
            working_dir='tree')
653
 
 
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
 
    def test_fixes_invalid_bug_number(self):
674
 
        tree = self.make_branch_and_tree('tree')
675
 
        self.build_tree(['tree/hello.txt'])
676
 
        tree.add('hello.txt')
677
 
        self.run_bzr_error(
678
 
            ["Did not understand bug identifier orange: Must be an integer. "
679
 
             "See \"brz help bugs\" for more information on this feature.\n"
680
 
             "Commit refused."],
681
 
            'commit -m add-b --fixes=lp:orange',
682
 
            working_dir='tree')
683
 
 
684
 
    def test_fixes_invalid_argument(self):
685
 
        """Raise an appropriate error when the fixes argument isn't tag:id."""
686
 
        tree = self.make_branch_and_tree('tree')
687
 
        self.build_tree(['tree/hello.txt'])
688
 
        tree.add('hello.txt')
689
 
        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',
694
 
            working_dir='tree')
695
 
 
696
 
    def test_no_author(self):
697
 
        """If the author is not specified, the author property is not set."""
698
 
        tree = self.make_branch_and_tree('tree')
699
 
        self.build_tree(['tree/hello.txt'])
700
 
        tree.add('hello.txt')
701
 
        self.run_bzr('commit -m hello tree/hello.txt')
702
 
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
703
 
        properties = last_rev.properties
704
 
        self.assertFalse('author' in properties)
705
 
 
706
 
    def test_author_sets_property(self):
707
 
        """commit --author='John Doe <jdoe@example.com>' sets the author
708
 
           revprop.
709
 
        """
710
 
        tree = self.make_branch_and_tree('tree')
711
 
        self.build_tree(['tree/hello.txt'])
712
 
        tree.add('hello.txt')
713
 
        self.run_bzr(["commit", '-m', 'hello',
714
 
                      '--author', u'John D\xf6 <jdoe@example.com>',
715
 
                      "tree/hello.txt"])
716
 
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
717
 
        properties = last_rev.properties
718
 
        self.assertEqual(u'John D\xf6 <jdoe@example.com>',
719
 
                         properties['authors'])
720
 
 
721
 
    def test_author_no_email(self):
722
 
        """Author's name without an email address is allowed, too."""
723
 
        tree = self.make_branch_and_tree('tree')
724
 
        self.build_tree(['tree/hello.txt'])
725
 
        tree.add('hello.txt')
726
 
        out, err = self.run_bzr("commit -m hello --author='John Doe' "
727
 
                                "tree/hello.txt")
728
 
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
729
 
        properties = last_rev.properties
730
 
        self.assertEqual('John Doe', properties['authors'])
731
 
 
732
 
    def test_multiple_authors(self):
733
 
        """Multiple authors can be specyfied, and all are stored."""
734
 
        tree = self.make_branch_and_tree('tree')
735
 
        self.build_tree(['tree/hello.txt'])
736
 
        tree.add('hello.txt')
737
 
        out, err = self.run_bzr("commit -m hello --author='John Doe' "
738
 
                                "--author='Jane Rey' tree/hello.txt")
739
 
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
740
 
        properties = last_rev.properties
741
 
        self.assertEqual('John Doe\nJane Rey', properties['authors'])
742
 
 
743
 
    def test_commit_time(self):
744
 
        tree = self.make_branch_and_tree('tree')
745
 
        self.build_tree(['tree/hello.txt'])
746
 
        tree.add('hello.txt')
747
 
        out, err = self.run_bzr("commit -m hello "
748
 
                                "--commit-time='2009-10-10 08:00:00 +0100' tree/hello.txt")
749
 
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
750
 
        self.assertEqual(
751
 
            'Sat 2009-10-10 08:00:00 +0100',
752
 
            osutils.format_date(last_rev.timestamp, last_rev.timezone))
753
 
 
754
 
    def test_commit_time_bad_time(self):
755
 
        tree = self.make_branch_and_tree('tree')
756
 
        self.build_tree(['tree/hello.txt'])
757
 
        tree.add('hello.txt')
758
 
        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")
774
 
 
775
 
    def test_partial_commit_with_renames_in_tree(self):
776
 
        # this test illustrates bug #140419
777
 
        t = self.make_branch_and_tree('.')
778
 
        self.build_tree(['dir/', 'dir/a', 'test'])
779
 
        t.add(['dir/', 'dir/a', 'test'])
780
 
        t.commit('initial commit')
781
 
        # important part: file dir/a should change parent
782
 
        # and should appear before old parent
783
 
        # then during partial commit we have error
784
 
        # parent_id {dir-XXX} not in inventory
785
 
        t.rename_one('dir/a', 'a')
786
 
        self.build_tree_contents([('test', b'changes in test')])
787
 
        # partial commit
788
 
        out, err = self.run_bzr('commit test -m "partial commit"')
789
 
        self.assertEqual('', out)
790
 
        self.assertContainsRe(err, r'modified test\nCommitted revision 2.')
791
 
 
792
 
    def test_commit_readonly_checkout(self):
793
 
        # https://bugs.launchpad.net/bzr/+bug/129701
794
 
        # "UnlockableTransport error trying to commit in checkout of readonly
795
 
        # branch"
796
 
        self.make_branch('master')
797
 
        master = ControlDir.open_from_transport(
798
 
            self.get_readonly_transport('master')).open_branch()
799
 
        master.create_checkout('checkout')
800
 
        out, err = self.run_bzr(['commit', '--unchanged', '-mfoo', 'checkout'],
801
 
                                retcode=3)
802
 
        self.assertContainsRe(err,
803
 
                              r'^brz: ERROR: Cannot lock.*readonly transport')
804
 
 
805
 
    def setup_editor(self):
806
 
        # Test that commit template hooks work
807
 
        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")
811
 
        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()
819
 
        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)
855
 
        tree = self.make_branch_and_tree('tree')
856
 
        self.build_tree(['tree/hello.txt'])
857
 
        tree.add('hello.txt')
858
 
        out, err = self.run_bzr("commit tree/hello.txt")
859
 
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
860
 
        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)
 
288
        self.build_tree_contents([('u1/hosts', 'merge resolution\n')])
 
289
        self.run_bzr('commit', '-m', 'checkin merge of the offline work from u1', 'u1')