/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: 2006-04-24 10:31:28 UTC
  • mfrom: (1684.1.2 bzr.mbp.integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060424103128-a637f56a7c529bad
(mbp) tutorial improvements

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.runbzr("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-'))
88
 
 
89
 
    def test_commit_with_path(self):
90
 
        """Commit tree with path of root specified"""
91
 
        a_tree = self.make_branch_and_tree('a')
92
 
        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'])
 
38
        self.runbzr("commit -m empty", retcode=3)
107
39
 
108
40
    def test_10_verbose_commit(self):
109
41
        """Add one file and examine verbose commit output"""
110
 
        tree = self.make_branch_and_tree('.')
 
42
        self.runbzr("init")
111
43
        self.build_tree(['hello.txt'])
112
 
        tree.add("hello.txt")
113
 
        out, err = self.run_bzr('commit -m added')
 
44
        self.runbzr("add hello.txt")
 
45
        out,err = self.run_bzr("commit", "-m", "added")
114
46
        self.assertEqual('', out)
115
 
        self.assertContainsRe(err, '^Committing to: .*\n'
116
 
                              'added hello.txt\n'
117
 
                              'Committed revision 1.\n$',)
 
47
        self.assertEqual('added hello.txt\n'
 
48
                         'Committed revision 1.\n',
 
49
                         err)
118
50
 
119
51
    def prepare_simple_history(self):
120
52
        """Prepare and return a working tree with one commit of one file"""
121
53
        # Commit with modified file should say so
122
 
        wt = ControlDir.create_standalone_workingtree('.')
 
54
        wt = BzrDir.create_standalone_workingtree('.')
123
55
        self.build_tree(['hello.txt', 'extra.txt'])
124
56
        wt.add(['hello.txt'])
125
57
        wt.commit(message='added')
128
60
    def test_verbose_commit_modified(self):
129
61
        # Verbose commit of modified file should say so
130
62
        wt = self.prepare_simple_history()
131
 
        self.build_tree_contents([('hello.txt', b'new contents')])
132
 
        out, err = self.run_bzr('commit -m modified')
 
63
        self.build_tree_contents([('hello.txt', 'new contents')])
 
64
        out, err = self.run_bzr("commit", "-m", "modified")
133
65
        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")
 
66
        self.assertEqual('modified hello.txt\n'
 
67
                         'Committed revision 2.\n',
 
68
                         err)
205
69
 
206
70
    def test_verbose_commit_renamed(self):
207
71
        # Verbose commit of renamed file should say so
208
72
        wt = self.prepare_simple_history()
209
73
        wt.rename_one('hello.txt', 'gutentag.txt')
210
 
        out, err = self.run_bzr('commit -m renamed')
 
74
        out, err = self.run_bzr("commit", "-m", "renamed")
211
75
        self.assertEqual('', out)
212
 
        self.assertContainsRe(err, '^Committing to: .*\n'
213
 
                              'renamed hello\\.txt => gutentag\\.txt\n'
214
 
                              'Committed revision 2\\.$\n')
 
76
        self.assertEqual('renamed gutentag.txt\n'
 
77
                         'Committed revision 2.\n',
 
78
                         err)
215
79
 
216
80
    def test_verbose_commit_moved(self):
217
81
        # Verbose commit of file moved to new directory should say so
219
83
        os.mkdir('subdir')
220
84
        wt.add(['subdir'])
221
85
        wt.rename_one('hello.txt', 'subdir/hello.txt')
222
 
        out, err = self.run_bzr('commit -m renamed')
 
86
        out, err = self.run_bzr("commit", "-m", "renamed")
223
87
        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')))
 
88
        self.assertEqualDiff('added subdir\n'
 
89
                             'renamed subdir/hello.txt\n'
 
90
                             'Committed revision 2.\n',
 
91
                             err)
231
92
 
232
93
    def test_verbose_commit_with_unknown(self):
233
94
        """Unknown files should not be listed by default in verbose output"""
234
95
        # Is that really the best policy?
235
 
        wt = ControlDir.create_standalone_workingtree('.')
 
96
        wt = BzrDir.create_standalone_workingtree('.')
236
97
        self.build_tree(['hello.txt', 'extra.txt'])
237
98
        wt.add(['hello.txt'])
238
 
        out, err = self.run_bzr('commit -m added')
 
99
        out,err = self.run_bzr("commit", "-m", "added")
239
100
        self.assertEqual('', out)
240
 
        self.assertContainsRe(err, '^Committing to: .*\n'
241
 
                              'added hello\\.txt\n'
242
 
                              'Committed revision 1\\.\n$')
 
101
        self.assertEqual('added hello.txt\n'
 
102
                         'Committed revision 1.\n',
 
103
                         err)
243
104
 
244
 
    def test_verbose_commit_with_unchanged(self):
 
105
    def test_16_verbose_commit_with_unchanged(self):
245
106
        """Unchanged files should not be listed by default in verbose output"""
246
 
        tree = self.make_branch_and_tree('.')
 
107
        self.runbzr("init")
247
108
        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')
252
 
        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)
287
 
 
288
 
    def test_commit_merge_reports_all_modified_files(self):
289
 
        # 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
291
 
        # changed by the user but rather through doing a merge.
292
 
        this_tree = self.make_branch_and_tree('this')
293
 
        # we need a bunch of files and dirs, to perform one action on each.
294
 
        self.build_tree([
295
 
            'this/dirtorename/',
296
 
            'this/dirtoreparent/',
297
 
            'this/dirtoleave/',
298
 
            'this/dirtoremove/',
299
 
            'this/filetoreparent',
300
 
            'this/filetorename',
301
 
            'this/filetomodify',
302
 
            'this/filetoremove',
303
 
            'this/filetoleave']
304
 
            )
305
 
        this_tree.add([
306
 
            'dirtorename',
307
 
            'dirtoreparent',
308
 
            'dirtoleave',
309
 
            'dirtoremove',
310
 
            'filetoreparent',
311
 
            'filetorename',
312
 
            'filetomodify',
313
 
            'filetoremove',
314
 
            'filetoleave']
315
 
            )
316
 
        this_tree.commit('create_files')
317
 
        other_dir = this_tree.controldir.sprout('other')
318
 
        other_tree = other_dir.open_workingtree()
319
 
        with other_tree.lock_write():
320
 
            # perform the needed actions on the files and dirs.
321
 
            other_tree.rename_one('dirtorename', 'renameddir')
322
 
            other_tree.rename_one('dirtoreparent', 'renameddir/reparenteddir')
323
 
            other_tree.rename_one('filetorename', 'renamedfile')
324
 
            other_tree.rename_one('filetoreparent',
325
 
                                  'renameddir/reparentedfile')
326
 
            other_tree.remove(['dirtoremove', 'filetoremove'])
327
 
            self.build_tree_contents([
328
 
                ('other/newdir/',),
329
 
                ('other/filetomodify', b'new content'),
330
 
                ('other/newfile', b'new file content')])
331
 
            other_tree.add('newfile')
332
 
            other_tree.add('newdir/')
333
 
            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')
336
 
        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')))
 
109
        self.runbzr('add unchanged.txt')
 
110
        self.runbzr('commit -m unchanged unchanged.txt')
 
111
        self.runbzr("add hello.txt")
 
112
        out,err = self.run_bzr("commit", "-m", "added")
 
113
        self.assertEqual('', out)
 
114
        self.assertEqual('added hello.txt\n'
 
115
                         'Committed revision 2.\n',
 
116
                         err)
351
117
 
352
118
    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 ""')
 
119
        self.runbzr("init")
 
120
        file('foo.c', 'wt').write('int main() {}')
 
121
        self.runbzr(['add', 'foo.c'])
 
122
        self.runbzr(["commit", "-m", ""] , retcode=3)
357
123
 
358
124
    def test_other_branch_commit(self):
359
125
        # this branch is to ensure consistent behaviour, whether we're run
360
126
        # 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'])
 
127
        os.mkdir('empty_branch')
 
128
        os.chdir('empty_branch')
 
129
        self.runbzr('init')
 
130
        os.mkdir('branch')
 
131
        os.chdir('branch')
 
132
        self.runbzr('init')
 
133
        file('foo.c', 'wt').write('int main() {}')
 
134
        file('bar.c', 'wt').write('int main() {}')
 
135
        os.chdir('..')
 
136
        self.runbzr(['add', 'branch/foo.c'])
 
137
        self.runbzr(['add', 'branch'])
367
138
        # 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')
 
139
        self.runbzr('commit -m newstuff branch/foo.c .', retcode=3)
 
140
        self.runbzr('commit -m newstuff branch/foo.c')
 
141
        self.runbzr('commit -m newstuff branch')
 
142
        self.runbzr('commit -m newstuff branch', retcode=3)
376
143
 
377
144
    def test_out_of_date_tree_commit(self):
378
145
        # check we get an error code and a clear message committing with an out
379
146
        # of date checkout
380
 
        tree = self.make_branch_and_tree('branch')
 
147
        self.make_branch_and_tree('branch')
381
148
        # make a checkout
382
 
        checkout = tree.branch.create_checkout('checkout', lightweight=True)
 
149
        self.runbzr('checkout --lightweight branch checkout')
383
150
        # commit to the original branch to make the checkout out of date
384
 
        tree.commit('message branch', allow_pointless=True)
 
151
        self.runbzr('commit --unchanged -m message branch')
385
152
        # 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)
 
153
        # ERROR: Out of date with the branch, 'bzr update' is suggested
 
154
        output = self.runbzr('commit --unchanged -m checkout_message '
 
155
                             'checkout', retcode=3)
389
156
        self.assertEqual(output,
390
157
                         ('',
391
 
                          "brz: ERROR: Working tree is out of date, please "
392
 
                          "run 'brz update'.\n"))
 
158
                          "bzr: ERROR: Working tree is out of date, please run "
 
159
                          "'bzr update'.\n"))
393
160
 
394
161
    def test_local_commit_unbound(self):
395
162
        # a --local commit on an unbound branch is an error
396
163
        self.make_branch_and_tree('.')
397
 
        out, err = self.run_bzr('commit --local', retcode=3)
 
164
        out, err = self.run_bzr('commit', '--local', retcode=3)
398
165
        self.assertEqualDiff('', out)
399
 
        self.assertEqualDiff('brz: ERROR: Cannot perform local-only commits '
 
166
        self.assertEqualDiff('bzr: ERROR: Cannot perform local-only commits '
400
167
                             'on unbound branches.\n', err)
401
 
 
402
 
    def test_commit_a_text_merge_in_a_checkout(self):
403
 
        # checkouts perform multiple actions in a transaction across bond
404
 
        # 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
406
 
        # a merge done in a checkout (using the update command) failed to
407
 
        # 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')
418
 
 
419
 
        # 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')
423
 
 
424
 
        # now try to pull in online work from u2, and then commit our offline
425
 
        # work as a merge
426
 
        # 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')
438
 
        # add a text change here to represent resolving the merge conflicts in
439
 
        # favour of a new version of the file not identical to either the u1
440
 
        # 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)