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)
