← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_commit.py

  • Committer: Jelmer Vernooij
  • Date: 2011-12-16 19:18:39 UTC
  • mto: This revision was merged to the branch mainline in revision 6391.
  • Revision ID: jelmer@samba.org-20111216191839-eg681lxqibi1qxu1
Fix remaining tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_commit.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 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
20
20
import bzrlib
21
21
from bzrlib import (
22
22
    bzrdir,
 
23
    config,
23
24
    errors,
24
 
    lockdir,
25
 
    osutils,
26
 
    tests,
27
25
    )
28
26
from bzrlib.branch import Branch
29
 
from bzrlib.bzrdir import BzrDir, BzrDirMetaFormat1
 
27
from bzrlib.bzrdir import BzrDirMetaFormat1
30
28
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
 
29
from bzrlib.errors import (
 
30
    PointlessCommit,
 
31
    BzrError,
 
32
    SigningFailed,
 
33
    LockContention,
 
34
    )
 
35
from bzrlib.tests import (
 
36
    TestCaseWithTransport,
 
37
    test_foreign,
 
38
    )
 
39
from bzrlib.tests.features import (
 
40
    SymlinkFeature,
 
41
    )
 
42
from bzrlib.tests.matchers import MatchesAncestry
36
43
 
37
44
 
38
45
# TODO: Test commit with some added, and added-but-missing files
39
46
 
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"
 
47
class MustSignConfig(config.Stack):
 
48
 
 
49
    def __init__(self, branch):
 
50
        store = config.IniFileStore()
 
51
        store._load_from_string('''
 
52
gpg_signing_command=cat -
 
53
create_signatures=always
 
54
''')
 
55
        super(MustSignConfig, self).__init__([store.get_sections])
 
56
        # FIXME: Strictly speaking we should fallback to the no-name section in
 
57
        # branch.conf but no tests need that so far -- vila 2011-12-14
 
58
 
 
59
 
 
60
class BranchWithHooks(config.Stack):
 
61
 
 
62
    def __init__(self, branch):
 
63
        store = config.IniFileStore()
 
64
        store._load_from_string('post_commit=bzrlib.ahook bzrlib.ahook')
 
65
        super(BranchWithHooks, self).__init__([store.get_sections])
 
66
        # FIXME: Strictly speaking we should fallback to the no-name section in
 
67
        # branch.conf but no tests need that so far -- vila 2011-12-14
53
68
 
54
69
 
55
70
class CapturingReporter(NullCommitReporter):
83
98
        b = wt.branch
84
99
        file('hello', 'w').write('hello world')
85
100
        wt.add('hello')
86
 
        wt.commit(message='add hello')
 
101
        rev1 = wt.commit(message='add hello')
87
102
        file_id = wt.path2id('hello')
88
103
 
89
104
        file('hello', 'w').write('version 2')
90
 
        wt.commit(message='commit 2')
 
105
        rev2 = wt.commit(message='commit 2')
91
106
 
92
107
        eq = self.assertEquals
93
108
        eq(b.revno(), 2)
94
 
        rh = b.revision_history()
95
 
        rev = b.repository.get_revision(rh[0])
 
109
        rev = b.repository.get_revision(rev1)
96
110
        eq(rev.message, 'add hello')
97
111
 
98
 
        tree1 = b.repository.revision_tree(rh[0])
 
112
        tree1 = b.repository.revision_tree(rev1)
99
113
        tree1.lock_read()
100
114
        text = tree1.get_file_text(file_id)
101
115
        tree1.unlock()
102
116
        self.assertEqual('hello world', text)
103
117
 
104
 
        tree2 = b.repository.revision_tree(rh[1])
 
118
        tree2 = b.repository.revision_tree(rev2)
105
119
        tree2.lock_read()
106
120
        text = tree2.get_file_text(file_id)
107
121
        tree2.unlock()
108
122
        self.assertEqual('version 2', text)
109
123
 
 
124
    def test_commit_lossy_native(self):
 
125
        """Attempt a lossy commit to a native branch."""
 
126
        wt = self.make_branch_and_tree('.')
 
127
        b = wt.branch
 
128
        file('hello', 'w').write('hello world')
 
129
        wt.add('hello')
 
130
        revid = wt.commit(message='add hello', rev_id='revid', lossy=True)
 
131
        self.assertEquals('revid', revid)
 
132
 
 
133
    def test_commit_lossy_foreign(self):
 
134
        """Attempt a lossy commit to a foreign branch."""
 
135
        test_foreign.register_dummy_foreign_for_test(self)
 
136
        wt = self.make_branch_and_tree('.',
 
137
            format=test_foreign.DummyForeignVcsDirFormat())
 
138
        b = wt.branch
 
139
        file('hello', 'w').write('hello world')
 
140
        wt.add('hello')
 
141
        revid = wt.commit(message='add hello', lossy=True,
 
142
            timestamp=1302659388, timezone=0)
 
143
        self.assertEquals('dummy-v1:1302659388.0-0-UNKNOWN', revid)
 
144
 
 
145
    def test_commit_bound_lossy_foreign(self):
 
146
        """Attempt a lossy commit to a bzr branch bound to a foreign branch."""
 
147
        test_foreign.register_dummy_foreign_for_test(self)
 
148
        foreign_branch = self.make_branch('foreign',
 
149
            format=test_foreign.DummyForeignVcsDirFormat())
 
150
        wt = foreign_branch.create_checkout("local")
 
151
        b = wt.branch
 
152
        file('local/hello', 'w').write('hello world')
 
153
        wt.add('hello')
 
154
        revid = wt.commit(message='add hello', lossy=True,
 
155
            timestamp=1302659388, timezone=0)
 
156
        self.assertEquals('dummy-v1:1302659388.0-0-0', revid)
 
157
        self.assertEquals('dummy-v1:1302659388.0-0-0',
 
158
            foreign_branch.last_revision())
 
159
        self.assertEquals('dummy-v1:1302659388.0-0-0',
 
160
            wt.branch.last_revision())
 
161
 
110
162
    def test_missing_commit(self):
111
163
        """Test a commit with a missing file"""
112
164
        wt = self.make_branch_and_tree('.')
116
168
        wt.commit(message='add hello')
117
169
 
118
170
        os.remove('hello')
119
 
        wt.commit('removed hello', rev_id='rev2')
 
171
        reporter = CapturingReporter()
 
172
        wt.commit('removed hello', rev_id='rev2', reporter=reporter)
 
173
        self.assertEquals(
 
174
            [('missing', u'hello'), ('deleted', u'hello')],
 
175
            reporter.calls)
120
176
 
121
177
        tree = b.repository.revision_tree('rev2')
122
178
        self.assertFalse(tree.has_id('hello-id'))
224
280
        eq(tree1.id2path('hello-id'), 'hello')
225
281
        eq(tree1.get_file_text('hello-id'), 'contents of hello\n')
226
282
        self.assertFalse(tree1.has_filename('fruity'))
227
 
        self.check_inventory_shape(tree1.inventory, ['hello'])
228
 
        ie = tree1.inventory['hello-id']
229
 
        eq(ie.revision, 'test@rev-1')
 
283
        self.check_tree_shape(tree1, ['hello'])
 
284
        eq(tree1.get_file_revision('hello-id'), 'test@rev-1')
230
285
 
231
286
        tree2 = b.repository.revision_tree('test@rev-2')
232
287
        tree2.lock_read()
233
288
        self.addCleanup(tree2.unlock)
234
289
        eq(tree2.id2path('hello-id'), 'fruity')
235
290
        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')
 
291
        self.check_tree_shape(tree2, ['fruity'])
 
292
        eq(tree2.get_file_revision('hello-id'), 'test@rev-2')
239
293
 
240
294
    def test_reused_rev_id(self):
241
295
        """Test that a revision id cannot be reused in a branch"""
262
316
        wt.commit('two', rev_id=r2, allow_pointless=False)
263
317
        wt.lock_read()
264
318
        try:
265
 
            self.check_inventory_shape(wt.read_working_inventory(),
266
 
                                       ['a/', 'a/hello', 'b/'])
 
319
            self.check_tree_shape(wt, ['a/', 'a/hello', 'b/'])
267
320
        finally:
268
321
            wt.unlock()
269
322
 
272
325
        wt.commit('three', rev_id=r3, allow_pointless=False)
273
326
        wt.lock_read()
274
327
        try:
275
 
            self.check_inventory_shape(wt.read_working_inventory(),
 
328
            self.check_tree_shape(wt,
276
329
                                       ['a/', 'a/hello', 'a/b/'])
277
 
            self.check_inventory_shape(b.repository.get_inventory(r3),
 
330
            self.check_tree_shape(b.repository.revision_tree(r3),
278
331
                                       ['a/', 'a/hello', 'a/b/'])
279
332
        finally:
280
333
            wt.unlock()
284
337
        wt.commit('four', rev_id=r4, allow_pointless=False)
285
338
        wt.lock_read()
286
339
        try:
287
 
            self.check_inventory_shape(wt.read_working_inventory(),
288
 
                                       ['a/', 'a/b/hello', 'a/b/'])
 
340
            self.check_tree_shape(wt, ['a/', 'a/b/hello', 'a/b/'])
289
341
        finally:
290
342
            wt.unlock()
291
343
 
320
372
            rev_ids.append(rev_id)
321
373
            wt.commit(message='rev %d' % (i+1),
322
374
                     rev_id=rev_id)
323
 
        eq = self.assertEquals
324
 
        eq(b.revision_history(), rev_ids)
325
375
        for i in range(4):
326
 
            anc = b.repository.get_ancestry(rev_ids[i])
327
 
            eq(anc, [None] + rev_ids[:i+1])
 
376
            self.assertThat(rev_ids[:i+1],
 
377
                MatchesAncestry(b.repository, rev_ids[i]))
328
378
 
329
379
    def test_commit_new_subdir_child_selective(self):
330
380
        wt = self.make_branch_and_tree('.')
353
403
    def test_strict_commit_without_unknowns(self):
354
404
        """Try and commit with no unknown files and strict = True,
355
405
        should work."""
356
 
        from bzrlib.errors import StrictCommitFailed
357
406
        wt = self.make_branch_and_tree('.')
358
407
        b = wt.branch
359
408
        file('hello', 'w').write('hello world')
385
434
        wt = self.make_branch_and_tree('.')
386
435
        branch = wt.branch
387
436
        wt.commit("base", allow_pointless=True, rev_id='A')
388
 
        self.failIf(branch.repository.has_signature_for_revision_id('A'))
 
437
        self.assertFalse(branch.repository.has_signature_for_revision_id('A'))
389
438
        try:
390
439
            from bzrlib.testament import Testament
391
440
            # monkey patch gpg signing mechanism
392
441
            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)
 
442
            commit.Commit(config_stack=MustSignConfig(branch)
 
443
                          ).commit(message="base", allow_pointless=True,
 
444
                                   rev_id='B', working_tree=wt)
397
445
            def sign(text):
398
446
                return bzrlib.gpg.LoopbackGPGStrategy(None).sign(text)
399
447
            self.assertEqual(sign(Testament.from_revision(branch.repository,
400
 
                             'B').as_short_text()),
 
448
                                                          'B').as_short_text()),
401
449
                             branch.repository.get_signature_text('B'))
402
450
        finally:
403
451
            bzrlib.gpg.GPGStrategy = oldstrategy
409
457
        wt = self.make_branch_and_tree('.')
410
458
        branch = wt.branch
411
459
        wt.commit("base", allow_pointless=True, rev_id='A')
412
 
        self.failIf(branch.repository.has_signature_for_revision_id('A'))
 
460
        self.assertFalse(branch.repository.has_signature_for_revision_id('A'))
413
461
        try:
414
 
            from bzrlib.testament import Testament
415
462
            # monkey patch gpg signing mechanism
416
463
            bzrlib.gpg.GPGStrategy = bzrlib.gpg.DisabledGPGStrategy
417
464
            config = MustSignConfig(branch)
418
465
            self.assertRaises(SigningFailed,
419
 
                              commit.Commit(config=config).commit,
 
466
                              commit.Commit(config_stack=config).commit,
420
467
                              message="base",
421
468
                              allow_pointless=True,
422
469
                              rev_id='B',
423
470
                              working_tree=wt)
424
471
            branch = Branch.open(self.get_url('.'))
425
 
            self.assertEqual(branch.revision_history(), ['A'])
426
 
            self.failIf(branch.repository.has_revision('B'))
 
472
            self.assertEqual(branch.last_revision(), 'A')
 
473
            self.assertFalse(branch.repository.has_revision('B'))
427
474
        finally:
428
475
            bzrlib.gpg.GPGStrategy = oldstrategy
429
476
 
437
484
        bzrlib.ahook = called
438
485
        try:
439
486
            config = BranchWithHooks(branch)
440
 
            commit.Commit(config=config).commit(
 
487
            commit.Commit(config_stack=config).commit(
441
488
                            message = "base",
442
489
                            allow_pointless=True,
443
490
                            rev_id='A', working_tree = wt)