Skip to main content Home Creators proffesor-for-testing agentic-qe middleware-testing-patterns
middleware-testing-patterns Enterprise middleware testing patterns for message routing, transformation, DLQ, protocol mediation, ESB error handling, and EIP patterns. Use when testing middleware layers, message brokers, ESBs, or integration buses.
Jump to install Skills Marketplace Discover and explore AI skills built by the community.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
Show prompt details A direct command skips the review prompt. Inspect the source before running it.
npx skills add https://github.com/proffesor-for-testing/agentic-qe --skill middleware-testing-patternsThe command stays on one line. Scroll horizontally to inspect it before copying.
Prefer a local copy? Download the files currently available to SkillsMP.
Download Zip Downloading... More from this repository Ruflo is a multi-agent orchestration platform for AI coding agents (Claude Code, Cursor, Codex, Copilot, Gemini, Amp, +12 more). Use this skill when the user wants to (1) install/init ruflo in a project, (2) run multi-agent swarms with hierarchical coordination, (3) use ruflo's 314+ MCP tools for memory, routing, hooks, sub-agents, or workflows, (4) check ruflo status/version/doctor health, or (5) discover which of ruflo's 30+ plugins fits their task.
Build dependency-aware execution plans for complex Agentic QE, Ruflo, integration, migration, or multi-stream engineering programs. Use when Codex must turn research or requirements into phased work, select a small AQE fleet, map critical paths and parallel streams, define acceptance gates, or sequence risky changes. Use aqe-plan-quality instead when the primary output is only a test or quality plan.
Conduct evidence-first technical research for Agentic QE, Ruflo, related ruvnet projects, or external tools. Use when Codex must investigate a repository, compare current upstream changes, trace dependencies and history, distinguish verified facts from inference, or synthesize findings into actionable engineering recommendations. Do not use for a simple known-answer lookup or an implementation-only task.
Related occupations SOC
Based on SOC occupation classification
name middleware-testing-patterns description Enterprise middleware testing patterns for message routing, transformation, DLQ, protocol mediation, ESB error handling, and EIP patterns. Use when testing middleware layers, message brokers, ESBs, or integration buses. category enterprise-integration priority high tokenEstimate 1800 agents ["qe-middleware-validator","qe-message-broker-tester","qe-soap-tester"] implementation_status optimized optimization_version 1 last_optimized "2026-02-04T00:00:00.000Z" dependencies ["api-testing-patterns","contract-testing"] quick_reference_card true tags ["middleware","esb","soap","messaging","iib","mq","transformation","routing"] trust_tier 3 validation {"schema_path":"schemas/output.json","validator_path":"scripts/validate-config.json","eval_path":"evals/middleware-testing-patterns.yaml"}
Middleware Testing Patterns
<default_to_action>
When testing enterprise middleware, ESBs, or message-driven systems:
VALIDATE message routing logic (content-based, header-based, recipient list)
TEST message transformations end-to-end (input format -> output format)
VERIFY dead letter queue handling (poison messages, retry exhaustion)
ASSERT message ordering and sequencing with correlation IDs
EXERCISE error handling and compensation patterns
TEST protocol mediation (SOAP-to-REST, sync-to-async)
VALIDATE EIP patterns (splitter, aggregator, content enricher, normalizer)
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
</default_to_action>
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
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, ActiveMQESBs : IBM IIB/ACE, MuleSoft, WSO2, Apache CamelTesting : SoapUI, Postman, custom harnessesVirtualization : Mountebank, WireMock, HoverFlyMonitoring : 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 ();
});
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);
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' },
items : [{ sku : 'MAT-200' , quantity : 5 }]
};
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 ('' );
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 : [] };
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 () => {
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 () => {
mockEndpoint.respondWith (500 , 'Service Unavailable' );
await broker.publish ('orders.process' , {
body : { orderId : 'ORD-FAIL' },
headers : { 'x-correlation-id' : 'corr-123' }
});
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);
});
it ('DLQ messages can be replayed after fix' , async () => {
mockEndpoint.respondWith (500 , 'Down' );
await broker.publish ('orders.process' , { body : { orderId : 'ORD-REPLAY' } });
const dlqMessage = await broker.consume ('orders.dlq' , { timeout : 30000 });
mockEndpoint.respondWith (200 , 'OK' );
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 () => {
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 }
});
}
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 () => {
mockServices.inventory .respondWith (200 );
mockServices.payment .respondWith (200 );
mockServices.shipping .respondWith (500 );
await broker.publish ('saga.order' , {
body : { orderId : 'ORD-SAGA' , amount : 100.00 }
});
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>
` ;
mockRestBackend.onGet ('/orders/ORD-700' ).reply (200 , {
orderId : 'ORD-700' ,
status : 'SHIPPED' ,
total : 150.00
});
const response = await soapClient.send (soapRequest, { endpoint : esbSoapEndpoint });
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 () => {
const response = await httpClient.post (`${esbEndpoint} /async-orders` , {
orderId : 'ORD-ASYNC' ,
items : [{ sku : 'X1' , qty : 5 }]
});
expect (response.status ).toBe (202 );
expect (response.body .correlationId ).toBeDefined ();
const correlationId = response.body .correlationId ;
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 =>body .sku ).sort ()).toEqual (['A1' , 'B2' , 'C3' ]);
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 =>status === 'PICKED' )).toBe (true );
});
it ('handles aggregation timeout for incomplete batches' , async () => {
const batchId = 'BATCH-TIMEOUT' ;
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 }
});
}
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 );
});
});
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 });
expect (timestamps).toHaveLength (4 );
const delay1 = timestamps[1 ] - timestamps[0 ];
const delay2 = timestamps[2 ] - timestamps[1 ];
expect (delay1).toBeGreaterThan (800 );
expect (delay2).toBeGreaterThan (1800 );
});
});
describe ('Circuit Breaker' , () => {
it ('opens circuit after threshold failures' , async () => {
mockEndpoint.onPost ('/process' ).reply (500 , 'Down' );
for (let i = 0 ; i < 5 ; i++) {
await broker.publish ('orders.circuit' , { body : { orderId : `ORD-CB-${i} ` } });
}
await sleep (5000 );
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 );
});
});
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
await Task ("Middleware Routing Validation" , {
routingConfig : 'esb/routing-rules.xml' ,
messageTypes : ['STANDARD_ORDER' , 'EXPRESS_ORDER' , 'RETURN' ],
validateDLQ : true ,
checkCorrelationIds : true
}, "qe-middleware-validator" );
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" );
await Task ("SOAP Service Contract Validation" , {
wsdl : 'services/OrderService.wsdl' ,
endpoints : ['CreateOrder' , 'GetOrderStatus' , 'CancelOrder' ],
validateWsSecurity : true ,
testFaultHandling : true
}, "qe-soap-tester" );
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' ,
'qe-message-broker-tester' ,
'qe-soap-tester'
],
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
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.
