Test Message Queue Systems

This skill tests asynchronous messaging systems across six categories: unit tests (producers/consumers in isolation), integration tests (real queue infrastructure), contract tests (message schema verification), end-to-end tests (complete flows), performance tests (throughput/latency), and chaos tests (failure and recovery). It addresses the unique challenges of async systems - unpredictable timing, message ordering and delivery guarantees, duplicate-message idempotency, dead-letter queue behavior, and network partition handling.

Unit testing patterns mock the connection layer entirely: a pytest example patches pika.BlockingConnection to assert a producer calls basic_publish with the correct exchange, routing key, and serialized body, while a consumer test calls the message handler directly with a JSON payload and asserts on both the return value and side effects. Integration testing is shown two ways: a Spring Boot test with an embedded RabbitMQ instance using a CountDownLatch to synchronize on asynchronous message processing, and a Testcontainers-based Python test that spins up a real RabbitMQ container, publishes a message, and verifies it was processed within a timeout.

@patch('pika.BlockingConnection')
def test_publish_order_created(self, mock_connection):
    mock_channel = Mock()
    mock_connection.return_value.channel.return_value = mock_channel
    producer.publish_order_created(order_data)
    mock_channel.basic_publish.assert_called_once_with(exchange='orders', routing_key='order.created', body=json.dumps(order_data))

Advanced patterns cover Pact-style contract testing defining the expected message schema between a consumer and provider service, and chaos testing that simulates connection failures to verify retry logic eventually succeeds, and injects failing messages to verify they land in a dead-letter queue while valid messages process normally. Performance testing uses Locust with a custom User class publishing AMQP messages and firing custom request_success/request_failure events to integrate queue-specific metrics into Locust's reporting. Best practices cover using containerized brokers for consistent test environments, cleaning up test data between runs, isolating test exchanges/queues, timeout-based (not fixed-delay) async assertions, explicit idempotency testing via duplicate messages, and testing serialization edge cases. Common pitfalls flagged include relying on fixed sleep delays instead of proper synchronization, testing only single messages instead of realistic volumes, and skipping dead-letter-queue and network-failure scenarios.

Use this skill when testing a message queue-based system - writing isolated producer/consumer unit tests, integration tests against a real or containerized broker, contract tests for message schemas, chaos tests for failure/retry/DLQ behavior, or load tests for queue throughput.

It is not the right tool for testing synchronous request/response APIs where there's no async messaging involved, or for message queue infrastructure evaluation/selection, which is a different (pre-implementation) decision than testing an existing messaging integration.

Input: the message producer/consumer code, the queue broker in use (RabbitMQ, Kafka, etc.), and the failure/ordering/idempotency guarantees that need verification. Output: unit tests with mocked connections, integration tests against embedded or Testcontainers-based brokers, contract tests defining message schemas, chaos tests verifying retry and dead-letter behavior, and Locust-based load tests measuring publish throughput and latency.

Built on pytest/unittest.mock and pika for RabbitMQ testing in Python, Spring Boot's embedded RabbitMQ and RabbitTemplate for Java integration tests, testcontainers for realistic containerized broker tests, Pact-style contract testing for schema verification, and Locust for load testing with custom AMQP event reporting.

Backend engineers testing asynchronous messaging systems - particularly those needing confidence in producer/consumer correctness, message contract stability, failure/retry/DLQ behavior, and queue throughput under load.