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(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_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 _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_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 test_postencode(self): m = Message(text_t('FOO'), channel=self.channel, postencode='ccyzz') with pytest.raises(LookupError): m._reraise_error() m.ack()
def setUp(self): self.conn = Connection("memory://") self.channel = self.conn.channel() self.message = Message(self.channel, delivery_tag=313)