def test_assert_handlers_called(self):
handler_vars = {
"create_handler_called": False,
"update_handler_called": False,
"delete_handler_called": False,
}
def create_handler(sensor_db):
handler_vars["create_handler_called"] = True
def update_handler(sensor_db):
handler_vars["update_handler_called"] = True
def delete_handler(sensor_db):
handler_vars["delete_handler_called"] = True
sensor_watcher = SensorWatcher(create_handler, update_handler,
delete_handler)
message = Message(None, delivery_info={"routing_key": "create"})
sensor_watcher.process_task(MOCK_SENSOR_DB, message)
self.assertTrue(handler_vars["create_handler_called"],
"create handler should be called.")
message = Message(None, delivery_info={"routing_key": "update"})
sensor_watcher.process_task(MOCK_SENSOR_DB, message)
self.assertTrue(handler_vars["update_handler_called"],
"update handler should be called.")
message = Message(None, delivery_info={"routing_key": "delete"})
sensor_watcher.process_task(MOCK_SENSOR_DB, message)
self.assertTrue(handler_vars["delete_handler_called"],
"delete handler should be called.")
def test_assert_handlers_called(self):
handler_vars = {
'create_handler_called': False,
'update_handler_called': False,
'delete_handler_called': False
}
def create_handler(sensor_db):
handler_vars['create_handler_called'] = True
def update_handler(sensor_db):
handler_vars['update_handler_called'] = True
def delete_handler(sensor_db):
handler_vars['delete_handler_called'] = True
sensor_watcher = SensorWatcher(create_handler, update_handler, delete_handler)
message = Message(None, delivery_info={'routing_key': 'create'})
sensor_watcher.process_task(MOCK_SENSOR_DB, message)
self.assertTrue(handler_vars['create_handler_called'], 'create handler should be called.')
message = Message(None, delivery_info={'routing_key': 'update'})
sensor_watcher.process_task(MOCK_SENSOR_DB, message)
self.assertTrue(handler_vars['update_handler_called'], 'update handler should be called.')
message = Message(None, delivery_info={'routing_key': 'delete'})
sensor_watcher.process_task(MOCK_SENSOR_DB, message)
self.assertTrue(handler_vars['delete_handler_called'], 'delete handler should be called.')
def test_decode(self):
m = Message('body', channel=Mock())
decode = m._decode = Mock()
assert m._decoded_cache is None
assert m.decode() is m._decode.return_value
assert m._decoded_cache is m._decode.return_value
m._decode.assert_called_with()
m._decode = Mock()
assert m.decode() is decode.return_value
def test_decode(self):
m = Message(Mock(), "body")
decode = m._decode = Mock()
self.assertIsNone(m._decoded_cache)
self.assertIs(m.decode(), m._decode.return_value)
self.assertIs(m._decoded_cache, m._decode.return_value)
m._decode.assert_called_with()
m._decode = Mock()
self.assertIs(m.decode(), decode.return_value)
def test_decode(self):
m = Message('body', channel=Mock())
decode = m._decode = Mock()
assert m._decoded_cache is None
assert m.decode() is m._decode.return_value
assert m._decoded_cache is m._decode.return_value
m._decode.assert_called_with()
m._decode = Mock()
assert m.decode() is decode.return_value
def test_decode(self):
m = Message(Mock(), 'body')
decode = m._decode = Mock()
self.assertIsNone(m._decoded_cache)
self.assertIs(m.decode(), m._decode.return_value)
self.assertIs(m._decoded_cache, m._decode.return_value)
m._decode.assert_called_with()
m._decode = Mock()
self.assertIs(m.decode(), decode.return_value)
def test_reraise_error(self):
m = Message(Mock(), 'body')
callback = Mock(name='callback')
try:
raise KeyError('foo')
except KeyError:
m.errors.append(sys.exc_info())
m._reraise_error(callback)
self.assertTrue(callback.called)
with self.assertRaises(KeyError):
m._reraise_error(None)
def test_reraise_error(self):
m = Message('body', channel=Mock())
callback = Mock(name='callback')
try:
raise KeyError('foo')
except KeyError:
m.errors.append(sys.exc_info())
m._reraise_error(callback)
callback.assert_called()
with pytest.raises(KeyError):
m._reraise_error(None)
def test_reraise_error(self):
m = Message(Mock(), "body")
callback = Mock(name="callback")
try:
raise KeyError("foo")
except KeyError:
m.errors.append(sys.exc_info())
m._reraise_error(callback)
callback.assert_called()
with self.assertRaises(KeyError):
m._reraise_error(None)
def test_unexpected_correlation_id(container_factory, rabbit_config):
container = container_factory(FooService, rabbit_config)
container.start()
with ServiceRpcProxy("foobar", rabbit_config) as proxy:
message = Message(channel=None, properties={
'reply_to': proxy.reply_listener.routing_key,
'correlation_id': 'invalid',
})
responder = Responder(container.config, message)
with patch('nameko.standalone.rpc._logger', autospec=True) as logger:
responder.send_response(None, None)
assert proxy.spam(ham='eggs') == 'eggs'
assert logger.debug.call_count == 1
def test_reraise_error(self):
m = Message(Mock(), 'body')
callback = Mock(name='callback')
try:
raise KeyError('foo')
except KeyError as exc:
m.errors.append(sys.exc_info())
m._reraise_error(callback)
self.assertTrue(callback.called)
with self.assertRaises(KeyError):
m._reraise_error(None)
def test_reraise_error(self):
m = Message('body', channel=Mock())
callback = Mock(name='callback')
try:
raise KeyError('foo')
except KeyError:
m.errors.append(sys.exc_info())
m._reraise_error(callback)
callback.assert_called()
with pytest.raises(KeyError):
m._reraise_error(None)
def test_handle_message(self, monkeypatch, mongo_db_mock, body,
routing_key, expected_save_data):
body = json.dumps(body)
monkeypatch.setattr(LoggingConsumerStep, "connect_db", Mock())
logging_consumer = LoggingConsumerStep(None)
logging_consumer.db = mongo_db_mock
msg = Message(Mock(),
body=body,
delivery_info={'routing_key': routing_key})
def tested_func():
logging_consumer.handle_message(body, msg)
if expected_save_data is not None:
tested_func()
mongo_db_mock.logs.insert_one.assert_called_once_with(
expected_save_data)
else:
with raises(TypeError):
tested_func()
def test_nova_consumer_bad_provider():
consumer = NovaRpcConsumer()
consumer.container = Mock()
message = Message(
channel=None,
delivery_info={'routing_key': 'some route'},
properties={},
)
with patch.multiple(
consumer,
get_provider_for_method=DEFAULT,
handle_result=DEFAULT,
) as mocks:
provider = mocks['get_provider_for_method']
handle_result = mocks['handle_result']
exception = LookupError('broken')
provider.side_effect = exception
consumer.handle_message({'args': ()}, message)
assert handle_result.call_count == 1
args, kwargs = handle_result.call_args
exc_info = args[-1]
exc_type, exc_value, traceback = exc_info
assert exc_value is exception
def setup(self):
self.conn = Connection('memory://')
self.channel = self.conn.channel()
self.message = Message(channel=self.channel, delivery_tag=313)
def test_postencode(self):
m = Message('FOO', channel=self.channel, postencode='ccyzz')
with pytest.raises(LookupError):
m._reraise_error()
m.ack()
def test_decompression_stores_error(self, decompress):
decompress.side_effect = RuntimeError()
m = Message(Mock(), 'body', headers={'compression': 'zlib'})
with self.assertRaises(RuntimeError):
m._reraise_error(None)
class test_Message:
def setup(self):
self.conn = Connection('memory://')
self.channel = self.conn.channel()
self.message = Message(channel=self.channel, delivery_tag=313)
def test_postencode(self):
m = Message('FOO', channel=self.channel, postencode='ccyzz')
with pytest.raises(LookupError):
m._reraise_error()
m.ack()
def test_ack_respects_no_ack_consumers(self):
self.channel.no_ack_consumers = {'abc'}
self.message.delivery_info['consumer_tag'] = 'abc'
ack = self.channel.basic_ack = Mock()
self.message.ack()
assert self.message._state != 'ACK'
ack.assert_not_called()
def test_ack_missing_consumer_tag(self):
self.channel.no_ack_consumers = {'abc'}
self.message.delivery_info = {}
ack = self.channel.basic_ack = Mock()
self.message.ack()
ack.assert_called_with(self.message.delivery_tag, multiple=False)
def test_ack_not_no_ack(self):
self.channel.no_ack_consumers = set()
self.message.delivery_info['consumer_tag'] = 'abc'
ack = self.channel.basic_ack = Mock()
self.message.ack()
ack.assert_called_with(self.message.delivery_tag, multiple=False)
def test_ack_log_error_when_no_error(self):
ack = self.message.ack = Mock()
self.message.ack_log_error(Mock(), KeyError)
ack.assert_called_with(multiple=False)
def test_ack_log_error_when_error(self):
ack = self.message.ack = Mock()
ack.side_effect = KeyError('foo')
logger = Mock()
self.message.ack_log_error(logger, KeyError)
ack.assert_called_with(multiple=False)
logger.critical.assert_called()
assert "Couldn't ack" in logger.critical.call_args[0][0]
def test_reject_log_error_when_no_error(self):
reject = self.message.reject = Mock()
self.message.reject_log_error(Mock(), KeyError, requeue=True)
reject.assert_called_with(requeue=True)
def test_reject_log_error_when_error(self):
reject = self.message.reject = Mock()
reject.side_effect = KeyError('foo')
logger = Mock()
self.message.reject_log_error(logger, KeyError)
reject.assert_called_with(requeue=False)
logger.critical.assert_called()
assert "Couldn't reject" in logger.critical.call_args[0][0]
class test_Message(Case):
def setUp(self):
self.conn = Connection('memory://')
self.channel = self.conn.channel()
self.message = Message(self.channel, delivery_tag=313)
def test_postencode(self):
m = Message(self.channel, text_t('FOO'), postencode='ccyzz')
with self.assertRaises(LookupError):
m._reraise_error()
m.ack()
def test_ack_respects_no_ack_consumers(self):
self.channel.no_ack_consumers = set(['abc'])
self.message.delivery_info['consumer_tag'] = 'abc'
ack = self.channel.basic_ack = Mock()
self.message.ack()
self.assertNotEqual(self.message._state, 'ACK')
self.assertFalse(ack.called)
def test_ack_missing_consumer_tag(self):
self.channel.no_ack_consumers = set(['abc'])
self.message.delivery_info = {}
ack = self.channel.basic_ack = Mock()
self.message.ack()
ack.assert_called_with(self.message.delivery_tag)
def test_ack_not_no_ack(self):
self.channel.no_ack_consumers = set()
self.message.delivery_info['consumer_tag'] = 'abc'
ack = self.channel.basic_ack = Mock()
self.message.ack()
ack.assert_called_with(self.message.delivery_tag)
def test_ack_log_error_when_no_error(self):
ack = self.message.ack = Mock()
self.message.ack_log_error(Mock(), KeyError)
ack.assert_called_with()
def test_ack_log_error_when_error(self):
ack = self.message.ack = Mock()
ack.side_effect = KeyError('foo')
logger = Mock()
self.message.ack_log_error(logger, KeyError)
ack.assert_called_with()
self.assertTrue(logger.critical.called)
self.assertIn("Couldn't ack", logger.critical.call_args[0][0])
def test_reject_log_error_when_no_error(self):
reject = self.message.reject = Mock()
self.message.reject_log_error(Mock(), KeyError, requeue=True)
reject.assert_called_with(requeue=True)
def test_reject_log_error_when_error(self):
reject = self.message.reject = Mock()
reject.side_effect = KeyError('foo')
logger = Mock()
self.message.reject_log_error(logger, KeyError)
reject.assert_called_with(requeue=False)
self.assertTrue(logger.critical.called)
self.assertIn("Couldn't reject", logger.critical.call_args[0][0])
def test_decompression_stores_error(self, decompress):
decompress.side_effect = RuntimeError()
m = Message(Mock(), "body", headers={"compression": "zlib"})
with self.assertRaises(RuntimeError):
m._reraise_error(None)
def test_decompression_stores_error(self, decompress):
decompress.side_effect = RuntimeError()
m = Message('body', channel=Mock(), headers={'compression': 'zlib'})
with pytest.raises(RuntimeError):
m._reraise_error(None)
def test_repr(self):
assert repr(Message('b', channel=Mock()))
def test_postencode(self):
with self.assertRaises(LookupError):
Message(self.channel, text_t('FOO'), postencode='ccyzz')
def test_postencode(self):
m = Message(self.channel, text_t('FOO'), postencode='ccyzz')
with self.assertRaises(LookupError):
m._reraise_error()
m.ack()
def test_postencode(self):
m = Message(self.channel, text_t('FOO'), postencode='ccyzz')
with self.assertRaises(LookupError):
m._reraise_error()
m.ack()
def _read_message(body: str, msg: KombuMessage) -> None:
self._logger.debug("Monitoring event received at: %s headers: %s payload: %s", datetime.utcnow().isoformat(), msg.headers, body)
self._message = self._message_factory.create_message(msg)
msg.ack()
def test_repr(self):
assert repr(Message(Mock(), 'b'))
def test_decompression_stores_error(self, decompress):
decompress.side_effect = RuntimeError()
m = Message(Mock(), 'body', headers={'compression': 'zlib'})
with self.assertRaises(RuntimeError):
m._reraise_error(None)
def test_repr(self):
self.assertTrue(repr(Message(Mock(), 'b')))
class test_Message:
def setup(self):
self.conn = Connection('memory://')
self.channel = self.conn.channel()
self.message = Message(channel=self.channel, delivery_tag=313)
def test_postencode(self):
m = Message(text_t('FOO'), channel=self.channel, postencode='ccyzz')
with pytest.raises(LookupError):
m._reraise_error()
m.ack()
def test_ack_respects_no_ack_consumers(self):
self.channel.no_ack_consumers = {'abc'}
self.message.delivery_info['consumer_tag'] = 'abc'
ack = self.channel.basic_ack = Mock()
self.message.ack()
assert self.message._state != 'ACK'
ack.assert_not_called()
def test_ack_missing_consumer_tag(self):
self.channel.no_ack_consumers = {'abc'}
self.message.delivery_info = {}
ack = self.channel.basic_ack = Mock()
self.message.ack()
ack.assert_called_with(self.message.delivery_tag, multiple=False)
def test_ack_not_no_ack(self):
self.channel.no_ack_consumers = set()
self.message.delivery_info['consumer_tag'] = 'abc'
ack = self.channel.basic_ack = Mock()
self.message.ack()
ack.assert_called_with(self.message.delivery_tag, multiple=False)
def test_ack_log_error_when_no_error(self):
ack = self.message.ack = Mock()
self.message.ack_log_error(Mock(), KeyError)
ack.assert_called_with(multiple=False)
def test_ack_log_error_when_error(self):
ack = self.message.ack = Mock()
ack.side_effect = KeyError('foo')
logger = Mock()
self.message.ack_log_error(logger, KeyError)
ack.assert_called_with(multiple=False)
logger.critical.assert_called()
assert "Couldn't ack" in logger.critical.call_args[0][0]
def test_reject_log_error_when_no_error(self):
reject = self.message.reject = Mock()
self.message.reject_log_error(Mock(), KeyError, requeue=True)
reject.assert_called_with(requeue=True)
def test_reject_log_error_when_error(self):
reject = self.message.reject = Mock()
reject.side_effect = KeyError('foo')
logger = Mock()
self.message.reject_log_error(logger, KeyError)
reject.assert_called_with(requeue=False)
logger.critical.assert_called()
assert "Couldn't reject" in logger.critical.call_args[0][0]
class test_Message(Case):
def setUp(self):
self.conn = Connection('memory://')
self.channel = self.conn.channel()
self.message = Message(self.channel, delivery_tag=313)
def test_postencode(self):
m = Message(self.channel, text_t('FOO'), postencode='ccyzz')
with self.assertRaises(LookupError):
m._reraise_error()
m.ack()
def test_ack_respects_no_ack_consumers(self):
self.channel.no_ack_consumers = {'abc'}
self.message.delivery_info['consumer_tag'] = 'abc'
ack = self.channel.basic_ack = Mock()
self.message.ack()
self.assertNotEqual(self.message._state, 'ACK')
self.assertFalse(ack.called)
def test_ack_missing_consumer_tag(self):
self.channel.no_ack_consumers = {'abc'}
self.message.delivery_info = {}
ack = self.channel.basic_ack = Mock()
self.message.ack()
ack.assert_called_with(self.message.delivery_tag)
def test_ack_not_no_ack(self):
self.channel.no_ack_consumers = set()
self.message.delivery_info['consumer_tag'] = 'abc'
ack = self.channel.basic_ack = Mock()
self.message.ack()
ack.assert_called_with(self.message.delivery_tag)
def test_ack_log_error_when_no_error(self):
ack = self.message.ack = Mock()
self.message.ack_log_error(Mock(), KeyError)
ack.assert_called_with()
def test_ack_log_error_when_error(self):
ack = self.message.ack = Mock()
ack.side_effect = KeyError('foo')
logger = Mock()
self.message.ack_log_error(logger, KeyError)
ack.assert_called_with()
self.assertTrue(logger.critical.called)
self.assertIn("Couldn't ack", logger.critical.call_args[0][0])
def test_reject_log_error_when_no_error(self):
reject = self.message.reject = Mock()
self.message.reject_log_error(Mock(), KeyError, requeue=True)
reject.assert_called_with(requeue=True)
def test_reject_log_error_when_error(self):
reject = self.message.reject = Mock()
reject.side_effect = KeyError('foo')
logger = Mock()
self.message.reject_log_error(logger, KeyError)
reject.assert_called_with(requeue=False)
self.assertTrue(logger.critical.called)
self.assertIn("Couldn't reject", logger.critical.call_args[0][0])
def setup(self):
self.conn = Connection('memory://')
self.channel = self.conn.channel()
self.message = Message(channel=self.channel, delivery_tag=313)
def test_postencode(self):
m = Message(text_t('FOO'), channel=self.channel, postencode='ccyzz')
with pytest.raises(LookupError):
m._reraise_error()
m.ack()
def test_decompression_stores_error(self, decompress):
decompress.side_effect = RuntimeError()
m = Message('body', channel=Mock(), headers={'compression': 'zlib'})
with pytest.raises(RuntimeError):
m._reraise_error(None)
def setUp(self):
self.conn = Connection("memory://")
self.channel = self.conn.channel()
self.message = Message(self.channel, delivery_tag=313)
