← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_hooks.py

  • Committer: John Arbash Meinel
  • Date: 2009-06-12 18:05:15 UTC
  • mto: (4371.4.5 vila-better-heads)
  • mto: This revision was merged to the branch mainline in revision 4449.
  • Revision ID: john@arbash-meinel.com-20090612180515-t0cwbjsnve094oik
Add a failing test for handling nodes that are in the same linear chain.

It fails because the ancestry skipping causes us to miss the fact that the two nodes
are actually directly related. We could check at the beginning, as the 
code used to do, but I think that will be incomplete for the more-than-two
heads cases.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_hooks.py
1
 
# Copyright (C) 2007-2010 Canonical Ltd
 
1
# Copyright (C) 2007, 2009 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 core Hooks logic."""
18
18
 
19
 
from bzrlib import (
20
 
    branch,
21
 
    errors,
22
 
    hooks as _mod_hooks,
23
 
    pyutils,
24
 
    tests,
25
 
    )
 
19
from bzrlib import branch, errors
26
20
from bzrlib.hooks import (
27
21
    HookPoint,
28
22
    Hooks,
29
 
    install_lazy_named_hook,
30
23
    known_hooks,
31
24
    known_hooks_key_to_object,
32
25
    known_hooks_key_to_parent_and_attribute,
33
26
    )
34
 
from bzrlib.symbol_versioning import (
35
 
    deprecated_in,
 
27
from bzrlib.errors import (
 
28
    UnknownHook,
36
29
    )
37
30
 
38
 
 
39
 
class TestHooks(tests.TestCase):
 
31
from bzrlib.tests import TestCase
 
32
 
 
33
 
 
34
class TestHooks(TestCase):
40
35
 
41
36
    def test_create_hook_first(self):
42
 
        hooks = Hooks("bzrlib.tests.test_hooks", "some_hooks")
 
37
        hooks = Hooks()
43
38
        doc = ("Invoked after changing the tip of a branch object. Called with"
44
39
            "a bzrlib.branch.PostChangeBranchTipParams object")
45
40
        hook = HookPoint("post_tip_change", doc, (0, 15), None)
46
 
        self.applyDeprecated(deprecated_in((2, 4)), hooks.create_hook, hook)
 
41
        hooks.create_hook(hook)
47
42
        self.assertEqual(hook, hooks['post_tip_change'])
48
43
 
49
44
    def test_create_hook_name_collision_errors(self):
50
 
        hooks = Hooks("bzrlib.tests.test_hooks", "some_hooks")
 
45
        hooks = Hooks()
51
46
        doc = ("Invoked after changing the tip of a branch object. Called with"
52
47
            "a bzrlib.branch.PostChangeBranchTipParams object")
53
48
        hook = HookPoint("post_tip_change", doc, (0, 15), None)
54
49
        hook2 = HookPoint("post_tip_change", None, None, None)
55
 
        self.applyDeprecated(deprecated_in((2, 4)), hooks.create_hook, hook)
56
 
        self.assertRaises(errors.DuplicateKey, self.applyDeprecated,
57
 
            deprecated_in((2, 4, 0)), hooks.create_hook, hook2)
 
50
        hooks.create_hook(hook)
 
51
        self.assertRaises(errors.DuplicateKey, hooks.create_hook, hook2)
58
52
        self.assertEqual(hook, hooks['post_tip_change'])
59
53
 
60
54
    def test_docs(self):
61
55
        """docs() should return something reasonable about the Hooks."""
62
56
        class MyHooks(Hooks):
63
57
            pass
64
 
        hooks = MyHooks("bzrlib.tests.test_hooks", "some_hooks")
 
58
        hooks = MyHooks()
65
59
        hooks['legacy'] = []
66
 
        hooks.add_hook('post_tip_change',
 
60
        hook1 = HookPoint('post_tip_change',
67
61
            "Invoked after the tip of a branch changes. Called with "
68
 
            "a ChangeBranchTipParams object.", (1, 4))
69
 
        hooks.add_hook('pre_tip_change',
 
62
            "a ChangeBranchTipParams object.", (1, 4), None)
 
63
        hook2 = HookPoint('pre_tip_change',
70
64
            "Invoked before the tip of a branch changes. Called with "
71
65
            "a ChangeBranchTipParams object. Hooks should raise "
72
66
            "TipChangeRejected to signal that a tip change is not permitted.",
73
67
            (1, 6), None)
 
68
        hooks.create_hook(hook1)
 
69
        hooks.create_hook(hook2)
74
70
        self.assertEqualDiff(
75
71
            "MyHooks\n"
76
72
            "-------\n"
84
80
            "~~~~~~~~~~~~~~~\n"
85
81
            "\n"
86
82
            "Introduced in: 1.4\n"
 
83
            "Deprecated in: Not deprecated\n"
87
84
            "\n"
88
85
            "Invoked after the tip of a branch changes. Called with a\n"
89
86
            "ChangeBranchTipParams object.\n"
92
89
            "~~~~~~~~~~~~~~\n"
93
90
            "\n"
94
91
            "Introduced in: 1.6\n"
 
92
            "Deprecated in: Not deprecated\n"
95
93
            "\n"
96
94
            "Invoked before the tip of a branch changes. Called with a\n"
97
95
            "ChangeBranchTipParams object. Hooks should raise TipChangeRejected to\n"
98
96
            "signal that a tip change is not permitted.\n", hooks.docs())
99
97
 
100
98
    def test_install_named_hook_raises_unknown_hook(self):
101
 
        hooks = Hooks("bzrlib.tests.test_hooks", "some_hooks")
102
 
        self.assertRaises(errors.UnknownHook, hooks.install_named_hook, 'silly',
 
99
        hooks = Hooks()
 
100
        self.assertRaises(UnknownHook, hooks.install_named_hook, 'silly',
103
101
                          None, "")
104
102
 
105
103
    def test_install_named_hook_appends_known_hook(self):
106
 
        hooks = Hooks("bzrlib.tests.test_hooks", "some_hooks")
 
104
        hooks = Hooks()
107
105
        hooks['set_rh'] = []
108
106
        hooks.install_named_hook('set_rh', None, "demo")
109
107
        self.assertEqual(hooks['set_rh'], [None])
110
108
 
111
109
    def test_install_named_hook_and_retrieve_name(self):
112
 
        hooks = Hooks("bzrlib.tests.test_hooks", "somehooks")
 
110
        hooks = Hooks()
113
111
        hooks['set_rh'] = []
114
112
        hooks.install_named_hook('set_rh', None, "demo")
115
113
        self.assertEqual("demo", hooks.get_hook_name(None))
116
114
 
117
 
    def test_uninstall_named_hook(self):
118
 
        hooks = Hooks("bzrlib.tests.test_hooks", "some_hooks")
119
 
        hooks.add_hook('set_rh', "Set revision history", (2, 0))
120
 
        hooks.install_named_hook('set_rh', None, "demo")
121
 
        self.assertEqual(1, len(hooks["set_rh"]))
122
 
        hooks.uninstall_named_hook("set_rh", "demo")
123
 
        self.assertEqual(0, len(hooks["set_rh"]))
124
 
 
125
 
    def test_uninstall_multiple_named_hooks(self):
126
 
        # Multiple callbacks with the same label all get removed
127
 
        hooks = Hooks("bzrlib.tests.test_hooks", "some_hooks")
128
 
        hooks.add_hook('set_rh', "Set revision history", (2, 0))
129
 
        hooks.install_named_hook('set_rh', 1, "demo")
130
 
        hooks.install_named_hook('set_rh', 2, "demo")
131
 
        hooks.install_named_hook('set_rh', 3, "othername")
132
 
        self.assertEqual(3, len(hooks["set_rh"]))
133
 
        hooks.uninstall_named_hook("set_rh", "demo")
134
 
        self.assertEqual(1, len(hooks["set_rh"]))
135
 
 
136
 
    def test_uninstall_named_hook_unknown_callable(self):
137
 
        hooks = Hooks("bzrlib.tests.test_hooks", "some_hooks")
138
 
        hooks.add_hook('set_rh', "Set revision hsitory", (2, 0))
139
 
        self.assertRaises(KeyError, hooks.uninstall_named_hook, "set_rh",
140
 
            "demo")
141
 
 
142
 
    def test_uninstall_named_hook_raises_unknown_hook(self):
143
 
        hooks = Hooks("bzrlib.tests.test_hooks", "some_hooks")
144
 
        self.assertRaises(errors.UnknownHook, hooks.uninstall_named_hook,
145
 
            'silly', "")
146
 
 
147
 
    def test_uninstall_named_hook_old_style(self):
148
 
        hooks = Hooks("bzrlib.tests.test_hooks", "some_hooks")
149
 
        hooks["set_rh"] = []
150
 
        hooks.install_named_hook('set_rh', None, "demo")
151
 
        self.assertRaises(errors.UnsupportedOperation,
152
 
            hooks.uninstall_named_hook, "set_rh", "demo")
153
 
 
154
 
    hooks = Hooks("bzrlib.tests.test_hooks", "TestHooks.hooks")
155
 
 
156
 
    def test_install_lazy_named_hook(self):
157
 
        # When the hook points are not yet registered the hook is
158
 
        # added to the _lazy_hooks dictionary in bzrlib.hooks.
159
 
        self.hooks.add_hook('set_rh', "doc", (0, 15))
160
 
        set_rh = lambda: None
161
 
        install_lazy_named_hook('bzrlib.tests.test_hooks',
162
 
            'TestHooks.hooks', 'set_rh', set_rh, "demo")
163
 
        set_rh_lazy_hooks = _mod_hooks._lazy_hooks[
164
 
            ('bzrlib.tests.test_hooks', 'TestHooks.hooks', 'set_rh')]
165
 
        self.assertEquals(1, len(set_rh_lazy_hooks))
166
 
        self.assertEquals(set_rh, set_rh_lazy_hooks[0][0].get_obj())
167
 
        self.assertEquals("demo", set_rh_lazy_hooks[0][1])
168
 
        self.assertEqual(list(TestHooks.hooks['set_rh']), [set_rh])
169
 
 
170
 
    set_rh = lambda: None
171
 
 
172
 
    def test_install_named_hook_lazy(self):
173
 
        hooks = Hooks("bzrlib.tests.hooks", "some_hooks")
174
 
        hooks['set_rh'] = HookPoint("set_rh", "doc", (0, 15), None)
175
 
        hooks.install_named_hook_lazy('set_rh', 'bzrlib.tests.test_hooks',
176
 
            'TestHooks.set_rh', "demo")
177
 
        self.assertEqual(list(hooks['set_rh']), [TestHooks.set_rh])
178
 
 
179
 
    def test_install_named_hook_lazy_old(self):
180
 
        # An exception is raised if a lazy hook is raised for
181
 
        # an old style hook point.
182
 
        hooks = Hooks("bzrlib.tests.hooks", "some_hooks")
183
 
        hooks['set_rh'] = []
184
 
        self.assertRaises(errors.UnsupportedOperation,
185
 
            hooks.install_named_hook_lazy,
186
 
            'set_rh', 'bzrlib.tests.test_hooks', 'TestHooks.set_rh',
187
 
            "demo")
188
 
 
189
 
    def test_valid_lazy_hooks(self):
190
 
        # Make sure that all the registered lazy hooks are referring to existing
191
 
        # hook points which allow lazy registration.
192
 
        for key, callbacks in _mod_hooks._lazy_hooks.iteritems():
193
 
            (module_name, member_name, hook_name) = key
194
 
            obj = pyutils.get_named_object(module_name, member_name)
195
 
            self.assertEquals(obj._module, module_name)
196
 
            self.assertEquals(obj._member_name, member_name)
197
 
            self.assertTrue(hook_name in obj)
198
 
            self.assertIs(callbacks, obj[hook_name]._callbacks)
199
 
 
200
 
 
201
 
class TestHook(tests.TestCase):
 
115
 
 
116
class TestHook(TestCase):
202
117
 
203
118
    def test___init__(self):
204
119
        doc = ("Invoked after changing the tip of a branch object. Called with"
218
133
            "~~~~~~~~~~~~~~~\n"
219
134
            "\n"
220
135
            "Introduced in: 0.15\n"
 
136
            "Deprecated in: Not deprecated\n"
221
137
            "\n"
222
138
            "Invoked after changing the tip of a branch object. Called with a\n"
223
139
            "bzrlib.branch.PostChangeBranchTipParams object\n", hook.docs())
229
145
        hook.hook(callback, "my callback")
230
146
        self.assertEqual([callback], list(hook))
231
147
 
232
 
    def lazy_callback():
233
 
        pass
234
 
 
235
 
    def test_lazy_hook(self):
236
 
        hook = HookPoint("foo", "no docs", None, None)
237
 
        hook.hook_lazy(
238
 
            "bzrlib.tests.test_hooks", "TestHook.lazy_callback",
239
 
            "my callback")
240
 
        self.assertEqual([TestHook.lazy_callback], list(hook))
241
 
 
242
 
    def test_uninstall(self):
243
 
        hook = HookPoint("foo", "no docs", None, None)
244
 
        hook.hook_lazy(
245
 
            "bzrlib.tests.test_hooks", "TestHook.lazy_callback",
246
 
            "my callback")
247
 
        self.assertEqual([TestHook.lazy_callback], list(hook))
248
 
        hook.uninstall("my callback")
249
 
        self.assertEqual([], list(hook))
250
 
 
251
 
    def test_uninstall_unknown(self):
252
 
        hook = HookPoint("foo", "no docs", None, None)
253
 
        self.assertRaises(KeyError, hook.uninstall, "my callback")
254
 
 
255
148
    def test___repr(self):
256
149
        # The repr should list all the callbacks, with names.
257
150
        hook = HookPoint("foo", "no docs", None, None)
264
157
            callback_repr, repr(hook))
265
158
 
266
159
 
267
 
class TestHookRegistry(tests.TestCase):
 
160
class TestHookRegistry(TestCase):
268
161
 
269
162
    def test_items_are_reasonable_keys(self):
270
163
        # All the items in the known_hooks registry need to map from
280
173
            new_hooks = factory()
281
174
            self.assertIsInstance(obj, Hooks)
282
175
            self.assertEqual(type(obj), type(new_hooks))
283
 
            self.assertEqual("No hook name", new_hooks.get_hook_name(None))
284
176
 
285
177
    def test_known_hooks_key_to_object(self):
286
178
        self.assertIs(branch.Branch.hooks,
287
179
            known_hooks_key_to_object(('bzrlib.branch', 'Branch.hooks')))
288
180
 
289
 
    def test_known_hooks_key_to_parent_and_attribute_deprecated(self):
290
 
        self.assertEqual((branch.Branch, 'hooks'),
291
 
            self.applyDeprecated(deprecated_in((2,3)),
292
 
                known_hooks_key_to_parent_and_attribute,
293
 
                ('bzrlib.branch', 'Branch.hooks')))
294
 
        self.assertEqual((branch, 'Branch'),
295
 
            self.applyDeprecated(deprecated_in((2,3)),
296
 
                known_hooks_key_to_parent_and_attribute,
297
 
                ('bzrlib.branch', 'Branch')))
298
 
 
299
181
    def test_known_hooks_key_to_parent_and_attribute(self):
300
182
        self.assertEqual((branch.Branch, 'hooks'),
301
 
            known_hooks.key_to_parent_and_attribute(
 
183
            known_hooks_key_to_parent_and_attribute(
302
184
            ('bzrlib.branch', 'Branch.hooks')))
303
185
        self.assertEqual((branch, 'Branch'),
304
 
            known_hooks.key_to_parent_and_attribute(
 
186
            known_hooks_key_to_parent_and_attribute(
305
187
            ('bzrlib.branch', 'Branch')))