def tearDown(self) -> None:
# Delete any queues and exchanges which are common across many tests
connect_to_rabbit(self.test_telegram_commands_handler.rabbitmq)
delete_queue_if_exists(self.test_telegram_commands_handler.rabbitmq,
self.test_rabbit_queue_name)
delete_queue_if_exists(
self.test_telegram_commands_handler.rabbitmq, self.
test_telegram_commands_handler._telegram_commands_handler_queue)
delete_exchange_if_exists(self.test_telegram_commands_handler.rabbitmq,
HEALTH_CHECK_EXCHANGE)
disconnect_from_rabbit(self.test_telegram_commands_handler.rabbitmq)
self.dummy_logger = None
self.test_channel_logger = None
self.test_command_handlers_logger = None
self.rabbitmq = None
self.cmd_handlers_rabbit = None
self.test_alert = None
self.test_channel = None
self.test_api = None
self.redis = None
self.mongo = None
self.test_telegram_commands_handler._updater.stop()
self.test_telegram_command_handlers = None
self.test_telegram_commands_handler = None
def test_send_data(self, config: Dict[str, Any]):
route_key = "test.route"
CONFIG_QUEUE = "hb_test"
try:
self.test_config_manager._initialise_rabbitmq()
connect_to_rabbit(self.rabbitmq)
queue_res = self.rabbitmq.queue_declare(queue=CONFIG_QUEUE,
durable=True,
exclusive=False,
auto_delete=False,
passive=False)
self.assertEqual(0, queue_res.method.message_count)
self.rabbitmq.queue_bind(CONFIG_QUEUE, CONFIG_EXCHANGE, route_key)
self.test_config_manager._send_data(copy.deepcopy(config),
route_key)
# By re-declaring the queue again we can get the number of messages
# in the queue.
queue_res = self.rabbitmq.queue_declare(queue=CONFIG_QUEUE,
durable=True,
exclusive=False,
auto_delete=False,
passive=True)
self.assertEqual(1, queue_res.method.message_count)
# Check that the message received is what's expected
_, _, body = self.rabbitmq.basic_get(CONFIG_QUEUE)
self.assertDictEqual(config, json.loads(body))
finally:
delete_queue_if_exists(self.rabbitmq, CONFIG_QUEUE)
disconnect_from_rabbit(self.test_config_manager._rabbitmq)
disconnect_from_rabbit(self.test_config_manager._heartbeat_rabbit)
def test__process_ping_sends_valid_hb(self, mock_is_alive: MagicMock):
mock_is_alive.return_value = True
expected_output = {
'component_name':
self.CONFIG_MANAGER_NAME,
'is_alive':
True,
'timestamp':
datetime(year=1997,
month=8,
day=15,
hour=10,
minute=21,
second=33,
microsecond=30).timestamp()
}
HEARTBEAT_QUEUE = "hb_test"
try:
connect_to_rabbit(self.rabbitmq)
self.rabbitmq.exchange_declare(HEALTH_CHECK_EXCHANGE, "topic",
False, True, False, False)
queue_res = self.rabbitmq.queue_declare(queue=HEARTBEAT_QUEUE,
durable=True,
exclusive=False,
auto_delete=False,
passive=False)
self.assertEqual(0, queue_res.method.message_count)
self.rabbitmq.queue_bind(HEARTBEAT_QUEUE, HEALTH_CHECK_EXCHANGE,
"heartbeat.*")
self.test_config_manager._initialise_rabbitmq()
blocking_channel = self.test_config_manager._rabbitmq.channel
method_chains = pika.spec.Basic.Deliver(routing_key="ping")
properties = pika.spec.BasicProperties()
self.test_config_manager._process_ping(blocking_channel,
method_chains, properties,
b"ping")
# By re-declaring the queue again we can get the number of messages
# in the queue.
queue_res = self.rabbitmq.queue_declare(queue=HEARTBEAT_QUEUE,
durable=True,
exclusive=False,
auto_delete=False,
passive=True)
self.assertEqual(1, queue_res.method.message_count)
# Check that the message received is a valid HB
_, _, body = self.rabbitmq.basic_get(HEARTBEAT_QUEUE)
self.assertDictEqual(expected_output, json.loads(body))
finally:
delete_queue_if_exists(self.rabbitmq, HEARTBEAT_QUEUE)
delete_exchange_if_exists(self.rabbitmq, HEALTH_CHECK_EXCHANGE)
disconnect_from_rabbit(self.test_config_manager._rabbitmq)
disconnect_from_rabbit(self.test_config_manager._heartbeat_rabbit)
def test_initialise_rabbitmq_initialises_rabbit_correctly(self) -> None:
try:
# To make sure that there is no connection/channel already
# established
self.assertIsNone(self.rabbitmq.connection)
self.assertIsNone(self.rabbitmq.channel)
# To make sure that the exchanges and queues have not already been
# declared
connect_to_rabbit(self.rabbitmq)
self.test_telegram_commands_handler.rabbitmq.queue_delete(
self.test_telegram_commands_handler.
_telegram_commands_handler_queue)
self.test_telegram_commands_handler.rabbitmq.exchange_delete(
HEALTH_CHECK_EXCHANGE)
disconnect_from_rabbit(self.rabbitmq)
self.test_telegram_commands_handler._initialise_rabbitmq()
# Perform checks that the connection has been opened and marked as
# open, that the delivery confirmation variable is set and basic_qos
# called successfully.
self.assertTrue(
self.test_telegram_commands_handler.rabbitmq.is_connected)
self.assertTrue(self.test_telegram_commands_handler.rabbitmq.
connection.is_open)
self.assertTrue(self.test_telegram_commands_handler.rabbitmq.
channel._delivery_confirmation)
# Check whether the consuming exchanges and queues have been
# creating by sending messages with the same routing keys as for the
# bindings. We will also check if the size of the queues is 0 to
# confirm that basic_consume was called (it will store the msg in
# the component memory immediately). If one of the exchanges or
# queues is not created or basic_consume is not called, then either
# an exception will be thrown or the queue size would be 1
# respectively. Note when deleting the exchanges in the beginning we
# also released every binding, hence there are no other queue binded
# with the same routing key to any exchange at this point.
self.test_telegram_commands_handler.rabbitmq.basic_publish_confirm(
exchange=HEALTH_CHECK_EXCHANGE,
routing_key=TCH_INPUT_ROUTING_KEY,
body=self.test_data_str,
is_body_dict=False,
properties=pika.BasicProperties(delivery_mode=2),
mandatory=True)
# Re-declare queue to get the number of messages
res = self.test_telegram_commands_handler.rabbitmq.queue_declare(
self.test_telegram_commands_handler.
_telegram_commands_handler_queue, False, True, False, False)
self.assertEqual(0, res.method.message_count)
except Exception as e:
self.fail("Test failed: {}".format(e))
def tearDown(self) -> None:
connect_to_rabbit(self.rabbitmq)
delete_queue_if_exists(self.rabbitmq, DATA_STORE_MAN_INPUT_QUEUE)
delete_exchange_if_exists(self.rabbitmq, HEALTH_CHECK_EXCHANGE)
disconnect_from_rabbit(self.rabbitmq)
connect_to_rabbit(self.test_rabbit_manager)
delete_queue_if_exists(self.test_rabbit_manager, self.test_queue_name)
disconnect_from_rabbit(self.test_rabbit_manager)
self.dummy_logger = None
self.dummy_process = None
self.connection_check_time_interval = None
self.rabbitmq = None
self.test_rabbit_manager = None
def test_start_after_watching(self, mock_observer_start: MagicMock,
mock_foreach: MagicMock,
mock_initialise_rabbit: MagicMock):
self.test_config_manager._watching = True
mock_foreach.return_value = None
mock_initialise_rabbit.return_value = None
mock_observer_start.return_value = None
self.test_config_manager.start()
mock_initialise_rabbit.assert_called_once()
mock_foreach.assert_called_once()
mock_observer_start.assert_not_called()
disconnect_from_rabbit(self.test_config_manager._rabbitmq)
disconnect_from_rabbit(self.test_config_manager._heartbeat_rabbit)
def tearDown(self) -> None:
connect_to_rabbit(self.rabbitmq)
delete_queue_if_exists(self.rabbitmq, STORE_CONFIGS_QUEUE_NAME)
delete_exchange_if_exists(self.rabbitmq, CONFIG_EXCHANGE)
delete_exchange_if_exists(self.rabbitmq, HEALTH_CHECK_EXCHANGE)
disconnect_from_rabbit(self.rabbitmq)
connect_to_rabbit(self.test_rabbit_manager)
delete_queue_if_exists(self.test_rabbit_manager, self.test_queue_name)
disconnect_from_rabbit(self.test_rabbit_manager)
self.redis.delete_all_unsafe()
self.redis = None
self.dummy_logger = None
self.connection_check_time_interval = None
self.rabbitmq = None
self.test_rabbit_manager = None
def tearDown(self) -> None:
# flush and consume all from rabbit queues and exchanges
connect_to_rabbit(self.rabbitmq)
queues = [CONFIG_PING_QUEUE]
for queue in queues:
delete_queue_if_exists(self.rabbitmq, queue)
exchanges = [CONFIG_EXCHANGE, HEALTH_CHECK_EXCHANGE]
for exchange in exchanges:
delete_exchange_if_exists(self.rabbitmq, exchange)
disconnect_from_rabbit(self.rabbitmq)
self.rabbitmq = None
self.test_config_manager._rabbitmq = None
self.test_config_manager._heartbeat_rabbit = None
self.test_config_manager = None
def tearDown(self) -> None:
connect_to_rabbit(self.rabbitmq)
delete_queue_if_exists(self.rabbitmq, ALERT_STORE_INPUT_QUEUE)
delete_exchange_if_exists(self.rabbitmq, STORE_EXCHANGE)
delete_exchange_if_exists(self.rabbitmq, HEALTH_CHECK_EXCHANGE)
disconnect_from_rabbit(self.rabbitmq)
connect_to_rabbit(self.test_rabbit_manager)
delete_queue_if_exists(self.test_rabbit_manager, self.test_queue_name)
disconnect_from_rabbit(self.test_rabbit_manager)
self.dummy_logger = None
self.connection_check_time_interval = None
self.rabbitmq = None
self.test_rabbit_manager = None
self.redis.delete_all_unsafe()
self.redis = None
self.mongo.drop_collection(self.parent_id)
self.mongo = None
self.test_store = None
def tearDown(self) -> None:
# Delete any queues and exchanges which are common across many tests
connect_to_rabbit(self.test_console_alerts_handler.rabbitmq)
delete_queue_if_exists(self.test_console_alerts_handler.rabbitmq,
self.test_rabbit_queue_name)
delete_queue_if_exists(
self.test_console_alerts_handler.rabbitmq,
self.test_console_alerts_handler._console_alerts_handler_queue)
delete_exchange_if_exists(self.test_console_alerts_handler.rabbitmq,
HEALTH_CHECK_EXCHANGE)
delete_exchange_if_exists(self.test_console_alerts_handler.rabbitmq,
ALERT_EXCHANGE)
disconnect_from_rabbit(self.test_console_alerts_handler.rabbitmq)
self.dummy_logger = None
self.test_channel_logger = None
self.rabbitmq = None
self.test_channel = None
self.test_console_alerts_handler = None
self.test_alert = None
def test__initialise_rabbit_initialises_queues(
self, queue_to_check: str, mock_basic_qos: MagicMock,
mock_basic_consume: MagicMock, mock_confirm_delivery: MagicMock):
mock_basic_consume.return_value = None
mock_confirm_delivery.return_value = None
try:
connect_to_rabbit(self.rabbitmq)
# Testing this separately since this is a critical function
self.test_config_manager._initialise_rabbitmq()
mock_basic_qos.assert_called_once()
mock_basic_consume.assert_called_once()
mock_confirm_delivery.assert_called()
self.rabbitmq.queue_declare(queue_to_check, passive=True)
except pika.exceptions.ConnectionClosedByBroker:
self.fail("Queue {} was not declared".format(queue_to_check))
finally:
disconnect_from_rabbit(self.test_config_manager._rabbitmq)
disconnect_from_rabbit(self.test_config_manager._heartbeat_rabbit)