/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: John Arbash Meinel
  • Date: 2009-06-18 18:18:36 UTC
  • mto: This revision was merged to the branch mainline in revision 4461.
  • Revision ID: john@arbash-meinel.com-20090618181836-biodfkat9a8eyzjz
The new add_inventory_by_delta is returning a CHKInventory when mapping from NULL
Which is completely valid, but 'broke' one of the tests.
So to fix it, changed the test to use CHKInventories on both sides, and add an __eq__
member. The nice thing is that CHKInventory.__eq__ is fairly cheap, since it only
has to check the root keys.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
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
 
16
 
 
17
 
 
18
"""Tests for the commit CLI of bzr."""
 
19
 
 
20
import os
 
21
import sys
 
22
 
 
23
from bzrlib import (
 
24
    osutils,
 
25
    ignores,
 
26
    msgeditor,
 
27
    osutils,
 
28
    )
 
29
from bzrlib.bzrdir import BzrDir
 
30
from bzrlib.tests import (
 
31
    probe_bad_non_ascii,
 
32
    TestSkipped,
 
33
    )
 
34
from bzrlib.tests.blackbox import ExternalBase
 
35
 
 
36
 
 
37
class TestCommit(ExternalBase):
 
38
 
 
39
    def test_05_empty_commit(self):
 
40
        """Commit of tree with no versioned files should fail"""
 
41
        # If forced, it should succeed, but this is not tested here.
 
42
        self.make_branch_and_tree('.')
 
43
        self.build_tree(['hello.txt'])
 
44
        out,err = self.run_bzr('commit -m empty', retcode=3)
 
45
        self.assertEqual('', out)
 
46
        self.assertContainsRe(err, 'bzr: ERROR: No changes to commit\.'
 
47
                                  ' Use --unchanged to commit anyhow.\n')
 
48
 
 
49
    def test_commit_success(self):
 
50
        """Successful commit should not leave behind a bzr-commit-* file"""
 
51
        self.make_branch_and_tree('.')
 
52
        self.run_bzr('commit --unchanged -m message')
 
53
        self.assertEqual('', self.run_bzr('unknowns')[0])
 
54
 
 
55
        # same for unicode messages
 
56
        self.run_bzr(["commit", "--unchanged", "-m", u'foo\xb5'])
 
57
        self.assertEqual('', self.run_bzr('unknowns')[0])
 
58
 
 
59
    def test_commit_with_path(self):
 
60
        """Commit tree with path of root specified"""
 
61
        a_tree = self.make_branch_and_tree('a')
 
62
        self.build_tree(['a/a_file'])
 
63
        a_tree.add('a_file')
 
64
        self.run_bzr(['commit', '-m', 'first commit', 'a'])
 
65
 
 
66
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
 
67
        self.build_tree_contents([('b/a_file', 'changes in b')])
 
68
        self.run_bzr(['commit', '-m', 'first commit in b', 'b'])
 
69
 
 
70
        self.build_tree_contents([('a/a_file', 'new contents')])
 
71
        self.run_bzr(['commit', '-m', 'change in a', 'a'])
 
72
 
 
73
        b_tree.merge_from_branch(a_tree.branch)
 
74
        self.assertEqual(len(b_tree.conflicts()), 1)
 
75
        self.run_bzr('resolved b/a_file')
 
76
        self.run_bzr(['commit', '-m', 'merge into b', 'b'])
 
77
 
 
78
 
 
79
    def test_10_verbose_commit(self):
 
80
        """Add one file and examine verbose commit output"""
 
81
        tree = self.make_branch_and_tree('.')
 
82
        self.build_tree(['hello.txt'])
 
83
        tree.add("hello.txt")
 
84
        out,err = self.run_bzr('commit -m added')
 
85
        self.assertEqual('', out)
 
86
        self.assertContainsRe(err, '^Committing to: .*\n'
 
87
                              'added hello.txt\n'
 
88
                              'Committed revision 1.\n$',)
 
89
 
 
90
    def prepare_simple_history(self):
 
91
        """Prepare and return a working tree with one commit of one file"""
 
92
        # Commit with modified file should say so
 
93
        wt = BzrDir.create_standalone_workingtree('.')
 
94
        self.build_tree(['hello.txt', 'extra.txt'])
 
95
        wt.add(['hello.txt'])
 
96
        wt.commit(message='added')
 
97
        return wt
 
98
 
 
99
    def test_verbose_commit_modified(self):
 
100
        # Verbose commit of modified file should say so
 
101
        wt = self.prepare_simple_history()
 
102
        self.build_tree_contents([('hello.txt', 'new contents')])
 
103
        out, err = self.run_bzr('commit -m modified')
 
104
        self.assertEqual('', out)
 
105
        self.assertContainsRe(err, '^Committing to: .*\n'
 
106
                              'modified hello\.txt\n'
 
107
                              'Committed revision 2\.\n$')
 
108
 
 
109
    def test_verbose_commit_renamed(self):
 
110
        # Verbose commit of renamed file should say so
 
111
        wt = self.prepare_simple_history()
 
112
        wt.rename_one('hello.txt', 'gutentag.txt')
 
113
        out, err = self.run_bzr('commit -m renamed')
 
114
        self.assertEqual('', out)
 
115
        self.assertContainsRe(err, '^Committing to: .*\n'
 
116
                              'renamed hello\.txt => gutentag\.txt\n'
 
117
                              'Committed revision 2\.$\n')
 
118
 
 
119
    def test_verbose_commit_moved(self):
 
120
        # Verbose commit of file moved to new directory should say so
 
121
        wt = self.prepare_simple_history()
 
122
        os.mkdir('subdir')
 
123
        wt.add(['subdir'])
 
124
        wt.rename_one('hello.txt', 'subdir/hello.txt')
 
125
        out, err = self.run_bzr('commit -m renamed')
 
126
        self.assertEqual('', out)
 
127
        self.assertEqual(set([
 
128
            'Committing to: %s/' % osutils.getcwd(),
 
129
            'added subdir',
 
130
            'renamed hello.txt => subdir/hello.txt',
 
131
            'Committed revision 2.',
 
132
            '',
 
133
            ]), set(err.split('\n')))
 
134
 
 
135
    def test_verbose_commit_with_unknown(self):
 
136
        """Unknown files should not be listed by default in verbose output"""
 
137
        # Is that really the best policy?
 
138
        wt = BzrDir.create_standalone_workingtree('.')
 
139
        self.build_tree(['hello.txt', 'extra.txt'])
 
140
        wt.add(['hello.txt'])
 
141
        out,err = self.run_bzr('commit -m added')
 
142
        self.assertEqual('', out)
 
143
        self.assertContainsRe(err, '^Committing to: .*\n'
 
144
                              'added hello\.txt\n'
 
145
                              'Committed revision 1\.\n$')
 
146
 
 
147
    def test_verbose_commit_with_unchanged(self):
 
148
        """Unchanged files should not be listed by default in verbose output"""
 
149
        tree = self.make_branch_and_tree('.')
 
150
        self.build_tree(['hello.txt', 'unchanged.txt'])
 
151
        tree.add('unchanged.txt')
 
152
        self.run_bzr('commit -m unchanged unchanged.txt')
 
153
        tree.add("hello.txt")
 
154
        out,err = self.run_bzr('commit -m added')
 
155
        self.assertEqual('', out)
 
156
        self.assertContainsRe(err, '^Committing to: .*\n'
 
157
                              'added hello\.txt\n'
 
158
                              'Committed revision 2\.$\n')
 
159
 
 
160
    def test_verbose_commit_includes_master_location(self):
 
161
        """Location of master is displayed when committing to bound branch"""
 
162
        a_tree = self.make_branch_and_tree('a')
 
163
        self.build_tree(['a/b'])
 
164
        a_tree.add('b')
 
165
        a_tree.commit(message='Initial message')
 
166
 
 
167
        b_tree = a_tree.branch.create_checkout('b')
 
168
        expected = "%s/" % (osutils.abspath('a'), )
 
169
        out, err = self.run_bzr('commit -m blah --unchanged', working_dir='b')
 
170
        self.assertEqual(err, 'Committing to: %s\n'
 
171
                         'Committed revision 2.\n' % expected)
 
172
 
 
173
    def test_commit_merge_reports_all_modified_files(self):
 
174
        # the commit command should show all the files that are shown by
 
175
        # bzr diff or bzr status when committing, even when they were not
 
176
        # changed by the user but rather through doing a merge.
 
177
        this_tree = self.make_branch_and_tree('this')
 
178
        # we need a bunch of files and dirs, to perform one action on each.
 
179
        self.build_tree([
 
180
            'this/dirtorename/',
 
181
            'this/dirtoreparent/',
 
182
            'this/dirtoleave/',
 
183
            'this/dirtoremove/',
 
184
            'this/filetoreparent',
 
185
            'this/filetorename',
 
186
            'this/filetomodify',
 
187
            'this/filetoremove',
 
188
            'this/filetoleave']
 
189
            )
 
190
        this_tree.add([
 
191
            'dirtorename',
 
192
            'dirtoreparent',
 
193
            'dirtoleave',
 
194
            'dirtoremove',
 
195
            'filetoreparent',
 
196
            'filetorename',
 
197
            'filetomodify',
 
198
            'filetoremove',
 
199
            'filetoleave']
 
200
            )
 
201
        this_tree.commit('create_files')
 
202
        other_dir = this_tree.bzrdir.sprout('other')
 
203
        other_tree = other_dir.open_workingtree()
 
204
        other_tree.lock_write()
 
205
        # perform the needed actions on the files and dirs.
 
206
        try:
 
207
            other_tree.rename_one('dirtorename', 'renameddir')
 
208
            other_tree.rename_one('dirtoreparent', 'renameddir/reparenteddir')
 
209
            other_tree.rename_one('filetorename', 'renamedfile')
 
210
            other_tree.rename_one('filetoreparent',
 
211
                                  'renameddir/reparentedfile')
 
212
            other_tree.remove(['dirtoremove', 'filetoremove'])
 
213
            self.build_tree_contents([
 
214
                ('other/newdir/',),
 
215
                ('other/filetomodify', 'new content'),
 
216
                ('other/newfile', 'new file content')])
 
217
            other_tree.add('newfile')
 
218
            other_tree.add('newdir/')
 
219
            other_tree.commit('modify all sample files and dirs.')
 
220
        finally:
 
221
            other_tree.unlock()
 
222
        this_tree.merge_from_branch(other_tree.branch)
 
223
        os.chdir('this')
 
224
        out,err = self.run_bzr('commit -m added')
 
225
        self.assertEqual('', out)
 
226
        self.assertEqual(set([
 
227
            'Committing to: %s/' % osutils.getcwd(),
 
228
            'modified filetomodify',
 
229
            'added newdir',
 
230
            'added newfile',
 
231
            'renamed dirtorename => renameddir',
 
232
            'renamed filetorename => renamedfile',
 
233
            'renamed dirtoreparent => renameddir/reparenteddir',
 
234
            'renamed filetoreparent => renameddir/reparentedfile',
 
235
            'deleted dirtoremove',
 
236
            'deleted filetoremove',
 
237
            'Committed revision 2.',
 
238
            ''
 
239
            ]), set(err.split('\n')))
 
240
 
 
241
    def test_empty_commit_message(self):
 
242
        tree = self.make_branch_and_tree('.')
 
243
        self.build_tree_contents([('foo.c', 'int main() {}')])
 
244
        tree.add('foo.c')
 
245
        self.run_bzr('commit -m ""', retcode=3)
 
246
 
 
247
    def test_unsupported_encoding_commit_message(self):
 
248
        tree = self.make_branch_and_tree('.')
 
249
        self.build_tree_contents([('foo.c', 'int main() {}')])
 
250
        tree.add('foo.c')
 
251
        # LANG env variable has no effect on Windows
 
252
        # but some characters anyway cannot be represented
 
253
        # in default user encoding
 
254
        char = probe_bad_non_ascii(osutils.get_user_encoding())
 
255
        if char is None:
 
256
            raise TestSkipped('Cannot find suitable non-ascii character'
 
257
                'for user_encoding (%s)' % osutils.get_user_encoding())
 
258
        out,err = self.run_bzr_subprocess('commit -m "%s"' % char,
 
259
                                          retcode=1,
 
260
                                          env_changes={'LANG': 'C'})
 
261
        self.assertContainsRe(err, r'bzrlib.errors.BzrError: Parameter.*is '
 
262
                                    'unsupported by the current encoding.')
 
263
 
 
264
    def test_other_branch_commit(self):
 
265
        # this branch is to ensure consistent behaviour, whether we're run
 
266
        # inside a branch, or not.
 
267
        outer_tree = self.make_branch_and_tree('.')
 
268
        inner_tree = self.make_branch_and_tree('branch')
 
269
        self.build_tree_contents([
 
270
            ('branch/foo.c', 'int main() {}'),
 
271
            ('branch/bar.c', 'int main() {}')])
 
272
        inner_tree.add('foo.c')
 
273
        inner_tree.add('bar.c')
 
274
        # can't commit files in different trees; sane error
 
275
        self.run_bzr('commit -m newstuff branch/foo.c .', retcode=3)
 
276
        self.run_bzr('commit -m newstuff branch/foo.c')
 
277
        self.run_bzr('commit -m newstuff branch')
 
278
        self.run_bzr('commit -m newstuff branch', retcode=3)
 
279
 
 
280
    def test_out_of_date_tree_commit(self):
 
281
        # check we get an error code and a clear message committing with an out
 
282
        # of date checkout
 
283
        tree = self.make_branch_and_tree('branch')
 
284
        # make a checkout
 
285
        checkout = tree.branch.create_checkout('checkout', lightweight=True)
 
286
        # commit to the original branch to make the checkout out of date
 
287
        tree.commit('message branch', allow_pointless=True)
 
288
        # now commit to the checkout should emit
 
289
        # ERROR: Out of date with the branch, 'bzr update' is suggested
 
290
        output = self.run_bzr('commit --unchanged -m checkout_message '
 
291
                             'checkout', retcode=3)
 
292
        self.assertEqual(output,
 
293
                         ('',
 
294
                          "bzr: ERROR: Working tree is out of date, please "
 
295
                          "run 'bzr update'.\n"))
 
296
 
 
297
    def test_local_commit_unbound(self):
 
298
        # a --local commit on an unbound branch is an error
 
299
        self.make_branch_and_tree('.')
 
300
        out, err = self.run_bzr('commit --local', retcode=3)
 
301
        self.assertEqualDiff('', out)
 
302
        self.assertEqualDiff('bzr: ERROR: Cannot perform local-only commits '
 
303
                             'on unbound branches.\n', err)
 
304
 
 
305
    def test_commit_a_text_merge_in_a_checkout(self):
 
306
        # checkouts perform multiple actions in a transaction across bond
 
307
        # branches and their master, and have been observed to fail in the
 
308
        # past. This is a user story reported to fail in bug #43959 where
 
309
        # a merge done in a checkout (using the update command) failed to
 
310
        # commit correctly.
 
311
        trunk = self.make_branch_and_tree('trunk')
 
312
 
 
313
        u1 = trunk.branch.create_checkout('u1')
 
314
        self.build_tree_contents([('u1/hosts', 'initial contents')])
 
315
        u1.add('hosts')
 
316
        self.run_bzr('commit -m add-hosts u1')
 
317
 
 
318
        u2 = trunk.branch.create_checkout('u2')
 
319
        self.build_tree_contents([('u2/hosts', 'altered in u2')])
 
320
        self.run_bzr('commit -m checkin-from-u2 u2')
 
321
 
 
322
        # make an offline commits
 
323
        self.build_tree_contents([('u1/hosts', 'first offline change in u1')])
 
324
        self.run_bzr('commit -m checkin-offline --local u1')
 
325
 
 
326
        # now try to pull in online work from u2, and then commit our offline
 
327
        # work as a merge
 
328
        # retcode 1 as we expect a text conflict
 
329
        self.run_bzr('update u1', retcode=1)
 
330
        self.run_bzr('resolved u1/hosts')
 
331
        # add a text change here to represent resolving the merge conflicts in
 
332
        # favour of a new version of the file not identical to either the u1
 
333
        # version or the u2 version.
 
334
        self.build_tree_contents([('u1/hosts', 'merge resolution\n')])
 
335
        self.run_bzr('commit -m checkin-merge-of-the-offline-work-from-u1 u1')
 
336
 
 
337
    def test_commit_exclude_excludes_modified_files(self):
 
338
        """Commit -x foo should ignore changes to foo."""
 
339
        tree = self.make_branch_and_tree('.')
 
340
        self.build_tree(['a', 'b', 'c'])
 
341
        tree.smart_add(['.'])
 
342
        out, err = self.run_bzr(['commit', '-m', 'test', '-x', 'b'])
 
343
        self.assertFalse('added b' in out)
 
344
        self.assertFalse('added b' in err)
 
345
        # If b was excluded it will still be 'added' in status.
 
346
        out, err = self.run_bzr(['added'])
 
347
        self.assertEqual('b\n', out)
 
348
        self.assertEqual('', err)
 
349
 
 
350
    def test_commit_exclude_twice_uses_both_rules(self):
 
351
        """Commit -x foo -x bar should ignore changes to foo and bar."""
 
352
        tree = self.make_branch_and_tree('.')
 
353
        self.build_tree(['a', 'b', 'c'])
 
354
        tree.smart_add(['.'])
 
355
        out, err = self.run_bzr(['commit', '-m', 'test', '-x', 'b', '-x', 'c'])
 
356
        self.assertFalse('added b' in out)
 
357
        self.assertFalse('added c' in out)
 
358
        self.assertFalse('added b' in err)
 
359
        self.assertFalse('added c' in err)
 
360
        # If b was excluded it will still be 'added' in status.
 
361
        out, err = self.run_bzr(['added'])
 
362
        self.assertTrue('b\n' in out)
 
363
        self.assertTrue('c\n' in out)
 
364
        self.assertEqual('', err)
 
365
 
 
366
    def test_commit_respects_spec_for_removals(self):
 
367
        """Commit with a file spec should only commit removals that match"""
 
368
        t = self.make_branch_and_tree('.')
 
369
        self.build_tree(['file-a', 'dir-a/', 'dir-a/file-b'])
 
370
        t.add(['file-a', 'dir-a', 'dir-a/file-b'])
 
371
        t.commit('Create')
 
372
        t.remove(['file-a', 'dir-a/file-b'])
 
373
        os.chdir('dir-a')
 
374
        result = self.run_bzr('commit . -m removed-file-b')[1]
 
375
        self.assertNotContainsRe(result, 'file-a')
 
376
        result = self.run_bzr('status')[0]
 
377
        self.assertContainsRe(result, 'removed:\n  file-a')
 
378
 
 
379
    def test_strict_commit(self):
 
380
        """Commit with --strict works if everything is known"""
 
381
        ignores._set_user_ignores([])
 
382
        tree = self.make_branch_and_tree('tree')
 
383
        self.build_tree(['tree/a'])
 
384
        tree.add('a')
 
385
        # A simple change should just work
 
386
        self.run_bzr('commit --strict -m adding-a',
 
387
                     working_dir='tree')
 
388
 
 
389
    def test_strict_commit_no_changes(self):
 
390
        """commit --strict gives "no changes" if there is nothing to commit"""
 
391
        tree = self.make_branch_and_tree('tree')
 
392
        self.build_tree(['tree/a'])
 
393
        tree.add('a')
 
394
        tree.commit('adding a')
 
395
 
 
396
        # With no changes, it should just be 'no changes'
 
397
        # Make sure that commit is failing because there is nothing to do
 
398
        self.run_bzr_error(['No changes to commit'],
 
399
                           'commit --strict -m no-changes',
 
400
                           working_dir='tree')
 
401
 
 
402
        # But --strict doesn't care if you supply --unchanged
 
403
        self.run_bzr('commit --strict --unchanged -m no-changes',
 
404
                     working_dir='tree')
 
405
 
 
406
    def test_strict_commit_unknown(self):
 
407
        """commit --strict fails if a file is unknown"""
 
408
        tree = self.make_branch_and_tree('tree')
 
409
        self.build_tree(['tree/a'])
 
410
        tree.add('a')
 
411
        tree.commit('adding a')
 
412
 
 
413
        # Add one file so there is a change, but forget the other
 
414
        self.build_tree(['tree/b', 'tree/c'])
 
415
        tree.add('b')
 
416
        self.run_bzr_error(['Commit refused because there are unknown files'],
 
417
                           'commit --strict -m add-b',
 
418
                           working_dir='tree')
 
419
 
 
420
        # --no-strict overrides --strict
 
421
        self.run_bzr('commit --strict -m add-b --no-strict',
 
422
                     working_dir='tree')
 
423
 
 
424
    def test_fixes_bug_output(self):
 
425
        """commit --fixes=lp:23452 succeeds without output."""
 
426
        tree = self.make_branch_and_tree('tree')
 
427
        self.build_tree(['tree/hello.txt'])
 
428
        tree.add('hello.txt')
 
429
        output, err = self.run_bzr(
 
430
            'commit -m hello --fixes=lp:23452 tree/hello.txt')
 
431
        self.assertEqual('', output)
 
432
        self.assertContainsRe(err, 'Committing to: .*\n'
 
433
                              'added hello\.txt\n'
 
434
                              'Committed revision 1\.\n')
 
435
 
 
436
    def test_no_bugs_no_properties(self):
 
437
        """If no bugs are fixed, the bugs property is not set.
 
438
 
 
439
        see https://beta.launchpad.net/bzr/+bug/109613
 
440
        """
 
441
        tree = self.make_branch_and_tree('tree')
 
442
        self.build_tree(['tree/hello.txt'])
 
443
        tree.add('hello.txt')
 
444
        self.run_bzr( 'commit -m hello tree/hello.txt')
 
445
        # Get the revision properties, ignoring the branch-nick property, which
 
446
        # we don't care about for this test.
 
447
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
448
        properties = dict(last_rev.properties)
 
449
        del properties['branch-nick']
 
450
        self.assertFalse('bugs' in properties)
 
451
 
 
452
    def test_fixes_bug_sets_property(self):
 
453
        """commit --fixes=lp:234 sets the lp:234 revprop to 'fixed'."""
 
454
        tree = self.make_branch_and_tree('tree')
 
455
        self.build_tree(['tree/hello.txt'])
 
456
        tree.add('hello.txt')
 
457
        self.run_bzr('commit -m hello --fixes=lp:234 tree/hello.txt')
 
458
 
 
459
        # Get the revision properties, ignoring the branch-nick property, which
 
460
        # we don't care about for this test.
 
461
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
462
        properties = dict(last_rev.properties)
 
463
        del properties['branch-nick']
 
464
 
 
465
        self.assertEqual({'bugs': 'https://launchpad.net/bugs/234 fixed'},
 
466
                         properties)
 
467
 
 
468
    def test_fixes_multiple_bugs_sets_properties(self):
 
469
        """--fixes can be used more than once to show that bugs are fixed."""
 
470
        tree = self.make_branch_and_tree('tree')
 
471
        self.build_tree(['tree/hello.txt'])
 
472
        tree.add('hello.txt')
 
473
        self.run_bzr('commit -m hello --fixes=lp:123 --fixes=lp:235'
 
474
                     ' tree/hello.txt')
 
475
 
 
476
        # Get the revision properties, ignoring the branch-nick property, which
 
477
        # we don't care about for this test.
 
478
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
479
        properties = dict(last_rev.properties)
 
480
        del properties['branch-nick']
 
481
 
 
482
        self.assertEqual(
 
483
            {'bugs': 'https://launchpad.net/bugs/123 fixed\n'
 
484
                     'https://launchpad.net/bugs/235 fixed'},
 
485
            properties)
 
486
 
 
487
    def test_fixes_bug_with_alternate_trackers(self):
 
488
        """--fixes can be used on a properly configured branch to mark bug
 
489
        fixes on multiple trackers.
 
490
        """
 
491
        tree = self.make_branch_and_tree('tree')
 
492
        tree.branch.get_config().set_user_option(
 
493
            'trac_twisted_url', 'http://twistedmatrix.com/trac')
 
494
        self.build_tree(['tree/hello.txt'])
 
495
        tree.add('hello.txt')
 
496
        self.run_bzr('commit -m hello --fixes=lp:123 --fixes=twisted:235 tree/')
 
497
 
 
498
        # Get the revision properties, ignoring the branch-nick property, which
 
499
        # we don't care about for this test.
 
500
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
501
        properties = dict(last_rev.properties)
 
502
        del properties['branch-nick']
 
503
 
 
504
        self.assertEqual(
 
505
            {'bugs': 'https://launchpad.net/bugs/123 fixed\n'
 
506
                     'http://twistedmatrix.com/trac/ticket/235 fixed'},
 
507
            properties)
 
508
 
 
509
    def test_fixes_unknown_bug_prefix(self):
 
510
        tree = self.make_branch_and_tree('tree')
 
511
        self.build_tree(['tree/hello.txt'])
 
512
        tree.add('hello.txt')
 
513
        self.run_bzr_error(
 
514
            ["Unrecognized bug %s. Commit refused." % 'xxx:123'],
 
515
            'commit -m add-b --fixes=xxx:123',
 
516
            working_dir='tree')
 
517
 
 
518
    def test_fixes_invalid_bug_number(self):
 
519
        tree = self.make_branch_and_tree('tree')
 
520
        self.build_tree(['tree/hello.txt'])
 
521
        tree.add('hello.txt')
 
522
        self.run_bzr_error(
 
523
            ["Did not understand bug identifier orange: Must be an integer. "
 
524
             "See \"bzr help bugs\" for more information on this feature.\n"
 
525
             "Commit refused."],
 
526
            'commit -m add-b --fixes=lp:orange',
 
527
            working_dir='tree')
 
528
 
 
529
    def test_fixes_invalid_argument(self):
 
530
        """Raise an appropriate error when the fixes argument isn't tag:id."""
 
531
        tree = self.make_branch_and_tree('tree')
 
532
        self.build_tree(['tree/hello.txt'])
 
533
        tree.add('hello.txt')
 
534
        self.run_bzr_error(
 
535
            [r"Invalid bug orange. Must be in the form of 'tracker:id'\. "
 
536
             r"See \"bzr help bugs\" for more information on this feature.\n"
 
537
             r"Commit refused\."],
 
538
            'commit -m add-b --fixes=orange',
 
539
            working_dir='tree')
 
540
 
 
541
    def test_no_author(self):
 
542
        """If the author is not specified, the author property is not set."""
 
543
        tree = self.make_branch_and_tree('tree')
 
544
        self.build_tree(['tree/hello.txt'])
 
545
        tree.add('hello.txt')
 
546
        self.run_bzr( 'commit -m hello tree/hello.txt')
 
547
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
548
        properties = last_rev.properties
 
549
        self.assertFalse('author' in properties)
 
550
 
 
551
    def test_author_sets_property(self):
 
552
        """commit --author='John Doe <jdoe@example.com>' sets the author
 
553
           revprop.
 
554
        """
 
555
        tree = self.make_branch_and_tree('tree')
 
556
        self.build_tree(['tree/hello.txt'])
 
557
        tree.add('hello.txt')
 
558
        self.run_bzr(["commit", '-m', 'hello',
 
559
                      '--author', u'John D\xf6 <jdoe@example.com>',
 
560
                     "tree/hello.txt"])
 
561
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
562
        properties = last_rev.properties
 
563
        self.assertEqual(u'John D\xf6 <jdoe@example.com>', properties['authors'])
 
564
 
 
565
    def test_author_no_email(self):
 
566
        """Author's name without an email address is allowed, too."""
 
567
        tree = self.make_branch_and_tree('tree')
 
568
        self.build_tree(['tree/hello.txt'])
 
569
        tree.add('hello.txt')
 
570
        out, err = self.run_bzr("commit -m hello --author='John Doe' "
 
571
                                "tree/hello.txt")
 
572
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
573
        properties = last_rev.properties
 
574
        self.assertEqual('John Doe', properties['authors'])
 
575
 
 
576
    def test_multiple_authors(self):
 
577
        """Multiple authors can be specyfied, and all are stored."""
 
578
        tree = self.make_branch_and_tree('tree')
 
579
        self.build_tree(['tree/hello.txt'])
 
580
        tree.add('hello.txt')
 
581
        out, err = self.run_bzr("commit -m hello --author='John Doe' "
 
582
                                "--author='Jane Rey' tree/hello.txt")
 
583
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
584
        properties = last_rev.properties
 
585
        self.assertEqual('John Doe\nJane Rey', properties['authors'])
 
586
 
 
587
    def test_partial_commit_with_renames_in_tree(self):
 
588
        # this test illustrates bug #140419
 
589
        t = self.make_branch_and_tree('.')
 
590
        self.build_tree(['dir/', 'dir/a', 'test'])
 
591
        t.add(['dir/', 'dir/a', 'test'])
 
592
        t.commit('initial commit')
 
593
        # important part: file dir/a should change parent
 
594
        # and should appear before old parent
 
595
        # then during partial commit we have error
 
596
        # parent_id {dir-XXX} not in inventory
 
597
        t.rename_one('dir/a', 'a')
 
598
        self.build_tree_contents([('test', 'changes in test')])
 
599
        # partial commit
 
600
        out, err = self.run_bzr('commit test -m "partial commit"')
 
601
        self.assertEquals('', out)
 
602
        self.assertContainsRe(err, r'modified test\nCommitted revision 2.')
 
603
 
 
604
    def test_commit_readonly_checkout(self):
 
605
        # https://bugs.edge.launchpad.net/bzr/+bug/129701
 
606
        # "UnlockableTransport error trying to commit in checkout of readonly
 
607
        # branch"
 
608
        self.make_branch('master')
 
609
        master = BzrDir.open_from_transport(
 
610
            self.get_readonly_transport('master')).open_branch()
 
611
        master.create_checkout('checkout')
 
612
        out, err = self.run_bzr(['commit', '--unchanged', '-mfoo', 'checkout'],
 
613
            retcode=3)
 
614
        self.assertContainsRe(err,
 
615
            r'^bzr: ERROR: Cannot lock.*readonly transport')
 
616
 
 
617
    def test_commit_hook_template(self):
 
618
        # Test that commit template hooks work
 
619
        def restoreDefaults():
 
620
            msgeditor.hooks['commit_message_template'] = []
 
621
            osutils.set_or_unset_env('BZR_EDITOR', default_editor)
 
622
        if sys.platform == "win32":
 
623
            f = file('fed.bat', 'w')
 
624
            f.write('@rem dummy fed')
 
625
            f.close()
 
626
            default_editor = osutils.set_or_unset_env('BZR_EDITOR', "fed.bat")
 
627
        else:
 
628
            f = file('fed.sh', 'wb')
 
629
            f.write('#!/bin/sh\n')
 
630
            f.close()
 
631
            os.chmod('fed.sh', 0755)
 
632
            default_editor = osutils.set_or_unset_env('BZR_EDITOR', "./fed.sh")
 
633
        self.addCleanup(restoreDefaults)
 
634
        msgeditor.hooks.install_named_hook("commit_message_template",
 
635
                lambda commit_obj, msg: "save me some typing\n", None)
 
636
        tree = self.make_branch_and_tree('tree')
 
637
        self.build_tree(['tree/hello.txt'])
 
638
        tree.add('hello.txt')
 
639
        out, err = self.run_bzr("commit tree/hello.txt")
 
640
        last_rev = tree.branch.repository.get_revision(tree.last_revision())
 
641
        self.assertEqual('save me some typing\n', last_rev.message)