64
59
plugin = SamplePlugin()
65
60
self.registry.add(plugin)
66
61
self.assertEquals(self.registry.get_plugin("sample"), plugin)
69
class BrokerClientPluginTest(LandscapeIsolatedTest):
70
helpers = [RemoteBrokerHelper]
73
super(BrokerClientPluginTest, self).setUp()
74
self.registry = BrokerClientPluginRegistry(self.remote)
76
def test_register_plugin(self):
77
sample_plugin = SamplePlugin()
78
self.registry.add(sample_plugin)
79
self.assertEquals(sample_plugin.registered, [self.registry])
81
def test_get_plugins(self):
82
plugin1 = SamplePlugin()
83
plugin2 = SamplePlugin()
84
self.registry.add(plugin1)
85
self.registry.add(plugin2)
86
self.assertEquals(self.registry.get_plugins()[-2:], [plugin1, plugin2])
88
def test_get_named_plugin(self):
90
If a plugin has a C{plugin_name} attribute, it is possible to look it
91
up by name after adding it to the L{Monitor}.
93
plugin = SamplePlugin()
94
self.registry.add(plugin)
95
self.assertEquals(self.registry.get_plugin("sample"), plugin)
97
def test_dispatch_message(self):
98
"""C{dispatch_message} calls a previously-registered message handler.
104
self.registry.register_message("foo", got_it)
105
msg = {"type": "foo", "value": "whatever"}
106
self.assertEquals(self.registry.dispatch_message(msg), "Heyo")
107
self.assertEquals(l, [msg])
109
def test_dispatch_nonexistent_message(self):
111
L{HandlerNotFoundError} is raised when a message handler can't be
114
msg = {"type": "foo", "value": "whatever"}
115
self.assertRaises(HandlerNotFoundError,
116
self.registry.dispatch_message, msg)
118
def test_register_message_registers_message_type_with_broker(self):
120
When register_plugin is called on a BrokerClientPluginRegistry, the
121
broker is notified that the message type is now accepted.
123
result1 = self.registry.register_message("foo", lambda m: None)
124
result2 = self.registry.register_message("bar", lambda m: None)
125
def got_result(result):
126
exchanger = self.broker_service.exchanger
127
self.assertEquals(exchanger.get_client_accepted_message_types(),
128
sorted(["bar", "foo"] + DEFAULT_ACCEPTED_TYPES))
129
return gather_results([result1, result2]).addCallback(got_result)
131
def test_exchange_calls_exchanges(self):
133
The L{PluginRegistry.exchange} method calls C{exchange} on all
134
plugins, if available.
136
plugin1 = SamplePlugin()
137
self.assertFalse(hasattr(plugin1, "exchange"))
139
exchange_plugin1 = ExchangePlugin()
140
exchange_plugin2 = ExchangePlugin()
142
self.registry.add(plugin1)
143
self.registry.add(exchange_plugin1)
144
self.registry.add(exchange_plugin2)
145
self.registry.add(SamplePlugin())
147
self.registry.exchange()
148
self.assertEquals(exchange_plugin1.exchanged, 1)
149
self.assertEquals(exchange_plugin2.exchanged, 1)
151
def test_exchange_logs_errors_and_continues(self):
152
self.log_helper.ignore_errors(ZeroDivisionError)
153
plugin1 = SamplePlugin()
154
plugin2 = ExchangePlugin()
155
plugin1.exchange = lambda: 1/0
156
self.registry.add(plugin1)
157
self.registry.add(plugin2)
159
self.registry.exchange()
160
self.assertEquals(plugin2.exchanged, 1)
161
self.assertTrue("ZeroDivisionError" in self.logfile.getvalue())
163
def test_broker_restart(self):
165
When L{BrokerClientPluginRegistry.broker_started} is called, any
166
message types previously registered with the broker are registered
169
result1 = self.registry.register_message("foo", lambda m: None)
170
result2 = self.registry.register_message("bar", lambda m: None)
173
def register_client_accepted_message_type(type):
177
def got_result(result):
178
self.registry.broker.register_client_accepted_message_type = \
179
register_client_accepted_message_type
180
self.registry.broker_started()
181
return d.addCallback(self.assertEquals, ["foo", "bar"])
182
return gather_results([result1, result2]).addCallback(got_result)
185
def assertReceivesMessages(test_case, broker_plugin, broker_service, remote):
187
Assert (with the given C{test_case}) that the given C{broker_plugin} is
188
correctly receiving messages sent by the given C{broker_service} when
189
registered with the given C{remote}.
191
@return: A deferred that you should return from your test case.
193
final_result = Deferred()
194
broker_plugin.registry.register_message("foo", final_result.callback)
196
result = remote.register_plugin(broker_plugin.bus_name,
197
broker_plugin.object_path)
199
def registered(result):
200
transport = broker_service.transport
201
transport.responses.append([{"type": "foo", "value": 42}])
202
return broker_service.exchanger.exchange()
203
result.addCallback(registered)
206
test_case.assertEquals(message, {"type": "foo", "value": 42})
208
final_result.addCallback(ready)
212
class MyBrokerPlugin(BrokerPlugin):
213
bus_name = "my.service"
214
object_path = "/my/service"
216
ping = method(bus_name)(BrokerPlugin.ping)
217
exit = method(bus_name)(BrokerPlugin.exit)
218
message = method(bus_name)(BrokerPlugin.message)
221
class BrokerPluginTests(LandscapeIsolatedTest):
222
"""Tests for L{BrokerPlugin}."""
224
helpers = [RemoteBrokerHelper]
227
super(BrokerPluginTests, self).setUp()
228
self.registry = BrokerClientPluginRegistry(self.remote)
230
def test_message_receiving(self):
232
BrokerPlugins can receive messages via Broker. Really this is a test
233
for L{assertReceivesMessages}.
235
plugin = MyBrokerPlugin(self.broker_service.bus, self.registry)
236
return assertReceivesMessages(self, plugin, self.broker_service,
239
def test_message_found(self):
241
When a message handler is found and dispatched, C{message} returns
245
self.registry.register_message("foo", l.append)
246
broker_plugin = MyBrokerPlugin(self.broker_service.bus, self.registry)
247
msg = {"type": "foo", "value": "x"}
248
array = map(ord, dumps(msg))
249
self.assertEquals(broker_plugin.dispatch_message(array), True)
250
self.assertEquals(l, [msg])
252
def test_message_not_found(self):
254
When a message handler is not found for a type of message, {message}
257
broker_plugin = MyBrokerPlugin(self.broker_service.bus, self.registry)
258
msg = {"type": "foo", "value": "x"}
259
array = map(ord, dumps(msg))
260
self.assertEquals(broker_plugin.dispatch_message(array), False)
262
def test_exchange_notification_calls_exchange(self):
264
When the L{Broker} notifies the L{MonitorDBusObject} that an
265
exchange is about to happen, the plugins' C{exchange} methods
268
exchange_plugin1 = ExchangePlugin()
269
exchange_plugin2 = ExchangePlugin()
270
self.registry.add(exchange_plugin1)
271
self.registry.add(exchange_plugin2)
273
broker_plugin = MyBrokerPlugin(self.broker_service.bus, self.registry)
274
self.broker_service.reactor.fire("impending-exchange")
276
d = gather_results([exchange_plugin1.wait_for_exchange(),
277
exchange_plugin2.wait_for_exchange()])
278
d.addCallback(self.assertEquals, [None, None])
added
removed
landscape/tests/test_plugin.py
