← 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: 2010-09-01 08:02:42 UTC
  • mfrom: (5390.3.3 faster-revert-593560)
  • Revision ID: pqm@pqm.ubuntu.com-20100901080242-esg62ody4frwmy66
(spiv) Avoid repeatedly calling self.target.all_file_ids() in
 InterTree.iter_changes. (Andrew Bennetts)

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
16
16
 
17
17
"""Tests for the Branch facility that are not interface  tests.
18
18
 
19
 
For interface tests see tests/branch_implementations/*.py.
 
19
For interface tests see tests/per_branch/*.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 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
 
        from bzrlib.config import (locations_config_filename,
109
 
                                   ensure_config_dir_exists)
110
 
        ensure_config_dir_exists()
111
 
        fn = locations_config_filename()
112
 
        # write correct newlines to locations.conf
113
 
        # by default ConfigObj uses native line-endings for new files
114
 
        # but uses already existing line-endings if file is not empty
115
 
        f = open(fn, 'wb')
116
 
        try:
117
 
            f.write('# comment\n')
118
 
        finally:
119
 
            f.close()
 
89
        conf = config.LocationConfig.from_string('# comment\n', '.', save=True)
120
90
 
121
91
        branch = self.make_branch('.', format='knit')
122
92
        branch.set_push_location('foo')
125
95
                             "[%s]\n"
126
96
                             "push_location = foo\n"
127
97
                             "push_location:policy = norecurse\n" % local_path,
128
 
                             fn)
 
98
                             config.locations_config_filename())
129
99
 
130
100
    # TODO RBC 20051029 test getting a push location from a branch in a
131
101
    # recursive section - that is, it appends the branch name.
132
102
 
133
103
 
134
 
class SampleBranchFormat(BranchFormat):
 
104
class SampleBranchFormat(_mod_branch.BranchFormat):
135
105
    """A sample format
136
106
 
137
107
    this format is initializable, unsupported to aid in testing the
142
112
        """See BzrBranchFormat.get_format_string()."""
143
113
        return "Sample branch format."
144
114
 
145
 
    def initialize(self, a_bzrdir):
 
115
    def initialize(self, a_bzrdir, name=None):
146
116
        """Format 4 branches cannot be created."""
147
 
        t = a_bzrdir.get_branch_transport(self)
 
117
        t = a_bzrdir.get_branch_transport(self, name=name)
148
118
        t.put_bytes('format', self.get_format_string())
149
119
        return 'A branch'
150
120
 
151
121
    def is_supported(self):
152
122
        return False
153
123
 
154
 
    def open(self, transport, _found=False, ignore_fallbacks=False):
 
124
    def open(self, transport, name=None, _found=False, ignore_fallbacks=False):
155
125
        return "opened branch."
156
126
 
157
127
 
158
 
class TestBzrBranchFormat(TestCaseWithTransport):
 
128
# Demonstrating how lazy loading is often implemented:
 
129
# A constant string is created.
 
130
SampleSupportedBranchFormatString = "Sample supported branch format."
 
131
 
 
132
# And the format class can then reference the constant to avoid skew.
 
133
class SampleSupportedBranchFormat(_mod_branch.BranchFormat):
 
134
    """A sample supported format."""
 
135
 
 
136
    def get_format_string(self):
 
137
        """See BzrBranchFormat.get_format_string()."""
 
138
        return SampleSupportedBranchFormatString
 
139
 
 
140
    def initialize(self, a_bzrdir, name=None):
 
141
        t = a_bzrdir.get_branch_transport(self, name=name)
 
142
        t.put_bytes('format', self.get_format_string())
 
143
        return 'A branch'
 
144
 
 
145
    def open(self, transport, name=None, _found=False, ignore_fallbacks=False):
 
146
        return "opened supported branch."
 
147
 
 
148
 
 
149
class TestBzrBranchFormat(tests.TestCaseWithTransport):
159
150
    """Tests for the BzrBranchFormat facility."""
160
151
 
161
152
    def test_find_format(self):
167
158
            dir = format._matchingbzrdir.initialize(url)
168
159
            dir.create_repository()
169
160
            format.initialize(dir)
170
 
            found_format = BranchFormat.find_format(dir)
 
161
            found_format = _mod_branch.BranchFormat.find_format(dir)
171
162
            self.failUnless(isinstance(found_format, format.__class__))
172
 
        check_format(BzrBranchFormat5(), "bar")
 
163
        check_format(_mod_branch.BzrBranchFormat5(), "bar")
 
164
 
 
165
    def test_find_format_factory(self):
 
166
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
 
167
        SampleSupportedBranchFormat().initialize(dir)
 
168
        factory = _mod_branch.MetaDirBranchFormatFactory(
 
169
            SampleSupportedBranchFormatString,
 
170
            "bzrlib.tests.test_branch", "SampleSupportedBranchFormat")
 
171
        _mod_branch.BranchFormat.register_format(factory)
 
172
        self.addCleanup(_mod_branch.BranchFormat.unregister_format, factory)
 
173
        b = _mod_branch.Branch.open(self.get_url())
 
174
        self.assertEqual(b, "opened supported branch.")
173
175
 
174
176
    def test_find_format_not_branch(self):
175
177
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
176
 
        self.assertRaises(NotBranchError,
177
 
                          BranchFormat.find_format,
 
178
        self.assertRaises(errors.NotBranchError,
 
179
                          _mod_branch.BranchFormat.find_format,
178
180
                          dir)
179
181
 
180
182
    def test_find_format_unknown_format(self):
181
183
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
182
184
        SampleBranchFormat().initialize(dir)
183
 
        self.assertRaises(UnknownFormatError,
184
 
                          BranchFormat.find_format,
 
185
        self.assertRaises(errors.UnknownFormatError,
 
186
                          _mod_branch.BranchFormat.find_format,
185
187
                          dir)
186
188
 
187
189
    def test_register_unregister_format(self):
191
193
        # make a branch
192
194
        format.initialize(dir)
193
195
        # register a format for it.
194
 
        BranchFormat.register_format(format)
 
196
        _mod_branch.BranchFormat.register_format(format)
195
197
        # which branch.Open will refuse (not supported)
196
 
        self.assertRaises(UnsupportedFormatError, Branch.open, self.get_url())
 
198
        self.assertRaises(errors.UnsupportedFormatError,
 
199
                          _mod_branch.Branch.open, self.get_url())
197
200
        self.make_branch_and_tree('foo')
198
201
        # but open_downlevel will work
199
 
        self.assertEqual(format.open(dir), bzrdir.BzrDir.open(self.get_url()).open_branch(unsupported=True))
 
202
        self.assertEqual(
 
203
            format.open(dir),
 
204
            bzrdir.BzrDir.open(self.get_url()).open_branch(unsupported=True))
200
205
        # unregister the format
201
 
        BranchFormat.unregister_format(format)
 
206
        _mod_branch.BranchFormat.unregister_format(format)
202
207
        self.make_branch_and_tree('bar')
203
208
 
204
209
 
 
210
#Used by TestMetaDirBranchFormatFactory 
 
211
FakeLazyFormat = None
 
212
 
 
213
 
 
214
class TestMetaDirBranchFormatFactory(tests.TestCase):
 
215
 
 
216
    def test_get_format_string_does_not_load(self):
 
217
        """Formats have a static format string."""
 
218
        factory = _mod_branch.MetaDirBranchFormatFactory("yo", None, None)
 
219
        self.assertEqual("yo", factory.get_format_string())
 
220
 
 
221
    def test_call_loads(self):
 
222
        # __call__ is used by the network_format_registry interface to get a
 
223
        # Format.
 
224
        global FakeLazyFormat
 
225
        del FakeLazyFormat
 
226
        factory = _mod_branch.MetaDirBranchFormatFactory(None,
 
227
            "bzrlib.tests.test_branch", "FakeLazyFormat")
 
228
        self.assertRaises(AttributeError, factory)
 
229
 
 
230
    def test_call_returns_call_of_referenced_object(self):
 
231
        global FakeLazyFormat
 
232
        FakeLazyFormat = lambda:'called'
 
233
        factory = _mod_branch.MetaDirBranchFormatFactory(None,
 
234
            "bzrlib.tests.test_branch", "FakeLazyFormat")
 
235
        self.assertEqual('called', factory())
 
236
 
 
237
 
205
238
class TestBranch67(object):
206
239
    """Common tests for both branch 6 and 7 which are mostly the same."""
207
240
 
215
248
        raise NotImplementedError(self.get_class)
216
249
 
217
250
    def test_creation(self):
218
 
        format = BzrDirMetaFormat1()
 
251
        format = bzrdir.BzrDirMetaFormat1()
219
252
        format.set_branch_format(_mod_branch.BzrBranchFormat6())
220
253
        branch = self.make_branch('a', format=format)
221
254
        self.assertIsInstance(branch, self.get_class())
228
261
        branch = self.make_branch('a', format=self.get_format_name())
229
262
        self.failUnlessExists('a/.bzr/branch/last-revision')
230
263
        self.failIfExists('a/.bzr/branch/revision-history')
 
264
        self.failIfExists('a/.bzr/branch/references')
231
265
 
232
266
    def test_config(self):
233
267
        """Ensure that all configuration data is stored in the branch"""
307
341
                         'locations.conf')
308
342
 
309
343
 
310
 
class TestBranch6(TestBranch67, TestCaseWithTransport):
 
344
class TestBranch6(TestBranch67, tests.TestCaseWithTransport):
311
345
 
312
346
    def get_class(self):
313
347
        return _mod_branch.BzrBranch6
328
362
        self.assertRaises(errors.UnstackableBranchFormat, branch.get_stacked_on_url)
329
363
 
330
364
 
331
 
class TestBranch7(TestBranch67, TestCaseWithTransport):
 
365
class TestBranch7(TestBranch67, tests.TestCaseWithTransport):
332
366
 
333
367
    def get_class(self):
334
368
        return _mod_branch.BzrBranch7
335
369
 
336
370
    def get_format_name(self):
337
 
        return "development"
 
371
        return "1.9"
338
372
 
339
373
    def get_format_name_subtree(self):
340
374
        return "development-subtree"
378
412
        self.assertTrue(branch.repository.has_revision(revid))
379
413
 
380
414
 
381
 
class TestBranchReference(TestCaseWithTransport):
 
415
class BzrBranch8(tests.TestCaseWithTransport):
 
416
 
 
417
    def make_branch(self, location, format=None):
 
418
        if format is None:
 
419
            format = bzrdir.format_registry.make_bzrdir('1.9')
 
420
            format.set_branch_format(_mod_branch.BzrBranchFormat8())
 
421
        return tests.TestCaseWithTransport.make_branch(
 
422
            self, location, format=format)
 
423
 
 
424
    def create_branch_with_reference(self):
 
425
        branch = self.make_branch('branch')
 
426
        branch._set_all_reference_info({'file-id': ('path', 'location')})
 
427
        return branch
 
428
 
 
429
    @staticmethod
 
430
    def instrument_branch(branch, gets):
 
431
        old_get = branch._transport.get
 
432
        def get(*args, **kwargs):
 
433
            gets.append((args, kwargs))
 
434
            return old_get(*args, **kwargs)
 
435
        branch._transport.get = get
 
436
 
 
437
    def test_reference_info_caching_read_locked(self):
 
438
        gets = []
 
439
        branch = self.create_branch_with_reference()
 
440
        branch.lock_read()
 
441
        self.addCleanup(branch.unlock)
 
442
        self.instrument_branch(branch, gets)
 
443
        branch.get_reference_info('file-id')
 
444
        branch.get_reference_info('file-id')
 
445
        self.assertEqual(1, len(gets))
 
446
 
 
447
    def test_reference_info_caching_read_unlocked(self):
 
448
        gets = []
 
449
        branch = self.create_branch_with_reference()
 
450
        self.instrument_branch(branch, gets)
 
451
        branch.get_reference_info('file-id')
 
452
        branch.get_reference_info('file-id')
 
453
        self.assertEqual(2, len(gets))
 
454
 
 
455
    def test_reference_info_caching_write_locked(self):
 
456
        gets = []
 
457
        branch = self.make_branch('branch')
 
458
        branch.lock_write()
 
459
        self.instrument_branch(branch, gets)
 
460
        self.addCleanup(branch.unlock)
 
461
        branch._set_all_reference_info({'file-id': ('path2', 'location2')})
 
462
        path, location = branch.get_reference_info('file-id')
 
463
        self.assertEqual(0, len(gets))
 
464
        self.assertEqual('path2', path)
 
465
        self.assertEqual('location2', location)
 
466
 
 
467
    def test_reference_info_caches_cleared(self):
 
468
        branch = self.make_branch('branch')
 
469
        branch.lock_write()
 
470
        branch.set_reference_info('file-id', 'path2', 'location2')
 
471
        branch.unlock()
 
472
        doppelganger = _mod_branch.Branch.open('branch')
 
473
        doppelganger.set_reference_info('file-id', 'path3', 'location3')
 
474
        self.assertEqual(('path3', 'location3'),
 
475
                         branch.get_reference_info('file-id'))
 
476
 
 
477
class TestBranchReference(tests.TestCaseWithTransport):
382
478
    """Tests for the branch reference facility."""
383
479
 
384
480
    def test_create_open_reference(self):
385
481
        bzrdirformat = bzrdir.BzrDirMetaFormat1()
386
 
        t = get_transport(self.get_url('.'))
 
482
        t = transport.get_transport(self.get_url('.'))
387
483
        t.mkdir('repo')
388
484
        dir = bzrdirformat.initialize(self.get_url('repo'))
389
485
        dir.create_repository()
390
486
        target_branch = dir.create_branch()
391
487
        t.mkdir('branch')
392
488
        branch_dir = bzrdirformat.initialize(self.get_url('branch'))
393
 
        made_branch = BranchReferenceFormat().initialize(branch_dir, target_branch)
 
489
        made_branch = _mod_branch.BranchReferenceFormat().initialize(
 
490
            branch_dir, target_branch=target_branch)
394
491
        self.assertEqual(made_branch.base, target_branch.base)
395
492
        opened_branch = branch_dir.open_branch()
396
493
        self.assertEqual(opened_branch.base, target_branch.base)
407
504
            _mod_branch.BranchReferenceFormat().get_reference(checkout.bzrdir))
408
505
 
409
506
 
410
 
class TestHooks(TestCase):
 
507
class TestHooks(tests.TestCaseWithTransport):
411
508
 
412
509
    def test_constructor(self):
413
510
        """Check that creating a BranchHooks instance has the right defaults."""
414
 
        hooks = BranchHooks()
 
511
        hooks = _mod_branch.BranchHooks()
415
512
        self.assertTrue("set_rh" in hooks, "set_rh not in %s" % hooks)
416
513
        self.assertTrue("post_push" in hooks, "post_push not in %s" % hooks)
417
514
        self.assertTrue("post_commit" in hooks, "post_commit not in %s" % hooks)
418
515
        self.assertTrue("pre_commit" in hooks, "pre_commit not in %s" % hooks)
419
516
        self.assertTrue("post_pull" in hooks, "post_pull not in %s" % hooks)
420
 
        self.assertTrue("post_uncommit" in hooks, "post_uncommit not in %s" % hooks)
 
517
        self.assertTrue("post_uncommit" in hooks,
 
518
                        "post_uncommit not in %s" % hooks)
421
519
        self.assertTrue("post_change_branch_tip" in hooks,
422
520
                        "post_change_branch_tip not in %s" % hooks)
 
521
        self.assertTrue("post_branch_init" in hooks,
 
522
                        "post_branch_init not in %s" % hooks)
 
523
        self.assertTrue("post_switch" in hooks,
 
524
                        "post_switch not in %s" % hooks)
423
525
 
424
526
    def test_installed_hooks_are_BranchHooks(self):
425
527
        """The installed hooks object should be a BranchHooks."""
426
528
        # the installed hooks are saved in self._preserved_hooks.
427
529
        self.assertIsInstance(self._preserved_hooks[_mod_branch.Branch][1],
428
 
            BranchHooks)
429
 
 
430
 
 
431
 
class TestPullResult(TestCase):
 
530
                              _mod_branch.BranchHooks)
 
531
 
 
532
    def test_post_branch_init_hook(self):
 
533
        calls = []
 
534
        _mod_branch.Branch.hooks.install_named_hook('post_branch_init',
 
535
            calls.append, None)
 
536
        self.assertLength(0, calls)
 
537
        branch = self.make_branch('a')
 
538
        self.assertLength(1, calls)
 
539
        params = calls[0]
 
540
        self.assertIsInstance(params, _mod_branch.BranchInitHookParams)
 
541
        self.assertTrue(hasattr(params, 'bzrdir'))
 
542
        self.assertTrue(hasattr(params, 'branch'))
 
543
 
 
544
    def test_post_branch_init_hook_repr(self):
 
545
        param_reprs = []
 
546
        _mod_branch.Branch.hooks.install_named_hook('post_branch_init',
 
547
            lambda params: param_reprs.append(repr(params)), None)
 
548
        branch = self.make_branch('a')
 
549
        self.assertLength(1, param_reprs)
 
550
        param_repr = param_reprs[0]
 
551
        self.assertStartsWith(param_repr, '<BranchInitHookParams of ')
 
552
 
 
553
    def test_post_switch_hook(self):
 
554
        from bzrlib import switch
 
555
        calls = []
 
556
        _mod_branch.Branch.hooks.install_named_hook('post_switch',
 
557
            calls.append, None)
 
558
        tree = self.make_branch_and_tree('branch-1')
 
559
        self.build_tree(['branch-1/file-1'])
 
560
        tree.add('file-1')
 
561
        tree.commit('rev1')
 
562
        to_branch = tree.bzrdir.sprout('branch-2').open_branch()
 
563
        self.build_tree(['branch-1/file-2'])
 
564
        tree.add('file-2')
 
565
        tree.remove('file-1')
 
566
        tree.commit('rev2')
 
567
        checkout = tree.branch.create_checkout('checkout')
 
568
        self.assertLength(0, calls)
 
569
        switch.switch(checkout.bzrdir, to_branch)
 
570
        self.assertLength(1, calls)
 
571
        params = calls[0]
 
572
        self.assertIsInstance(params, _mod_branch.SwitchHookParams)
 
573
        self.assertTrue(hasattr(params, 'to_branch'))
 
574
        self.assertTrue(hasattr(params, 'revision_id'))
 
575
 
 
576
 
 
577
class TestBranchOptions(tests.TestCaseWithTransport):
 
578
 
 
579
    def setUp(self):
 
580
        super(TestBranchOptions, self).setUp()
 
581
        self.branch = self.make_branch('.')
 
582
        self.config = self.branch.get_config()
 
583
 
 
584
    def check_append_revisions_only(self, expected_value, value=None):
 
585
        """Set append_revisions_only in config and check its interpretation."""
 
586
        if value is not None:
 
587
            self.config.set_user_option('append_revisions_only', value)
 
588
        self.assertEqual(expected_value,
 
589
                         self.branch._get_append_revisions_only())
 
590
 
 
591
    def test_valid_append_revisions_only(self):
 
592
        self.assertEquals(None,
 
593
                          self.config.get_user_option('append_revisions_only'))
 
594
        self.check_append_revisions_only(None)
 
595
        self.check_append_revisions_only(False, 'False')
 
596
        self.check_append_revisions_only(True, 'True')
 
597
        # The following values will cause compatibility problems on projects
 
598
        # using older bzr versions (<2.2) but are accepted
 
599
        self.check_append_revisions_only(False, 'false')
 
600
        self.check_append_revisions_only(True, 'true')
 
601
 
 
602
    def test_invalid_append_revisions_only(self):
 
603
        """Ensure warning is noted on invalid settings"""
 
604
        self.warnings = []
 
605
        def warning(*args):
 
606
            self.warnings.append(args[0] % args[1:])
 
607
        self.overrideAttr(trace, 'warning', warning)
 
608
        self.check_append_revisions_only(None, 'not-a-bool')
 
609
        self.assertLength(1, self.warnings)
 
610
        self.assertEqual(
 
611
            'Value "not-a-bool" is not a boolean for "append_revisions_only"',
 
612
            self.warnings[0])
 
613
 
 
614
 
 
615
class TestPullResult(tests.TestCase):
432
616
 
433
617
    def test_pull_result_to_int(self):
434
618
        # to support old code, the pull result can be used as an int
435
 
        r = PullResult()
 
619
        r = _mod_branch.PullResult()
436
620
        r.old_revno = 10
437
621
        r.new_revno = 20
438
622
        # this usage of results is not recommended for new code (because it
441
625
        a = "%d revisions pulled" % r
442
626
        self.assertEqual(a, "10 revisions pulled")
443
627
 
 
628
    def test_report_changed(self):
 
629
        r = _mod_branch.PullResult()
 
630
        r.old_revid = "old-revid"
 
631
        r.old_revno = 10
 
632
        r.new_revid = "new-revid"
 
633
        r.new_revno = 20
 
634
        f = StringIO()
 
635
        r.report(f)
 
636
        self.assertEqual("Now on revision 20.\n", f.getvalue())
 
637
 
 
638
    def test_report_unchanged(self):
 
639
        r = _mod_branch.PullResult()
 
640
        r.old_revid = "same-revid"
 
641
        r.new_revid = "same-revid"
 
642
        f = StringIO()
 
643
        r.report(f)
 
644
        self.assertEqual("No revisions to pull.\n", f.getvalue())
444
645
 
445
646
 
446
647
class _StubLockable(object):
467
668
    """Helper for TestRunWithWriteLockedTarget."""
468
669
 
469
670
 
470
 
class TestRunWithWriteLockedTarget(TestCase):
 
671
class TestRunWithWriteLockedTarget(tests.TestCase):
471
672
    """Tests for _run_with_write_locked_target."""
472
673
 
473
674
    def setUp(self):
474
 
        TestCase.setUp(self)
 
675
        tests.TestCase.setUp(self)
475
676
        self._calls = []
476
677
 
477
678
    def func_that_returns_ok(self):
484
685
 
485
686
    def test_success_unlocks(self):
486
687
        lockable = _StubLockable(self._calls)
487
 
        result = _run_with_write_locked_target(
 
688
        result = _mod_branch._run_with_write_locked_target(
488
689
            lockable, self.func_that_returns_ok)
489
690
        self.assertEqual('ok', result)
490
691
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
492
693
    def test_exception_unlocks_and_propagates(self):
493
694
        lockable = _StubLockable(self._calls)
494
695
        self.assertRaises(_ErrorFromCallable,
495
 
            _run_with_write_locked_target, lockable, self.func_that_raises)
 
696
                          _mod_branch._run_with_write_locked_target,
 
697
                          lockable, self.func_that_raises)
496
698
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
497
699
 
498
700
    def test_callable_succeeds_but_error_during_unlock(self):
499
701
        lockable = _StubLockable(self._calls, unlock_exc=_ErrorFromUnlock())
500
702
        self.assertRaises(_ErrorFromUnlock,
501
 
            _run_with_write_locked_target, lockable, self.func_that_returns_ok)
 
703
                          _mod_branch._run_with_write_locked_target,
 
704
                          lockable, self.func_that_returns_ok)
502
705
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
503
706
 
504
707
    def test_error_during_unlock_does_not_mask_original_error(self):
505
708
        lockable = _StubLockable(self._calls, unlock_exc=_ErrorFromUnlock())
506
709
        self.assertRaises(_ErrorFromCallable,
507
 
            _run_with_write_locked_target, lockable, self.func_that_raises)
 
710
                          _mod_branch._run_with_write_locked_target,
 
711
                          lockable, self.func_that_raises)
508
712
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
509
713
 
510
714