← 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: Patch Queue Manager
  • Date: 2011-10-14 16:54:26 UTC
  • mfrom: (6216.1.1 remove-this-file)
  • Revision ID: pqm@pqm.ubuntu.com-20111014165426-tjix4e6idryf1r2z
(jelmer) Remove an accidentally committed .THIS file. (Jelmer Vernooij)

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-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
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/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
    symbol_versioning,
 
33
    tests,
32
34
    trace,
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.format_registry.get_default(),
 
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.format_registry.get_default(),
 
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.format_registry.get_default()
 
57
        _mod_branch.format_registry.set_default(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.format_registry.set_default(old_format)
 
66
        self.assertEqual(old_format,
 
67
                         _mod_branch.format_registry.get_default())
 
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 = _mod_branch.BzrBranchFormat5().initialize(bdir)
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, repository=None,
 
116
                   append_revisions_only=None):
146
117
        """Format 4 branches cannot be created."""
147
 
        t = a_bzrdir.get_branch_transport(self)
 
118
        t = a_bzrdir.get_branch_transport(self, name=name)
148
119
        t.put_bytes('format', self.get_format_string())
149
120
        return 'A branch'
150
121
 
151
122
    def is_supported(self):
152
123
        return False
153
124
 
154
 
    def open(self, transport, _found=False, ignore_fallbacks=False):
 
125
    def open(self, transport, name=None, _found=False, ignore_fallbacks=False):
155
126
        return "opened branch."
156
127
 
157
128
 
158
 
class TestBzrBranchFormat(TestCaseWithTransport):
 
129
# Demonstrating how lazy loading is often implemented:
 
130
# A constant string is created.
 
131
SampleSupportedBranchFormatString = "Sample supported branch format."
 
132
 
 
133
# And the format class can then reference the constant to avoid skew.
 
134
class SampleSupportedBranchFormat(_mod_branch.BranchFormat):
 
135
    """A sample supported format."""
 
136
 
 
137
    def get_format_string(self):
 
138
        """See BzrBranchFormat.get_format_string()."""
 
139
        return SampleSupportedBranchFormatString
 
140
 
 
141
    def initialize(self, a_bzrdir, name=None, append_revisions_only=None):
 
142
        t = a_bzrdir.get_branch_transport(self, name=name)
 
143
        t.put_bytes('format', self.get_format_string())
 
144
        return 'A branch'
 
145
 
 
146
    def open(self, transport, name=None, _found=False, ignore_fallbacks=False):
 
147
        return "opened supported branch."
 
148
 
 
149
 
 
150
class SampleExtraBranchFormat(_mod_branch.BranchFormat):
 
151
    """A sample format that is not usable in a metadir."""
 
152
 
 
153
    def get_format_string(self):
 
154
        # This format is not usable in a metadir.
 
155
        return None
 
156
 
 
157
    def network_name(self):
 
158
        # Network name always has to be provided.
 
159
        return "extra"
 
160
 
 
161
    def initialize(self, a_bzrdir, name=None):
 
162
        raise NotImplementedError(self.initialize)
 
163
 
 
164
    def open(self, transport, name=None, _found=False, ignore_fallbacks=False):
 
165
        raise NotImplementedError(self.open)
 
166
 
 
167
 
 
168
class TestBzrBranchFormat(tests.TestCaseWithTransport):
159
169
    """Tests for the BzrBranchFormat facility."""
160
170
 
161
171
    def test_find_format(self):
167
177
            dir = format._matchingbzrdir.initialize(url)
168
178
            dir.create_repository()
169
179
            format.initialize(dir)
170
 
            found_format = BranchFormat.find_format(dir)
171
 
            self.failUnless(isinstance(found_format, format.__class__))
172
 
        check_format(BzrBranchFormat5(), "bar")
 
180
            found_format = _mod_branch.BranchFormat.find_format(dir)
 
181
            self.assertIsInstance(found_format, format.__class__)
 
182
        check_format(_mod_branch.BzrBranchFormat5(), "bar")
 
183
 
 
184
    def test_find_format_factory(self):
 
185
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
 
186
        SampleSupportedBranchFormat().initialize(dir)
 
187
        factory = _mod_branch.MetaDirBranchFormatFactory(
 
188
            SampleSupportedBranchFormatString,
 
189
            "bzrlib.tests.test_branch", "SampleSupportedBranchFormat")
 
190
        _mod_branch.format_registry.register(factory)
 
191
        self.addCleanup(_mod_branch.format_registry.remove, factory)
 
192
        b = _mod_branch.Branch.open(self.get_url())
 
193
        self.assertEqual(b, "opened supported branch.")
173
194
 
174
195
    def test_find_format_not_branch(self):
175
196
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
176
 
        self.assertRaises(NotBranchError,
177
 
                          BranchFormat.find_format,
 
197
        self.assertRaises(errors.NotBranchError,
 
198
                          _mod_branch.BranchFormat.find_format,
178
199
                          dir)
179
200
 
180
201
    def test_find_format_unknown_format(self):
181
202
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
182
203
        SampleBranchFormat().initialize(dir)
183
 
        self.assertRaises(UnknownFormatError,
184
 
                          BranchFormat.find_format,
 
204
        self.assertRaises(errors.UnknownFormatError,
 
205
                          _mod_branch.BranchFormat.find_format,
185
206
                          dir)
186
207
 
187
208
    def test_register_unregister_format(self):
 
209
        # Test the deprecated format registration functions
188
210
        format = SampleBranchFormat()
189
211
        # make a control dir
190
212
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
191
213
        # make a branch
192
214
        format.initialize(dir)
193
215
        # register a format for it.
194
 
        BranchFormat.register_format(format)
 
216
        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
 
217
            _mod_branch.BranchFormat.register_format, format)
195
218
        # which branch.Open will refuse (not supported)
196
 
        self.assertRaises(UnsupportedFormatError, Branch.open, self.get_url())
 
219
        self.assertRaises(errors.UnsupportedFormatError,
 
220
                          _mod_branch.Branch.open, self.get_url())
197
221
        self.make_branch_and_tree('foo')
198
222
        # but open_downlevel will work
199
 
        self.assertEqual(format.open(dir), bzrdir.BzrDir.open(self.get_url()).open_branch(unsupported=True))
 
223
        self.assertEqual(
 
224
            format.open(dir),
 
225
            bzrdir.BzrDir.open(self.get_url()).open_branch(unsupported=True))
200
226
        # unregister the format
201
 
        BranchFormat.unregister_format(format)
 
227
        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
 
228
            _mod_branch.BranchFormat.unregister_format, format)
202
229
        self.make_branch_and_tree('bar')
203
230
 
204
231
 
 
232
class TestBranchFormatRegistry(tests.TestCase):
 
233
 
 
234
    def setUp(self):
 
235
        super(TestBranchFormatRegistry, self).setUp()
 
236
        self.registry = _mod_branch.BranchFormatRegistry()
 
237
 
 
238
    def test_default(self):
 
239
        self.assertIs(None, self.registry.get_default())
 
240
        format = SampleBranchFormat()
 
241
        self.registry.set_default(format)
 
242
        self.assertEquals(format, self.registry.get_default())
 
243
 
 
244
    def test_register_unregister_format(self):
 
245
        format = SampleBranchFormat()
 
246
        self.registry.register(format)
 
247
        self.assertEquals(format,
 
248
            self.registry.get("Sample branch format."))
 
249
        self.registry.remove(format)
 
250
        self.assertRaises(KeyError, self.registry.get,
 
251
            "Sample branch format.")
 
252
 
 
253
    def test_get_all(self):
 
254
        format = SampleBranchFormat()
 
255
        self.assertEquals([], self.registry._get_all())
 
256
        self.registry.register(format)
 
257
        self.assertEquals([format], self.registry._get_all())
 
258
 
 
259
    def test_register_extra(self):
 
260
        format = SampleExtraBranchFormat()
 
261
        self.assertEquals([], self.registry._get_all())
 
262
        self.registry.register_extra(format)
 
263
        self.assertEquals([format], self.registry._get_all())
 
264
 
 
265
    def test_register_extra_lazy(self):
 
266
        self.assertEquals([], self.registry._get_all())
 
267
        self.registry.register_extra_lazy("bzrlib.tests.test_branch",
 
268
            "SampleExtraBranchFormat")
 
269
        formats = self.registry._get_all()
 
270
        self.assertEquals(1, len(formats))
 
271
        self.assertIsInstance(formats[0], SampleExtraBranchFormat)
 
272
 
 
273
 
 
274
#Used by TestMetaDirBranchFormatFactory 
 
275
FakeLazyFormat = None
 
276
 
 
277
 
 
278
class TestMetaDirBranchFormatFactory(tests.TestCase):
 
279
 
 
280
    def test_get_format_string_does_not_load(self):
 
281
        """Formats have a static format string."""
 
282
        factory = _mod_branch.MetaDirBranchFormatFactory("yo", None, None)
 
283
        self.assertEqual("yo", factory.get_format_string())
 
284
 
 
285
    def test_call_loads(self):
 
286
        # __call__ is used by the network_format_registry interface to get a
 
287
        # Format.
 
288
        global FakeLazyFormat
 
289
        del FakeLazyFormat
 
290
        factory = _mod_branch.MetaDirBranchFormatFactory(None,
 
291
            "bzrlib.tests.test_branch", "FakeLazyFormat")
 
292
        self.assertRaises(AttributeError, factory)
 
293
 
 
294
    def test_call_returns_call_of_referenced_object(self):
 
295
        global FakeLazyFormat
 
296
        FakeLazyFormat = lambda:'called'
 
297
        factory = _mod_branch.MetaDirBranchFormatFactory(None,
 
298
            "bzrlib.tests.test_branch", "FakeLazyFormat")
 
299
        self.assertEqual('called', factory())
 
300
 
 
301
 
205
302
class TestBranch67(object):
206
303
    """Common tests for both branch 6 and 7 which are mostly the same."""
207
304
 
215
312
        raise NotImplementedError(self.get_class)
216
313
 
217
314
    def test_creation(self):
218
 
        format = BzrDirMetaFormat1()
 
315
        format = bzrdir.BzrDirMetaFormat1()
219
316
        format.set_branch_format(_mod_branch.BzrBranchFormat6())
220
317
        branch = self.make_branch('a', format=format)
221
318
        self.assertIsInstance(branch, self.get_class())
226
323
 
227
324
    def test_layout(self):
228
325
        branch = self.make_branch('a', format=self.get_format_name())
229
 
        self.failUnlessExists('a/.bzr/branch/last-revision')
230
 
        self.failIfExists('a/.bzr/branch/revision-history')
231
 
        self.failIfExists('a/.bzr/branch/references')
 
326
        self.assertPathExists('a/.bzr/branch/last-revision')
 
327
        self.assertPathDoesNotExist('a/.bzr/branch/revision-history')
 
328
        self.assertPathDoesNotExist('a/.bzr/branch/references')
232
329
 
233
330
    def test_config(self):
234
331
        """Ensure that all configuration data is stored in the branch"""
235
332
        branch = self.make_branch('a', format=self.get_format_name())
236
 
        branch.set_parent('http://bazaar-vcs.org')
237
 
        self.failIfExists('a/.bzr/branch/parent')
238
 
        self.assertEqual('http://bazaar-vcs.org', branch.get_parent())
239
 
        branch.set_push_location('sftp://bazaar-vcs.org')
 
333
        branch.set_parent('http://example.com')
 
334
        self.assertPathDoesNotExist('a/.bzr/branch/parent')
 
335
        self.assertEqual('http://example.com', branch.get_parent())
 
336
        branch.set_push_location('sftp://example.com')
240
337
        config = branch.get_config()._get_branch_data_config()
241
 
        self.assertEqual('sftp://bazaar-vcs.org',
 
338
        self.assertEqual('sftp://example.com',
242
339
                         config.get_user_option('push_location'))
243
 
        branch.set_bound_location('ftp://bazaar-vcs.org')
244
 
        self.failIfExists('a/.bzr/branch/bound')
245
 
        self.assertEqual('ftp://bazaar-vcs.org', branch.get_bound_location())
 
340
        branch.set_bound_location('ftp://example.com')
 
341
        self.assertPathDoesNotExist('a/.bzr/branch/bound')
 
342
        self.assertEqual('ftp://example.com', branch.get_bound_location())
246
343
 
247
344
    def test_set_revision_history(self):
248
345
        builder = self.make_branch_builder('.', format=self.get_format_name())
253
350
        branch = builder.get_branch()
254
351
        branch.lock_write()
255
352
        self.addCleanup(branch.unlock)
256
 
        branch.set_revision_history(['foo', 'bar'])
257
 
        branch.set_revision_history(['foo'])
 
353
        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
 
354
            branch.set_revision_history, ['foo', 'bar'])
 
355
        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
 
356
                branch.set_revision_history, ['foo'])
258
357
        self.assertRaises(errors.NotLefthandHistory,
259
 
                          branch.set_revision_history, ['bar'])
 
358
            self.applyDeprecated, symbol_versioning.deprecated_in((2, 4, 0)),
 
359
            branch.set_revision_history, ['bar'])
260
360
 
261
361
    def do_checkout_test(self, lightweight=False):
262
362
        tree = self.make_branch_and_tree('source',
275
375
        subtree.commit('a subtree file')
276
376
        subsubtree.commit('a subsubtree file')
277
377
        tree.branch.create_checkout('target', lightweight=lightweight)
278
 
        self.failUnlessExists('target')
279
 
        self.failUnlessExists('target/subtree')
280
 
        self.failUnlessExists('target/subtree/file')
281
 
        self.failUnlessExists('target/subtree/subsubtree/file')
 
378
        self.assertPathExists('target')
 
379
        self.assertPathExists('target/subtree')
 
380
        self.assertPathExists('target/subtree/file')
 
381
        self.assertPathExists('target/subtree/subsubtree/file')
282
382
        subbranch = _mod_branch.Branch.open('target/subtree/subsubtree')
283
383
        if lightweight:
284
384
            self.assertEndsWith(subbranch.base, 'source/subtree/subsubtree/')
308
408
                         'locations.conf')
309
409
 
310
410
 
311
 
class TestBranch6(TestBranch67, TestCaseWithTransport):
 
411
class TestBranch6(TestBranch67, tests.TestCaseWithTransport):
312
412
 
313
413
    def get_class(self):
314
414
        return _mod_branch.BzrBranch6
329
429
        self.assertRaises(errors.UnstackableBranchFormat, branch.get_stacked_on_url)
330
430
 
331
431
 
332
 
class TestBranch7(TestBranch67, TestCaseWithTransport):
 
432
class TestBranch7(TestBranch67, tests.TestCaseWithTransport):
333
433
 
334
434
    def get_class(self):
335
435
        return _mod_branch.BzrBranch7
379
479
        self.assertTrue(branch.repository.has_revision(revid))
380
480
 
381
481
 
382
 
class BzrBranch8(TestCaseWithTransport):
 
482
class BzrBranch8(tests.TestCaseWithTransport):
383
483
 
384
484
    def make_branch(self, location, format=None):
385
485
        if format is None:
386
486
            format = bzrdir.format_registry.make_bzrdir('1.9')
387
487
            format.set_branch_format(_mod_branch.BzrBranchFormat8())
388
 
        return TestCaseWithTransport.make_branch(self, location, format=format)
 
488
        return tests.TestCaseWithTransport.make_branch(
 
489
            self, location, format=format)
389
490
 
390
491
    def create_branch_with_reference(self):
391
492
        branch = self.make_branch('branch')
435
536
        branch.lock_write()
436
537
        branch.set_reference_info('file-id', 'path2', 'location2')
437
538
        branch.unlock()
438
 
        doppelganger = Branch.open('branch')
 
539
        doppelganger = _mod_branch.Branch.open('branch')
439
540
        doppelganger.set_reference_info('file-id', 'path3', 'location3')
440
541
        self.assertEqual(('path3', 'location3'),
441
542
                         branch.get_reference_info('file-id'))
442
543
 
443
 
class TestBranchReference(TestCaseWithTransport):
 
544
    def _recordParentMapCalls(self, repo):
 
545
        self._parent_map_calls = []
 
546
        orig_get_parent_map = repo.revisions.get_parent_map
 
547
        def get_parent_map(q):
 
548
            q = list(q)
 
549
            self._parent_map_calls.extend([e[0] for e in q])
 
550
            return orig_get_parent_map(q)
 
551
        repo.revisions.get_parent_map = get_parent_map
 
552
 
 
553
 
 
554
class TestBranchReference(tests.TestCaseWithTransport):
444
555
    """Tests for the branch reference facility."""
445
556
 
446
557
    def test_create_open_reference(self):
447
558
        bzrdirformat = bzrdir.BzrDirMetaFormat1()
448
 
        t = get_transport(self.get_url('.'))
 
559
        t = self.get_transport()
449
560
        t.mkdir('repo')
450
561
        dir = bzrdirformat.initialize(self.get_url('repo'))
451
562
        dir.create_repository()
452
563
        target_branch = dir.create_branch()
453
564
        t.mkdir('branch')
454
565
        branch_dir = bzrdirformat.initialize(self.get_url('branch'))
455
 
        made_branch = BranchReferenceFormat().initialize(branch_dir, target_branch)
 
566
        made_branch = _mod_branch.BranchReferenceFormat().initialize(
 
567
            branch_dir, target_branch=target_branch)
456
568
        self.assertEqual(made_branch.base, target_branch.base)
457
569
        opened_branch = branch_dir.open_branch()
458
570
        self.assertEqual(opened_branch.base, target_branch.base)
469
581
            _mod_branch.BranchReferenceFormat().get_reference(checkout.bzrdir))
470
582
 
471
583
 
472
 
class TestHooks(TestCase):
 
584
class TestHooks(tests.TestCaseWithTransport):
473
585
 
474
586
    def test_constructor(self):
475
587
        """Check that creating a BranchHooks instance has the right defaults."""
476
 
        hooks = BranchHooks()
 
588
        hooks = _mod_branch.BranchHooks()
477
589
        self.assertTrue("set_rh" in hooks, "set_rh not in %s" % hooks)
478
590
        self.assertTrue("post_push" in hooks, "post_push not in %s" % hooks)
479
591
        self.assertTrue("post_commit" in hooks, "post_commit not in %s" % hooks)
480
592
        self.assertTrue("pre_commit" in hooks, "pre_commit not in %s" % hooks)
481
593
        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)
 
594
        self.assertTrue("post_uncommit" in hooks,
 
595
                        "post_uncommit not in %s" % hooks)
483
596
        self.assertTrue("post_change_branch_tip" in hooks,
484
597
                        "post_change_branch_tip not in %s" % hooks)
 
598
        self.assertTrue("post_branch_init" in hooks,
 
599
                        "post_branch_init not in %s" % hooks)
 
600
        self.assertTrue("post_switch" in hooks,
 
601
                        "post_switch not in %s" % hooks)
485
602
 
486
603
    def test_installed_hooks_are_BranchHooks(self):
487
604
        """The installed hooks object should be a BranchHooks."""
488
605
        # the installed hooks are saved in self._preserved_hooks.
489
606
        self.assertIsInstance(self._preserved_hooks[_mod_branch.Branch][1],
490
 
            BranchHooks)
491
 
 
492
 
 
493
 
class TestPullResult(TestCase):
 
607
                              _mod_branch.BranchHooks)
 
608
 
 
609
    def test_post_branch_init_hook(self):
 
610
        calls = []
 
611
        _mod_branch.Branch.hooks.install_named_hook('post_branch_init',
 
612
            calls.append, None)
 
613
        self.assertLength(0, calls)
 
614
        branch = self.make_branch('a')
 
615
        self.assertLength(1, calls)
 
616
        params = calls[0]
 
617
        self.assertIsInstance(params, _mod_branch.BranchInitHookParams)
 
618
        self.assertTrue(hasattr(params, 'bzrdir'))
 
619
        self.assertTrue(hasattr(params, 'branch'))
 
620
 
 
621
    def test_post_branch_init_hook_repr(self):
 
622
        param_reprs = []
 
623
        _mod_branch.Branch.hooks.install_named_hook('post_branch_init',
 
624
            lambda params: param_reprs.append(repr(params)), None)
 
625
        branch = self.make_branch('a')
 
626
        self.assertLength(1, param_reprs)
 
627
        param_repr = param_reprs[0]
 
628
        self.assertStartsWith(param_repr, '<BranchInitHookParams of ')
 
629
 
 
630
    def test_post_switch_hook(self):
 
631
        from bzrlib import switch
 
632
        calls = []
 
633
        _mod_branch.Branch.hooks.install_named_hook('post_switch',
 
634
            calls.append, None)
 
635
        tree = self.make_branch_and_tree('branch-1')
 
636
        self.build_tree(['branch-1/file-1'])
 
637
        tree.add('file-1')
 
638
        tree.commit('rev1')
 
639
        to_branch = tree.bzrdir.sprout('branch-2').open_branch()
 
640
        self.build_tree(['branch-1/file-2'])
 
641
        tree.add('file-2')
 
642
        tree.remove('file-1')
 
643
        tree.commit('rev2')
 
644
        checkout = tree.branch.create_checkout('checkout')
 
645
        self.assertLength(0, calls)
 
646
        switch.switch(checkout.bzrdir, to_branch)
 
647
        self.assertLength(1, calls)
 
648
        params = calls[0]
 
649
        self.assertIsInstance(params, _mod_branch.SwitchHookParams)
 
650
        self.assertTrue(hasattr(params, 'to_branch'))
 
651
        self.assertTrue(hasattr(params, 'revision_id'))
 
652
 
 
653
 
 
654
class TestBranchOptions(tests.TestCaseWithTransport):
 
655
 
 
656
    def setUp(self):
 
657
        super(TestBranchOptions, self).setUp()
 
658
        self.branch = self.make_branch('.')
 
659
        self.config = self.branch.get_config()
 
660
 
 
661
    def check_append_revisions_only(self, expected_value, value=None):
 
662
        """Set append_revisions_only in config and check its interpretation."""
 
663
        if value is not None:
 
664
            self.config.set_user_option('append_revisions_only', value)
 
665
        self.assertEqual(expected_value,
 
666
                         self.branch.get_append_revisions_only())
 
667
 
 
668
    def test_valid_append_revisions_only(self):
 
669
        self.assertEquals(None,
 
670
                          self.config.get_user_option('append_revisions_only'))
 
671
        self.check_append_revisions_only(None)
 
672
        self.check_append_revisions_only(False, 'False')
 
673
        self.check_append_revisions_only(True, 'True')
 
674
        # The following values will cause compatibility problems on projects
 
675
        # using older bzr versions (<2.2) but are accepted
 
676
        self.check_append_revisions_only(False, 'false')
 
677
        self.check_append_revisions_only(True, 'true')
 
678
 
 
679
    def test_invalid_append_revisions_only(self):
 
680
        """Ensure warning is noted on invalid settings"""
 
681
        self.warnings = []
 
682
        def warning(*args):
 
683
            self.warnings.append(args[0] % args[1:])
 
684
        self.overrideAttr(trace, 'warning', warning)
 
685
        self.check_append_revisions_only(None, 'not-a-bool')
 
686
        self.assertLength(1, self.warnings)
 
687
        self.assertEqual(
 
688
            'Value "not-a-bool" is not a boolean for "append_revisions_only"',
 
689
            self.warnings[0])
 
690
 
 
691
 
 
692
class TestPullResult(tests.TestCase):
494
693
 
495
694
    def test_pull_result_to_int(self):
496
695
        # to support old code, the pull result can be used as an int
497
 
        r = PullResult()
 
696
        r = _mod_branch.PullResult()
498
697
        r.old_revno = 10
499
698
        r.new_revno = 20
500
699
        # this usage of results is not recommended for new code (because it
501
700
        # doesn't describe very well what happened), but for api stability
502
701
        # it's still supported
503
 
        a = "%d revisions pulled" % r
504
 
        self.assertEqual(a, "10 revisions pulled")
505
 
 
506
 
 
507
 
 
508
 
class _StubLockable(object):
509
 
    """Helper for TestRunWithWriteLockedTarget."""
510
 
 
511
 
    def __init__(self, calls, unlock_exc=None):
512
 
        self.calls = calls
513
 
        self.unlock_exc = unlock_exc
514
 
 
515
 
    def lock_write(self):
516
 
        self.calls.append('lock_write')
517
 
 
518
 
    def unlock(self):
519
 
        self.calls.append('unlock')
520
 
        if self.unlock_exc is not None:
521
 
            raise self.unlock_exc
522
 
 
523
 
 
524
 
class _ErrorFromCallable(Exception):
525
 
    """Helper for TestRunWithWriteLockedTarget."""
526
 
 
527
 
 
528
 
class _ErrorFromUnlock(Exception):
529
 
    """Helper for TestRunWithWriteLockedTarget."""
530
 
 
531
 
 
532
 
class TestRunWithWriteLockedTarget(TestCase):
533
 
    """Tests for _run_with_write_locked_target."""
534
 
 
535
 
    def setUp(self):
536
 
        TestCase.setUp(self)
537
 
        self._calls = []
538
 
 
539
 
    def func_that_returns_ok(self):
540
 
        self._calls.append('func called')
541
 
        return 'ok'
542
 
 
543
 
    def func_that_raises(self):
544
 
        self._calls.append('func called')
545
 
        raise _ErrorFromCallable()
546
 
 
547
 
    def test_success_unlocks(self):
548
 
        lockable = _StubLockable(self._calls)
549
 
        result = _run_with_write_locked_target(
550
 
            lockable, self.func_that_returns_ok)
551
 
        self.assertEqual('ok', result)
552
 
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
553
 
 
554
 
    def test_exception_unlocks_and_propagates(self):
555
 
        lockable = _StubLockable(self._calls)
556
 
        self.assertRaises(_ErrorFromCallable,
557
 
            _run_with_write_locked_target, lockable, self.func_that_raises)
558
 
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
559
 
 
560
 
    def test_callable_succeeds_but_error_during_unlock(self):
561
 
        lockable = _StubLockable(self._calls, unlock_exc=_ErrorFromUnlock())
562
 
        self.assertRaises(_ErrorFromUnlock,
563
 
            _run_with_write_locked_target, lockable, self.func_that_returns_ok)
564
 
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
565
 
 
566
 
    def test_error_during_unlock_does_not_mask_original_error(self):
567
 
        lockable = _StubLockable(self._calls, unlock_exc=_ErrorFromUnlock())
568
 
        self.assertRaises(_ErrorFromCallable,
569
 
            _run_with_write_locked_target, lockable, self.func_that_raises)
570
 
        self.assertEqual(['lock_write', 'func called', 'unlock'], self._calls)
571
 
 
 
702
        self.assertEqual(self.applyDeprecated(
 
703
            symbol_versioning.deprecated_in((2, 3, 0)),
 
704
            r.__int__),
 
705
            10)
 
706
 
 
707
    def test_report_changed(self):
 
708
        r = _mod_branch.PullResult()
 
709
        r.old_revid = "old-revid"
 
710
        r.old_revno = 10
 
711
        r.new_revid = "new-revid"
 
712
        r.new_revno = 20
 
713
        f = StringIO()
 
714
        r.report(f)
 
715
        self.assertEqual("Now on revision 20.\n", f.getvalue())
 
716
 
 
717
    def test_report_unchanged(self):
 
718
        r = _mod_branch.PullResult()
 
719
        r.old_revid = "same-revid"
 
720
        r.new_revid = "same-revid"
 
721
        f = StringIO()
 
722
        r.report(f)
 
723
        self.assertEqual("No revisions or tags to pull.\n", f.getvalue())
572
724