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 stop(self) -> None:
self._consumer_configuration.pipeline.put(create_quit_message())
def stop(self):
self._queue.put(create_quit_message())
self._state = ChannelState.stopping