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)