← 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: 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_hooks.py
1
 
# Copyright (C) 2007, 2009 Canonical Ltd
 
1
# Copyright (C) 2007-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 core Hooks logic."""
18
18
 
19
 
from bzrlib import branch, errors
 
19
from bzrlib import (
 
20
    branch,
 
21
    errors,
 
22
    hooks as _mod_hooks,
 
23
    pyutils,
 
24
    tests,
 
25
    )
20
26
from bzrlib.hooks import (
21
27
    HookPoint,
22
28
    Hooks,
 
29
    install_lazy_named_hook,
23
30
    known_hooks,
24
31
    known_hooks_key_to_object,
25
32
    known_hooks_key_to_parent_and_attribute,
26
33
    )
27
 
from bzrlib.errors import (
28
 
    UnknownHook,
 
34
from bzrlib.symbol_versioning import (
 
35
    deprecated_in,
29
36
    )
30
37
 
31
 
from bzrlib.tests import TestCase
32
 
 
33
 
 
34
 
class TestHooks(TestCase):
 
38
 
 
39
class TestHooks(tests.TestCase):
35
40
 
36
41
    def test_create_hook_first(self):
37
 
        hooks = Hooks()
 
42
        hooks = Hooks("bzrlib.tests.test_hooks", "some_hooks")
38
43
        doc = ("Invoked after changing the tip of a branch object. Called with"
39
44
            "a bzrlib.branch.PostChangeBranchTipParams object")
40
45
        hook = HookPoint("post_tip_change", doc, (0, 15), None)
41
 
        hooks.create_hook(hook)
 
46
        self.applyDeprecated(deprecated_in((2, 4)), hooks.create_hook, hook)
42
47
        self.assertEqual(hook, hooks['post_tip_change'])
43
48
 
44
49
    def test_create_hook_name_collision_errors(self):
45
 
        hooks = Hooks()
 
50
        hooks = Hooks("bzrlib.tests.test_hooks", "some_hooks")
46
51
        doc = ("Invoked after changing the tip of a branch object. Called with"
47
52
            "a bzrlib.branch.PostChangeBranchTipParams object")
48
53
        hook = HookPoint("post_tip_change", doc, (0, 15), None)
49
54
        hook2 = HookPoint("post_tip_change", None, None, None)
50
 
        hooks.create_hook(hook)
51
 
        self.assertRaises(errors.DuplicateKey, hooks.create_hook, hook2)
 
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)
52
58
        self.assertEqual(hook, hooks['post_tip_change'])
53
59
 
54
60
    def test_docs(self):
55
61
        """docs() should return something reasonable about the Hooks."""
56
62
        class MyHooks(Hooks):
57
63
            pass
58
 
        hooks = MyHooks()
 
64
        hooks = MyHooks("bzrlib.tests.test_hooks", "some_hooks")
59
65
        hooks['legacy'] = []
60
 
        hook1 = HookPoint('post_tip_change',
 
66
        hooks.add_hook('post_tip_change',
61
67
            "Invoked after the tip of a branch changes. Called with "
62
 
            "a ChangeBranchTipParams object.", (1, 4), None)
63
 
        hook2 = HookPoint('pre_tip_change',
 
68
            "a ChangeBranchTipParams object.", (1, 4))
 
69
        hooks.add_hook('pre_tip_change',
64
70
            "Invoked before the tip of a branch changes. Called with "
65
71
            "a ChangeBranchTipParams object. Hooks should raise "
66
72
            "TipChangeRejected to signal that a tip change is not permitted.",
67
73
            (1, 6), None)
68
 
        hooks.create_hook(hook1)
69
 
        hooks.create_hook(hook2)
70
74
        self.assertEqualDiff(
71
75
            "MyHooks\n"
72
76
            "-------\n"
80
84
            "~~~~~~~~~~~~~~~\n"
81
85
            "\n"
82
86
            "Introduced in: 1.4\n"
83
 
            "Deprecated in: Not deprecated\n"
84
87
            "\n"
85
88
            "Invoked after the tip of a branch changes. Called with a\n"
86
89
            "ChangeBranchTipParams object.\n"
89
92
            "~~~~~~~~~~~~~~\n"
90
93
            "\n"
91
94
            "Introduced in: 1.6\n"
92
 
            "Deprecated in: Not deprecated\n"
93
95
            "\n"
94
96
            "Invoked before the tip of a branch changes. Called with a\n"
95
97
            "ChangeBranchTipParams object. Hooks should raise TipChangeRejected to\n"
96
98
            "signal that a tip change is not permitted.\n", hooks.docs())
97
99
 
98
100
    def test_install_named_hook_raises_unknown_hook(self):
99
 
        hooks = Hooks()
100
 
        self.assertRaises(UnknownHook, hooks.install_named_hook, 'silly',
 
101
        hooks = Hooks("bzrlib.tests.test_hooks", "some_hooks")
 
102
        self.assertRaises(errors.UnknownHook, hooks.install_named_hook, 'silly',
101
103
                          None, "")
102
104
 
103
105
    def test_install_named_hook_appends_known_hook(self):
104
 
        hooks = Hooks()
 
106
        hooks = Hooks("bzrlib.tests.test_hooks", "some_hooks")
105
107
        hooks['set_rh'] = []
106
108
        hooks.install_named_hook('set_rh', None, "demo")
107
109
        self.assertEqual(hooks['set_rh'], [None])
108
110
 
109
111
    def test_install_named_hook_and_retrieve_name(self):
110
 
        hooks = Hooks()
 
112
        hooks = Hooks("bzrlib.tests.test_hooks", "somehooks")
111
113
        hooks['set_rh'] = []
112
114
        hooks.install_named_hook('set_rh', None, "demo")
113
115
        self.assertEqual("demo", hooks.get_hook_name(None))
114
116
 
115
 
 
116
 
class TestHook(TestCase):
 
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):
117
202
 
118
203
    def test___init__(self):
119
204
        doc = ("Invoked after changing the tip of a branch object. Called with"
133
218
            "~~~~~~~~~~~~~~~\n"
134
219
            "\n"
135
220
            "Introduced in: 0.15\n"
136
 
            "Deprecated in: Not deprecated\n"
137
221
            "\n"
138
222
            "Invoked after changing the tip of a branch object. Called with a\n"
139
223
            "bzrlib.branch.PostChangeBranchTipParams object\n", hook.docs())
145
229
        hook.hook(callback, "my callback")
146
230
        self.assertEqual([callback], list(hook))
147
231
 
 
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
 
148
255
    def test___repr(self):
149
256
        # The repr should list all the callbacks, with names.
150
257
        hook = HookPoint("foo", "no docs", None, None)
157
264
            callback_repr, repr(hook))
158
265
 
159
266
 
160
 
class TestHookRegistry(TestCase):
 
267
class TestHookRegistry(tests.TestCase):
161
268
 
162
269
    def test_items_are_reasonable_keys(self):
163
270
        # All the items in the known_hooks registry need to map from
173
280
            new_hooks = factory()
174
281
            self.assertIsInstance(obj, Hooks)
175
282
            self.assertEqual(type(obj), type(new_hooks))
 
283
            self.assertEqual("No hook name", new_hooks.get_hook_name(None))
176
284
 
177
285
    def test_known_hooks_key_to_object(self):
178
286
        self.assertIs(branch.Branch.hooks,
179
287
            known_hooks_key_to_object(('bzrlib.branch', 'Branch.hooks')))
180
288
 
 
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
 
181
299
    def test_known_hooks_key_to_parent_and_attribute(self):
182
300
        self.assertEqual((branch.Branch, 'hooks'),
183
 
            known_hooks_key_to_parent_and_attribute(
 
301
            known_hooks.key_to_parent_and_attribute(
184
302
            ('bzrlib.branch', 'Branch.hooks')))
185
303
        self.assertEqual((branch, 'Branch'),
186
 
            known_hooks_key_to_parent_and_attribute(
 
304
            known_hooks.key_to_parent_and_attribute(
187
305
            ('bzrlib.branch', 'Branch')))