def test_should_consumer_react_to_chaos_inputs(
max_retries_allowed, expected_number_event_consumed, chaos
):
spy = SpyEvents()
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.with_retry_ttl_10ms()
configurer.configure_subscribers(subscribers)
bus = RabbitMqEventBusMother.default()
bus.publish(event)
consumer = RabbitMqEventConsumerMother.with_chaos(chaos, max_retries_allowed)
consumer.add_subscribers(subscribers)
consumer.start()
sleep(1.0)
consumer.stop()
configurer.clear()
spy.assert_count_by_event_id(event.event_id, expected_number_event_consumed)
def test_should_consumer_react_to_chaos_with_failure_simulation_and_check_logger_with_subscribers():
spy = SpyEvents()
spy_dead_letter = 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
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_100ms()
configurer.configure_subscribers(subscribers)
bus = RabbitMqEventBusMother.default()
bus.publish(event)
max_retries_allowed = 5
chaos = RabbitMqEventChaos(
percentage_simulate_failures=1.0,
protected_routing_keys=[
"dead_letter.alice.petisco.1.event.user_created.assert_consumer"
],
)
consumer = RabbitMqEventConsumerMother.with_chaos(
chaos, max_retries_allowed, logger
)
consumer.add_subscribers(subscribers)
consumer.add_handler_on_queue(
"dead_letter.alice.petisco.1.event.user_created.assert_consumer",
assert_dead_letter_consumer,
)
consumer.start()
sleep(1.5)
consumer.stop()
configurer.clear()
spy.assert_count_by_event_id(event.event_id, 0)
spy_dead_letter.assert_count_by_event_id(event.event_id, 1)
assert_logger_represents_simulated_failure_scenario(logger, max_retries_allowed)
def test_should_store_consumer_react_to_chaos_with_nck_simulation_and_send_several_event_to_dead_letter():
spy = 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_store_consumer(event: Event) -> Result[bool, Error]:
spy_dead_letter_store.append(event)
return isSuccess
configurer = RabbitMqEventConfigurerMother.with_main_and_retry_ttl_10ms()
configurer.configure()
bus = RabbitMqEventBusMother.default()
event_ids = []
for _ in range(5):
event = EventUserCreatedMother.random()
event_ids.append(event.event_id)
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_handler_on_store(assert_consumer)
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.store", assert_dead_letter_store_consumer
)
consumer_without_chaos.start()
sleep(1.0)
consumer_without_chaos.stop()
configurer.clear()
for event_id in event_ids:
spy.assert_count_by_event_id(event_id, 0) # Rejected before by Event Chaos
spy_dead_letter_store.assert_count_by_event_id(event_id, 1)
def test_should_consumer_react_to_chaos_with_nck_simulation_and_check_logger():
spy = SpyEvents()
logger = FakeLogger()
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.with_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 = RabbitMqEventConsumerMother.with_chaos(
chaos, max_retries_allowed, logger
)
consumer.add_subscribers(subscribers)
consumer.start()
sleep(1.0)
consumer.stop()
configurer.clear()
assert len(logger.get_logging_messages()) >= 200
first_logging_message = logger.get_logging_messages()[0]
assert first_logging_message[0] == DEBUG
assert first_logging_message[1]["meta"] == {
"layer": "rabbitmq_event_consumer",
"operation": "assert_consumer",
}
assert (
first_logging_message[1]["data"]["message"]["chaos_action"] == "nack simulated"
)
def test_should_consumer_react_to_chaos_with_zero_probability():
spy = SpyEvents()
logger = FakeLogger()
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.with_retry_ttl_10ms()
configurer.configure_subscribers(subscribers)
bus = RabbitMqEventBusMother.default()
bus.publish(event)
max_retries_allowed = 5
chaos = RabbitMqEventChaos(
percentage_simulate_nack=0.0, percentage_simulate_failures=0.0
)
consumer = RabbitMqEventConsumerMother.with_chaos(
chaos, max_retries_allowed, logger
)
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)
assert len(logger.get_logging_messages()) == 2
logging_message = logger.get_logging_messages()[1]
assert logging_message[0] == DEBUG
assert logging_message[1]["data"]["message"]["derived_action"] == {}
def test_should_consumer_react_to_chaos_with_failure_simulation_and_check_logger_without_subscribers():
spy = SpyEvents()
spy_dead_letter = SpyEvents()
logger = FakeLogger()
def assert_store_consumer(event: Event) -> Result[bool, Error]:
spy.append(event)
return isSuccess
def assert_dead_letter_store_consumer(event: Event) -> Result[bool, Error]:
spy_dead_letter.append(event)
return isSuccess
event = EventUserCreatedMother.random()
configurer = RabbitMqEventConfigurerMother.with_main_and_retry_ttl_100ms()
configurer.configure()
bus = RabbitMqEventBusMother.default()
bus.publish(event)
max_retries_allowed = 5
chaos = RabbitMqEventChaos(
percentage_simulate_failures=1.0, protected_routing_keys=["dead_letter.store"]
)
consumer = RabbitMqEventConsumerMother.with_chaos(
chaos, max_retries_allowed, logger
)
consumer.add_handler_on_store(assert_store_consumer)
consumer.add_handler_on_queue(
"dead_letter.store", assert_dead_letter_store_consumer
)
consumer.start()
sleep(1.5)
consumer.stop()
configurer.clear()
spy.assert_count_by_event_id(event.event_id, 0)
spy_dead_letter.assert_count_by_event_id(event.event_id, 1)