rabbitmq-test/README_TESTS.md

RabbitMQ Test Suite

This directory contains comprehensive tests for different RabbitMQ exchange types and patterns.

Test Files

Individual Test Files

1. run_fanout_test.py - Tests Fanout Exchange

   • Broadcasts messages to all bound queues
   • Demonstrates one-to-many messaging pattern
   • Run: python run_fanout_test.py

2. run_direct_test.py - Tests Direct Exchange

   • Routes messages based on exact routing key matches
   • Demonstrates selective message routing
   • Run: python run_direct_test.py

3. run_topic_test.py - Tests Topic Exchange

   • Routes messages using wildcard patterns (* and #)
   • Demonstrates hierarchical message routing
   • Run: python run_topic_test.py

4. run_multi_queue_test.py - Tests Multi-Queue Load Balancing

   • Distributes messages across multiple queues
   • Demonstrates load balancing and parallel processing
   • Run: python run_multi_queue_test.py

Combined Test File

5. test.py - Runs all tests sequentially
   • Executes all exchange type tests in order
   • Run: python test.py

Test Features

Producer and Consumer Coordination

• Each test starts consumers in the background
• Producers send messages after consumers are ready
• Tests demonstrate real-time message processing
• Automatic cleanup and task cancellation

Message Patterns Tested

Fanout Exchange

• Pattern: One-to-many broadcasting
• Queues: 3 queues (demo.fanout.queue-0, demo.fanout.queue-1, demo.fanout.queue-2)
• Behavior: All queues receive every message
• Use Case: Notifications, announcements, logging

Direct Exchange

• Pattern: Exact routing key matching
• Queues: error, warning, info (with debug routing to info)
• Behavior: Messages routed based on exact routing key
• Use Case: Log level routing, priority-based processing

Topic Exchange

• Pattern: Wildcard pattern matching
• Queues: Critical, Success, Failed
• Behavior: Messages routed using * and # wildcards
• Use Case: Hierarchical event routing, microservice communication

Multi-Queue Load Balancing

• Pattern: Round-robin distribution
• Queues: 3 balanced queues
• Behavior: Messages distributed evenly across queues
• Use Case: Horizontal scaling, parallel processing

Running Tests

Prerequisites

• RabbitMQ server running on localhost:5673
• Python 3.7+ with asyncio support
• Required packages: aio-pika

Individual Test Execution

# Test Fanout Exchange
python run_fanout_test.py

# Test Direct Exchange
python run_direct_test.py

# Test Topic Exchange
python run_topic_test.py

# Test Multi-Queue Load Balancing
python run_multi_queue_test.py

Run All Tests

python test.py

Test Output

Each test provides detailed output showing:

• Consumer startup messages
• Message reception and processing
• Queue routing behavior
• Message persistence status
• Test completion status

Configuration

Tests use the configuration from config.py:

• RabbitMQ URI: amqp://guest:guest@localhost:5673/
• Exchange and queue naming conventions
• Message persistence settings

Architecture

Producer Side

• Sets up exchanges and queues
• Publishes test messages with appropriate routing keys
• Handles connection management

Consumer Side

• Starts multiple consumers for different queues
• Processes messages with simulated business logic
• Demonstrates concurrent message handling

Test Coordination

• Uses asyncio tasks for concurrent execution
• Implements proper startup/shutdown sequences
• Ensures clean resource cleanup

Extending Tests

To add new test scenarios:

1. Create a new test file following the naming pattern run_xxx_test.py
2. Import appropriate producer and consumer functions
3. Implement the test logic with proper async/await patterns
4. Add consumer startup, message publishing, and cleanup phases
5. Update this README with the new test description