← Back to branch summary

~ahasenack/landscape-client/landscape-client-1.5.5-0ubuntu0.9.04.0

« back to all changes in this revision

Viewing changes to landscape/tests/test_plugin.py

  • Committer: Bazaar Package Importer
  • Author(s): Rick Clark
  • Date: 2008-09-08 16:35:57 UTC
  • mto: This revision was merged to the branch mainline in revision 2.
  • Revision ID: james.westby@ubuntu.com-20080908163557-fl0d2oc35hur473w
Tags: upstream-1.0.18
Import upstream version 1.0.18

Show diffs side-by-side

added added

removed removed

Lines of Context:
landscape/tests/test_plugin.py
 
1
from twisted.internet.defer import Deferred
 
2
 
 
3
from landscape.tests.helpers import LandscapeTest, LandscapeIsolatedTest
 
4
 
 
5
from landscape.plugin import PluginRegistry, BrokerPlugin, HandlerNotFoundError
 
6
from landscape.lib.dbus_util import method
 
7
from landscape.lib.bpickle import loads, dumps
 
8
from landscape.tests.helpers import RemoteBrokerHelper
 
9
 
 
10
 
 
11
class SamplePlugin(object):
 
12
    plugin_name = "sample"
 
13
 
 
14
    def __init__(self):
 
15
        self.registered = []
 
16
 
 
17
    def register(self, monitor):
 
18
        self.registered.append(monitor)
 
19
 
 
20
 
 
21
class PluginTest(LandscapeTest):
 
22
 
 
23
    def setUp(self):
 
24
        super(PluginTest, self).setUp()
 
25
        self.registry = PluginRegistry()
 
26
 
 
27
    def test_register_plugin(self):
 
28
        sample_plugin = SamplePlugin()
 
29
        self.registry.add(sample_plugin)
 
30
        self.assertEquals(sample_plugin.registered, [self.registry])
 
31
 
 
32
    def test_get_plugins(self):
 
33
        plugin1 = SamplePlugin()
 
34
        plugin2 = SamplePlugin()
 
35
        self.registry.add(plugin1)
 
36
        self.registry.add(plugin2)
 
37
        self.assertEquals(self.registry.get_plugins()[-2:], [plugin1, plugin2])
 
38
 
 
39
    def test_get_named_plugin(self):
 
40
        """
 
41
        If a plugin has a C{plugin_name} attribute, it is possible to look it
 
42
        up by name after adding it to the L{Monitor}.
 
43
        """
 
44
        plugin = SamplePlugin()
 
45
        self.registry.add(plugin)
 
46
        self.assertEquals(self.registry.get_plugin("sample"), plugin)
 
47
 
 
48
    def test_dispatch_message(self):
 
49
        """C{dispatch_message} calls a previously-registered message handler.
 
50
        """
 
51
        l = []
 
52
        def got_it(message):
 
53
            l.append(message)
 
54
            return "Heyo"
 
55
        self.registry.register_message("foo", got_it)
 
56
        msg = {"type": "foo", "value": "whatever"}
 
57
        self.assertEquals(self.registry.dispatch_message(msg), "Heyo")
 
58
        self.assertEquals(l, [msg])
 
59
 
 
60
    def test_dispatch_nonexistent_message(self):
 
61
        """
 
62
        L{HandlerNotFoundError} is raised when a message handler can't be
 
63
        found.
 
64
        """
 
65
        msg = {"type": "foo", "value": "whatever"}
 
66
        self.assertRaises(HandlerNotFoundError,
 
67
                          self.registry.dispatch_message, msg)
 
68
 
 
69
 
 
70
def assertReceivesMessages(test_case, broker_plugin, broker_service, remote):
 
71
    """
 
72
    Assert (with the given C{test_case}) that the given C{broker_plugin} is
 
73
    correctly receiving messages sent by the given C{broker_service} when
 
74
    registered with the given C{remote}.
 
75
 
 
76
    @return: A deferred that you should return from your test case.
 
77
    """
 
78
    final_result = Deferred()
 
79
    broker_plugin.registry.register_message("foo", final_result.callback)
 
80
 
 
81
    result = remote.register_plugin(broker_plugin.bus_name,
 
82
                                    broker_plugin.object_path)
 
83
 
 
84
    def registered(result):
 
85
        transport = broker_service.transport
 
86
        transport.responses.append([{"type": "foo", "value": 42}])
 
87
        return broker_service.exchanger.exchange()
 
88
    result.addCallback(registered)
 
89
 
 
90
    def ready(message):
 
91
        test_case.assertEquals(message, {"type": "foo", "value": 42})
 
92
 
 
93
    final_result.addCallback(ready)
 
94
    return final_result
 
95
 
 
96
 
 
97
class MyBrokerPlugin(BrokerPlugin):
 
98
    bus_name = "my.service"
 
99
    object_path = "/my/service"
 
100
 
 
101
    ping = method(bus_name)(BrokerPlugin.ping)
 
102
    exit = method(bus_name)(BrokerPlugin.exit)
 
103
    message = method(bus_name)(BrokerPlugin.message)
 
104
 
 
105
 
 
106
class BrokerPluginTests(LandscapeIsolatedTest):
 
107
    """Tests for L{BrokerPlugin}."""
 
108
 
 
109
    helpers = [RemoteBrokerHelper]
 
110
 
 
111
    def test_message_receiving(self):
 
112
        """
 
113
        BrokerPlugins can receive messages via Broker. Really this is a test
 
114
        for L{assertReceivesMessages}.
 
115
        """
 
116
        registry = PluginRegistry()
 
117
        plugin = MyBrokerPlugin(self.broker_service.bus, registry)
 
118
        return assertReceivesMessages(self, plugin, self.broker_service,
 
119
                                      self.remote)
 
120
 
 
121
    def test_message_found(self):
 
122
        """
 
123
        When a message handler is found and dispatched, C{message} returns
 
124
        True.
 
125
        """
 
126
        l = []
 
127
        registry = PluginRegistry()
 
128
        registry.register_message("foo", l.append)
 
129
        broker_plugin = MyBrokerPlugin(self.broker_service.bus, registry)
 
130
        msg = {"type": "foo", "value": "x"}
 
131
        array = map(ord, dumps(msg))
 
132
        self.assertEquals(broker_plugin.dispatch_message(array), True)
 
133
        self.assertEquals(l, [msg])
 
134
 
 
135
    def test_message_not_found(self):
 
136
        """
 
137
        When a message handler is not found for a type of message, {message}
 
138
        returns False.
 
139
        """
 
140
        registry = PluginRegistry()
 
141
        broker_plugin = MyBrokerPlugin(self.broker_service.bus, registry)
 
142
        msg = {"type": "foo", "value": "x"}
 
143
        array = map(ord, dumps(msg))
 
144
        self.assertEquals(broker_plugin.dispatch_message(array), False)