def test_should_publish_consume_with_event_handler_with_default_parameters_when_success_consumer( given_any_petisco ): spy = SpyEvents() @event_handler() def assert_consumer(event: Event) -> Result[bool, Error]: spy.append(event) return isSuccess event = EventUserCreatedMother.random() subscribers = [ EventSubscriber( event_name=event.event_name, event_version=event.event_version, handlers=[assert_consumer], ) ] configurer = RabbitMqEventConfigurerMother.default() configurer.configure_subscribers(subscribers) bus = RabbitMqEventBusMother.default() bus.publish(event) consumer = RabbitMqEventConsumerMother.without_retry() consumer.add_subscribers(subscribers) consumer.start() sleep(1.0) consumer.stop() configurer.clear() spy.assert_number_unique_events(1) spy.assert_first_event(event) spy.assert_count_by_event_id(event.event_id, 1)
def test_should_recover_from_connection_error_when_publish_an_event( make_user_created_event, ): connector = RabbitMqConnector() original_wait_seconds_retry = connector.wait_seconds_retry connector.wait_seconds_retry = 0.1 configurer = RabbitMqEventConfigurerMother.default(connector) event = make_user_created_event() configurer.configure_event(event) bus = RabbitMqEventBusMother.default(connector) connection = connector.get_connection(DEFAULT_EXCHANGE_NAME) connection.close() bus.publish(event) connector.wait_seconds_retry = original_wait_seconds_retry configurer.clear()
def test_should_publish_event_on_consumer_with_event_handler(): spy = SpyEvents() @event_handler(logger=FakeLogger()) def assert_consumer(event: Event, event_bus: IEventBus) -> BoolResult: spy.append(event) event = EventUserUpdatedMother.random() event_bus.publish(event) return isSuccess event = EventUserCreatedMother.random() subscribers = [ EventSubscriber( event_name=event.event_name, event_version=event.event_version, handlers=[assert_consumer], ) ] configurer = RabbitMqEventConfigurerMother.with_retry_ttl_10ms() configurer.configure_subscribers(subscribers) consumer = RabbitMqEventConsumerMother.with_max_retries(1) consumer.add_subscribers(subscribers) consumer.start() bus = RabbitMqEventBusMother.default() for _ in range(1): event = EventUserCreatedMother.random() bus.publish(event) sleep(1.0) consumer.stop() configurer.clear() spy.assert_number_unique_events(1)
def test_should_publish_consume_from_store_queue_from_rabbitmq_with_stop_and_start(): spy = SpyEvents() def assert_consumer_event_store(event: Event) -> BoolResult: spy.append(event) return isSuccess bus = RabbitMqEventBusMother.default() first_event = EventUserCreatedMother.random() configurer = RabbitMqEventConfigurerMother.default() configurer.configure_event(first_event) # First Start & Stop bus.publish(first_event) first_consumer = RabbitMqEventConsumerMother.default() first_consumer.add_handler_on_store(assert_consumer_event_store) first_consumer.start() sleep(1.0) first_consumer.stop() # Second Start & Stop second_event = EventUserCreatedMother.random() second_consumer = RabbitMqEventConsumerMother.default() second_consumer.add_handler_on_store(assert_consumer_event_store) second_consumer.start() bus.publish(second_event) sleep(1.0) second_consumer.stop() configurer.clear() spy.assert_number_unique_events(2) spy.assert_count_by_event_id(first_event.event_id, 1) spy.assert_count_by_event_id(second_event.event_id, 1)
def test_should_publish_event_without_rabbitmq_configuration_and_info_id(): event = EventUserCreatedMother.random() bus = RabbitMqEventBusMother.with_info_id() bus.publish(event) bus.configurer.clear()
def assert_consumer_default_queue(event: Event) -> BoolResult: spy_consumer_default_queue.append(event) bus = RabbitMqEventBusMother.default() bus.retry_publish_only_on_store_queue(event) return isSuccess
def test_should_consumer_react_to_chaos_with_nck_simulation_and_send_event_to_dead_letter(): spy = SpyEvents() spy_dead_letter = SpyEvents() spy_dead_letter_store = SpyEvents() logger = FakeLogger() def assert_consumer(event: Event) -> Result[bool, Error]: spy.append(event) return isSuccess def assert_dead_letter_consumer(event: Event) -> Result[bool, Error]: spy_dead_letter.append(event) return isSuccess def assert_dead_letter_store_consumer(event: Event) -> Result[bool, Error]: spy_dead_letter_store.append(event) return isSuccess event = EventUserCreatedMother.random() subscribers = [ EventSubscriber( event_name=event.event_name, event_version=event.event_version, handlers=[assert_consumer], ) ] configurer = RabbitMqEventConfigurerMother.with_main_and_retry_ttl_10ms() configurer.configure_subscribers(subscribers) bus = RabbitMqEventBusMother.default() bus.publish(event) max_retries_allowed = 5 chaos = RabbitMqEventChaos(percentage_simulate_nack=1.0) consumer_with_chaos = RabbitMqEventConsumerMother.with_chaos( chaos, max_retries_allowed, logger ) consumer_with_chaos.add_subscribers(subscribers) consumer_with_chaos.start() sleep(1.0) consumer_with_chaos.stop() consumer_without_chaos = RabbitMqEventConsumerMother.default() consumer_without_chaos.add_handler_on_queue( "dead_letter.alice.petisco.1.event.user_created.assert_consumer", assert_dead_letter_consumer, ) consumer_without_chaos.add_handler_on_queue( "dead_letter.store", assert_dead_letter_store_consumer ) consumer_without_chaos.start() sleep(1.0) consumer_without_chaos.stop() configurer.clear() spy.assert_count_by_event_id(event.event_id, 0) # Rejected before by Event Chaos spy_dead_letter.assert_count_by_event_id(event.event_id, 1) spy_dead_letter_store.assert_count_by_event_id(event.event_id, 1)
def test_should_publish_consume_and_retry_event_not_affecting_other_queue_including_store_queue_from_rabbitmq( max_retries_allowed, expected_number_event_consumed_by_store, expected_number_event_consumed_by_handler_1, expected_number_event_consumed_by_handler_2, simulated_results_store, simulated_results_handler_1, simulated_results_handler_2, ): spy_consumer_event_store = SpyEvents() spy_consumer_handler_1 = SpyEvents() spy_consumer_handler_2 = SpyEvents() def assert_consumer_event_store(event: Event) -> Result[bool, Error]: spy_consumer_event_store.append(event) result = simulated_results_store.pop(0) return result def assert_consumer_handler_1(event: Event) -> Result[bool, Error]: spy_consumer_handler_1.append(event) result = simulated_results_handler_1.pop(0) return result def assert_consumer_handler_2(event: Event) -> Result[bool, Error]: spy_consumer_handler_2.append(event) result = simulated_results_handler_2.pop(0) return result event = EventUserCreatedMother.random() subscribers = [ EventSubscriber( event_name=event.event_name, event_version=event.event_version, handlers=[assert_consumer_handler_1, assert_consumer_handler_2], ) ] configurer = RabbitMqEventConfigurerMother.with_retry_ttl_10ms() configurer.configure_subscribers(subscribers) bus = RabbitMqEventBusMother.default() bus.publish(event) consumer = RabbitMqEventConsumerMother.with_max_retries( max_retries_allowed) consumer.add_subscribers(subscribers) consumer.add_handler_on_store(assert_consumer_event_store) consumer.start() sleep(1.0) consumer.stop() configurer.clear() spy_consumer_event_store.assert_number_unique_events(1) spy_consumer_event_store.assert_first_event(event) spy_consumer_event_store.assert_count_by_event_id( event.event_id, expected_number_event_consumed_by_store) spy_consumer_handler_1.assert_number_unique_events(1) spy_consumer_handler_1.assert_first_event(event) spy_consumer_handler_1.assert_count_by_event_id( event.event_id, expected_number_event_consumed_by_handler_1) spy_consumer_handler_2.assert_number_unique_events(1) spy_consumer_handler_2.assert_first_event(event) spy_consumer_handler_2.assert_count_by_event_id( event.event_id, expected_number_event_consumed_by_handler_2)