def test_errors_during_logging_should_be_ignored_and_event_processing_continues(self):
failing_logger = Mock()
failing_logger.configure_mock(**{'error.side_effect': RuntimeError})
exchange = Exchange(failing_logger)
ts_error = TestSubscriber(exchange)
ts_after_error = TestSubscriber(exchange)
event = Event("bong")
exchange.subscribe("bong",ts_error.bad_call)
exchange.subscribe("bong",ts_after_error.callme)
exchange.publish(event)
failing_logger.error.assert_has_calls([call('Exchange, RuntimeError: oops')])
self.assertEqual(ts_after_error.event_call_count("bong"),1)
def test_errors_during_logging_should_be_ignored_and_event_processing_continues(
self):
failing_logger = Mock()
failing_logger.configure_mock(**{'error.side_effect': RuntimeError})
exchange = Exchange(failing_logger)
ts_error = TestSubscriber(exchange)
ts_after_error = TestSubscriber(exchange)
event = Event("bong")
exchange.subscribe("bong", ts_error.bad_call)
exchange.subscribe("bong", ts_after_error.callme)
exchange.publish(event)
failing_logger.error.assert_has_calls(
[call('Exchange, RuntimeError: oops')])
self.assertEqual(ts_after_error.event_call_count("bong"), 1)
class EventTestCase(unittest.TestCase):
def setUp(self):
self.last_event = Event("None")
self.events = {}
self.exchange = Exchange(test_logger(logging.ERROR))
def event_recorder(self, event):
self.last_event = event
self.events[event.name].append(event)
def listen(self, event_name):
self.events[event_name] = []
self.exchange.subscribe(event_name, self.event_recorder)
def event_count(self, event_name):
if event_name in self.events:
return len(self.events[event_name])
else:
return 0
class EventTestCase(unittest.TestCase):
def setUp(self):
self.last_event = Event("None")
self.events = {}
self.exchange = Exchange(test_logger(logging.ERROR))
def event_recorder(self,event):
self.last_event = event
self.events[event.name].append(event)
def listen(self,event_name):
self.events[event_name] = []
self.exchange.subscribe(event_name,self.event_recorder)
def event_count(self,event_name):
if event_name in self.events:
return len(self.events[event_name])
else:
return 0
class TestEventSource(unittest.TestCase):
def setUp(self):
self.mock_logger = Mock()
self.exchange = Exchange(self.mock_logger)
self.timer = Mock()
self.last_event = None
def event_recorder(self, event):
self.last_listened_event = event
self.event_count += 1
def intercept_publish(self, event):
self.exchange.original_publish(event)
if event.name == EventName.tick:
raise RuntimeError("oops")
def listen(self, event_name):
self.event_count = 0
self.exchange.subscribe(event_name, self.event_recorder)
def after(self, times, event_name):
self.ticks_left = times
self.end_event_name = event_name
def count_down_ticks(self, args):
self.ticks_left -= 1
if self.ticks_left <= 0:
self.exchange.publish(Event(self.end_event_name))
def finish(self, args):
self.exchange.publish(Event(EventName.end))
def test_should_publish_start_navigation_event(self):
self.listen(EventName.start)
self.timer.wait_for = Mock(side_effect=self.finish)
event_source = EventSource(self.exchange, self.timer, self.mock_logger,
CONFIG)
event_source.start()
self.assertEqual(self.last_listened_event.name, EventName.start)
def test_should_publish_a_tick_event(self):
self.listen(EventName.tick)
self.timer.wait_for = Mock(side_effect=self.finish)
event_source = EventSource(self.exchange, self.timer, self.mock_logger,
CONFIG)
event_source.start()
self.assertEqual(self.last_listened_event.name, EventName.tick)
def test_should_publish_multiple_events_until_nav_complete(self):
self.listen(EventName.tick)
self.after(5, EventName.end)
self.timer.wait_for = Mock(side_effect=self.count_down_ticks)
event_source = EventSource(self.exchange, self.timer, self.mock_logger,
CONFIG)
event_source.start()
self.assertEqual(self.event_count, 5)
def test_errors_should_be_logged_and_events_continue(self):
self.listen(EventName.tick)
self.after(2, EventName.end)
self.timer.wait_for = Mock(side_effect=self.count_down_ticks)
self.exchange.original_publish = self.exchange.publish
self.exchange.publish = self.intercept_publish
event_source = EventSource(self.exchange, self.timer, self.mock_logger,
CONFIG)
event_source.start()
self.mock_logger.error.assert_has_calls(
[call('EventSource, RuntimeError: oops')])
self.assertEqual(self.event_count, 2)
def test_errors_during_logging_should_be_ignored_and_event_processing_continues(
self):
failing_logger = Mock()
failing_logger.configure_mock(**{'error.side_effect': RuntimeError})
self.listen(EventName.tick)
self.after(2, EventName.end)
self.timer.wait_for = Mock(side_effect=self.count_down_ticks)
self.exchange.original_publish = self.exchange.publish
self.exchange.publish = self.intercept_publish
event_source = EventSource(self.exchange, self.timer, failing_logger,
CONFIG)
event_source.start()
failing_logger.error.assert_has_calls(
[call('EventSource, RuntimeError: oops')])
self.assertEqual(self.event_count, 2)
class TestEvents(unittest.TestCase):
def setUp(self):
self.mock_logger = Mock()
self.exchange = Exchange(self.mock_logger)
def test_should_return_nil_event_if_not_called(self):
ts = TestSubscriber()
self.assertEqual(ts.last_event_called.name, "nil")
def test_should_call_back(self):
ts = TestSubscriber(self.exchange)
self.exchange.subscribe("thing", ts.callme)
self.exchange.publish(Event("thing"))
def test_should_ignore_events_with_no_subscribers_and_log_warning(self):
self.exchange.publish(Event("doesnotexist"))
self.mock_logger.warn.assert_called_with(
"Event(doesnotexist) published but no subscribers")
def test_should_be_able_to_unsubscribe(self):
ts1 = TestSubscriber(self.exchange)
self.exchange.subscribe("never", ts1.callme)
self.exchange.unsubscribe("never", ts1.callme)
self.exchange.publish(Event("never"))
self.assertEqual(ts1.last_event_called.name, "nil")
self.mock_logger.warn.assert_called_with(
"Event(never) published but no subscribers")
def test_should_accept_unsubscribe_without_subscribe(self):
ts1 = TestSubscriber(self.exchange)
self.exchange.unsubscribe("never", ts1.callme)
self.exchange.publish(Event("never"))
self.assertEqual(ts1.last_event_called.name, "nil")
self.mock_logger.warn.assert_called_with(
"Event(never) published but no subscribers")
def test_should_signal_events_to_multiple_subscribers(self):
ts1 = TestSubscriber(self.exchange)
ts2 = TestSubscriber(self.exchange)
self.exchange.subscribe("boo", ts1.callme)
self.exchange.subscribe("boo", ts2.callme)
self.exchange.publish(Event("boo"))
self.assertEqual(ts1.last_event_called.name, "boo")
self.assertEqual(ts2.last_event_called.name, "boo")
def test_should_be_able_to_chain_events(self):
ts1 = TestSubscriber(self.exchange)
ts2 = TestSubscriber(self.exchange)
self.exchange.subscribe("chain", ts1.callme)
self.exchange.subscribe("secondevent", ts2.callme)
self.exchange.publish(Event("chain"))
self.assertEqual(ts2.last_event_called.name, "secondevent")
def test_should_chain_a_few_events(self):
ts = TestSubscriber(self.exchange)
ts2 = TestSubscriber(self.exchange)
self.exchange.subscribe("chain", ts.callme)
self.exchange.subscribe("secondevent", ts.callme)
self.exchange.subscribe("secondevent", ts2.callme)
self.exchange.publish(Event("chain"))
self.assertEqual(ts.event_call_count("secondevent"), 1)
self.assertEqual(ts2.event_call_count("secondevent"), 1)
def test_should_call_events_again_if_we_signal_primary_event_again(self):
ts = TestSubscriber(self.exchange)
event = Event("bing")
self.exchange.subscribe("bing", ts.callme)
self.exchange.publish(event)
self.exchange.publish(event)
self.exchange.publish(event)
self.assertEqual(ts.event_call_count("bing"), 3)
def test_errors_should_be_logged_and_event_processing_continues(self):
ts_error = TestSubscriber(self.exchange)
ts_after_error = TestSubscriber(self.exchange)
event = Event("bong")
self.exchange.subscribe("bong", ts_error.bad_call)
self.exchange.subscribe("bong", ts_after_error.callme)
self.exchange.publish(event)
self.mock_logger.error.assert_has_calls(
[call('Exchange, RuntimeError: oops')])
self.assertEqual(ts_after_error.event_call_count("bong"), 1)
def test_errors_during_logging_should_be_ignored_and_event_processing_continues(
self):
failing_logger = Mock()
failing_logger.configure_mock(**{'error.side_effect': RuntimeError})
exchange = Exchange(failing_logger)
ts_error = TestSubscriber(exchange)
ts_after_error = TestSubscriber(exchange)
event = Event("bong")
exchange.subscribe("bong", ts_error.bad_call)
exchange.subscribe("bong", ts_after_error.callme)
exchange.publish(event)
failing_logger.error.assert_has_calls(
[call('Exchange, RuntimeError: oops')])
self.assertEqual(ts_after_error.event_call_count("bong"), 1)
class TestEvents(unittest.TestCase):
def setUp(self):
self.mock_logger = Mock()
self.exchange = Exchange(self.mock_logger)
def test_should_return_nil_event_if_not_called(self):
ts = TestSubscriber()
self.assertEqual(ts.last_event_called.name,"nil")
def test_should_call_back(self):
ts = TestSubscriber(self.exchange)
self.exchange.subscribe("thing",ts.callme)
self.exchange.publish(Event("thing"))
def test_should_ignore_events_with_no_subscribers_and_log_warning(self):
self.exchange.publish(Event("doesnotexist"))
self.mock_logger.warn.assert_called_with("Event(doesnotexist) published but no subscribers")
def test_should_be_able_to_unsubscribe(self):
ts1 = TestSubscriber(self.exchange)
self.exchange.subscribe("never",ts1.callme)
self.exchange.unsubscribe("never",ts1.callme)
self.exchange.publish(Event("never"))
self.assertEqual(ts1.last_event_called.name,"nil")
self.mock_logger.warn.assert_called_with("Event(never) published but no subscribers")
def test_should_accept_unsubscribe_without_subscribe(self):
ts1 = TestSubscriber(self.exchange)
self.exchange.unsubscribe("never",ts1.callme)
self.exchange.publish(Event("never"))
self.assertEqual(ts1.last_event_called.name,"nil")
self.mock_logger.warn.assert_called_with("Event(never) published but no subscribers")
def test_should_signal_events_to_multiple_subscribers(self):
ts1 = TestSubscriber(self.exchange)
ts2 = TestSubscriber(self.exchange)
self.exchange.subscribe("boo",ts1.callme)
self.exchange.subscribe("boo",ts2.callme)
self.exchange.publish(Event("boo"))
self.assertEqual(ts1.last_event_called.name,"boo")
self.assertEqual(ts2.last_event_called.name,"boo")
def test_should_be_able_to_chain_events(self):
ts1 = TestSubscriber(self.exchange)
ts2 = TestSubscriber(self.exchange)
self.exchange.subscribe("chain",ts1.callme)
self.exchange.subscribe("secondevent",ts2.callme)
self.exchange.publish(Event("chain"))
self.assertEqual(ts2.last_event_called.name,"secondevent")
def test_should_chain_a_few_events(self):
ts = TestSubscriber(self.exchange)
ts2 = TestSubscriber(self.exchange)
self.exchange.subscribe("chain",ts.callme)
self.exchange.subscribe("secondevent",ts.callme)
self.exchange.subscribe("secondevent",ts2.callme)
self.exchange.publish(Event("chain"))
self.assertEqual(ts.event_call_count("secondevent"),1)
self.assertEqual(ts2.event_call_count("secondevent"),1)
def test_should_call_events_again_if_we_signal_primary_event_again(self):
ts = TestSubscriber(self.exchange)
event = Event("bing")
self.exchange.subscribe("bing",ts.callme)
self.exchange.publish(event)
self.exchange.publish(event)
self.exchange.publish(event)
self.assertEqual(ts.event_call_count("bing"),3)
def test_errors_should_be_logged_and_event_processing_continues(self):
ts_error = TestSubscriber(self.exchange)
ts_after_error = TestSubscriber(self.exchange)
event = Event("bong")
self.exchange.subscribe("bong",ts_error.bad_call)
self.exchange.subscribe("bong",ts_after_error.callme)
self.exchange.publish(event)
self.mock_logger.error.assert_has_calls([call('Exchange, RuntimeError: oops')])
self.assertEqual(ts_after_error.event_call_count("bong"),1)
def test_errors_during_logging_should_be_ignored_and_event_processing_continues(self):
failing_logger = Mock()
failing_logger.configure_mock(**{'error.side_effect': RuntimeError})
exchange = Exchange(failing_logger)
ts_error = TestSubscriber(exchange)
ts_after_error = TestSubscriber(exchange)
event = Event("bong")
exchange.subscribe("bong",ts_error.bad_call)
exchange.subscribe("bong",ts_after_error.callme)
exchange.publish(event)
failing_logger.error.assert_has_calls([call('Exchange, RuntimeError: oops')])
self.assertEqual(ts_after_error.event_call_count("bong"),1)
class TestEventSource(unittest.TestCase):
def setUp(self):
self.mock_logger = Mock()
self.exchange = Exchange(self.mock_logger)
self.timer = Mock()
self.last_event = None
def event_recorder(self,event):
self.last_listened_event = event
self.event_count += 1
def intercept_publish(self,event):
self.exchange.original_publish(event)
if event.name == EventName.tick:
raise RuntimeError("oops")
def listen(self,event_name):
self.event_count = 0
self.exchange.subscribe(event_name,self.event_recorder)
def after(self,times,event_name):
self.ticks_left = times
self.end_event_name = event_name
def count_down_ticks(self,args):
self.ticks_left -= 1
if self.ticks_left <= 0:
self.exchange.publish(Event(self.end_event_name))
def finish(self,args):
self.exchange.publish(Event(EventName.end))
def test_should_publish_start_navigation_event(self):
self.listen(EventName.start)
self.timer.wait_for = Mock(side_effect=self.finish)
event_source = EventSource(self.exchange,self.timer, self.mock_logger,CONFIG)
event_source.start()
self.assertEqual(self.last_listened_event.name,EventName.start)
def test_should_publish_a_tick_event(self):
self.listen(EventName.tick)
self.timer.wait_for = Mock(side_effect=self.finish)
event_source = EventSource(self.exchange, self.timer, self.mock_logger, CONFIG)
event_source.start()
self.assertEqual(self.last_listened_event.name,EventName.tick)
def test_should_publish_multiple_events_until_nav_complete(self):
self.listen(EventName.tick)
self.after(5,EventName.end)
self.timer.wait_for = Mock(side_effect=self.count_down_ticks)
event_source = EventSource(self.exchange,self.timer, self.mock_logger,CONFIG)
event_source.start()
self.assertEqual(self.event_count,5)
def test_errors_should_be_logged_and_events_continue(self):
self.listen(EventName.tick)
self.after(2,EventName.end)
self.timer.wait_for = Mock(side_effect=self.count_down_ticks)
self.exchange.original_publish = self.exchange.publish
self.exchange.publish = self.intercept_publish
event_source = EventSource(self.exchange,self.timer, self.mock_logger,CONFIG)
event_source.start()
self.mock_logger.error.assert_has_calls([call('EventSource, RuntimeError: oops')])
self.assertEqual(self.event_count,2)
def test_errors_during_logging_should_be_ignored_and_event_processing_continues(self):
failing_logger = Mock()
failing_logger.configure_mock(**{'error.side_effect': RuntimeError})
self.listen(EventName.tick)
self.after(2,EventName.end)
self.timer.wait_for = Mock(side_effect=self.count_down_ticks)
self.exchange.original_publish = self.exchange.publish
self.exchange.publish = self.intercept_publish
event_source = EventSource(self.exchange,self.timer, failing_logger,CONFIG)
event_source.start()
failing_logger.error.assert_has_calls([call('EventSource, RuntimeError: oops')])
self.assertEqual(self.event_count,2)
