proffesor-for-testing Middleware Testing Patterns
Quick Pattern Selection:
- Message routing issues -> Content-based router tests
- Transformation failures -> Schema-in/schema-out validation
- Lost messages -> DLQ and retry pattern tests
- Protocol bridging -> Mediation round-trip tests
- Complex flows -> Correlation ID tracing tests
Critical Success Factors:
- Middleware is invisible when it works; test the invisible
- Always validate both the happy path AND the error channel (DLQ)
- Correlation IDs are your lifeline for tracing multi-hop messages
Quick Reference Card
When to Use
- Testing ESB message flows (IBM IIB/ACE, MuleSoft, WSO2)
- Validating message transformations (XSLT, JSON-to-XML, flat-file parsing)
- Testing message broker routing (MQ, Kafka, RabbitMQ)
- Verifying dead letter queue behavior
- Testing protocol mediation (SOAP/REST bridging)
- Validating Enterprise Integration Patterns (EIP)
Testing Levels
| Level | Purpose | Dependencies | Speed |
|---|---|---|---|
| Unit Transform | Single mapping correctness | None | Fast |
| Route Logic | Routing decision accuracy | Mocked endpoints | Fast |
| Integration | End-to-end message flow | Broker + endpoints | Medium |
| DLQ/Error | Error handling and recovery | Full middleware stack | Slower |
Critical Test Scenarios
| Scenario | Must Test | Example |
|---|---|---|
| Routing | Correct destination selection | Order type A -> Queue A, type B -> Queue B |
| Transformation | Schema compliance after mapping | XML -> JSON field mapping accuracy |
| DLQ | Poison message handling | Malformed XML lands in DLQ, not lost |
| Ordering | Sequence preservation | Messages 1-2-3 arrive in order |
| Correlation | Multi-hop tracing | Request-reply matched by correlation ID |
| Retry | Transient failure recovery | 3 retries with backoff, then DLQ |
| Mediation | Protocol bridging fidelity | SOAP request produces correct REST call |
Tools
- Message Brokers: IBM MQ, RabbitMQ, Apache Kafka, ActiveMQ
- ESBs: IBM IIB/ACE, MuleSoft, WSO2, Apache Camel
- Testing: SoapUI, Postman, custom harnesses
- Virtualization: Mountebank, WireMock, HoverFly
- Monitoring: Splunk, ELK, Datadog
Agent Coordination
qe-middleware-validator: Validate routing rules, transformation accuracy, EIP patternsqe-message-broker-tester: Test broker connectivity, DLQ behavior, message orderingqe-soap-tester: SOAP/WSDL validation, WS-Security, protocol mediation
Message Routing Pattern Testing
Content-Based Router
describe('Content-Based Router - Order Type', () => {
it('routes standard orders to fulfillment queue', async () => {
const message = {
correlationId: uuid(),
body: { orderType: 'STANDARD', orderId: 'ORD-001', items: [{ sku: 'A1', qty: 2 }] }
};
await broker.publish('orders.inbound', message);
const routed = await broker.consume('orders.fulfillment', { timeout: 5000 });
expect(routed.body.orderId).toBe('ORD-001');
expect(routed.correlationId).toBe(message.correlationId);
const dlq = await broker.tryConsume('orders.dlq', { timeout: 1000 });
expect(dlq).toBeNull(); // Nothing in DLQ
});
it('routes express orders to priority queue', async () => {
const message = {
correlationId: uuid(),
body: { orderType: 'EXPRESS', orderId: 'ORD-002', items: [{ sku: 'B1', qty: 1 }] }
};
await broker.publish('orders.inbound', message);
const routed = await broker.consume('orders.priority', { timeout: 5000 });
expect(routed.body.orderId).toBe('ORD-002');
});
it('sends unrecognized order types to DLQ', async () => {
const message = {
correlationId: uuid(),
body: { orderType: 'UNKNOWN', orderId: 'ORD-003' }
};
await broker.publish('orders.inbound', message);
const dlqMessage = await broker.consume('orders.dlq', { timeout: 5000 });
expect(dlqMessage.body.orderId).toBe('ORD-003');
expect(dlqMessage.headers['x-error-reason']).toContain('Unrecognized orderType');
});
});
Header-Based Router
describe('Header-Based Router - Region', () => {
it('routes by x-region header to regional queues', async () => {
const regions = ['US', 'EU', 'APAC'];
for (const region of regions) {
const message = {
headers: { 'x-region': region },
body: { orderId: `ORD-${region}` }
};
await broker.publish('orders.global', message);
const routed = await broker.consume(`orders.${region.toLowerCase()}`, { timeout: 5000 });
expect(routed.body.orderId).toBe(`ORD-${region}`);
}
});
it('routes messages without region header to default queue', async () => {
await broker.publish('orders.global', { body: { orderId: 'ORD-NO-REGION' } });
const routed = await broker.consume('orders.default', { timeout: 5000 });
expect(routed.body.orderId).toBe('ORD-NO-REGION');
});
});
Recipient List
describe('Recipient List - Order Notifications', () => {
it('fans out order to all registered recipients', async () => {
const message = {
body: { orderId: 'ORD-100', total: 250.00 }
};
await broker.publish('orders.confirmed', message);
// All three systems should receive the message
const [warehouse, billing, crm] = await Promise.all([
broker.consume('notify.warehouse', { timeout: 5000 }),
broker.consume('notify.billing', { timeout: 5000 }),
broker.consume('notify.crm', { timeout: 5000 })
]);
expect(warehouse.body.orderId).toBe('ORD-100');
expect(billing.body.orderId).toBe('ORD-100');
expect(crm.body.orderId).toBe('ORD-100');
});
});
Message Transformation Testing
JSON-to-XML Transformation
describe('JSON to XML Transformation', () => {
it('transforms order JSON to SAP XML format', async () => {
const jsonInput = {
orderId: 'ORD-500',
customer: { id: 'CUST-01', name: 'Acme Corp' },
items: [
{ sku: 'MAT-100', quantity: 10, unitPrice: 25.00 }
]
};
await broker.publish('transform.json-in', { body: jsonInput });
const xmlOutput = await broker.consume('transform.xml-out', { timeout: 5000 });
const parsed = parseXml(xmlOutput.body);
expect(parsed.SalesOrder.OrderNumber).toBe('ORD-500');
expect(parsed.SalesOrder.SoldToParty.CustomerID).toBe('CUST-01');
expect(parsed.SalesOrder.Items.Item[0].MaterialNumber).toBe('MAT-100');
expect(parsed.SalesOrder.Items.Item[0].Quantity).toBe('10');
});
it('handles missing optional fields gracefully', async () => {
const jsonInput = {
orderId: 'ORD-501',
customer: { id: 'CUST-02' }, // name is missing
items: [{ sku: 'MAT-200', quantity: 5 }] // unitPrice missing
};
await broker.publish('transform.json-in', { body: jsonInput });
const xmlOutput = await broker.consume('transform.xml-out', { timeout: 5000 });
const parsed = parseXml(xmlOutput.body);
expect(parsed.SalesOrder.SoldToParty.Name).toBe(''); // Default empty
expect(parsed.SalesOrder.Items.Item[0].UnitPrice).toBe('0.00');
});
it('rejects invalid input and sends to DLQ with error details', async () => {
const invalidInput = { items: [] }; // Missing required orderId and customer
await broker.publish('transform.json-in', { body: invalidInput });
const dlq = await broker.consume('transform.dlq', { timeout: 5000 });
expect(dlq.headers['x-error-reason']).toContain('orderId is required');
});
});
Flat-File to XML Transformation
describe('Flat-File to XML Transformation', () => {
it('parses fixed-width flat file into structured XML', async () => {
// Fixed-width: positions 1-10 = orderId, 11-20 = sku, 21-25 = qty
const flatFile = 'ORD-001 MAT-10000010\nORD-001 MAT-20000005\n';
await broker.publish('transform.flatfile-in', { body: flatFile });
const xmlOutput = await broker.consume('transform.flatfile-xml-out', { timeout: 5000 });
const parsed = parseXml(xmlOutput.body);
expect(parsed.Orders.Order).toHaveLength(1);
expect(parsed.Orders.Order[0].Items.Item).toHaveLength(2);
expect(parsed.Orders.Order[0].Items.Item[0].Quantity).toBe('10');
});
it('handles lines with trailing whitespace correctly', async () => {
const flatFile = 'ORD-002 MAT-30000001 \n';
await broker.publish('transform.flatfile-in', { body: flatFile });
const xmlOutput = await broker.consume('transform.flatfile-xml-out', { timeout: 5000 });
const parsed = parseXml(xmlOutput.body);
expect(parsed.Orders.Order[0].OrderId).toBe('ORD-002');
expect(parsed.Orders.Order[0].Items.Item[0].Quantity).toBe('1');
});
});
Dead Letter Queue (DLQ) Testing
describe('Dead Letter Queue Strategy', () => {
it('moves message to DLQ after max retries', async () => {
// Configure endpoint to always fail
mockEndpoint.respondWith(500, 'Service Unavailable');
await broker.publish('orders.process', {
body: { orderId: 'ORD-FAIL' },
headers: { 'x-correlation-id': 'corr-123' }
});
// Wait for retries to exhaust (3 retries with backoff)
const dlqMessage = await broker.consume('orders.dlq', { timeout: 30000 });
expect(dlqMessage.body.orderId).toBe('ORD-FAIL');
expect(dlqMessage.headers['x-retry-count']).toBe('3');
expect(dlqMessage.headers['x-original-queue']).toBe('orders.process');
expect(dlqMessage.headers['x-correlation-id']).toBe('corr-123');
expect(dlqMessage.headers['x-error-reason']).toContain('Service Unavailable');
expect(dlqMessage.headers['x-first-failure-timestamp']).toBeDefined();
});
it('preserves original message body in DLQ', async () => {
const originalBody = {
orderId: 'ORD-PRESERVE',
items: [{ sku: 'A', qty: 1 }, { sku: 'B', qty: 2 }]
};
mockEndpoint.respondWith(500, 'Timeout');
await broker.publish('orders.process', { body: originalBody });
const dlqMessage = await broker.consume('orders.dlq', { timeout: 30000 });
expect(dlqMessage.body).toEqual(originalBody); // Body unchanged
});
it('DLQ messages can be replayed after fix', async () => {
// Step 1: Message fails, lands in DLQ
mockEndpoint.respondWith(500, 'Down');
await broker.publish('orders.process', { body: { orderId: 'ORD-REPLAY' } });
const dlqMessage = await broker.consume('orders.dlq', { timeout: 30000 });
// Step 2: Fix the endpoint
mockEndpoint.respondWith(200, 'OK');
// Step 3: Replay from DLQ
await broker.publish('orders.process', dlqMessage);
const success = await broker.consume('orders.completed', { timeout: 5000 });
expect(success.body.orderId).toBe('ORD-REPLAY');
});
});
Message Ordering and Sequencing
describe('Message Ordering Validation', () => {
it('preserves FIFO order within same partition key', async () => {
const messages = Array.from({ length: 10 }, (_, i) => ({
headers: { 'x-partition-key': 'ORDER-GROUP-1', 'x-sequence': String(i + 1) },
body: { orderId: `ORD-${i + 1}`, sequence: i + 1 }
}));
for (const msg of messages) {
await broker.publish('orders.sequenced', msg);
}
const received = [];
for (let i = 0; i < 10; i++) {
const msg = await broker.consume('orders.sequenced.out', { timeout: 5000 });
received.push(msg.body.sequence);
}
expect(received).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
});
it('detects out-of-order messages via sequence gap', async () => {
// Send messages 1, 2, 4 (skip 3)
for (const seq of [1, 2, 4]) {
await broker.publish('orders.sequenced', {
headers: { 'x-partition-key': 'GROUP-2', 'x-sequence': String(seq) },
body: { sequence: seq }
});
}
// The middleware should detect the gap and raise an alert
const alert = await broker.consume('orders.sequence-gap', { timeout: 10000 });
expect(alert.body.missingSequence).toBe(3);
expect(alert.body.partitionKey).toBe('GROUP-2');
});
});
ESB Error Handling and Compensation
describe('Compensation Pattern - Saga', () => {
it('compensates completed steps when a later step fails', async () => {
// Saga: Reserve Inventory -> Charge Payment -> Ship
// If Ship fails, Payment and Inventory must be compensated
mockServices.inventory.respondWith(200); // Step 1 succeeds
mockServices.payment.respondWith(200); // Step 2 succeeds
mockServices.shipping.respondWith(500); // Step 3 fails
await broker.publish('saga.order', {
body: { orderId: 'ORD-SAGA', amount: 100.00 }
});
// Verify compensation messages were sent
const paymentRefund = await broker.consume('saga.compensate.payment', { timeout: 10000 });
expect(paymentRefund.body.action).toBe('REFUND');
expect(paymentRefund.body.orderId).toBe('ORD-SAGA');
const inventoryRelease = await broker.consume('saga.compensate.inventory', { timeout: 10000 });
expect(inventoryRelease.body.action).toBe('RELEASE');
expect(inventoryRelease.body.orderId).toBe('ORD-SAGA');
});
});
Protocol Mediation Testing
SOAP-to-REST Mediation
describe('SOAP to REST Protocol Mediation', () => {
it('converts SOAP request to REST call and back', async () => {
const soapRequest = `
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:ord="http://example.com/orders">
<soapenv:Body>
<ord:GetOrder>
<ord:OrderId>ORD-700</ord:OrderId>
</ord:GetOrder>
</soapenv:Body>
</soapenv:Envelope>
`;
// ESB should convert SOAP -> REST GET /orders/ORD-700
mockRestBackend.onGet('/orders/ORD-700').reply(200, {
orderId: 'ORD-700',
status: 'SHIPPED',
total: 150.00
});
const response = await soapClient.send(soapRequest, { endpoint: esbSoapEndpoint });
// Verify SOAP response wraps REST data correctly
const parsed = parseSoapResponse(response);
expect(parsed.OrderId).toBe('ORD-700');
expect(parsed.Status).toBe('SHIPPED');
expect(parsed.Total).toBe('150.00');
});
it('maps REST error to SOAP fault', async () => {
const soapRequest = buildSoapGetOrder('ORD-NOTFOUND');
mockRestBackend.onGet('/orders/ORD-NOTFOUND').reply(404, {
error: 'Order not found'
});
const response = await soapClient.send(soapRequest, { endpoint: esbSoapEndpoint });
const fault = parseSoapFault(response);
expect(fault.faultCode).toBe('Client');
expect(fault.faultString).toContain('Order not found');
});
});
Sync-to-Async Mediation
describe('Sync to Async Mediation', () => {
it('accepts sync request, returns correlation ID, delivers result async', async () => {
// Client sends synchronous HTTP POST
const response = await httpClient.post(`${esbEndpoint}/async-orders`, {
orderId: 'ORD-ASYNC',
items: [{ sku: 'X1', qty: 5 }]
});
// ESB returns 202 Accepted with correlation ID
expect(response.status).toBe(202);
expect(response.body.correlationId).toBeDefined();
const correlationId = response.body.correlationId;
// Result arrives asynchronously on callback queue
const result = await broker.consume('orders.async.results', {
timeout: 15000,
filter: (msg) => msg.headers['x-correlation-id'] === correlationId
});
expect(result.body.orderId).toBe('ORD-ASYNC');
expect(result.body.status).toBe('ACCEPTED');
});
});
Enterprise Integration Patterns (EIP)
Splitter Pattern
describe('Splitter - Batch Order to Individual Items', () => {
it('splits batch order into individual item messages', async () => {
const batchOrder = {
orderId: 'BATCH-001',
items: [
{ sku: 'A1', qty: 10 },
{ sku: 'B2', qty: 5 },
{ sku: 'C3', qty: 20 }
]
};
await broker.publish('orders.batch', { body: batchOrder });
const splitMessages = [];
for (let i = 0; i < 3; i++) {
splitMessages.push(await broker.consume('orders.items', { timeout: 5000 }));
}
expect(splitMessages).toHaveLength(3);
expect(splitMessages.map(m => m.body.sku).sort()).toEqual(['A1', 'B2', 'C3']);
// Each split message retains parent correlation
for (const msg of splitMessages) {
expect(msg.headers['x-batch-id']).toBe('BATCH-001');
expect(msg.headers['x-split-total']).toBe('3');
}
});
});
Aggregator Pattern
describe('Aggregator - Collect Item Results', () => {
it('aggregates individual item results into batch response', async () => {
const batchId = 'BATCH-002';
const itemResults = [
{ sku: 'A1', status: 'PICKED', batchId },
{ sku: 'B2', status: 'PICKED', batchId },
{ sku: 'C3', status: 'PICKED', batchId }
];
for (const result of itemResults) {
await broker.publish('items.completed', {
headers: { 'x-batch-id': batchId, 'x-split-total': '3' },
body: result
});
}
const aggregated = await broker.consume('orders.batch.completed', { timeout: 10000 });
expect(aggregated.body.batchId).toBe('BATCH-002');
expect(aggregated.body.items).toHaveLength(3);
expect(aggregated.body.items.every(i => i.status === 'PICKED')).toBe(true);
});
it('handles aggregation timeout for incomplete batches', async () => {
const batchId = 'BATCH-TIMEOUT';
// Only send 2 of 3 expected items
for (let i = 0; i < 2; i++) {
await broker.publish('items.completed', {
headers: { 'x-batch-id': batchId, 'x-split-total': '3' },
body: { sku: `ITEM-${i}`, status: 'PICKED', batchId }
});
}
// After timeout, aggregator should emit partial result with error
const partial = await broker.consume('orders.batch.incomplete', { timeout: 60000 });
expect(partial.body.batchId).toBe('BATCH-TIMEOUT');
expect(partial.body.receivedCount).toBe(2);
expect(partial.body.expectedCount).toBe(3);
});
});
Content Enricher Pattern
describe('Content Enricher - Customer Data Lookup', () => {
it('enriches order with customer details from CRM', async () => {
mockCrm.onGet('/customers/CUST-50').reply(200, {
name: 'Acme Corp',
tier: 'GOLD',
creditLimit: 50000
});
await broker.publish('orders.enrich', {
body: { orderId: 'ORD-ENRICH', customerId: 'CUST-50', total: 1200 }
});
const enriched = await broker.consume('orders.enriched', { timeout: 5000 });
expect(enriched.body.orderId).toBe('ORD-ENRICH');
expect(enriched.body.customer.name).toBe('Acme Corp');
expect(enriched.body.customer.tier).toBe('GOLD');
expect(enriched.body.creditCheckPassed).toBe(true); // 1200 < 50000
});
});
Retry and Circuit Breaker Patterns
describe('Retry with Exponential Backoff', () => {
it('retries 3 times with increasing delays before DLQ', async () => {
const timestamps = [];
mockEndpoint.onPost('/process').reply(() => {
timestamps.push(Date.now());
return [500, 'Temporary failure'];
});
await broker.publish('orders.process', { body: { orderId: 'ORD-RETRY' } });
await broker.consume('orders.dlq', { timeout: 60000 });
// Verify exponential backoff timing (1s, 2s, 4s approximately)
expect(timestamps).toHaveLength(4); // 1 initial + 3 retries
const delay1 = timestamps[1] - timestamps[0];
const delay2 = timestamps[2] - timestamps[1];
expect(delay1).toBeGreaterThan(800); // ~1s
expect(delay2).toBeGreaterThan(1800); // ~2s
});
});
describe('Circuit Breaker', () => {
it('opens circuit after threshold failures', async () => {
// Fail 5 messages to trip circuit breaker (threshold = 5)
mockEndpoint.onPost('/process').reply(500, 'Down');
for (let i = 0; i < 5; i++) {
await broker.publish('orders.circuit', { body: { orderId: `ORD-CB-${i}` } });
}
// Wait for circuit to open
await sleep(5000);
// Next message should be immediately rejected (circuit open)
const startTime = Date.now();
await broker.publish('orders.circuit', { body: { orderId: 'ORD-CB-FAST-FAIL' } });
const dlq = await broker.consume('orders.circuit.dlq', { timeout: 3000 });
const elapsed = Date.now() - startTime;
expect(dlq.headers['x-circuit-state']).toBe('OPEN');
expect(elapsed).toBeLessThan(2000); // Fast fail, no retry
});
});
Service Virtualization for Isolated Testing
describe('Service Virtualization - Middleware Isolation', () => {
let virtualService;
beforeAll(async () => {
virtualService = await mountebank.createImposter({
port: 4545,
protocol: 'http',
stubs: [
{
predicates: [{ equals: { method: 'POST', path: '/sap/orders' } }],
responses: [{
is: {
statusCode: 200,
headers: { 'Content-Type': 'application/xml' },
body: '<OrderResponse><Status>CREATED</Status><SapOrderId>SAP-001</SapOrderId></OrderResponse>'
}
}]
},
{
predicates: [{ equals: { method: 'POST', path: '/sap/orders' },
contains: { body: '<InvalidField>' } }],
responses: [{
is: { statusCode: 400, body: '<Error>Invalid request</Error>' }
}]
}
]
});
});
afterAll(async () => {
await mountebank.deleteImposter(4545);
});
it('middleware correctly handles SAP success response', async () => {
await broker.publish('orders.to-sap', {
body: { orderId: 'ORD-VIRT', customer: 'CUST-01' }
});
const result = await broker.consume('orders.sap-confirmed', { timeout: 5000 });
expect(result.body.sapOrderId).toBe('SAP-001');
});
});
Best Practices
Do This
- Test both the happy path AND the error channel (DLQ) for every flow
- Use correlation IDs to trace messages across multi-hop middleware
- Validate schema compliance at every transformation boundary
- Test message ordering with partitioned/sequenced queues
- Use service virtualization to isolate middleware from backend systems
- Test retry exhaustion to confirm DLQ behavior
- Validate compensation patterns (saga rollback) for multi-step flows
Avoid This
- Testing only the happy path and ignoring DLQ/error queues
- Hardcoding queue names; use configuration-driven tests
- Ignoring message ordering requirements
- Skipping transformation edge cases (empty fields, special characters, encoding)
- Testing middleware without correlation ID validation
- Assuming retries work correctly without verifying backoff timing
- Deploying without testing the circuit breaker threshold
Agent-Assisted Middleware Testing
// Validate middleware routing rules
await Task("Middleware Routing Validation", {
routingConfig: 'esb/routing-rules.xml',
messageTypes: ['STANDARD_ORDER', 'EXPRESS_ORDER', 'RETURN'],
validateDLQ: true,
checkCorrelationIds: true
}, "qe-middleware-validator");
// Test message broker behavior
await Task("Message Broker DLQ Test", {
broker: 'rabbitmq',
queues: ['orders.inbound', 'orders.process', 'orders.dlq'],
retryPolicy: { maxRetries: 3, backoff: 'exponential' },
poisonMessages: ['malformed-xml', 'missing-required-fields', 'oversized-payload']
}, "qe-message-broker-tester");
// SOAP/WSDL contract validation
await Task("SOAP Service Contract Validation", {
wsdl: 'services/OrderService.wsdl',
endpoints: ['CreateOrder', 'GetOrderStatus', 'CancelOrder'],
validateWsSecurity: true,
testFaultHandling: true
}, "qe-soap-tester");
// Transformation accuracy testing
await Task("Transformation Accuracy Suite", {
transformations: [
{ name: 'JSON-to-SAP-XML', input: 'testdata/order.json', expected: 'testdata/order-sap.xml' },
{ name: 'Flat-to-XML', input: 'testdata/inventory.dat', expected: 'testdata/inventory.xml' }
],
validateSchemas: true,
edgeCases: ['empty-fields', 'special-chars', 'max-length']
}, "qe-middleware-validator");
Agent Coordination Hints
Memory Namespace
aqe/middleware-testing/
routing/ - Routing rule configurations and test results
transformations/ - Mapping definitions and validation results
dlq/ - DLQ test results and replay outcomes
eip-patterns/ - EIP pattern test coverage
circuit-breakers/ - Circuit breaker state and threshold configs
correlation/ - Correlation ID tracing results
Fleet Coordination
const middlewareFleet = await FleetManager.coordinate({
strategy: 'middleware-testing',
agents: [
'qe-middleware-validator', // Routing, transformation, EIP patterns
'qe-message-broker-tester', // DLQ, ordering, retry, circuit breaker
'qe-soap-tester' // SOAP contracts, WS-Security, mediation
],
topology: 'mesh'
});
await middlewareFleet.execute({
flows: [
{ name: 'order-inbound', stages: ['route', 'transform', 'enrich', 'deliver'] },
{ name: 'payment-processing', stages: ['validate', 'authorize', 'settle'] }
],
testDLQ: true,
testCompensation: true
});
Related Skills
- api-testing-patterns - REST/GraphQL API testing fundamentals
- contract-testing - Consumer-driven contract testing with Pact
- enterprise-integration-testing - Orchestrating all enterprise agents
- chaos-engineering-resilience - Fault injection and resilience testing
- wms-testing-patterns - Warehouse system integration testing
Remember
Middleware is the nervous system of enterprise architecture. When it works, nobody notices. When it fails, everything breaks. Test the routing decisions, the transformations, the error channels, and the compensation patterns. Always validate with correlation IDs across multi-hop flows, and always confirm that poison messages end up in the DLQ with enough metadata to diagnose and replay.
With Agents: Agents validate routing rules against message types, test transformation accuracy with schema compliance, and exercise DLQ/retry/circuit-breaker behavior systematically. Use agents to cover the combinatorial explosion of routing paths and transformation edge cases that manual testing cannot reach.