class PublishingElement(Element):
"""
>>> pub.subscribe(sub.handle_event)
>>> pub.publish(Event())
"""
def __init__(self):
super(PublishingElement, self).__init__()
self.pubsub_router = Router()
# Subscribe/Publish Paradigm
def subscribe(self, callback, event_cls=None):
"""
Parameters
----------
callback : callable
Handler called when publishing an event
event_cls : Event Class (optional)
Type of Event to register the handler. If omitted, it will default to all Events
"""
if event_cls is None:
event_cls = Event
self.pubsub_router.bind(event_cls, callback, 'event')
def publish(self, event):
"""
Note, this is called by Component.broadcast
"""
self.pubsub_router.send(event)
def test_router_logging_off(self):
"""
Test that turning off logging works like normal.
"""
r = Router(logging=False)
# test binding
sevt = SourceEvent()
r.send(sevt)
assert len(r.logs) == 0
# we bind send to the old def send()
assert r.send == r._send
def test_router_logging(self):
"""
Test that logging works for router
"""
r = Router(logging=True)
# test binding
sevt = SourceEvent()
r.send(sevt)
assert r.logs[0] is sevt
sevt2 = SourceEvent()
r.send(sevt2)
assert r.logs[1] is sevt2
def test_router_start_logging(self):
"""
Test that we can turn the logging on
"""
r = Router(logging=False)
assert r.send == r._send
sevt = SourceEvent()
r.send(sevt)
assert len(r.logs) == 0
r.start_logging()
sevt2 = SourceEvent()
r.send(sevt2)
assert r.logs[0] is sevt2
def test_router_queue(self):
"""
Testing that broadcasting during event propogation gets queued properly
"""
r = Router()
# test binding
logger = LoggingObj(r)
logger.handle_source_event = MagicMock(side_effect=logger.handle_source_event)
logger.handle_event = MagicMock(side_effect=logger.handle_event)
r.bind(SourceEvent, logger.handle_source_event, "event")
r.bind(be.Event, logger.handle_event, "event")
sevt = SourceEvent()
r.send(sevt)
logger.handle_source_event.assert_called_once_with(sevt)
# called once for SourceEvent and TestEvent
assert logger.handle_event.call_count == 2
assert isinstance(logger.logs[1], TestEvent)
def test_router(self):
r = Router()
# test binding
comp = MagicMock()
r.bind(SourceEvent, comp.handle_source_event, "event")
r.bind(be.Event, comp.handle_event, "event")
sevt = SourceEvent()
r.send(sevt)
# assert that SourceEvent triggers both handlers
comp.handle_source_event.assert_called_once_with(sevt)
comp.handle_event.assert_called_once_with(sevt)
evt = be.Event()
r.send(evt)
# assert be.Event only triggers handle_event
assert comp.handle_source_event.call_count == 1
assert comp.handle_event.call_count == 2
