← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_commit.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-08-17 07:52:09 UTC
  • mfrom: (1910.3.4 trivial)
  • Revision ID: pqm@pqm.ubuntu.com-20060817075209-e85a1f9e05ff8b87
(andrew) Trivial fixes to NotImplemented errors.

Show diffs side-by-side

added added

removed removed

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