/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_hooks.py

  • Committer: John Arbash Meinel
  • Date: 2009-12-22 16:28:47 UTC
  • mto: This revision was merged to the branch mainline in revision 4922.
  • Revision ID: john@arbash-meinel.com-20091222162847-tvnsc69to4l4uf5r
Implement a permute_for_extension helper.

Use it for all of the 'simple' extension permutations.
It basically permutes all tests in the current module, by setting TestCase.module.
Which works well for most of our extension tests. Some had more advanced
handling of permutations (extra permutations, custom vars, etc.)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_hooks.py
 
1
# Copyright (C) 2007, 2009 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
"""Tests for the core Hooks logic."""
 
18
 
 
19
from bzrlib import (
 
20
    branch,
 
21
    errors,
 
22
    tests,
 
23
    )
 
24
from bzrlib.hooks import (
 
25
    HookPoint,
 
26
    Hooks,
 
27
    known_hooks,
 
28
    known_hooks_key_to_object,
 
29
    known_hooks_key_to_parent_and_attribute,
 
30
    )
 
31
 
 
32
 
 
33
class TestHooks(tests.TestCase):
 
34
 
 
35
    def test_create_hook_first(self):
 
36
        hooks = Hooks()
 
37
        doc = ("Invoked after changing the tip of a branch object. Called with"
 
38
            "a bzrlib.branch.PostChangeBranchTipParams object")
 
39
        hook = HookPoint("post_tip_change", doc, (0, 15), None)
 
40
        hooks.create_hook(hook)
 
41
        self.assertEqual(hook, hooks['post_tip_change'])
 
42
 
 
43
    def test_create_hook_name_collision_errors(self):
 
44
        hooks = Hooks()
 
45
        doc = ("Invoked after changing the tip of a branch object. Called with"
 
46
            "a bzrlib.branch.PostChangeBranchTipParams object")
 
47
        hook = HookPoint("post_tip_change", doc, (0, 15), None)
 
48
        hook2 = HookPoint("post_tip_change", None, None, None)
 
49
        hooks.create_hook(hook)
 
50
        self.assertRaises(errors.DuplicateKey, hooks.create_hook, hook2)
 
51
        self.assertEqual(hook, hooks['post_tip_change'])
 
52
 
 
53
    def test_docs(self):
 
54
        """docs() should return something reasonable about the Hooks."""
 
55
        class MyHooks(Hooks):
 
56
            pass
 
57
        hooks = MyHooks()
 
58
        hooks['legacy'] = []
 
59
        hook1 = HookPoint('post_tip_change',
 
60
            "Invoked after the tip of a branch changes. Called with "
 
61
            "a ChangeBranchTipParams object.", (1, 4), None)
 
62
        hook2 = HookPoint('pre_tip_change',
 
63
            "Invoked before the tip of a branch changes. Called with "
 
64
            "a ChangeBranchTipParams object. Hooks should raise "
 
65
            "TipChangeRejected to signal that a tip change is not permitted.",
 
66
            (1, 6), None)
 
67
        hooks.create_hook(hook1)
 
68
        hooks.create_hook(hook2)
 
69
        self.assertEqualDiff(
 
70
            "MyHooks\n"
 
71
            "-------\n"
 
72
            "\n"
 
73
            "legacy\n"
 
74
            "~~~~~~\n"
 
75
            "\n"
 
76
            "An old-style hook. For documentation see the __init__ method of 'MyHooks'\n"
 
77
            "\n"
 
78
            "post_tip_change\n"
 
79
            "~~~~~~~~~~~~~~~\n"
 
80
            "\n"
 
81
            "Introduced in: 1.4\n"
 
82
            "\n"
 
83
            "Invoked after the tip of a branch changes. Called with a\n"
 
84
            "ChangeBranchTipParams object.\n"
 
85
            "\n"
 
86
            "pre_tip_change\n"
 
87
            "~~~~~~~~~~~~~~\n"
 
88
            "\n"
 
89
            "Introduced in: 1.6\n"
 
90
            "\n"
 
91
            "Invoked before the tip of a branch changes. Called with a\n"
 
92
            "ChangeBranchTipParams object. Hooks should raise TipChangeRejected to\n"
 
93
            "signal that a tip change is not permitted.\n", hooks.docs())
 
94
 
 
95
    def test_install_named_hook_raises_unknown_hook(self):
 
96
        hooks = Hooks()
 
97
        self.assertRaises(errors.UnknownHook, hooks.install_named_hook, 'silly',
 
98
                          None, "")
 
99
 
 
100
    def test_install_named_hook_appends_known_hook(self):
 
101
        hooks = Hooks()
 
102
        hooks['set_rh'] = []
 
103
        hooks.install_named_hook('set_rh', None, "demo")
 
104
        self.assertEqual(hooks['set_rh'], [None])
 
105
 
 
106
    def test_install_named_hook_and_retrieve_name(self):
 
107
        hooks = Hooks()
 
108
        hooks['set_rh'] = []
 
109
        hooks.install_named_hook('set_rh', None, "demo")
 
110
        self.assertEqual("demo", hooks.get_hook_name(None))
 
111
 
 
112
 
 
113
class TestHook(tests.TestCase):
 
114
 
 
115
    def test___init__(self):
 
116
        doc = ("Invoked after changing the tip of a branch object. Called with"
 
117
            "a bzrlib.branch.PostChangeBranchTipParams object")
 
118
        hook = HookPoint("post_tip_change", doc, (0, 15), None)
 
119
        self.assertEqual(doc, hook.__doc__)
 
120
        self.assertEqual("post_tip_change", hook.name)
 
121
        self.assertEqual((0, 15), hook.introduced)
 
122
        self.assertEqual(None, hook.deprecated)
 
123
        self.assertEqual([], list(hook))
 
124
 
 
125
    def test_docs(self):
 
126
        doc = ("Invoked after changing the tip of a branch object. Called with"
 
127
            " a bzrlib.branch.PostChangeBranchTipParams object")
 
128
        hook = HookPoint("post_tip_change", doc, (0, 15), None)
 
129
        self.assertEqual("post_tip_change\n"
 
130
            "~~~~~~~~~~~~~~~\n"
 
131
            "\n"
 
132
            "Introduced in: 0.15\n"
 
133
            "\n"
 
134
            "Invoked after changing the tip of a branch object. Called with a\n"
 
135
            "bzrlib.branch.PostChangeBranchTipParams object\n", hook.docs())
 
136
 
 
137
    def test_hook(self):
 
138
        hook = HookPoint("foo", "no docs", None, None)
 
139
        def callback():
 
140
            pass
 
141
        hook.hook(callback, "my callback")
 
142
        self.assertEqual([callback], list(hook))
 
143
 
 
144
    def test___repr(self):
 
145
        # The repr should list all the callbacks, with names.
 
146
        hook = HookPoint("foo", "no docs", None, None)
 
147
        def callback():
 
148
            pass
 
149
        hook.hook(callback, "my callback")
 
150
        callback_repr = repr(callback)
 
151
        self.assertEqual(
 
152
            '<HookPoint(foo), callbacks=[%s(my callback)]>' %
 
153
            callback_repr, repr(hook))
 
154
 
 
155
 
 
156
class TestHookRegistry(tests.TestCase):
 
157
 
 
158
    def test_items_are_reasonable_keys(self):
 
159
        # All the items in the known_hooks registry need to map from
 
160
        # (module_name, member_name) tuples to the callable used to get an
 
161
        # empty Hooks for that attribute. This is used to support the test
 
162
        # suite which needs to generate empty hooks (and HookPoints) to ensure
 
163
        # isolation and prevent tests failing spuriously.
 
164
        for key, factory in known_hooks.items():
 
165
            self.assertTrue(callable(factory),
 
166
                "The factory(%r) for %r is not callable" % (factory, key))
 
167
            obj = known_hooks_key_to_object(key)
 
168
            self.assertIsInstance(obj, Hooks)
 
169
            new_hooks = factory()
 
170
            self.assertIsInstance(obj, Hooks)
 
171
            self.assertEqual(type(obj), type(new_hooks))
 
172
            self.assertEqual("No hook name", new_hooks.get_hook_name(None))
 
173
 
 
174
    def test_known_hooks_key_to_object(self):
 
175
        self.assertIs(branch.Branch.hooks,
 
176
            known_hooks_key_to_object(('bzrlib.branch', 'Branch.hooks')))
 
177
 
 
178
    def test_known_hooks_key_to_parent_and_attribute(self):
 
179
        self.assertEqual((branch.Branch, 'hooks'),
 
180
            known_hooks_key_to_parent_and_attribute(
 
181
            ('bzrlib.branch', 'Branch.hooks')))
 
182
        self.assertEqual((branch, 'Branch'),
 
183
            known_hooks_key_to_parent_and_attribute(
 
184
            ('bzrlib.branch', 'Branch')))