← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_branch.py

  • Committer: John Arbash Meinel
  • Date: 2010-08-24 19:21:32 UTC
  • mto: This revision was merged to the branch mainline in revision 5390.
  • Revision ID: john@arbash-meinel.com-20100824192132-2ktt5adkbk5bk1ct
Handle test_source and extensions. Also define an 'extern' protocol, to allow
the test suite to recognize that returning an object of that type is a Python object.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_branch.py
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2006-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
22
22
also see this file.
23
23
"""
24
24
 
25
 
from StringIO import StringIO
 
25
from cStringIO import StringIO
26
26
 
27
27
from bzrlib import (
28
28
    branch as _mod_branch,
29
29
    bzrdir,
30
30
    config,
31
31
    errors,
 
32
    tests,
32
33
    trace,
 
34
    transport,
33
35
    urlutils,
34
36
    )
35
 
from bzrlib.branch import (
36
 
    Branch,
37
 
    BranchHooks,
38
 
    BranchFormat,
39
 
    BranchReferenceFormat,
40
 
    BzrBranch5,
41
 
    BzrBranchFormat5,
42
 
    BzrBranchFormat6,
43
 
    PullResult,
44
 
    _run_with_write_locked_target,
45
 
    )
46
 
from bzrlib.bzrdir import (BzrDirMetaFormat1, BzrDirMeta1,
47
 
                           BzrDir, BzrDirFormat)
48
 
from bzrlib.errors import (NotBranchError,
49
 
                           UnknownFormatError,
50
 
                           UnknownHook,
51
 
                           UnsupportedFormatError,
52
 
                           )
53
 
 
54
 
from bzrlib.tests import TestCase, TestCaseWithTransport
55
 
from bzrlib.transport import get_transport
56
 
 
57
 
 
58
 
class TestDefaultFormat(TestCase):
 
37
 
 
38
 
 
39
class TestDefaultFormat(tests.TestCase):
59
40
 
60
41
    def test_default_format(self):
61
42
        # update this if you change the default branch format
62
 
        self.assertIsInstance(BranchFormat.get_default_format(),
63
 
                BzrBranchFormat6)
 
43
        self.assertIsInstance(_mod_branch.BranchFormat.get_default_format(),
 
44
                _mod_branch.BzrBranchFormat7)
64
45
 
65
46
    def test_default_format_is_same_as_bzrdir_default(self):
66
47
        # XXX: it might be nice if there was only one place the default was
67
48
        # set, but at the moment that's not true -- mbp 20070814 --
68
49
        # https://bugs.launchpad.net/bzr/+bug/132376
69
 
        self.assertEqual(BranchFormat.get_default_format(),
70
 
                BzrDirFormat.get_default_format().get_branch_format())
 
50
        self.assertEqual(
 
51
            _mod_branch.BranchFormat.get_default_format(),
 
52
            bzrdir.BzrDirFormat.get_default_format().get_branch_format())
71
53
 
72
54
    def test_get_set_default_format(self):
73
55
        # set the format and then set it back again
74
 
        old_format = BranchFormat.get_default_format()
75
 
        BranchFormat.set_default_format(SampleBranchFormat())
 
56
        old_format = _mod_branch.BranchFormat.get_default_format()
 
57
        _mod_branch.BranchFormat.set_default_format(SampleBranchFormat())
76
58
        try:
77
59
            # the default branch format is used by the meta dir format
78
60
            # which is not the default bzrdir format at this point
79
 
            dir = BzrDirMetaFormat1().initialize('memory:///')
 
61
            dir = bzrdir.BzrDirMetaFormat1().initialize('memory:///')
80
62
            result = dir.create_branch()
81
63
            self.assertEqual(result, 'A branch')
82
64
        finally:
83
 
            BranchFormat.set_default_format(old_format)
84
 
        self.assertEqual(old_format, BranchFormat.get_default_format())
85
 
 
86
 
 
87
 
class TestBranchFormat5(TestCaseWithTransport):
 
65
            _mod_branch.BranchFormat.set_default_format(old_format)
 
66
        self.assertEqual(old_format,
 
67
                         _mod_branch.BranchFormat.get_default_format())
 
68
 
 
69
 
 
70
class TestBranchFormat5(tests.TestCaseWithTransport):
88
71
    """Tests specific to branch format 5"""
89
72
 
90
73
    def test_branch_format_5_uses_lockdir(self):
91
74
        url = self.get_url()
92
 
        bzrdir = BzrDirMetaFormat1().initialize(url)
93
 
        bzrdir.create_repository()
94
 
        branch = bzrdir.create_branch()
 
75
        bdir = bzrdir.BzrDirMetaFormat1().initialize(url)
 
76
        bdir.create_repository()
 
77
        branch = bdir.create_branch()
95
78
        t = self.get_transport()
96
79
        self.log("branch instance is %r" % branch)
97
 
        self.assert_(isinstance(branch, BzrBranch5))
 
80
        self.assert_(isinstance(branch, _mod_branch.BzrBranch5))
98
81
        self.assertIsDirectory('.', t)
99
82
        self.assertIsDirectory('.bzr/branch', t)
100
83
        self.assertIsDirectory('.bzr/branch/lock', t)
101
84
        branch.lock_write()
102
 
        try:
103
 
            self.assertIsDirectory('.bzr/branch/lock/held', t)
104
 
        finally:
105
 
            branch.unlock()
 
85
        self.addCleanup(branch.unlock)
 
86
        self.assertIsDirectory('.bzr/branch/lock/held', t)
106
87
 
107
88
    def test_set_push_location(self):
108
89
        from bzrlib.config import (locations_config_filename,
131
112
    # recursive section - that is, it appends the branch name.
132
113
 
133
114
 
134
 
class SampleBranchFormat(BranchFormat):
 
115
class SampleBranchFormat(_mod_branch.BranchFormat):
135
116
    """A sample format
136
117
 
137
118
    this format is initializable, unsupported to aid in testing the
142
123
        """See BzrBranchFormat.get_format_string()."""
143
124
        return "Sample branch format."
144
125
 
145
 
    def initialize(self, a_bzrdir):
 
126
    def initialize(self, a_bzrdir, name=None):
146
127
        """Format 4 branches cannot be created."""
147
 
        t = a_bzrdir.get_branch_transport(self)
 
128
        t = a_bzrdir.get_branch_transport(self, name=name)
148
129
        t.put_bytes('format', self.get_format_string())
149
130
        return 'A branch'
150
131
 
151
132
    def is_supported(self):
152
133
        return False
153
134
 
154
 
    def open(self, transport, _found=False, ignore_fallbacks=False):
 
135
    def open(self, transport, name=None, _found=False, ignore_fallbacks=False):
155
136
        return "opened branch."
156
137
 
157
138
 
158
 
class TestBzrBranchFormat(TestCaseWithTransport):
 
139
# Demonstrating how lazy loading is often implemented:
 
140
# A constant string is created.
 
141
SampleSupportedBranchFormatString = "Sample supported branch format."
 
142
 
 
143
# And the format class can then reference the constant to avoid skew.
 
144
class SampleSupportedBranchFormat(_mod_branch.BranchFormat):
 
145
    """A sample supported format."""
 
146
 
 
147
    def get_format_string(self):
 
148
        """See BzrBranchFormat.get_format_string()."""
 
149
        return SampleSupportedBranchFormatString
 
150
 
 
151
    def initialize(self, a_bzrdir, name=None):
 
152
        t = a_bzrdir.get_branch_transport(self, name=name)
 
153
        t.put_bytes('format', self.get_format_string())
 
154
        return 'A branch'
 
155
 
 
156
    def open(self, transport, name=None, _found=False, ignore_fallbacks=False):
 
157
        return "opened supported branch."
 
158
 
 
159
 
 
160
class TestBzrBranchFormat(tests.TestCaseWithTransport):
159
161
    """Tests for the BzrBranchFormat facility."""
160
162
 
161
163
    def test_find_format(self):
167
169
            dir = format._matchingbzrdir.initialize(url)
168
170
            dir.create_repository()
169
171
            format.initialize(dir)
170
 
            found_format = BranchFormat.find_format(dir)
 
172
            found_format = _mod_branch.BranchFormat.find_format(dir)
171
173
            self.failUnless(isinstance(found_format, format.__class__))
172
 
        check_format(BzrBranchFormat5(), "bar")
 
174
        check_format(_mod_branch.BzrBranchFormat5(), "bar")
 
175
 
 
176
    def test_find_format_factory(self):
 
177
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
 
178
        SampleSupportedBranchFormat().initialize(dir)
 
179
        factory = _mod_branch.MetaDirBranchFormatFactory(
 
180
            SampleSupportedBranchFormatString,
 
181
            "bzrlib.tests.test_branch", "SampleSupportedBranchFormat")
 
182
        _mod_branch.BranchFormat.register_format(factory)
 
183
        self.addCleanup(_mod_branch.BranchFormat.unregister_format, factory)
 
184
        b = _mod_branch.Branch.open(self.get_url())
 
185
        self.assertEqual(b, "opened supported branch.")
173
186
 
174
187
    def test_find_format_not_branch(self):
175
188
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
176
 
        self.assertRaises(NotBranchError,
177
 
                          BranchFormat.find_format,
 
189
        self.assertRaises(errors.NotBranchError,
 
190
                          _mod_branch.BranchFormat.find_format,
178
191
                          dir)
179
192
 
180
193
    def test_find_format_unknown_format(self):
181
194
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
182
195
        SampleBranchFormat().initialize(dir)
183
 
        self.assertRaises(UnknownFormatError,
184
 
                          BranchFormat.find_format,
 
196
        self.assertRaises(errors.UnknownFormatError,
 
197
                          _mod_branch.BranchFormat.find_format,
185
198
                          dir)
186
199
 
187
200
    def test_register_unregister_format(self):
191
204
        # make a branch
192
205
        format.initialize(dir)
193
206
        # register a format for it.
194
 
        BranchFormat.register_format(format)
 
207
        _mod_branch.BranchFormat.register_format(format)
195
208
        # which branch.Open will refuse (not supported)
196
 
        self.assertRaises(UnsupportedFormatError, Branch.open, self.get_url())
 
209
        self.assertRaises(errors.UnsupportedFormatError,
 
210
                          _mod_branch.Branch.open, self.get_url())
197
211
        self.make_branch_and_tree('foo')
198
212
        # but open_downlevel will work
199
 
        self.assertEqual(format.open(dir), bzrdir.BzrDir.open(self.get_url()).open_branch(unsupported=True))
 
213
        self.assertEqual(
 
214
            format.open(dir),
 
215
            bzrdir.BzrDir.open(self.get_url()).open_branch(unsupported=True))
200
216
        # unregister the format
201
 
        BranchFormat.unregister_format(format)
 
217
        _mod_branch.BranchFormat.unregister_format(format)
202
218
        self.make_branch_and_tree('bar')
203
219
 
204
220
 
 
221
#Used by TestMetaDirBranchFormatFactory 
 
222
FakeLazyFormat = None
 
223
 
 
224
 
 
225
class TestMetaDirBranchFormatFactory(tests.TestCase):
 
226
 
 
227
    def test_get_format_string_does_not_load(self):
 
228
        """Formats have a static format string."""
 
229
        factory = _mod_branch.MetaDirBranchFormatFactory("yo", None, None)
 
230
        self.assertEqual("yo", factory.get_format_string())
 
231
 
 
232
    def test_call_loads(self):
 
233
        # __call__ is used by the network_format_registry interface to get a
 
234
        # Format.
 
235
        global FakeLazyFormat
 
236
        del FakeLazyFormat
 
237
        factory = _mod_branch.MetaDirBranchFormatFactory(None,
 
238
            "bzrlib.tests.test_branch", "FakeLazyFormat")
 
239
        self.assertRaises(AttributeError, factory)
 
240
 
 
241
    def test_call_returns_call_of_referenced_object(self):
 
242
        global FakeLazyFormat
 
243
        FakeLazyFormat = lambda:'called'
 
244
        factory = _mod_branch.MetaDirBranchFormatFactory(None,
 
245
            "bzrlib.tests.test_branch", "FakeLazyFormat")
 
246
        self.assertEqual('called', factory())
 
247
 
 
248
 
205
249
class TestBranch67(object):
206
250
    """Common tests for both branch 6 and 7 which are mostly the same."""
207
251
 
215
259
        raise NotImplementedError(self.get_class)
216
260
 
217
261
    def test_creation(self):
218
 
        format = BzrDirMetaFormat1()
 
262
        format = bzrdir.BzrDirMetaFormat1()
219
263
        format.set_branch_format(_mod_branch.BzrBranchFormat6())
220
264
        branch = self.make_branch('a', format=format)
221
265
        self.assertIsInstance(branch, self.get_class())
308
352
                         'locations.conf')
309
353
 
310
354
 
311
 
class TestBranch6(TestBranch67, TestCaseWithTransport):
 
355
class TestBranch6(TestBranch67, tests.TestCaseWithTransport):
312
356
 
313
357
    def get_class(self):
314
358
        return _mod_branch.BzrBranch6
329
373
        self.assertRaises(errors.UnstackableBranchFormat, branch.get_stacked_on_url)
330
374
 
331
375
 
332
 
class TestBranch7(TestBranch67, TestCaseWithTransport):
 
376
class TestBranch7(TestBranch67, tests.TestCaseWithTransport):
333
377
 
334
378
    def get_class(self):
335
379
        return _mod_branch.BzrBranch7
379
423
        self.assertTrue(branch.repository.has_revision(revid))
380
424
 
381
425
 
382
 
class BzrBranch8(TestCaseWithTransport):
 
426
class BzrBranch8(tests.TestCaseWithTransport):
383
427
 
384
428
    def make_branch(self, location, format=None):
385
429
        if format is None:
386
430
            format = bzrdir.format_registry.make_bzrdir('1.9')
387
431
            format.set_branch_format(_mod_branch.BzrBranchFormat8())
388
 
        return TestCaseWithTransport.make_branch(self, location, format=format)
 
432
        return tests.TestCaseWithTransport.make_branch(
 
433
            self, location, format=format)
389
434
 
390
435
    def create_branch_with_reference(self):
391
436
        branch = self.make_branch('branch')
435
480
        branch.lock_write()
436
481
        branch.set_reference_info('file-id', 'path2', 'location2')
437
482
        branch.unlock()
438
 
        doppelganger = Branch.open('branch')
 
483
        doppelganger = _mod_branch.Branch.open('branch')
439
484
        doppelganger.set_reference_info('file-id', 'path3', 'location3')
440
485
        self.assertEqual(('path3', 'location3'),
441
486
                         branch.get_reference_info('file-id'))
442
487
 
443
 
class TestBranchReference(TestCaseWithTransport):
 
488
class TestBranchReference(tests.TestCaseWithTransport):
444
489
    """Tests for the branch reference facility."""
445
490
 
446
491
    def test_create_open_reference(self):
447
492
        bzrdirformat = bzrdir.BzrDirMetaFormat1()
448
 
        t = get_transport(self.get_url('.'))
 
493
        t = transport.get_transport(self.get_url('.'))
449
494
        t.mkdir('repo')
450
495
        dir = bzrdirformat.initialize(self.get_url('repo'))
451
496
        dir.create_repository()
452
497
        target_branch = dir.create_branch()
453
498
        t.mkdir('branch')
454
499
        branch_dir = bzrdirformat.initialize(self.get_url('branch'))
455
 
        made_branch = BranchReferenceFormat().initialize(branch_dir, target_branch)
 
500
        made_branch = _mod_branch.BranchReferenceFormat().initialize(
 
501
            branch_dir, target_branch=target_branch)
456
502
        self.assertEqual(made_branch.base, target_branch.base)
457
503
        opened_branch = branch_dir.open_branch()
458
504
        self.assertEqual(opened_branch.base, target_branch.base)
469
515
            _mod_branch.BranchReferenceFormat().get_reference(checkout.bzrdir))
470
516
 
471
517
 
472
 
class TestHooks(TestCase):
 
518
class TestHooks(tests.TestCaseWithTransport):
473
519
 
474
520
    def test_constructor(self):
475
521
        """Check that creating a BranchHooks instance has the right defaults."""
476
 
        hooks = BranchHooks()
 
522
        hooks = _mod_branch.BranchHooks()
477
523
        self.assertTrue("set_rh" in hooks, "set_rh not in %s" % hooks)
478
524
        self.assertTrue("post_push" in hooks, "post_push not in %s" % hooks)
479
525
        self.assertTrue("post_commit" in hooks, "post_commit not in %s" % hooks)
480
526
        self.assertTrue("pre_commit" in hooks, "pre_commit not in %s" % hooks)
481
527
        self.assertTrue("post_pull" in hooks, "post_pull not in %s" % hooks)
482
 
        self.assertTrue("post_uncommit" in hooks, "post_uncommit not in %s" % hooks)
 
528
        self.assertTrue("post_uncommit" in hooks,
 
529
                        "post_uncommit not in %s" % hooks)
483
530
        self.assertTrue("post_change_branch_tip" in hooks,
484
531
                        "post_change_branch_tip not in %s" % hooks)
 
532
        self.assertTrue("post_branch_init" in hooks,
 
533
                        "post_branch_init not in %s" % hooks)
 
534
        self.assertTrue("post_switch" in hooks,
 
535
                        "post_switch not in %s" % hooks)
485
536
 
486
537
    def test_installed_hooks_are_BranchHooks(self):
487
538
        """The installed hooks object should be a BranchHooks."""
488
539
        # the installed hooks are saved in self._preserved_hooks.
489
540
        self.assertIsInstance(self._preserved_hooks[_mod_branch.Branch][1],
490
 
            BranchHooks)
491
 
 
492
 
 
493
 
class TestPullResult(TestCase):
 
541
                              _mod_branch.BranchHooks)
 
542
 
 
543
    def test_post_branch_init_hook(self):
 
544
        calls = []
 
545
        _mod_branch.Branch.hooks.install_named_hook('post_branch_init',
 
546
            calls.append, None)
 
547
        self.assertLength(0, calls)
 
548
        branch = self.make_branch('a')
 
549
        self.assertLength(1, calls)
 
550
        params = calls[0]
 
551
        self.assertIsInstance(params, _mod_branch.BranchInitHookParams)
 
552
        self.assertTrue(hasattr(params, 'bzrdir'))
 
553
        self.assertTrue(hasattr(params, 'branch'))
 
554
 
 
555
    def test_post_branch_init_hook_repr(self):
 
556
        param_reprs = []
 
557
        _mod_branch.Branch.hooks.install_named_hook('post_branch_init',
 
558
            lambda params: param_reprs.append(repr(params)), None)
 
559
        branch = self.make_branch('a')
 
560
        self.assertLength(1, param_reprs)
 
561
        param_repr = param_reprs[0]
 
562
        self.assertStartsWith(param_repr, '<BranchInitHookParams of ')
 
563
 
 
564
    def test_post_switch_hook(self):
 
565
        from bzrlib import switch
 
566
        calls = []
 
567
        _mod_branch.Branch.hooks.install_named_hook('post_switch',
 
568
            calls.append, None)
 
569
        tree = self.make_branch_and_tree('branch-1')
 
570
        self.build_tree(['branch-1/file-1'])
 
571
        tree.add('file-1')
 
572
        tree.commit('rev1')
 
573
        to_branch = tree.bzrdir.sprout('branch-2').open_branch()
 
574
        self.build_tree(['branch-1/file-2'])
 
575
        tree.add('file-2')
 
576
        tree.remove('file-1')
 
577
        tree.commit('rev2')
 
578
        checkout = tree.branch.create_checkout('checkout')
 
579
        self.assertLength(0, calls)
 
580
        switch.switch(checkout.bzrdir, to_branch)
 
581
        self.assertLength(1, calls)
 
582
        params = calls[0]
 
583
        self.assertIsInstance(params, _mod_branch.SwitchHookParams)
 
584
        self.assertTrue(hasattr(params, 'to_branch'))
 
585
        self.assertTrue(hasattr(params, 'revision_id'))
 
586
 
 
587
 
 
588
class TestBranchOptions(tests.TestCaseWithTransport):
 
589
 
 
590
    def setUp(self):
 
591
        super(TestBranchOptions, self).setUp()
 
592
        self.branch = self.make_branch('.')
 
593
        self.config = self.branch.get_config()
 
594
 
 
595
    def check_append_revisions_only(self, expected_value, value=None):
 
596
        """Set append_revisions_only in config and check its interpretation."""
 
597
        if value is not None:
 
598
            self.config.set_user_option('append_revisions_only', value)
 
599
        self.assertEqual(expected_value,
 
600
                         self.branch._get_append_revisions_only())
 
601
 
 
602
    def test_valid_append_revisions_only(self):
 
603
        self.assertEquals(None,
 
604
                          self.config.get_user_option('append_revisions_only'))
 
605
        self.check_append_revisions_only(None)
 
606
        self.check_append_revisions_only(False, 'False')
 
607
        self.check_append_revisions_only(True, 'True')
 
608
        # The following values will cause compatibility problems on projects
 
609
        # using older bzr versions (<2.2) but are accepted
 
610
        self.check_append_revisions_only(False, 'false')
 
611
        self.check_append_revisions_only(True, 'true')
 
612
 
 
613
    def test_invalid_append_revisions_only(self):
 
614
        """Ensure warning is noted on invalid settings"""
 
615
        self.warnings = []
 
616
        def warning(*args):
 
617
            self.warnings.append(args[0] % args[1:])
 
618
        self.overrideAttr(trace, 'warning', warning)
 
619
        self.check_append_revisions_only(None, 'not-a-bool')
 
620
        self.assertLength(1, self.warnings)
 
621
        self.assertEqual(
 
622
            'Value "not-a-bool" is not a boolean for "append_revisions_only"',
 
623
            self.warnings[0])
 
624
 
 
625
 
 
626
class TestPullResult(tests.TestCase):
494
627
 
495
628
    def test_pull_result_to_int(self):
496
629
        # to support old code, the pull result can be used as an int
497
 
        r = PullResult()
 
630
        r = _mod_branch.PullResult()
498
631
        r.old_revno = 10
499
632
        r.new_revno = 20
500
633
        # this usage of results is not recommended for new code (because it
503
636
        a = "%d revisions pulled" % r
504
637
        self.assertEqual(a, "10 revisions pulled")
505
638
 
 
639
    def test_report_changed(self):
 
640
        r = _mod_branch.PullResult()
 
641
        r.old_revid = "old-revid"
 
642
        r.old_revno = 10
 
643
        r.new_revid = "new-revid"
 
644
        r.new_revno = 20
 
645
        f = StringIO()
 
646
        r.report(f)
 
647
        self.assertEqual("Now on revision 20.\n", f.getvalue())
 
648
 
 
649
    def test_report_unchanged(self):
 
650
        r = _mod_branch.PullResult()
 
651
        r.old_revid = "same-revid"
 
652
        r.new_revid = "same-revid"
 
653
        f = StringIO()
 
654
        r.report(f)
 
655
        self.assertEqual("No revisions to pull.\n", f.getvalue())
506
656
 
507
657
 
508
658
class _StubLockable(object):
529
679
    """Helper for TestRunWithWriteLockedTarget."""
530
680
 
531
681
 
532
 
class TestRunWithWriteLockedTarget(TestCase):
 
682
class TestRunWithWriteLockedTarget(tests.TestCase):
533
683
    """Tests for _run_with_write_locked_target."""
534
684
 
535
685
    def setUp(self):
536
 
        TestCase.setUp(self)
 
686
        tests.TestCase.setUp(self)
537
687
        self._calls = []
538
688
 
539
689
    def func_that_returns_ok(self):
546
696
 
547
697
    def test_success_unlocks(self):
548
698
        lockable = _StubLockable(self._calls)
549
 
        result = _run_with_write_locked_target(
 
699
        result = _mod_branch._run_with_write_locked_target(
550
700
            lockable, self.func_that_returns_ok)
551
701
        self.assertEqual('ok', result)
552
702
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
554
704
    def test_exception_unlocks_and_propagates(self):
555
705
        lockable = _StubLockable(self._calls)
556
706
        self.assertRaises(_ErrorFromCallable,
557
 
            _run_with_write_locked_target, lockable, self.func_that_raises)
 
707
                          _mod_branch._run_with_write_locked_target,
 
708
                          lockable, self.func_that_raises)
558
709
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
559
710
 
560
711
    def test_callable_succeeds_but_error_during_unlock(self):
561
712
        lockable = _StubLockable(self._calls, unlock_exc=_ErrorFromUnlock())
562
713
        self.assertRaises(_ErrorFromUnlock,
563
 
            _run_with_write_locked_target, lockable, self.func_that_returns_ok)
 
714
                          _mod_branch._run_with_write_locked_target,
 
715
                          lockable, self.func_that_returns_ok)
564
716
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
565
717
 
566
718
    def test_error_during_unlock_does_not_mask_original_error(self):
567
719
        lockable = _StubLockable(self._calls, unlock_exc=_ErrorFromUnlock())
568
720
        self.assertRaises(_ErrorFromCallable,
569
 
            _run_with_write_locked_target, lockable, self.func_that_raises)
 
721
                          _mod_branch._run_with_write_locked_target,
 
722
                          lockable, self.func_that_raises)
570
723
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
571
724
 
572
725