← 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: Martin Pool
  • Date: 2005-08-24 08:59:32 UTC
  • Revision ID: mbp@sourcefrog.net-20050824085932-c61f1f1f1c930e13
- Add a simple UIFactory 

  The idea of this is to let a client of bzrlib set some 
  policy about how output is displayed.

  In this revision all that's done is that progress bars
  are constructed by a policy established by the application
  rather than being randomly constructed in the library 
  or passed down the calls.  This avoids progress bars
  popping up while running the test suite and cleans up
  some code.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_hooks.py
1
 
# Copyright (C) 2007-2010 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')))