Source Code for Module elisa.core.tests.test_message_bus

  1  # Moovida - Home multimedia server 
  2  # Copyright (C) 2006-2009 Fluendo Embedded S.L. (www.fluendo.com). 
  3  # All rights reserved. 
  4  # 
  5  # This file is available under one of two license agreements. 
  6  # 
  7  # This file is licensed under the GPL version 3. 
  8  # See "LICENSE.GPL" in the root of this distribution including a special 
  9  # exception to use Moovida with Fluendo's plugins. 
 10  # 
 11  # The GPL part of Moovida is also available under a commercial licensing 
 12  # agreement from Fluendo. 
 13  # See "LICENSE.Moovida" in the root directory of this distribution package 
 14  # for details on that license. 
 15   
 16  from elisa.core.tests.elisa_test_case import ElisaTestCase 
 17   
 18  from elisa.core.components.message import Message 
 19   
 20  from elisa.core import bus 
 21   
 22 -class DataMessage(Message): 
 23 -    def __init__(self, data): 
 24          Message.__init__(self) 
 25          self.data = data 
 26   
 27 -class FooMessage(Message): 
 28 -    def __init__(self, foo): 
 29          Message.__init__(self) 
 30          self.foo = foo 
 31   
 32 -class BarMessage(Message): 
 33      pass 
 34   
 35 -class TestMessageBus(ElisaTestCase): 
 36   
 37 -    def setUp(self): 
 38          self._bus = bus.Bus() 
 39          self._bus.start() 
 40          return ElisaTestCase.setUp(self) 
 41   
 42 -    def tearDown(self): 
 43          self._bus.stop() 
 44          return ElisaTestCase.tearDown(self) 
 45   
 46 -    def test_delayed_dispatch(self): 
 47          """ Create a bus, send messages and start it. Check the 
 48          messages sent before startup are correctly dispatched. 
 49          """ 
 50          global received_messages 
 51          received_messages = [] 
 52          mybus = bus.Bus() 
 53   
 54          def on_message(message, sender): 
 55              global received_messages 
 56              received_messages.append(message) 
 57   
 58          mybus.register(on_message) 
 59   
 60          for i in range(5): 
 61              data = '%s. Hello you' % i 
 62              mybus.send_message(DataMessage(data), sender=self) 
 63   
 64          def done(result): 
 65              global received_messages 
 66              self.assertEqual(len(received_messages), 5) 
 67              mybus.unregister(on_message) 
 68   
 69          dfr = mybus.deferred_dispatch() 
 70          dfr.addCallback(done) 
 71          return dfr 
 72   
 73 -    def test_simple_emit(self): 
 74          """ Check a message receiver callback correctly gets called on 
 75          message bus dispatch. 
 76          """ 
 77          global received_messages 
 78          received_messages = [] 
 79   
 80          def on_message(message, sender): 
 81              global received_messages 
 82              received_messages.append(message) 
 83   
 84          self._bus.register(on_message) 
 85   
 86          def done(result): 
 87              global received_messages 
 88              self.assertEqual(len(received_messages), 1) 
 89   
 90          dfr = self._bus.send_message(DataMessage("data"), sender=self) 
 91          dfr.addCallback(done) 
 92          return dfr 
 93   
 94 -    def test_dispatch_with_callback_failure(self): 
 95          """ Check a message receiver callback raising an exception 
 96          doesn't break the call chain of the other callbacks. 
 97          """ 
 98          global dispatched 
 99          dispatched = False 
100   
101          def first_callback(message, sender): 
102              raise Exception("I am a failed callback") 
103   
104          def second_callback(message, sender): 
105              global dispatched 
106              dispatched = True 
107   
108          self._bus.register(first_callback) 
109          self._bus.register(second_callback) 
110   
111          def done(result): 
112              global dispatched 
113              self.assertEqual(dispatched, True) 
114   
115          def on_failure(failure): 
116              self.fail("should not be reached") 
117   
118          dfr = self._bus.send_message(DataMessage("data"), sender=self) 
119          dfr.addCallbacks(done, on_failure) 
120          return dfr 
121   
122 -    def test_message_filter(self): 
123          """ Check the receiver callback is called only for some 
124          Message types defined at callback registration. 
125          """ 
126          global received_messages 
127          received_messages = [] 
128   
129          def on_message(message, sender): 
130              global received_messages 
131              received_messages.append(message) 
132   
133          self._bus.register(on_message, FooMessage) 
134   
135          def data_sent(result): 
136              self.assertEqual(len(received_messages), 0) 
137   
138          def send_foo_message(result): 
139              return self._bus.send_message(FooMessage("data"), sender=self) 
140   
141          def foo_sent(result): 
142              self.assertEqual(len(received_messages), 1) 
143   
144          dfr = self._bus.send_message(DataMessage("data"), sender=self) 
145          dfr.addCallback(data_sent) 
146          dfr.addCallback(send_foo_message) 
147          dfr.addCallback(foo_sent) 
148          return dfr 
149   
150 -    def test_multiple_filters(self): 
151          """ Test messages dispatch to callbacks supporting multiple 
152          Message types. 
153          """ 
154          global received_messages 
155          received_messages = [] 
156   
157          def on_message(message, sender): 
158              global received_messages 
159              received_messages.append(message) 
160   
161          self._bus.register(on_message, DataMessage,FooMessage) 
162   
163          def data_sent(result): 
164              self.assertEqual(len(received_messages), 1) 
165   
166          def send_foo_message(result): 
167              msg = FooMessage("data") 
168              return self._bus.send_message(msg, sender=self) 
169   
170          def foo_sent(result): 
171              self.assertEqual(len(received_messages), 2) 
172   
173          def send_bar_message(result): 
174              return self._bus.send_message(BarMessage(), sender=self) 
175   
176          def bar_sent(result): 
177              self.assertEqual(len(received_messages), 2) 
178   
179          dfr = self._bus.send_message(DataMessage("data"), sender=self) 
180          dfr.addCallback(data_sent) 
181          dfr.addCallback(send_foo_message) 
182          dfr.addCallback(foo_sent) 
183          dfr.addCallback(send_bar_message) 
184          dfr.addCallback(bar_sent) 
185          return dfr 
186   
187 -    def test_decorator(self): 
188          """ Check receiver callback registration and message dispatch 
189          using the bus_listener function decorator. 
190          """ 
191          global received_messages 
192          received_messages = [] 
193   
194          @bus.bus_listener(self._bus, FooMessage) 
195          def on_message(message, sender): 
196              global received_messages 
197              received_messages.append(message) 
198   
199          def done(result): 
200              self.assertEqual(len(received_messages), 1) 
201   
202          dfr = self._bus.send_message(FooMessage("data"), sender=self) 
203          dfr.addCallback(done) 
204          return dfr 
205   
206 -    def test_register_callback_during_dispatch(self): 
207          """ Check that registering a new callback during dispatch of one 
208          message doesn't affect current dispatching process. 
209   
210          See also: https://bugs.launchpad.net/elisa/+bug/251732 
211          """ 
212          global second_callback_called 
213          second_callback_called = False 
214   
215          class DataMessage(Message): 
216              def __init__(self, register_new_cb): 
217                  self.register_new_cb = register_new_cb 
218   
219          def first_callback(message, sender): 
220              if message.register_new_cb: 
221                  self._bus.register(second_callback) 
222   
223          def second_callback(message, sender): 
224              global second_callback_called 
225              second_callback_called = True 
226   
227          self._bus.register(first_callback) 
228   
229          def second_dispatch_done(result): 
230              global second_callback_called 
231              self.assertEqual(second_callback_called, True) 
232   
233          def first_dispatch_done(result): 
234              global second_callback_called 
235              self.assertEqual(second_callback_called, False) 
236              # send another message, this time not asking to register 
237              # another callback 
238              dfr = self._bus.send_message(DataMessage(False), sender=self) 
239              dfr.addCallback(second_dispatch_done) 
240              return dfr 
241   
242          # send a message asking to register a new callback 
243          dfr = self._bus.send_message(DataMessage(True), sender=self) 
244          dfr.addCallback(first_dispatch_done) 
245          return dfr 
246