← 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-04-08 12:39:40 UTC
  • mfrom: (4266.2.1 tests.output)
  • Revision ID: pqm@pqm.ubuntu.com-20090408123940-kaho6cwr21163fjn
(robertc) Remove clutter from bzr selftest --list. (Robert Collins)

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
16
16
 
17
17
"""Tests for the Branch facility that are not interface  tests.
18
18
 
19
 
For interface tests see tests/per_branch/*.py.
 
19
For interface tests see tests/branch_implementations/*.py.
20
20
 
21
21
For concrete class tests see this file, and for meta-branch tests
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())
272
228
        branch = self.make_branch('a', format=self.get_format_name())
273
229
        self.failUnlessExists('a/.bzr/branch/last-revision')
274
230
        self.failIfExists('a/.bzr/branch/revision-history')
275
 
        self.failIfExists('a/.bzr/branch/references')
276
231
 
277
232
    def test_config(self):
278
233
        """Ensure that all configuration data is stored in the branch"""
352
307
                         'locations.conf')
353
308
 
354
309
 
355
 
class TestBranch6(TestBranch67, tests.TestCaseWithTransport):
 
310
class TestBranch6(TestBranch67, TestCaseWithTransport):
356
311
 
357
312
    def get_class(self):
358
313
        return _mod_branch.BzrBranch6
373
328
        self.assertRaises(errors.UnstackableBranchFormat, branch.get_stacked_on_url)
374
329
 
375
330
 
376
 
class TestBranch7(TestBranch67, tests.TestCaseWithTransport):
 
331
class TestBranch7(TestBranch67, TestCaseWithTransport):
377
332
 
378
333
    def get_class(self):
379
334
        return _mod_branch.BzrBranch7
423
378
        self.assertTrue(branch.repository.has_revision(revid))
424
379
 
425
380
 
426
 
class BzrBranch8(tests.TestCaseWithTransport):
427
 
 
428
 
    def make_branch(self, location, format=None):
429
 
        if format is None:
430
 
            format = bzrdir.format_registry.make_bzrdir('1.9')
431
 
            format.set_branch_format(_mod_branch.BzrBranchFormat8())
432
 
        return tests.TestCaseWithTransport.make_branch(
433
 
            self, location, format=format)
434
 
 
435
 
    def create_branch_with_reference(self):
436
 
        branch = self.make_branch('branch')
437
 
        branch._set_all_reference_info({'file-id': ('path', 'location')})
438
 
        return branch
439
 
 
440
 
    @staticmethod
441
 
    def instrument_branch(branch, gets):
442
 
        old_get = branch._transport.get
443
 
        def get(*args, **kwargs):
444
 
            gets.append((args, kwargs))
445
 
            return old_get(*args, **kwargs)
446
 
        branch._transport.get = get
447
 
 
448
 
    def test_reference_info_caching_read_locked(self):
449
 
        gets = []
450
 
        branch = self.create_branch_with_reference()
451
 
        branch.lock_read()
452
 
        self.addCleanup(branch.unlock)
453
 
        self.instrument_branch(branch, gets)
454
 
        branch.get_reference_info('file-id')
455
 
        branch.get_reference_info('file-id')
456
 
        self.assertEqual(1, len(gets))
457
 
 
458
 
    def test_reference_info_caching_read_unlocked(self):
459
 
        gets = []
460
 
        branch = self.create_branch_with_reference()
461
 
        self.instrument_branch(branch, gets)
462
 
        branch.get_reference_info('file-id')
463
 
        branch.get_reference_info('file-id')
464
 
        self.assertEqual(2, len(gets))
465
 
 
466
 
    def test_reference_info_caching_write_locked(self):
467
 
        gets = []
468
 
        branch = self.make_branch('branch')
469
 
        branch.lock_write()
470
 
        self.instrument_branch(branch, gets)
471
 
        self.addCleanup(branch.unlock)
472
 
        branch._set_all_reference_info({'file-id': ('path2', 'location2')})
473
 
        path, location = branch.get_reference_info('file-id')
474
 
        self.assertEqual(0, len(gets))
475
 
        self.assertEqual('path2', path)
476
 
        self.assertEqual('location2', location)
477
 
 
478
 
    def test_reference_info_caches_cleared(self):
479
 
        branch = self.make_branch('branch')
480
 
        branch.lock_write()
481
 
        branch.set_reference_info('file-id', 'path2', 'location2')
482
 
        branch.unlock()
483
 
        doppelganger = _mod_branch.Branch.open('branch')
484
 
        doppelganger.set_reference_info('file-id', 'path3', 'location3')
485
 
        self.assertEqual(('path3', 'location3'),
486
 
                         branch.get_reference_info('file-id'))
487
 
 
488
 
class TestBranchReference(tests.TestCaseWithTransport):
 
381
class TestBranchReference(TestCaseWithTransport):
489
382
    """Tests for the branch reference facility."""
490
383
 
491
384
    def test_create_open_reference(self):
492
385
        bzrdirformat = bzrdir.BzrDirMetaFormat1()
493
 
        t = transport.get_transport(self.get_url('.'))
 
386
        t = get_transport(self.get_url('.'))
494
387
        t.mkdir('repo')
495
388
        dir = bzrdirformat.initialize(self.get_url('repo'))
496
389
        dir.create_repository()
497
390
        target_branch = dir.create_branch()
498
391
        t.mkdir('branch')
499
392
        branch_dir = bzrdirformat.initialize(self.get_url('branch'))
500
 
        made_branch = _mod_branch.BranchReferenceFormat().initialize(
501
 
            branch_dir, target_branch=target_branch)
 
393
        made_branch = BranchReferenceFormat().initialize(branch_dir, target_branch)
502
394
        self.assertEqual(made_branch.base, target_branch.base)
503
395
        opened_branch = branch_dir.open_branch()
504
396
        self.assertEqual(opened_branch.base, target_branch.base)
515
407
            _mod_branch.BranchReferenceFormat().get_reference(checkout.bzrdir))
516
408
 
517
409
 
518
 
class TestHooks(tests.TestCaseWithTransport):
 
410
class TestHooks(TestCase):
519
411
 
520
412
    def test_constructor(self):
521
413
        """Check that creating a BranchHooks instance has the right defaults."""
522
 
        hooks = _mod_branch.BranchHooks()
 
414
        hooks = BranchHooks()
523
415
        self.assertTrue("set_rh" in hooks, "set_rh not in %s" % hooks)
524
416
        self.assertTrue("post_push" in hooks, "post_push not in %s" % hooks)
525
417
        self.assertTrue("post_commit" in hooks, "post_commit not in %s" % hooks)
526
418
        self.assertTrue("pre_commit" in hooks, "pre_commit not in %s" % hooks)
527
419
        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)
 
420
        self.assertTrue("post_uncommit" in hooks, "post_uncommit not in %s" % hooks)
530
421
        self.assertTrue("post_change_branch_tip" in hooks,
531
422
                        "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
423
 
537
424
    def test_installed_hooks_are_BranchHooks(self):
538
425
        """The installed hooks object should be a BranchHooks."""
539
426
        # the installed hooks are saved in self._preserved_hooks.
540
427
        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_switch_hook(self):
556
 
        from bzrlib import switch
557
 
        calls = []
558
 
        _mod_branch.Branch.hooks.install_named_hook('post_switch',
559
 
            calls.append, None)
560
 
        tree = self.make_branch_and_tree('branch-1')
561
 
        self.build_tree(['branch-1/file-1'])
562
 
        tree.add('file-1')
563
 
        tree.commit('rev1')
564
 
        to_branch = tree.bzrdir.sprout('branch-2').open_branch()
565
 
        self.build_tree(['branch-1/file-2'])
566
 
        tree.add('file-2')
567
 
        tree.remove('file-1')
568
 
        tree.commit('rev2')
569
 
        checkout = tree.branch.create_checkout('checkout')
570
 
        self.assertLength(0, calls)
571
 
        switch.switch(checkout.bzrdir, to_branch)
572
 
        self.assertLength(1, calls)
573
 
        params = calls[0]
574
 
        self.assertIsInstance(params, _mod_branch.SwitchHookParams)
575
 
        self.assertTrue(hasattr(params, 'to_branch'))
576
 
        self.assertTrue(hasattr(params, 'revision_id'))
577
 
 
578
 
 
579
 
class TestBranchOptions(tests.TestCaseWithTransport):
580
 
 
581
 
    def setUp(self):
582
 
        super(TestBranchOptions, self).setUp()
583
 
        self.branch = self.make_branch('.')
584
 
        self.config = self.branch.get_config()
585
 
 
586
 
    def check_append_revisions_only(self, expected_value, value=None):
587
 
        """Set append_revisions_only in config and check its interpretation."""
588
 
        if value is not None:
589
 
            self.config.set_user_option('append_revisions_only', value)
590
 
        self.assertEqual(expected_value,
591
 
                         self.branch._get_append_revisions_only())
592
 
 
593
 
    def test_valid_append_revisions_only(self):
594
 
        self.assertEquals(None,
595
 
                          self.config.get_user_option('append_revisions_only'))
596
 
        self.check_append_revisions_only(None)
597
 
        self.check_append_revisions_only(False, 'False')
598
 
        self.check_append_revisions_only(True, 'True')
599
 
        # The following values will cause compatibility problems on projects
600
 
        # using older bzr versions (<2.2) but are accepted
601
 
        self.check_append_revisions_only(False, 'false')
602
 
        self.check_append_revisions_only(True, 'true')
603
 
 
604
 
    def test_invalid_append_revisions_only(self):
605
 
        """Ensure warning is noted on invalid settings"""
606
 
        self.warnings = []
607
 
        def warning(*args):
608
 
            self.warnings.append(args[0] % args[1:])
609
 
        self.overrideAttr(trace, 'warning', warning)
610
 
        self.check_append_revisions_only(None, 'not-a-bool')
611
 
        self.assertLength(1, self.warnings)
612
 
        self.assertEqual(
613
 
            'Value "not-a-bool" is not a boolean for "append_revisions_only"',
614
 
            self.warnings[0])
615
 
 
616
 
 
617
 
class TestPullResult(tests.TestCase):
 
428
            BranchHooks)
 
429
 
 
430
 
 
431
class TestPullResult(TestCase):
618
432
 
619
433
    def test_pull_result_to_int(self):
620
434
        # to support old code, the pull result can be used as an int
621
 
        r = _mod_branch.PullResult()
 
435
        r = PullResult()
622
436
        r.old_revno = 10
623
437
        r.new_revno = 20
624
438
        # this usage of results is not recommended for new code (because it
627
441
        a = "%d revisions pulled" % r
628
442
        self.assertEqual(a, "10 revisions pulled")
629
443
 
630
 
    def test_report_changed(self):
631
 
        r = _mod_branch.PullResult()
632
 
        r.old_revid = "old-revid"
633
 
        r.old_revno = 10
634
 
        r.new_revid = "new-revid"
635
 
        r.new_revno = 20
636
 
        f = StringIO()
637
 
        r.report(f)
638
 
        self.assertEqual("Now on revision 20.\n", f.getvalue())
639
 
 
640
 
    def test_report_unchanged(self):
641
 
        r = _mod_branch.PullResult()
642
 
        r.old_revid = "same-revid"
643
 
        r.new_revid = "same-revid"
644
 
        f = StringIO()
645
 
        r.report(f)
646
 
        self.assertEqual("No revisions to pull.\n", f.getvalue())
647
444
 
648
445
 
649
446
class _StubLockable(object):
670
467
    """Helper for TestRunWithWriteLockedTarget."""
671
468
 
672
469
 
673
 
class TestRunWithWriteLockedTarget(tests.TestCase):
 
470
class TestRunWithWriteLockedTarget(TestCase):
674
471
    """Tests for _run_with_write_locked_target."""
675
472
 
676
473
    def setUp(self):
677
 
        tests.TestCase.setUp(self)
 
474
        TestCase.setUp(self)
678
475
        self._calls = []
679
476
 
680
477
    def func_that_returns_ok(self):
687
484
 
688
485
    def test_success_unlocks(self):
689
486
        lockable = _StubLockable(self._calls)
690
 
        result = _mod_branch._run_with_write_locked_target(
 
487
        result = _run_with_write_locked_target(
691
488
            lockable, self.func_that_returns_ok)
692
489
        self.assertEqual('ok', result)
693
490
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
695
492
    def test_exception_unlocks_and_propagates(self):
696
493
        lockable = _StubLockable(self._calls)
697
494
        self.assertRaises(_ErrorFromCallable,
698
 
                          _mod_branch._run_with_write_locked_target,
699
 
                          lockable, self.func_that_raises)
 
495
            _run_with_write_locked_target, lockable, self.func_that_raises)
700
496
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
701
497
 
702
498
    def test_callable_succeeds_but_error_during_unlock(self):
703
499
        lockable = _StubLockable(self._calls, unlock_exc=_ErrorFromUnlock())
704
500
        self.assertRaises(_ErrorFromUnlock,
705
 
                          _mod_branch._run_with_write_locked_target,
706
 
                          lockable, self.func_that_returns_ok)
 
501
            _run_with_write_locked_target, lockable, self.func_that_returns_ok)
707
502
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
708
503
 
709
504
    def test_error_during_unlock_does_not_mask_original_error(self):
710
505
        lockable = _StubLockable(self._calls, unlock_exc=_ErrorFromUnlock())
711
506
        self.assertRaises(_ErrorFromCallable,
712
 
                          _mod_branch._run_with_write_locked_target,
713
 
                          lockable, self.func_that_raises)
 
507
            _run_with_write_locked_target, lockable, self.func_that_raises)
714
508
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
715
509
 
716
510