← 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: Canonical.com Patch Queue Manager
  • Date: 2009-08-14 05:49:27 UTC
  • mfrom: (4476.3.86 inventory-delta)
  • Revision ID: pqm@pqm.ubuntu.com-20090814054927-k0k18dn46ax4b91f
(andrew) Add inventory-delta streaming for cross-format fetch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_branch.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 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 cStringIO import StringIO
 
25
from StringIO 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,
33
32
    trace,
34
 
    transport,
35
33
    urlutils,
36
34
    )
37
 
 
38
 
 
39
 
class TestDefaultFormat(tests.TestCase):
 
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):
40
59
 
41
60
    def test_default_format(self):
42
61
        # update this if you change the default branch format
43
 
        self.assertIsInstance(_mod_branch.BranchFormat.get_default_format(),
44
 
                _mod_branch.BzrBranchFormat7)
 
62
        self.assertIsInstance(BranchFormat.get_default_format(),
 
63
                BzrBranchFormat6)
45
64
 
46
65
    def test_default_format_is_same_as_bzrdir_default(self):
47
66
        # XXX: it might be nice if there was only one place the default was
48
67
        # set, but at the moment that's not true -- mbp 20070814 --
49
68
        # https://bugs.launchpad.net/bzr/+bug/132376
50
 
        self.assertEqual(
51
 
            _mod_branch.BranchFormat.get_default_format(),
52
 
            bzrdir.BzrDirFormat.get_default_format().get_branch_format())
 
69
        self.assertEqual(BranchFormat.get_default_format(),
 
70
                BzrDirFormat.get_default_format().get_branch_format())
53
71
 
54
72
    def test_get_set_default_format(self):
55
73
        # set the format and then set it back again
56
 
        old_format = _mod_branch.BranchFormat.get_default_format()
57
 
        _mod_branch.BranchFormat.set_default_format(SampleBranchFormat())
 
74
        old_format = BranchFormat.get_default_format()
 
75
        BranchFormat.set_default_format(SampleBranchFormat())
58
76
        try:
59
77
            # the default branch format is used by the meta dir format
60
78
            # which is not the default bzrdir format at this point
61
 
            dir = bzrdir.BzrDirMetaFormat1().initialize('memory:///')
 
79
            dir = BzrDirMetaFormat1().initialize('memory:///')
62
80
            result = dir.create_branch()
63
81
            self.assertEqual(result, 'A branch')
64
82
        finally:
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):
 
83
            BranchFormat.set_default_format(old_format)
 
84
        self.assertEqual(old_format, BranchFormat.get_default_format())
 
85
 
 
86
 
 
87
class TestBranchFormat5(TestCaseWithTransport):
71
88
    """Tests specific to branch format 5"""
72
89
 
73
90
    def test_branch_format_5_uses_lockdir(self):
74
91
        url = self.get_url()
75
 
        bdir = bzrdir.BzrDirMetaFormat1().initialize(url)
76
 
        bdir.create_repository()
77
 
        branch = bdir.create_branch()
 
92
        bzrdir = BzrDirMetaFormat1().initialize(url)
 
93
        bzrdir.create_repository()
 
94
        branch = bzrdir.create_branch()
78
95
        t = self.get_transport()
79
96
        self.log("branch instance is %r" % branch)
80
 
        self.assert_(isinstance(branch, _mod_branch.BzrBranch5))
 
97
        self.assert_(isinstance(branch, BzrBranch5))
81
98
        self.assertIsDirectory('.', t)
82
99
        self.assertIsDirectory('.bzr/branch', t)
83
100
        self.assertIsDirectory('.bzr/branch/lock', t)
84
101
        branch.lock_write()
85
 
        self.addCleanup(branch.unlock)
86
 
        self.assertIsDirectory('.bzr/branch/lock/held', t)
 
102
        try:
 
103
            self.assertIsDirectory('.bzr/branch/lock/held', t)
 
104
        finally:
 
105
            branch.unlock()
87
106
 
88
107
    def test_set_push_location(self):
89
108
        from bzrlib.config import (locations_config_filename,
112
131
    # recursive section - that is, it appends the branch name.
113
132
 
114
133
 
115
 
class SampleBranchFormat(_mod_branch.BranchFormat):
 
134
class SampleBranchFormat(BranchFormat):
116
135
    """A sample format
117
136
 
118
137
    this format is initializable, unsupported to aid in testing the
123
142
        """See BzrBranchFormat.get_format_string()."""
124
143
        return "Sample branch format."
125
144
 
126
 
    def initialize(self, a_bzrdir, name=None):
 
145
    def initialize(self, a_bzrdir):
127
146
        """Format 4 branches cannot be created."""
128
 
        t = a_bzrdir.get_branch_transport(self, name=name)
 
147
        t = a_bzrdir.get_branch_transport(self)
129
148
        t.put_bytes('format', self.get_format_string())
130
149
        return 'A branch'
131
150
 
132
151
    def is_supported(self):
133
152
        return False
134
153
 
135
 
    def open(self, transport, name=None, _found=False, ignore_fallbacks=False):
 
154
    def open(self, transport, _found=False, ignore_fallbacks=False):
136
155
        return "opened branch."
137
156
 
138
157
 
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):
 
158
class TestBzrBranchFormat(TestCaseWithTransport):
161
159
    """Tests for the BzrBranchFormat facility."""
162
160
 
163
161
    def test_find_format(self):
169
167
            dir = format._matchingbzrdir.initialize(url)
170
168
            dir.create_repository()
171
169
            format.initialize(dir)
172
 
            found_format = _mod_branch.BranchFormat.find_format(dir)
 
170
            found_format = BranchFormat.find_format(dir)
173
171
            self.failUnless(isinstance(found_format, format.__class__))
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.")
 
172
        check_format(BzrBranchFormat5(), "bar")
186
173
 
187
174
    def test_find_format_not_branch(self):
188
175
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
189
 
        self.assertRaises(errors.NotBranchError,
190
 
                          _mod_branch.BranchFormat.find_format,
 
176
        self.assertRaises(NotBranchError,
 
177
                          BranchFormat.find_format,
191
178
                          dir)
192
179
 
193
180
    def test_find_format_unknown_format(self):
194
181
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
195
182
        SampleBranchFormat().initialize(dir)
196
 
        self.assertRaises(errors.UnknownFormatError,
197
 
                          _mod_branch.BranchFormat.find_format,
 
183
        self.assertRaises(UnknownFormatError,
 
184
                          BranchFormat.find_format,
198
185
                          dir)
199
186
 
200
187
    def test_register_unregister_format(self):
204
191
        # make a branch
205
192
        format.initialize(dir)
206
193
        # register a format for it.
207
 
        _mod_branch.BranchFormat.register_format(format)
 
194
        BranchFormat.register_format(format)
208
195
        # which branch.Open will refuse (not supported)
209
 
        self.assertRaises(errors.UnsupportedFormatError,
210
 
                          _mod_branch.Branch.open, self.get_url())
 
196
        self.assertRaises(UnsupportedFormatError, Branch.open, self.get_url())
211
197
        self.make_branch_and_tree('foo')
212
198
        # but open_downlevel will work
213
 
        self.assertEqual(
214
 
            format.open(dir),
215
 
            bzrdir.BzrDir.open(self.get_url()).open_branch(unsupported=True))
 
199
        self.assertEqual(format.open(dir), bzrdir.BzrDir.open(self.get_url()).open_branch(unsupported=True))
216
200
        # unregister the format
217
 
        _mod_branch.BranchFormat.unregister_format(format)
 
201
        BranchFormat.unregister_format(format)
218
202
        self.make_branch_and_tree('bar')
219
203
 
220
204
 
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
 
 
249
205
class TestBranch67(object):
250
206
    """Common tests for both branch 6 and 7 which are mostly the same."""
251
207
 
259
215
        raise NotImplementedError(self.get_class)
260
216
 
261
217
    def test_creation(self):
262
 
        format = bzrdir.BzrDirMetaFormat1()
 
218
        format = BzrDirMetaFormat1()
263
219
        format.set_branch_format(_mod_branch.BzrBranchFormat6())
264
220
        branch = self.make_branch('a', format=format)
265
221
        self.assertIsInstance(branch, self.get_class())
352
308
                         'locations.conf')
353
309
 
354
310
 
355
 
class TestBranch6(TestBranch67, tests.TestCaseWithTransport):
 
311
class TestBranch6(TestBranch67, TestCaseWithTransport):
356
312
 
357
313
    def get_class(self):
358
314
        return _mod_branch.BzrBranch6
373
329
        self.assertRaises(errors.UnstackableBranchFormat, branch.get_stacked_on_url)
374
330
 
375
331
 
376
 
class TestBranch7(TestBranch67, tests.TestCaseWithTransport):
 
332
class TestBranch7(TestBranch67, TestCaseWithTransport):
377
333
 
378
334
    def get_class(self):
379
335
        return _mod_branch.BzrBranch7
423
379
        self.assertTrue(branch.repository.has_revision(revid))
424
380
 
425
381
 
426
 
class BzrBranch8(tests.TestCaseWithTransport):
 
382
class BzrBranch8(TestCaseWithTransport):
427
383
 
428
384
    def make_branch(self, location, format=None):
429
385
        if format is None:
430
386
            format = bzrdir.format_registry.make_bzrdir('1.9')
431
387
            format.set_branch_format(_mod_branch.BzrBranchFormat8())
432
 
        return tests.TestCaseWithTransport.make_branch(
433
 
            self, location, format=format)
 
388
        return TestCaseWithTransport.make_branch(self, location, format=format)
434
389
 
435
390
    def create_branch_with_reference(self):
436
391
        branch = self.make_branch('branch')
480
435
        branch.lock_write()
481
436
        branch.set_reference_info('file-id', 'path2', 'location2')
482
437
        branch.unlock()
483
 
        doppelganger = _mod_branch.Branch.open('branch')
 
438
        doppelganger = Branch.open('branch')
484
439
        doppelganger.set_reference_info('file-id', 'path3', 'location3')
485
440
        self.assertEqual(('path3', 'location3'),
486
441
                         branch.get_reference_info('file-id'))
487
442
 
488
 
class TestBranchReference(tests.TestCaseWithTransport):
 
443
class TestBranchReference(TestCaseWithTransport):
489
444
    """Tests for the branch reference facility."""
490
445
 
491
446
    def test_create_open_reference(self):
492
447
        bzrdirformat = bzrdir.BzrDirMetaFormat1()
493
 
        t = transport.get_transport(self.get_url('.'))
 
448
        t = get_transport(self.get_url('.'))
494
449
        t.mkdir('repo')
495
450
        dir = bzrdirformat.initialize(self.get_url('repo'))
496
451
        dir.create_repository()
497
452
        target_branch = dir.create_branch()
498
453
        t.mkdir('branch')
499
454
        branch_dir = bzrdirformat.initialize(self.get_url('branch'))
500
 
        made_branch = _mod_branch.BranchReferenceFormat().initialize(
501
 
            branch_dir, target_branch=target_branch)
 
455
        made_branch = BranchReferenceFormat().initialize(branch_dir, target_branch)
502
456
        self.assertEqual(made_branch.base, target_branch.base)
503
457
        opened_branch = branch_dir.open_branch()
504
458
        self.assertEqual(opened_branch.base, target_branch.base)
515
469
            _mod_branch.BranchReferenceFormat().get_reference(checkout.bzrdir))
516
470
 
517
471
 
518
 
class TestHooks(tests.TestCaseWithTransport):
 
472
class TestHooks(TestCase):
519
473
 
520
474
    def test_constructor(self):
521
475
        """Check that creating a BranchHooks instance has the right defaults."""
522
 
        hooks = _mod_branch.BranchHooks()
 
476
        hooks = BranchHooks()
523
477
        self.assertTrue("set_rh" in hooks, "set_rh not in %s" % hooks)
524
478
        self.assertTrue("post_push" in hooks, "post_push not in %s" % hooks)
525
479
        self.assertTrue("post_commit" in hooks, "post_commit not in %s" % hooks)
526
480
        self.assertTrue("pre_commit" in hooks, "pre_commit not in %s" % hooks)
527
481
        self.assertTrue("post_pull" in hooks, "post_pull not in %s" % hooks)
528
 
        self.assertTrue("post_uncommit" in hooks,
529
 
                        "post_uncommit not in %s" % hooks)
 
482
        self.assertTrue("post_uncommit" in hooks, "post_uncommit not in %s" % hooks)
530
483
        self.assertTrue("post_change_branch_tip" in hooks,
531
484
                        "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)
536
485
 
537
486
    def test_installed_hooks_are_BranchHooks(self):
538
487
        """The installed hooks object should be a BranchHooks."""
539
488
        # the installed hooks are saved in self._preserved_hooks.
540
489
        self.assertIsInstance(self._preserved_hooks[_mod_branch.Branch][1],
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):
 
490
            BranchHooks)
 
491
 
 
492
 
 
493
class TestPullResult(TestCase):
627
494
 
628
495
    def test_pull_result_to_int(self):
629
496
        # to support old code, the pull result can be used as an int
630
 
        r = _mod_branch.PullResult()
 
497
        r = PullResult()
631
498
        r.old_revno = 10
632
499
        r.new_revno = 20
633
500
        # this usage of results is not recommended for new code (because it
636
503
        a = "%d revisions pulled" % r
637
504
        self.assertEqual(a, "10 revisions pulled")
638
505
 
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())
656
506
 
657
507
 
658
508
class _StubLockable(object):
679
529
    """Helper for TestRunWithWriteLockedTarget."""
680
530
 
681
531
 
682
 
class TestRunWithWriteLockedTarget(tests.TestCase):
 
532
class TestRunWithWriteLockedTarget(TestCase):
683
533
    """Tests for _run_with_write_locked_target."""
684
534
 
685
535
    def setUp(self):
686
 
        tests.TestCase.setUp(self)
 
536
        TestCase.setUp(self)
687
537
        self._calls = []
688
538
 
689
539
    def func_that_returns_ok(self):
696
546
 
697
547
    def test_success_unlocks(self):
698
548
        lockable = _StubLockable(self._calls)
699
 
        result = _mod_branch._run_with_write_locked_target(
 
549
        result = _run_with_write_locked_target(
700
550
            lockable, self.func_that_returns_ok)
701
551
        self.assertEqual('ok', result)
702
552
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
704
554
    def test_exception_unlocks_and_propagates(self):
705
555
        lockable = _StubLockable(self._calls)
706
556
        self.assertRaises(_ErrorFromCallable,
707
 
                          _mod_branch._run_with_write_locked_target,
708
 
                          lockable, self.func_that_raises)
 
557
            _run_with_write_locked_target, lockable, self.func_that_raises)
709
558
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
710
559
 
711
560
    def test_callable_succeeds_but_error_during_unlock(self):
712
561
        lockable = _StubLockable(self._calls, unlock_exc=_ErrorFromUnlock())
713
562
        self.assertRaises(_ErrorFromUnlock,
714
 
                          _mod_branch._run_with_write_locked_target,
715
 
                          lockable, self.func_that_returns_ok)
 
563
            _run_with_write_locked_target, lockable, self.func_that_returns_ok)
716
564
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
717
565
 
718
566
    def test_error_during_unlock_does_not_mask_original_error(self):
719
567
        lockable = _StubLockable(self._calls, unlock_exc=_ErrorFromUnlock())
720
568
        self.assertRaises(_ErrorFromCallable,
721
 
                          _mod_branch._run_with_write_locked_target,
722
 
                          lockable, self.func_that_raises)
 
569
            _run_with_write_locked_target, lockable, self.func_that_raises)
723
570
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
724
571
 
725
572