def test_the_pump_should_fail_on_a_missing_message_mapper(self):
"""
Given that I have a message pump for a channel
When there is no message mapper for that channel
Then we shhould throw an exception to indicate a configuration error
"""
handler = MyCommandHandler()
request = MyCommand()
channel = Mock(spec=Channel)
command_processor = Mock(spec=CommandProcessor)
message_pump = MessagePump(command_processor, channel, None)
header = BrightsideMessageHeader(uuid4(), request.__class__.__name__, BrightsideMessageType.MT_COMMAND)
body = BrightsideMessageBody(JsonRequestSerializer(request=request).serialize_to_json(),
BrightsideMessageBodyType.application_json)
message = BrightsideMessage(header, body)
quit_message = create_quit_message()
# add messages to that when channel is called it returns first message then qui tmessage
response_queue = [message, quit_message]
channel_spec = {"receive.side_effect": response_queue}
channel.configure_mock(**channel_spec)
excepton_caught = False
try:
message_pump.run()
except ConfigurationException:
excepton_caught = True
self.assertTrue(excepton_caught)
def test_the_pump_should_dispatch_a_command_processor(self):
"""
Given that I have a message pump for a channel
When I read a message from that channel
Then the message should be dispatched to a handler
"""
handler = MyCommandHandler()
request = MyCommand()
channel = Mock(spec=Channel)
command_processor = Mock(spec=CommandProcessor)
message_pump = MessagePump(command_processor, channel, map_my_command_to_request)
header = BrightsideMessageHeader(uuid4(), request.__class__.__name__, BrightsideMessageType.MT_COMMAND)
body = BrightsideMessageBody(JsonRequestSerializer(request=request).serialize_to_json(),
BrightsideMessageBodyType.application_json)
message = BrightsideMessage(header, body)
quit_message = create_quit_message()
# add messages to that when channel is called it returns first message then quit message
response_queue = [message, quit_message]
channel_spec = {"receive.side_effect": response_queue}
channel.configure_mock(**channel_spec)
message_pump.run()
channel.receive.assert_called_with(0.5)
self.assertEqual(channel.receive.call_count, 2)
self.assertTrue(command_processor.send.call_count, 1)
self.assertEqual(channel.acknowledge.call_count, 1)
def test_the_pump_should_ack_failed_messages(self):
"""
Given that I have a message pump for a channel
When the handler raises an application exception for that message
Then ack the message to prevent 'poison pill' message
"""
handler = MyCommandHandler()
request = MyCommand()
channel = Mock(spec=Channel)
command_processor = Mock(spec=CommandProcessor)
message_pump = MessagePump(command_processor, channel, map_my_command_to_request)
header = BrightsideMessageHeader(uuid4(), request.__class__.__name__, BrightsideMessageType.MT_COMMAND)
body = BrightsideMessageBody(JsonRequestSerializer(request=request).serialize_to_json(),
BrightsideMessageBodyType.application_json)
message = BrightsideMessage(header, body)
quit_message = create_quit_message()
# add messages to that when channel is called it returns first message then qui tmessage
response_queue = [message, quit_message]
channel_spec = {"receive.side_effect": response_queue}
channel.configure_mock(**channel_spec)
app_error_spec = {"send.side_effect": ZeroDivisionError()}
command_processor.configure_mock(**app_error_spec)
message_pump.run()
channel.receive.assert_called_with(0.5)
self.assertEqual(channel.receive.call_count, 2)
self.assertTrue(command_processor.send.call_count, 1)
self.assertEqual(channel.acknowledge.call_count, 1)
def test_the_pump_should_acknowledge_and_discard_an_unacceptable_message(self):
"""
Given that I have a message pump for a channel
When I cannot read the message received from that channel
Then I should acknowledge the message to dicard it
"""
handler = MyCommandHandler()
request = MyCommand()
channel = Mock(spec=Channel)
command_processor = Mock(spec=CommandProcessor)
message_pump = MessagePump(command_processor, channel, map_my_command_to_request)
header = BrightsideMessageHeader(uuid4(), request.__class__.__name__, BrightsideMessageType.MT_UNACCEPTABLE)
body = BrightsideMessageBody(JsonRequestSerializer(request=request).serialize_to_json(),
BrightsideMessageBodyType.application_json)
message = BrightsideMessage(header, body)
quit_message = create_quit_message()
# add messages to that when channel is called it returns first message then qui tmessage
response_queue = [message, quit_message]
channel_spec = {"receive.side_effect": response_queue}
channel.configure_mock(**channel_spec)
message_pump.run()
channel.receive.assert_called_with(0.5)
self.assertEqual(channel.receive.call_count, 2)
# We acknowledge so that a 'poison pill' message cannot block our queue
self.assertEqual(channel.acknowledge.call_count, 1)
# Does not send the message, just discards it
self.assertEqual(command_processor.send.call_count, 0)
def test_handle_command(self):
""" given that we have a handler registered for a command, when we send a command, it should call the handler"""
self._handler = MyCommandHandler()
self._request = MyCommand()
self._subscriber_registry.register(MyCommand, lambda: self._handler)
self._commandProcessor.send(self._request)
self.assertTrue(self._handler.called, "Expected the handle method on the handler to be called with the message")
def test_missing_command_handler_registration(self):
"""Given that we are missing a handler for a command, when we send a command, it should throw an exception"""
self._handler = MyCommandHandler()
self._request = MyCommand()
exception_thrown = False
try:
self._commandProcessor.send(self._request)
except:
exception_thrown = True
self.assertTrue(exception_thrown, "Expected an exception to be thrown when no handler is registered for a command")
def test_logging_a_handler(self):
"""s
Given that I have a handler decorated for logging
When I call that handler
Then I should receive logs indicating the call and return of the handler
* N.b. This is an example of using decorators to extend the Brightside pipeline
"""
handler = MyCommandHandler()
request = MyCommand()
self._subscriber_registry.register(MyCommand, lambda: handler)
logger = logging.getLogger("tests.handlers_testdoubles")
with patch.object(logger, 'log') as mock_log:
self._commandProcessor.send(request)
mock_log.assert_has_calls([
call(logging.DEBUG, "Entering handle " + str(request)),
call(logging.DEBUG, "Exiting handle " + str(request))
])
def test_handle_requeue_has_upper_bound(self):
"""
Given that I have a channel
When I receive a requeue on that channel
I should ask the consumer to requeue, up to a retry limit
So that poison messages do not fill our queues
"""
handler = MyCommandHandler()
request = MyCommand()
channel = FakeChannel(name="MyCommand")
command_processor = Mock(spec=CommandProcessor)
message_pump = MessagePump(command_processor, channel, map_my_command_to_request, requeue_count=3)
header = BrightsideMessageHeader(uuid4(), request.__class__.__name__, BrightsideMessageType.MT_COMMAND)
body = BrightsideMessageBody(JsonRequestSerializer(request=request).serialize_to_json(),
BrightsideMessageBodyType.application_json)
message = BrightsideMessage(header, body)
channel.add(message)
requeue_spec = {"send.side_effect": DeferMessageException()}
command_processor.configure_mock(**requeue_spec)
started_event = Event()
t = Thread(target=message_pump.run, args=(started_event,))
t.start()
started_event.wait()
time.sleep(1)
channel.stop()
t.join()
self.assertTrue(command_processor.send.call_count, 3)