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

  • Committer: Marius Kruger
  • Date: 2010-07-10 21:28:56 UTC
  • mto: (5384.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5385.
  • Revision ID: marius.kruger@enerweb.co.za-20100710212856-uq4ji3go0u5se7hx
* Update documentation
* add NEWS

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_commit.py
1
 
# Copyright (C) 2005-2012, 2016 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
16
16
 
17
17
 
18
18
import os
19
 
from io import BytesIO
20
19
 
21
 
import breezy
22
 
from .. import (
23
 
    config,
24
 
    controldir,
 
20
import bzrlib
 
21
from bzrlib import (
 
22
    bzrdir,
25
23
    errors,
26
 
    trace,
27
 
    )
28
 
from ..branch import Branch
29
 
from ..bzr.bzrdir import BzrDirMetaFormat1
30
 
from ..commit import (
31
 
    CannotCommitSelectedFileMerge,
32
 
    Commit,
33
 
    NullCommitReporter,
34
 
    PointlessCommit,
35
 
    filter_excluded,
36
 
    )
37
 
from ..errors import (
38
 
    BzrError,
39
 
    LockContention,
40
 
    )
41
 
from ..tree import TreeChange
42
 
from . import (
43
 
    TestCase,
44
 
    TestCaseWithTransport,
45
 
    test_foreign,
46
 
    )
47
 
from .features import (
48
 
    SymlinkFeature,
49
 
    )
50
 
from .matchers import MatchesAncestry
 
24
    lockdir,
 
25
    osutils,
 
26
    tests,
 
27
    )
 
28
from bzrlib.branch import Branch
 
29
from bzrlib.bzrdir import BzrDir, BzrDirMetaFormat1
 
30
from bzrlib.commit import Commit, NullCommitReporter
 
31
from bzrlib.config import BranchConfig
 
32
from bzrlib.errors import (PointlessCommit, BzrError, SigningFailed,
 
33
                           LockContention)
 
34
from bzrlib.tests import SymlinkFeature, TestCaseWithTransport
 
35
from bzrlib.workingtree import WorkingTree
51
36
 
52
37
 
53
38
# TODO: Test commit with some added, and added-but-missing files
54
39
 
55
 
class MustSignConfig(config.MemoryStack):
56
 
 
57
 
    def __init__(self):
58
 
        super(MustSignConfig, self).__init__(b'''
59
 
create_signatures=always
60
 
''')
 
40
class MustSignConfig(BranchConfig):
 
41
 
 
42
    def signature_needed(self):
 
43
        return True
 
44
 
 
45
    def gpg_signing_command(self):
 
46
        return ['cat', '-']
 
47
 
 
48
 
 
49
class BranchWithHooks(BranchConfig):
 
50
 
 
51
    def post_commit(self):
 
52
        return "bzrlib.ahook bzrlib.ahook"
61
53
 
62
54
 
63
55
class CapturingReporter(NullCommitReporter):
89
81
        """Commit and check two versions of a single file."""
90
82
        wt = self.make_branch_and_tree('.')
91
83
        b = wt.branch
92
 
        with open('hello', 'w') as f:
93
 
            f.write('hello world')
 
84
        file('hello', 'w').write('hello world')
94
85
        wt.add('hello')
95
 
        rev1 = wt.commit(message='add hello')
96
 
 
97
 
        with open('hello', 'w') as f:
98
 
            f.write('version 2')
99
 
        rev2 = wt.commit(message='commit 2')
100
 
 
101
 
        eq = self.assertEqual
 
86
        wt.commit(message='add hello')
 
87
        file_id = wt.path2id('hello')
 
88
 
 
89
        file('hello', 'w').write('version 2')
 
90
        wt.commit(message='commit 2')
 
91
 
 
92
        eq = self.assertEquals
102
93
        eq(b.revno(), 2)
103
 
        rev = b.repository.get_revision(rev1)
 
94
        rh = b.revision_history()
 
95
        rev = b.repository.get_revision(rh[0])
104
96
        eq(rev.message, 'add hello')
105
97
 
106
 
        tree1 = b.repository.revision_tree(rev1)
 
98
        tree1 = b.repository.revision_tree(rh[0])
107
99
        tree1.lock_read()
108
 
        text = tree1.get_file_text('hello')
 
100
        text = tree1.get_file_text(file_id)
109
101
        tree1.unlock()
110
 
        self.assertEqual(b'hello world', text)
 
102
        self.assertEqual('hello world', text)
111
103
 
112
 
        tree2 = b.repository.revision_tree(rev2)
 
104
        tree2 = b.repository.revision_tree(rh[1])
113
105
        tree2.lock_read()
114
 
        text = tree2.get_file_text('hello')
 
106
        text = tree2.get_file_text(file_id)
115
107
        tree2.unlock()
116
 
        self.assertEqual(b'version 2', text)
117
 
 
118
 
    def test_commit_lossy_native(self):
119
 
        """Attempt a lossy commit to a native branch."""
120
 
        wt = self.make_branch_and_tree('.')
121
 
        b = wt.branch
122
 
        with open('hello', 'w') as f:
123
 
            f.write('hello world')
124
 
        wt.add('hello')
125
 
        revid = wt.commit(message='add hello', rev_id=b'revid', lossy=True)
126
 
        self.assertEqual(b'revid', revid)
127
 
 
128
 
    def test_commit_lossy_foreign(self):
129
 
        """Attempt a lossy commit to a foreign branch."""
130
 
        test_foreign.register_dummy_foreign_for_test(self)
131
 
        wt = self.make_branch_and_tree('.',
132
 
                                       format=test_foreign.DummyForeignVcsDirFormat())
133
 
        b = wt.branch
134
 
        with open('hello', 'w') as f:
135
 
            f.write('hello world')
136
 
        wt.add('hello')
137
 
        revid = wt.commit(message='add hello', lossy=True,
138
 
                          timestamp=1302659388, timezone=0)
139
 
        self.assertEqual(b'dummy-v1:1302659388-0-UNKNOWN', revid)
140
 
 
141
 
    def test_commit_bound_lossy_foreign(self):
142
 
        """Attempt a lossy commit to a bzr branch bound to a foreign branch."""
143
 
        test_foreign.register_dummy_foreign_for_test(self)
144
 
        foreign_branch = self.make_branch('foreign',
145
 
                                          format=test_foreign.DummyForeignVcsDirFormat())
146
 
        wt = foreign_branch.create_checkout("local")
147
 
        b = wt.branch
148
 
        with open('local/hello', 'w') as f:
149
 
            f.write('hello world')
150
 
        wt.add('hello')
151
 
        revid = wt.commit(message='add hello', lossy=True,
152
 
                          timestamp=1302659388, timezone=0)
153
 
        self.assertEqual(b'dummy-v1:1302659388-0-0', revid)
154
 
        self.assertEqual(b'dummy-v1:1302659388-0-0',
155
 
                         foreign_branch.last_revision())
156
 
        self.assertEqual(b'dummy-v1:1302659388-0-0',
157
 
                         wt.branch.last_revision())
 
108
        self.assertEqual('version 2', text)
158
109
 
159
110
    def test_missing_commit(self):
160
111
        """Test a commit with a missing file"""
161
112
        wt = self.make_branch_and_tree('.')
162
113
        b = wt.branch
163
 
        with open('hello', 'w') as f:
164
 
            f.write('hello world')
165
 
        wt.add(['hello'], [b'hello-id'])
 
114
        file('hello', 'w').write('hello world')
 
115
        wt.add(['hello'], ['hello-id'])
166
116
        wt.commit(message='add hello')
167
117
 
168
118
        os.remove('hello')
169
 
        reporter = CapturingReporter()
170
 
        wt.commit('removed hello', rev_id=b'rev2', reporter=reporter)
171
 
        self.assertEqual(
172
 
            [('missing', u'hello'), ('deleted', u'hello')],
173
 
            reporter.calls)
 
119
        wt.commit('removed hello', rev_id='rev2')
174
120
 
175
 
        tree = b.repository.revision_tree(b'rev2')
176
 
        self.assertFalse(tree.has_filename('hello'))
 
121
        tree = b.repository.revision_tree('rev2')
 
122
        self.assertFalse(tree.has_id('hello-id'))
177
123
 
178
124
    def test_partial_commit_move(self):
179
125
        """Test a partial commit where a file was renamed but not committed.
188
134
        b = wt.branch
189
135
        self.build_tree(['annotate/', 'annotate/foo.py',
190
136
                         'olive/', 'olive/dialog.py'
191
 
                         ])
 
137
                        ])
192
138
        wt.add(['annotate', 'olive', 'annotate/foo.py', 'olive/dialog.py'])
193
139
        wt.commit(message='add files')
194
140
        wt.rename_one("olive/dialog.py", "aaa")
195
 
        self.build_tree_contents([('annotate/foo.py', b'modified\n')])
 
141
        self.build_tree_contents([('annotate/foo.py', 'modified\n')])
196
142
        wt.commit('renamed hello', specific_files=["annotate"])
197
143
 
198
144
    def test_pointless_commit(self):
199
145
        """Commit refuses unless there are changes or it's forced."""
200
146
        wt = self.make_branch_and_tree('.')
201
147
        b = wt.branch
202
 
        with open('hello', 'w') as f:
203
 
            f.write('hello')
 
148
        file('hello', 'w').write('hello')
204
149
        wt.add(['hello'])
205
150
        wt.commit(message='add hello')
206
 
        self.assertEqual(b.revno(), 1)
 
151
        self.assertEquals(b.revno(), 1)
207
152
        self.assertRaises(PointlessCommit,
208
153
                          wt.commit,
209
154
                          message='fails',
210
155
                          allow_pointless=False)
211
 
        self.assertEqual(b.revno(), 1)
 
156
        self.assertEquals(b.revno(), 1)
212
157
 
213
158
    def test_commit_empty(self):
214
159
        """Commiting an empty tree works."""
220
165
                          message='empty tree',
221
166
                          allow_pointless=False)
222
167
        wt.commit(message='empty tree', allow_pointless=True)
223
 
        self.assertEqual(b.revno(), 2)
 
168
        self.assertEquals(b.revno(), 2)
224
169
 
225
170
    def test_selective_delete(self):
226
171
        """Selective commit in tree with deletions"""
227
172
        wt = self.make_branch_and_tree('.')
228
173
        b = wt.branch
229
 
        with open('hello', 'w') as f:
230
 
            f.write('hello')
231
 
        with open('buongia', 'w') as f:
232
 
            f.write('buongia')
 
174
        file('hello', 'w').write('hello')
 
175
        file('buongia', 'w').write('buongia')
233
176
        wt.add(['hello', 'buongia'],
234
 
               [b'hello-id', b'buongia-id'])
 
177
              ['hello-id', 'buongia-id'])
235
178
        wt.commit(message='add files',
236
 
                  rev_id=b'test@rev-1')
 
179
                 rev_id='test@rev-1')
237
180
 
238
181
        os.remove('hello')
239
 
        with open('buongia', 'w') as f:
240
 
            f.write('new text')
 
182
        file('buongia', 'w').write('new text')
241
183
        wt.commit(message='update text',
242
 
                  specific_files=['buongia'],
243
 
                  allow_pointless=False,
244
 
                  rev_id=b'test@rev-2')
 
184
                 specific_files=['buongia'],
 
185
                 allow_pointless=False,
 
186
                 rev_id='test@rev-2')
245
187
 
246
188
        wt.commit(message='remove hello',
247
 
                  specific_files=['hello'],
248
 
                  allow_pointless=False,
249
 
                  rev_id=b'test@rev-3')
 
189
                 specific_files=['hello'],
 
190
                 allow_pointless=False,
 
191
                 rev_id='test@rev-3')
250
192
 
251
 
        eq = self.assertEqual
 
193
        eq = self.assertEquals
252
194
        eq(b.revno(), 3)
253
195
 
254
 
        tree2 = b.repository.revision_tree(b'test@rev-2')
 
196
        tree2 = b.repository.revision_tree('test@rev-2')
255
197
        tree2.lock_read()
256
198
        self.addCleanup(tree2.unlock)
257
199
        self.assertTrue(tree2.has_filename('hello'))
258
 
        self.assertEqual(tree2.get_file_text('hello'), b'hello')
259
 
        self.assertEqual(tree2.get_file_text('buongia'), b'new text')
 
200
        self.assertEquals(tree2.get_file_text('hello-id'), 'hello')
 
201
        self.assertEquals(tree2.get_file_text('buongia-id'), 'new text')
260
202
 
261
 
        tree3 = b.repository.revision_tree(b'test@rev-3')
 
203
        tree3 = b.repository.revision_tree('test@rev-3')
262
204
        tree3.lock_read()
263
205
        self.addCleanup(tree3.unlock)
264
206
        self.assertFalse(tree3.has_filename('hello'))
265
 
        self.assertEqual(tree3.get_file_text('buongia'), b'new text')
 
207
        self.assertEquals(tree3.get_file_text('buongia-id'), 'new text')
266
208
 
267
209
    def test_commit_rename(self):
268
210
        """Test commit of a revision where a file is renamed."""
269
211
        tree = self.make_branch_and_tree('.')
270
212
        b = tree.branch
271
213
        self.build_tree(['hello'], line_endings='binary')
272
 
        tree.add(['hello'], [b'hello-id'])
273
 
        tree.commit(message='one', rev_id=b'test@rev-1', allow_pointless=False)
 
214
        tree.add(['hello'], ['hello-id'])
 
215
        tree.commit(message='one', rev_id='test@rev-1', allow_pointless=False)
274
216
 
275
217
        tree.rename_one('hello', 'fruity')
276
 
        tree.commit(message='renamed', rev_id=b'test@rev-2',
277
 
                    allow_pointless=False)
 
218
        tree.commit(message='renamed', rev_id='test@rev-2', allow_pointless=False)
278
219
 
279
 
        eq = self.assertEqual
280
 
        tree1 = b.repository.revision_tree(b'test@rev-1')
 
220
        eq = self.assertEquals
 
221
        tree1 = b.repository.revision_tree('test@rev-1')
281
222
        tree1.lock_read()
282
223
        self.addCleanup(tree1.unlock)
283
 
        eq(tree1.id2path(b'hello-id'), 'hello')
284
 
        eq(tree1.get_file_text('hello'), b'contents of hello\n')
 
224
        eq(tree1.id2path('hello-id'), 'hello')
 
225
        eq(tree1.get_file_text('hello-id'), 'contents of hello\n')
285
226
        self.assertFalse(tree1.has_filename('fruity'))
286
 
        self.check_tree_shape(tree1, ['hello'])
287
 
        eq(tree1.get_file_revision('hello'), b'test@rev-1')
 
227
        self.check_inventory_shape(tree1.inventory, ['hello'])
 
228
        ie = tree1.inventory['hello-id']
 
229
        eq(ie.revision, 'test@rev-1')
288
230
 
289
 
        tree2 = b.repository.revision_tree(b'test@rev-2')
 
231
        tree2 = b.repository.revision_tree('test@rev-2')
290
232
        tree2.lock_read()
291
233
        self.addCleanup(tree2.unlock)
292
 
        eq(tree2.id2path(b'hello-id'), 'fruity')
293
 
        eq(tree2.get_file_text('fruity'), b'contents of hello\n')
294
 
        self.check_tree_shape(tree2, ['fruity'])
295
 
        eq(tree2.get_file_revision('fruity'), b'test@rev-2')
 
234
        eq(tree2.id2path('hello-id'), 'fruity')
 
235
        eq(tree2.get_file_text('hello-id'), 'contents of hello\n')
 
236
        self.check_inventory_shape(tree2.inventory, ['fruity'])
 
237
        ie = tree2.inventory['hello-id']
 
238
        eq(ie.revision, 'test@rev-2')
296
239
 
297
240
    def test_reused_rev_id(self):
298
241
        """Test that a revision id cannot be reused in a branch"""
299
242
        wt = self.make_branch_and_tree('.')
300
243
        b = wt.branch
301
 
        wt.commit('initial', rev_id=b'test@rev-1', allow_pointless=True)
 
244
        wt.commit('initial', rev_id='test@rev-1', allow_pointless=True)
302
245
        self.assertRaises(Exception,
303
246
                          wt.commit,
304
247
                          message='reused id',
305
 
                          rev_id=b'test@rev-1',
 
248
                          rev_id='test@rev-1',
306
249
                          allow_pointless=True)
307
250
 
308
251
    def test_commit_move(self):
309
252
        """Test commit of revisions with moved files and directories"""
310
 
        eq = self.assertEqual
 
253
        eq = self.assertEquals
311
254
        wt = self.make_branch_and_tree('.')
312
255
        b = wt.branch
313
 
        r1 = b'test@rev-1'
 
256
        r1 = 'test@rev-1'
314
257
        self.build_tree(['hello', 'a/', 'b/'])
315
 
        wt.add(['hello', 'a', 'b'], [b'hello-id', b'a-id', b'b-id'])
 
258
        wt.add(['hello', 'a', 'b'], ['hello-id', 'a-id', 'b-id'])
316
259
        wt.commit('initial', rev_id=r1, allow_pointless=False)
317
260
        wt.move(['hello'], 'a')
318
 
        r2 = b'test@rev-2'
 
261
        r2 = 'test@rev-2'
319
262
        wt.commit('two', rev_id=r2, allow_pointless=False)
320
263
        wt.lock_read()
321
264
        try:
322
 
            self.check_tree_shape(wt, ['a/', 'a/hello', 'b/'])
 
265
            self.check_inventory_shape(wt.read_working_inventory(),
 
266
                                       ['a/', 'a/hello', 'b/'])
323
267
        finally:
324
268
            wt.unlock()
325
269
 
326
270
        wt.move(['b'], 'a')
327
 
        r3 = b'test@rev-3'
 
271
        r3 = 'test@rev-3'
328
272
        wt.commit('three', rev_id=r3, allow_pointless=False)
329
273
        wt.lock_read()
330
274
        try:
331
 
            self.check_tree_shape(wt,
332
 
                                  ['a/', 'a/hello', 'a/b/'])
333
 
            self.check_tree_shape(b.repository.revision_tree(r3),
334
 
                                  ['a/', 'a/hello', 'a/b/'])
 
275
            self.check_inventory_shape(wt.read_working_inventory(),
 
276
                                       ['a/', 'a/hello', 'a/b/'])
 
277
            self.check_inventory_shape(b.repository.get_inventory(r3),
 
278
                                       ['a/', 'a/hello', 'a/b/'])
335
279
        finally:
336
280
            wt.unlock()
337
281
 
338
282
        wt.move(['a/hello'], 'a/b')
339
 
        r4 = b'test@rev-4'
 
283
        r4 = 'test@rev-4'
340
284
        wt.commit('four', rev_id=r4, allow_pointless=False)
341
285
        wt.lock_read()
342
286
        try:
343
 
            self.check_tree_shape(wt, ['a/', 'a/b/hello', 'a/b/'])
 
287
            self.check_inventory_shape(wt.read_working_inventory(),
 
288
                                       ['a/', 'a/b/hello', 'a/b/'])
344
289
        finally:
345
290
            wt.unlock()
346
291
 
347
292
        inv = b.repository.get_inventory(r4)
348
 
        eq(inv.get_entry(b'hello-id').revision, r4)
349
 
        eq(inv.get_entry(b'a-id').revision, r1)
350
 
        eq(inv.get_entry(b'b-id').revision, r3)
 
293
        eq(inv['hello-id'].revision, r4)
 
294
        eq(inv['a-id'].revision, r1)
 
295
        eq(inv['b-id'].revision, r3)
351
296
 
352
297
    def test_removed_commit(self):
353
298
        """Commit with a removed file"""
354
299
        wt = self.make_branch_and_tree('.')
355
300
        b = wt.branch
356
 
        with open('hello', 'w') as f:
357
 
            f.write('hello world')
358
 
        wt.add(['hello'], [b'hello-id'])
 
301
        file('hello', 'w').write('hello world')
 
302
        wt.add(['hello'], ['hello-id'])
359
303
        wt.commit(message='add hello')
360
304
        wt.remove('hello')
361
 
        wt.commit('removed hello', rev_id=b'rev2')
 
305
        wt.commit('removed hello', rev_id='rev2')
362
306
 
363
 
        tree = b.repository.revision_tree(b'rev2')
364
 
        self.assertFalse(tree.has_filename('hello'))
 
307
        tree = b.repository.revision_tree('rev2')
 
308
        self.assertFalse(tree.has_id('hello-id'))
365
309
 
366
310
    def test_committed_ancestry(self):
367
311
        """Test commit appends revisions to ancestry."""
369
313
        b = wt.branch
370
314
        rev_ids = []
371
315
        for i in range(4):
372
 
            with open('hello', 'w') as f:
373
 
                f.write((str(i) * 4) + '\n')
 
316
            file('hello', 'w').write((str(i) * 4) + '\n')
374
317
            if i == 0:
375
 
                wt.add(['hello'], [b'hello-id'])
376
 
            rev_id = b'test@rev-%d' % (i + 1)
 
318
                wt.add(['hello'], ['hello-id'])
 
319
            rev_id = 'test@rev-%d' % (i+1)
377
320
            rev_ids.append(rev_id)
378
 
            wt.commit(message='rev %d' % (i + 1),
379
 
                      rev_id=rev_id)
 
321
            wt.commit(message='rev %d' % (i+1),
 
322
                     rev_id=rev_id)
 
323
        eq = self.assertEquals
 
324
        eq(b.revision_history(), rev_ids)
380
325
        for i in range(4):
381
 
            self.assertThat(rev_ids[:i + 1],
382
 
                            MatchesAncestry(b.repository, rev_ids[i]))
 
326
            anc = b.repository.get_ancestry(rev_ids[i])
 
327
            eq(anc, [None] + rev_ids[:i+1])
383
328
 
384
329
    def test_commit_new_subdir_child_selective(self):
385
330
        wt = self.make_branch_and_tree('.')
386
331
        b = wt.branch
387
332
        self.build_tree(['dir/', 'dir/file1', 'dir/file2'])
388
333
        wt.add(['dir', 'dir/file1', 'dir/file2'],
389
 
               [b'dirid', b'file1id', b'file2id'])
390
 
        wt.commit('dir/file1', specific_files=['dir/file1'], rev_id=b'1')
391
 
        inv = b.repository.get_inventory(b'1')
392
 
        self.assertEqual(b'1', inv.get_entry(b'dirid').revision)
393
 
        self.assertEqual(b'1', inv.get_entry(b'file1id').revision)
 
334
              ['dirid', 'file1id', 'file2id'])
 
335
        wt.commit('dir/file1', specific_files=['dir/file1'], rev_id='1')
 
336
        inv = b.repository.get_inventory('1')
 
337
        self.assertEqual('1', inv['dirid'].revision)
 
338
        self.assertEqual('1', inv['file1id'].revision)
394
339
        # FIXME: This should raise a KeyError I think, rbc20051006
395
 
        self.assertRaises(BzrError, inv.get_entry, b'file2id')
 
340
        self.assertRaises(BzrError, inv.__getitem__, 'file2id')
396
341
 
397
342
    def test_strict_commit(self):
398
343
        """Try and commit with unknown files and strict = True, should fail."""
399
 
        from ..errors import StrictCommitFailed
 
344
        from bzrlib.errors import StrictCommitFailed
400
345
        wt = self.make_branch_and_tree('.')
401
346
        b = wt.branch
402
 
        with open('hello', 'w') as f:
403
 
            f.write('hello world')
 
347
        file('hello', 'w').write('hello world')
404
348
        wt.add('hello')
405
 
        with open('goodbye', 'w') as f:
406
 
            f.write('goodbye cruel world!')
 
349
        file('goodbye', 'w').write('goodbye cruel world!')
407
350
        self.assertRaises(StrictCommitFailed, wt.commit,
408
 
                          message='add hello but not goodbye', strict=True)
 
351
            message='add hello but not goodbye', strict=True)
409
352
 
410
353
    def test_strict_commit_without_unknowns(self):
411
354
        """Try and commit with no unknown files and strict = True,
412
355
        should work."""
 
356
        from bzrlib.errors import StrictCommitFailed
413
357
        wt = self.make_branch_and_tree('.')
414
358
        b = wt.branch
415
 
        with open('hello', 'w') as f:
416
 
            f.write('hello world')
 
359
        file('hello', 'w').write('hello world')
417
360
        wt.add('hello')
418
361
        wt.commit(message='add hello', strict=True)
419
362
 
421
364
        """Try and commit with unknown files and strict = False, should work."""
422
365
        wt = self.make_branch_and_tree('.')
423
366
        b = wt.branch
424
 
        with open('hello', 'w') as f:
425
 
            f.write('hello world')
 
367
        file('hello', 'w').write('hello world')
426
368
        wt.add('hello')
427
 
        with open('goodbye', 'w') as f:
428
 
            f.write('goodbye cruel world!')
 
369
        file('goodbye', 'w').write('goodbye cruel world!')
429
370
        wt.commit(message='add hello but not goodbye', strict=False)
430
371
 
431
372
    def test_nonstrict_commit_without_unknowns(self):
433
374
        should work."""
434
375
        wt = self.make_branch_and_tree('.')
435
376
        b = wt.branch
436
 
        with open('hello', 'w') as f:
437
 
            f.write('hello world')
 
377
        file('hello', 'w').write('hello world')
438
378
        wt.add('hello')
439
379
        wt.commit(message='add hello', strict=False)
440
380
 
441
381
    def test_signed_commit(self):
442
 
        import breezy.gpg
443
 
        import breezy.commit as commit
444
 
        oldstrategy = breezy.gpg.GPGStrategy
 
382
        import bzrlib.gpg
 
383
        import bzrlib.commit as commit
 
384
        oldstrategy = bzrlib.gpg.GPGStrategy
445
385
        wt = self.make_branch_and_tree('.')
446
386
        branch = wt.branch
447
 
        wt.commit("base", allow_pointless=True, rev_id=b'A')
448
 
        self.assertFalse(branch.repository.has_signature_for_revision_id(b'A'))
 
387
        wt.commit("base", allow_pointless=True, rev_id='A')
 
388
        self.failIf(branch.repository.has_signature_for_revision_id('A'))
449
389
        try:
450
 
            from ..bzr.testament import Testament
 
390
            from bzrlib.testament import Testament
451
391
            # monkey patch gpg signing mechanism
452
 
            breezy.gpg.GPGStrategy = breezy.gpg.LoopbackGPGStrategy
453
 
            conf = config.MemoryStack(b'''
454
 
create_signatures=always
455
 
''')
456
 
            commit.Commit(config_stack=conf).commit(
457
 
                message="base", allow_pointless=True, rev_id=b'B',
458
 
                working_tree=wt)
459
 
 
 
392
            bzrlib.gpg.GPGStrategy = bzrlib.gpg.LoopbackGPGStrategy
 
393
            commit.Commit(config=MustSignConfig(branch)).commit(message="base",
 
394
                                                      allow_pointless=True,
 
395
                                                      rev_id='B',
 
396
                                                      working_tree=wt)
460
397
            def sign(text):
461
 
                return breezy.gpg.LoopbackGPGStrategy(None).sign(
462
 
                    text, breezy.gpg.MODE_CLEAR)
 
398
                return bzrlib.gpg.LoopbackGPGStrategy(None).sign(text)
463
399
            self.assertEqual(sign(Testament.from_revision(branch.repository,
464
 
                                                          b'B').as_short_text()),
465
 
                             branch.repository.get_signature_text(b'B'))
 
400
                             'B').as_short_text()),
 
401
                             branch.repository.get_signature_text('B'))
466
402
        finally:
467
 
            breezy.gpg.GPGStrategy = oldstrategy
 
403
            bzrlib.gpg.GPGStrategy = oldstrategy
468
404
 
469
405
    def test_commit_failed_signature(self):
470
 
        import breezy.gpg
471
 
        import breezy.commit as commit
472
 
        oldstrategy = breezy.gpg.GPGStrategy
 
406
        import bzrlib.gpg
 
407
        import bzrlib.commit as commit
 
408
        oldstrategy = bzrlib.gpg.GPGStrategy
473
409
        wt = self.make_branch_and_tree('.')
474
410
        branch = wt.branch
475
 
        wt.commit("base", allow_pointless=True, rev_id=b'A')
476
 
        self.assertFalse(branch.repository.has_signature_for_revision_id(b'A'))
 
411
        wt.commit("base", allow_pointless=True, rev_id='A')
 
412
        self.failIf(branch.repository.has_signature_for_revision_id('A'))
477
413
        try:
 
414
            from bzrlib.testament import Testament
478
415
            # monkey patch gpg signing mechanism
479
 
            breezy.gpg.GPGStrategy = breezy.gpg.DisabledGPGStrategy
480
 
            conf = config.MemoryStack(b'''
481
 
create_signatures=always
482
 
''')
483
 
            self.assertRaises(breezy.gpg.SigningFailed,
484
 
                              commit.Commit(config_stack=conf).commit,
 
416
            bzrlib.gpg.GPGStrategy = bzrlib.gpg.DisabledGPGStrategy
 
417
            config = MustSignConfig(branch)
 
418
            self.assertRaises(SigningFailed,
 
419
                              commit.Commit(config=config).commit,
485
420
                              message="base",
486
421
                              allow_pointless=True,
487
 
                              rev_id=b'B',
 
422
                              rev_id='B',
488
423
                              working_tree=wt)
489
424
            branch = Branch.open(self.get_url('.'))
490
 
            self.assertEqual(branch.last_revision(), b'A')
491
 
            self.assertFalse(branch.repository.has_revision(b'B'))
 
425
            self.assertEqual(branch.revision_history(), ['A'])
 
426
            self.failIf(branch.repository.has_revision('B'))
492
427
        finally:
493
 
            breezy.gpg.GPGStrategy = oldstrategy
 
428
            bzrlib.gpg.GPGStrategy = oldstrategy
494
429
 
495
430
    def test_commit_invokes_hooks(self):
496
 
        import breezy.commit as commit
 
431
        import bzrlib.commit as commit
497
432
        wt = self.make_branch_and_tree('.')
498
433
        branch = wt.branch
499
434
        calls = []
500
 
 
501
435
        def called(branch, rev_id):
502
436
            calls.append('called')
503
 
        breezy.ahook = called
 
437
        bzrlib.ahook = called
504
438
        try:
505
 
            conf = config.MemoryStack(b'post_commit=breezy.ahook breezy.ahook')
506
 
            commit.Commit(config_stack=conf).commit(
507
 
                message="base", allow_pointless=True, rev_id=b'A',
508
 
                working_tree=wt)
 
439
            config = BranchWithHooks(branch)
 
440
            commit.Commit(config=config).commit(
 
441
                            message = "base",
 
442
                            allow_pointless=True,
 
443
                            rev_id='A', working_tree = wt)
509
444
            self.assertEqual(['called', 'called'], calls)
510
445
        finally:
511
 
            del breezy.ahook
 
446
            del bzrlib.ahook
512
447
 
513
448
    def test_commit_object_doesnt_set_nick(self):
514
449
        # using the Commit object directly does not set the branch nick.
515
450
        wt = self.make_branch_and_tree('.')
516
451
        c = Commit()
517
452
        c.commit(working_tree=wt, message='empty tree', allow_pointless=True)
518
 
        self.assertEqual(wt.branch.revno(), 1)
 
453
        self.assertEquals(wt.branch.revno(), 1)
519
454
        self.assertEqual({},
520
455
                         wt.branch.repository.get_revision(
521
 
            wt.branch.last_revision()).properties)
 
456
                            wt.branch.last_revision()).properties)
522
457
 
523
458
    def test_safe_master_lock(self):
524
459
        os.mkdir('master')
542
477
        bound_tree = self.make_branch_and_tree('bound')
543
478
        bound_tree.branch.bind(master_branch)
544
479
 
545
 
        self.build_tree_contents(
546
 
            [('bound/content_file', b'initial contents\n')])
 
480
        self.build_tree_contents([('bound/content_file', 'initial contents\n')])
547
481
        bound_tree.add(['content_file'])
548
482
        bound_tree.commit(message='woo!')
549
483
 
550
 
        other_bzrdir = master_branch.controldir.sprout('other')
 
484
        other_bzrdir = master_branch.bzrdir.sprout('other')
551
485
        other_tree = other_bzrdir.open_workingtree()
552
486
 
553
487
        # do a commit to the other branch changing the content file so
554
488
        # that our commit after merging will have a merged revision in the
555
489
        # content file history.
556
 
        self.build_tree_contents(
557
 
            [('other/content_file', b'change in other\n')])
 
490
        self.build_tree_contents([('other/content_file', 'change in other\n')])
558
491
        other_tree.commit('change in other')
559
492
 
560
493
        # do a merge into the bound branch from other, and then change the
561
494
        # content file locally to force a new revision (rather than using the
562
495
        # revision from other). This forces extra processing in commit.
563
496
        bound_tree.merge_from_branch(other_tree.branch)
564
 
        self.build_tree_contents(
565
 
            [('bound/content_file', b'change in bound\n')])
 
497
        self.build_tree_contents([('bound/content_file', 'change in bound\n')])
566
498
 
567
499
        # before #34959 was fixed, this failed with 'revision not present in
568
500
        # weave' when trying to implicitly push from the bound branch to the master
596
528
            'filetoleave']
597
529
            )
598
530
        this_tree.commit('create_files')
599
 
        other_dir = this_tree.controldir.sprout('other')
 
531
        other_dir = this_tree.bzrdir.sprout('other')
600
532
        other_tree = other_dir.open_workingtree()
601
533
        other_tree.lock_write()
602
534
        # perform the needed actions on the files and dirs.
604
536
            other_tree.rename_one('dirtorename', 'renameddir')
605
537
            other_tree.rename_one('dirtoreparent', 'renameddir/reparenteddir')
606
538
            other_tree.rename_one('filetorename', 'renamedfile')
607
 
            other_tree.rename_one(
608
 
                'filetoreparent', 'renameddir/reparentedfile')
 
539
            other_tree.rename_one('filetoreparent', 'renameddir/reparentedfile')
609
540
            other_tree.remove(['dirtoremove', 'filetoremove'])
610
541
            self.build_tree_contents([
611
542
                ('other/newdir/', ),
612
 
                ('other/filetomodify', b'new content'),
613
 
                ('other/newfile', b'new file content')])
 
543
                ('other/filetomodify', 'new content'),
 
544
                ('other/newfile', 'new file content')])
614
545
            other_tree.add('newfile')
615
546
            other_tree.add('newdir/')
616
547
            other_tree.commit('modify all sample files and dirs.')
619
550
        this_tree.merge_from_branch(other_tree.branch)
620
551
        reporter = CapturingReporter()
621
552
        this_tree.commit('do the commit', reporter=reporter)
622
 
        expected = {
 
553
        expected = set([
623
554
            ('change', 'modified', 'filetomodify'),
624
555
            ('change', 'added', 'newdir'),
625
556
            ('change', 'added', 'newfile'),
629
560
            ('renamed', 'renamed', 'filetoreparent', 'renameddir/reparentedfile'),
630
561
            ('deleted', 'dirtoremove'),
631
562
            ('deleted', 'filetoremove'),
632
 
            }
 
563
            ])
633
564
        result = set(reporter.calls)
634
565
        missing = expected - result
635
566
        new = result - expected
644
575
        tree.remove(['a', 'b'])
645
576
        tree.commit('removed a', specific_files='a')
646
577
        basis = tree.basis_tree()
647
 
        with tree.lock_read():
648
 
            self.assertFalse(basis.is_versioned('a'))
649
 
            self.assertTrue(basis.is_versioned('b'))
 
578
        tree.lock_read()
 
579
        try:
 
580
            self.assertIs(None, basis.path2id('a'))
 
581
            self.assertFalse(basis.path2id('b') is None)
 
582
        finally:
 
583
            tree.unlock()
650
584
 
651
585
    def test_commit_saves_1ms_timestamp(self):
652
586
        """Passing in a timestamp is saved with 1ms resolution"""
654
588
        self.build_tree(['a'])
655
589
        tree.add('a')
656
590
        tree.commit('added a', timestamp=1153248633.4186721, timezone=0,
657
 
                    rev_id=b'a1')
 
591
                    rev_id='a1')
658
592
 
659
 
        rev = tree.branch.repository.get_revision(b'a1')
 
593
        rev = tree.branch.repository.get_revision('a1')
660
594
        self.assertEqual(1153248633.419, rev.timestamp)
661
595
 
662
596
    def test_commit_has_1ms_resolution(self):
664
598
        tree = self.make_branch_and_tree('.')
665
599
        self.build_tree(['a'])
666
600
        tree.add('a')
667
 
        tree.commit('added a', rev_id=b'a1')
 
601
        tree.commit('added a', rev_id='a1')
668
602
 
669
 
        rev = tree.branch.repository.get_revision(b'a1')
 
603
        rev = tree.branch.repository.get_revision('a1')
670
604
        timestamp = rev.timestamp
671
605
        timestamp_1ms = round(timestamp, 3)
672
606
        self.assertEqual(timestamp_1ms, timestamp)
673
607
 
674
 
    def assertBasisTreeKind(self, kind, tree, path):
 
608
    def assertBasisTreeKind(self, kind, tree, file_id):
675
609
        basis = tree.basis_tree()
676
610
        basis.lock_read()
677
611
        try:
678
 
            self.assertEqual(kind, basis.kind(path))
 
612
            self.assertEqual(kind, basis.kind(file_id))
679
613
        finally:
680
614
            basis.unlock()
681
615
 
682
 
    def test_unsupported_symlink_commit(self):
683
 
        self.requireFeature(SymlinkFeature)
684
 
        tree = self.make_branch_and_tree('.')
685
 
        self.build_tree(['hello'])
686
 
        tree.add('hello')
687
 
        tree.commit('added hello', rev_id=b'hello_id')
688
 
        os.symlink('hello', 'foo')
689
 
        tree.add('foo')
690
 
        tree.commit('added foo', rev_id=b'foo_id')
691
 
        log = BytesIO()
692
 
        trace.push_log_file(log)
693
 
        os_symlink = getattr(os, 'symlink', None)
694
 
        os.symlink = None
695
 
        try:
696
 
            # At this point as bzr thinks symlinks are not supported
697
 
            # we should get a warning about symlink foo and bzr should
698
 
            # not think its removed.
699
 
            os.unlink('foo')
700
 
            self.build_tree(['world'])
701
 
            tree.add('world')
702
 
            tree.commit('added world', rev_id=b'world_id')
703
 
        finally:
704
 
            if os_symlink:
705
 
                os.symlink = os_symlink
706
 
        self.assertContainsRe(
707
 
            log.getvalue(),
708
 
            b'Ignoring "foo" as symlinks are not '
709
 
            b'supported on this filesystem\\.')
710
 
 
711
616
    def test_commit_kind_changes(self):
712
617
        self.requireFeature(SymlinkFeature)
713
618
        tree = self.make_branch_and_tree('.')
714
619
        os.symlink('target', 'name')
715
 
        tree.add('name', b'a-file-id')
 
620
        tree.add('name', 'a-file-id')
716
621
        tree.commit('Added a symlink')
717
 
        self.assertBasisTreeKind('symlink', tree, 'name')
 
622
        self.assertBasisTreeKind('symlink', tree, 'a-file-id')
718
623
 
719
624
        os.unlink('name')
720
625
        self.build_tree(['name'])
721
626
        tree.commit('Changed symlink to file')
722
 
        self.assertBasisTreeKind('file', tree, 'name')
 
627
        self.assertBasisTreeKind('file', tree, 'a-file-id')
723
628
 
724
629
        os.unlink('name')
725
630
        os.symlink('target', 'name')
726
631
        tree.commit('file to symlink')
727
 
        self.assertBasisTreeKind('symlink', tree, 'name')
 
632
        self.assertBasisTreeKind('symlink', tree, 'a-file-id')
728
633
 
729
634
        os.unlink('name')
730
635
        os.mkdir('name')
731
636
        tree.commit('symlink to directory')
732
 
        self.assertBasisTreeKind('directory', tree, 'name')
 
637
        self.assertBasisTreeKind('directory', tree, 'a-file-id')
733
638
 
734
639
        os.rmdir('name')
735
640
        os.symlink('target', 'name')
736
641
        tree.commit('directory to symlink')
737
 
        self.assertBasisTreeKind('symlink', tree, 'name')
 
642
        self.assertBasisTreeKind('symlink', tree, 'a-file-id')
738
643
 
739
644
        # prepare for directory <-> file tests
740
645
        os.unlink('name')
741
646
        os.mkdir('name')
742
647
        tree.commit('symlink to directory')
743
 
        self.assertBasisTreeKind('directory', tree, 'name')
 
648
        self.assertBasisTreeKind('directory', tree, 'a-file-id')
744
649
 
745
650
        os.rmdir('name')
746
651
        self.build_tree(['name'])
747
652
        tree.commit('Changed directory to file')
748
 
        self.assertBasisTreeKind('file', tree, 'name')
 
653
        self.assertBasisTreeKind('file', tree, 'a-file-id')
749
654
 
750
655
        os.unlink('name')
751
656
        os.mkdir('name')
752
657
        tree.commit('file to directory')
753
 
        self.assertBasisTreeKind('directory', tree, 'name')
 
658
        self.assertBasisTreeKind('directory', tree, 'a-file-id')
754
659
 
755
660
    def test_commit_unversioned_specified(self):
756
661
        """Commit should raise if specified files isn't in basis or worktree"""
776
681
        tree = self.make_branch_and_tree('.')
777
682
        try:
778
683
            tree.commit()
779
 
        except Exception as e:
 
684
        except Exception, e:
780
685
            self.assertTrue(isinstance(e, BzrError))
781
686
            self.assertEqual('The message or message_callback keyword'
782
687
                             ' parameter is required for commit().', str(e))
803
708
        cb = self.Callback(u'commit 2', self)
804
709
        repository = tree.branch.repository
805
710
        # simulate network failure
806
 
 
807
711
        def raise_(self, arg, arg2, arg3=None, arg4=None):
808
712
            raise errors.NoSuchFile('foo')
809
713
        repository.add_inventory = raise_
816
720
        tree = self.make_branch_and_tree('foo')
817
721
        # pending merge would turn into a left parent
818
722
        tree.commit('commit 1')
819
 
        tree.add_parent_tree_id(b'example')
 
723
        tree.add_parent_tree_id('example')
820
724
        self.build_tree(['foo/bar', 'foo/baz'])
821
725
        tree.add(['bar', 'baz'])
822
 
        err = self.assertRaises(CannotCommitSelectedFileMerge,
823
 
                                tree.commit, 'commit 2', specific_files=['bar', 'baz'])
 
726
        err = self.assertRaises(errors.CannotCommitSelectedFileMerge,
 
727
            tree.commit, 'commit 2', specific_files=['bar', 'baz'])
824
728
        self.assertEqual(['bar', 'baz'], err.files)
825
729
        self.assertEqual('Selected-file commit of merges is not supported'
826
730
                         ' yet: files bar, baz', str(err))
847
751
        self.assertFalse('authors' in rev.properties)
848
752
 
849
753
    def test_commit_author(self):
850
 
        """Passing a non-empty authors kwarg to MutableTree.commit should add
 
754
        """Passing a non-empty author kwarg to MutableTree.commit should add
851
755
        the 'author' revision property.
852
756
        """
853
757
        tree = self.make_branch_and_tree('foo')
854
 
        rev_id = tree.commit(
855
 
            'commit 1',
856
 
            authors=['John Doe <jdoe@example.com>'])
 
758
        rev_id = self.callDeprecated(['The parameter author was '
 
759
                'deprecated in version 1.13. Use authors instead'],
 
760
                tree.commit, 'commit 1', author='John Doe <jdoe@example.com>')
857
761
        rev = tree.branch.repository.get_revision(rev_id)
858
762
        self.assertEqual('John Doe <jdoe@example.com>',
859
763
                         rev.properties['authors'])
870
774
    def test_multiple_authors(self):
871
775
        tree = self.make_branch_and_tree('foo')
872
776
        rev_id = tree.commit('commit 1',
873
 
                             authors=['John Doe <jdoe@example.com>',
874
 
                                      'Jane Rey <jrey@example.com>'])
 
777
                authors=['John Doe <jdoe@example.com>',
 
778
                         'Jane Rey <jrey@example.com>'])
875
779
        rev = tree.branch.repository.get_revision(rev_id)
876
780
        self.assertEqual('John Doe <jdoe@example.com>\n'
877
 
                         'Jane Rey <jrey@example.com>', rev.properties['authors'])
 
781
                'Jane Rey <jrey@example.com>', rev.properties['authors'])
878
782
        self.assertFalse('author' in rev.properties)
879
783
 
 
784
    def test_author_and_authors_incompatible(self):
 
785
        tree = self.make_branch_and_tree('foo')
 
786
        self.assertRaises(AssertionError, tree.commit, 'commit 1',
 
787
                authors=['John Doe <jdoe@example.com>',
 
788
                         'Jane Rey <jrey@example.com>'],
 
789
                author="Jack Me <jme@example.com>")
 
790
 
880
791
    def test_author_with_newline_rejected(self):
881
792
        tree = self.make_branch_and_tree('foo')
882
793
        self.assertRaises(AssertionError, tree.commit, 'commit 1',
883
 
                          authors=['John\nDoe <jdoe@example.com>'])
 
794
                authors=['John\nDoe <jdoe@example.com>'])
884
795
 
885
796
    def test_commit_with_checkout_and_branch_sharing_repo(self):
886
797
        repo = self.make_repository('repo', shared=True)
887
798
        # make_branch_and_tree ignores shared repos
888
 
        branch = controldir.ControlDir.create_branch_convenience('repo/branch')
 
799
        branch = bzrdir.BzrDir.create_branch_convenience('repo/branch')
889
800
        tree2 = branch.create_checkout('repo/tree2')
890
 
        tree2.commit('message', rev_id=b'rev1')
891
 
        self.assertTrue(tree2.branch.repository.has_revision(b'rev1'))
892
 
 
893
 
 
894
 
class FilterExcludedTests(TestCase):
895
 
 
896
 
    def test_add_file_not_excluded(self):
897
 
        changes = [
898
 
            TreeChange(
899
 
                'fid', (None, 'newpath'),
900
 
                0, (False, False), ('pid', 'pid'), ('newpath', 'newpath'),
901
 
                ('file', 'file'), (True, True))]
902
 
        self.assertEqual(changes, list(
903
 
            filter_excluded(changes, ['otherpath'])))
904
 
 
905
 
    def test_add_file_excluded(self):
906
 
        changes = [
907
 
            TreeChange(
908
 
                'fid', (None, 'newpath'),
909
 
                0, (False, False), ('pid', 'pid'), ('newpath', 'newpath'),
910
 
                ('file', 'file'), (True, True))]
911
 
        self.assertEqual([], list(filter_excluded(changes, ['newpath'])))
912
 
 
913
 
    def test_delete_file_excluded(self):
914
 
        changes = [
915
 
            TreeChange(
916
 
                'fid', ('somepath', None),
917
 
                0, (False, None), ('pid', None), ('newpath', None),
918
 
                ('file', None), (True, None))]
919
 
        self.assertEqual([], list(filter_excluded(changes, ['somepath'])))
920
 
 
921
 
    def test_move_from_or_to_excluded(self):
922
 
        changes = [
923
 
            TreeChange(
924
 
                'fid', ('oldpath', 'newpath'),
925
 
                0, (False, False), ('pid', 'pid'), ('oldpath', 'newpath'),
926
 
                ('file', 'file'), (True, True))]
927
 
        self.assertEqual([], list(filter_excluded(changes, ['oldpath'])))
928
 
        self.assertEqual([], list(filter_excluded(changes, ['newpath'])))
 
801
        tree2.commit('message', rev_id='rev1')
 
802
        self.assertTrue(tree2.branch.repository.has_revision('rev1'))