Enterprise Integration Testing

<default_to_action> When testing enterprise integrations or SAP-connected systems:

1. MAP the end-to-end flow (web -> API -> middleware -> backend -> response)
2. IDENTIFY integration points and protocols (REST, SOAP, RFC, IDoc, OData, EDI)
3. SELECT the right agent for each integration type
4. TEST each integration boundary with contract and data validation
5. VALIDATE cross-system data consistency (SAP <-> WMS <-> middleware)
6. EXERCISE enterprise error handling (compensation, retry, alerting)
7. GATE releases with enterprise-specific quality criteria

Agent Selection Guide:

• SAP RFC/BAPI calls -> qe-sap-rfc-tester
• SAP IDoc flows -> qe-sap-idoc-tester
• OData/Fiori services -> qe-odata-contract-tester
• SOAP/ESB endpoints -> qe-soap-tester
• Message broker flows -> qe-message-broker-tester
• Middleware routing/transformation -> qe-middleware-validator
• Authorization / SoD conflicts -> qe-sod-analyzer

Critical Success Factors:

• Enterprise testing is cross-system: no system is tested in isolation
• Data consistency across systems is the primary quality signal
• Environment access and test data are the biggest bottlenecks </default_to_action>

Quick Reference Card

When to Use

• Testing SAP-connected enterprise systems (S/4HANA, ECC, BW)
• Validating end-to-end business processes (Order-to-Cash, Procure-to-Pay)
• Testing middleware/ESB integrations (IIB, MuleSoft, SAP PI/PO)
• Cross-system data reconciliation (SAP <-> WMS <-> CRM)
• Enterprise release readiness assessment

Enterprise Integration Types

Critical Test Scenarios

Tools

• SAP: SAP GUI, Transaction codes (SE37, WE19, SEGW), Eclipse ADT
• Middleware: IBM IIB/ACE, MuleSoft, SAP PI/PO/CPI
• Testing: SoapUI, Postman, Playwright, custom harnesses
• Monitoring: SAP Solution Manager, Splunk, Dynatrace
• Data: SAP LSMW, SECATT, eCATT

Agent Coordination

• qe-sap-rfc-tester: SAP RFC/BAPI function module testing
• qe-sap-idoc-tester: IDoc inbound/outbound processing validation
• qe-odata-contract-tester: OData service contract and Fiori app testing
• qe-soap-tester: SOAP/WSDL contract validation and WS-Security
• qe-message-broker-tester: Message broker flows, DLQ, ordering
• qe-middleware-validator: ESB routing, transformation, EIP patterns
• qe-sod-analyzer: Segregation of Duties and authorization testing

E2E Enterprise Flow Testing

Order-to-Cash Flow

javascript
1describe('Order-to-Cash E2E Flow', () => {
2  it('processes web order through SAP to warehouse fulfillment', async () => {
3    // Step 1: Create order via web API
4    const webOrder = await api.post('/orders', {
5      customerId: 'CUST-1000',
6      items: [{ materialNumber: 'MAT-500', quantity: 10 }],
7      shippingAddress: { city: 'Portland', state: 'OR' }
8    });
9    expect(webOrder.status).toBe(201);
10    const webOrderId = webOrder.body.orderId;
11
12    // Step 2: Verify SAP Sales Order created via middleware
13    const sapOrder = await sapClient.call('BAPI_SALESORDER_GETLIST', {
14      CUSTOMER_NUMBER: 'CUST-1000',
15      SALES_ORGANIZATION: '1000'
16    });
17    const matchingSapOrder = sapOrder.find(o => o.PURCHASE_ORDER_NO === webOrderId);
18    expect(matchingSapOrder).toBeDefined();
19    const sapOrderId = matchingSapOrder.SD_DOC;
20
21    // Step 3: Verify WMS received pick instruction
22    const wmsPickTask = await wmsApi.get(`/pick-tasks?externalRef=${sapOrderId}`);
23    expect(wmsPickTask.status).toBe(200);
24    expect(wmsPickTask.body.status).toBe('PENDING');
25
26    // Step 4: Complete pick in WMS
27    await wmsApi.post(`/pick-tasks/${wmsPickTask.body.taskId}/complete`, {
28      pickedItems: [{ sku: 'MAT-500', quantity: 10, location: 'A-01-03' }]
29    });
30
31    // Step 5: Verify SAP delivery created (via IDoc confirmation)
32    await waitFor(async () => {
33      const delivery = await sapClient.call('BAPI_DELIVERYPROCESSING_GETLIST', {
34        SALES_ORDER: sapOrderId
35      });
36      return delivery.length > 0 && delivery[0].DELVRY_STATUS === 'C';
37    }, { timeout: 30000, interval: 3000 });
38
39    // Step 6: Verify invoice posted in SAP
40    await waitFor(async () => {
41      const invoice = await sapClient.call('BAPI_BILLINGDOC_GETLIST', {
42        REFDOCNUMBER: sapOrderId
43      });
44      return invoice.length > 0;
45    }, { timeout: 30000, interval: 3000 });
46  });
47});

Procure-to-Pay Flow

javascript
1describe('Procure-to-Pay E2E Flow', () => {
2  it('creates purchase requisition through to vendor payment', async () => {
3    // Step 1: Create Purchase Requisition
4    const prResult = await sapClient.call('BAPI_PR_CREATE', {
5      PRHEADER: { PR_TYPE: 'NB', CTRL_IND: '' },
6      PRHEADERX: { PR_TYPE: 'X' },
7      PRITEMS: [{ MATERIAL: 'MAT-RAW-100', QUANTITY: 500, UNIT: 'EA', PLANT: '1000' }]
8    });
9    expect(prResult.NUMBER).toBeDefined();
10    const prNumber = prResult.NUMBER;
11
12    // Step 2: Verify PR triggers sourcing (ME57 equivalent)
13    const sourcingResult = await sapClient.call('BAPI_PR_GETDETAIL', {
14      NUMBER: prNumber
15    });
16    expect(sourcingResult.PRITEM[0].PREQ_NO).toBe(prNumber);
17
18    // Step 3: Create Purchase Order from PR
19    const poResult = await sapClient.call('BAPI_PO_CREATE1', {
20      POHEADER: { COMP_CODE: '1000', DOC_TYPE: 'NB', VENDOR: 'VEND-500' },
21      POITEMS: [{ PO_ITEM: '00010', MATERIAL: 'MAT-RAW-100', QUANTITY: 500, PLANT: '1000' }]
22    });
23    expect(poResult.PO_NUMBER).toBeDefined();
24
25    // Step 4: Verify PO IDoc sent to vendor
26    const idocStatus = await sapClient.call('IDOC_STATUS_READ', {
27      DOCNUM: poResult.IDOC_NUMBER
28    });
29    expect(idocStatus.STATUS).toBe('03'); // Successfully sent
30  });
31});

SAP-Specific Testing Patterns

RFC/BAPI Testing

javascript
1describe('SAP RFC/BAPI Testing', () => {
2  it('validates BAPI return structure and error handling', async () => {
3    // Test with valid input
4    const result = await sapClient.call('BAPI_MATERIAL_GETDETAIL', {
5      MATERIAL: 'MAT-EXIST'
6    });
7    expect(result.RETURN.TYPE).not.toBe('E');
8    expect(result.MATERIAL_GENERAL_DATA.MATL_DESC).toBeDefined();
9
10    // Test with invalid material
11    const errorResult = await sapClient.call('BAPI_MATERIAL_GETDETAIL', {
12      MATERIAL: 'MAT-NONEXIST'
13    });
14    expect(errorResult.RETURN.TYPE).toBe('E');
15    expect(errorResult.RETURN.MESSAGE).toContain('does not exist');
16  });
17
18  it('handles BAPI commit correctly', async () => {
19    const createResult = await sapClient.call('BAPI_SALESORDER_CREATEFROMDAT2', {
20      ORDER_HEADER_IN: {
21        DOC_TYPE: 'OR',
22        SALES_ORG: '1000',
23        DISTR_CHAN: '10',
24        DIVISION: '00'
25      },
26      ORDER_PARTNERS: [{ PARTN_ROLE: 'AG', PARTN_NUMB: 'CUST-1000' }],
27      ORDER_ITEMS_IN: [{ MATERIAL: 'MAT-500', TARGET_QTY: 10 }]
28    });
29
30    // Must call BAPI_TRANSACTION_COMMIT to persist
31    await sapClient.call('BAPI_TRANSACTION_COMMIT', { WAIT: 'X' });
32
33    // Verify order exists after commit
34    const getResult = await sapClient.call('BAPI_SALESORDER_GETDETAIL', {
35      SALESDOCUMENT: createResult.SALESDOCUMENT
36    });
37    expect(getResult.ORDER_HEADER_OUT.SD_DOC_CAT).toBe('C');
38  });
39});

IDoc Testing

javascript
1describe('SAP IDoc Processing', () => {
2  it('validates inbound IDoc creates correct SAP document', async () => {
3    // Send IDoc via middleware
4    const idocPayload = {
5      IDOCTYP: 'ORDERS05',
6      MESTYP: 'ORDERS',
7      SNDPOR: 'SAPEXT',
8      SNDPRT: 'LS',
9      SNDPRN: 'EXTERN',
10      RCVPOR: 'SAPSI1',
11      RCVPRT: 'LS',
12      RCVPRN: 'SAPCLNT100',
13      segments: {
14        E1EDK01: { BELNR: 'EXT-PO-001' },
15        E1EDK14: [{ QUESSION: '001', ORGID: '1000' }],
16        E1EDP01: [{ POSEX: '000010', MENGE: '100', MENEE: 'EA', MATNR: 'MAT-500' }]
17      }
18    };
19
20    const idocNumber = await middlewareClient.sendIDoc(idocPayload);
21
22    // Wait for IDoc processing in SAP
23    await waitFor(async () => {
24      const status = await sapClient.call('IDOC_STATUS_READ', { DOCNUM: idocNumber });
25      return status.STATUS === '53'; // Application document posted successfully
26    }, { timeout: 60000, interval: 5000 });
27
28    // Verify SAP document was created
29    const sapDoc = await sapClient.call('BAPI_SALESORDER_GETLIST', {
30      PURCHASE_ORDER_NO: 'EXT-PO-001'
31    });
32    expect(sapDoc).toHaveLength(1);
33  });
34
35  it('handles IDoc error status correctly', async () => {
36    // Send IDoc with invalid material
37    const idocPayload = buildIdocPayload({ materialNumber: 'INVALID-MAT' });
38    const idocNumber = await middlewareClient.sendIDoc(idocPayload);
39
40    await waitFor(async () => {
41      const status = await sapClient.call('IDOC_STATUS_READ', { DOCNUM: idocNumber });
42      return ['51', '56'].includes(status.STATUS); // Error statuses
43    }, { timeout: 60000 });
44
45    const status = await sapClient.call('IDOC_STATUS_READ', { DOCNUM: idocNumber });
46    expect(status.STATUS_TEXT).toContain('Material');
47  });
48});

OData Service Testing

javascript
1describe('SAP OData Service Testing', () => {
2  it('validates OData entity CRUD operations', async () => {
3    // CREATE
4    const createResponse = await odataClient.post('/sap/opu/odata/sap/API_SALES_ORDER_SRV/A_SalesOrder', {
5      SalesOrderType: 'OR',
6      SalesOrganization: '1000',
7      DistributionChannel: '10',
8      OrganizationDivision: '00',
9      SoldToParty: 'CUST-1000'
10    });
11    expect(createResponse.status).toBe(201);
12    const salesOrder = createResponse.body.d.SalesOrder;
13
14    // READ with $expand
15    const readResponse = await odataClient.get(
16      `/sap/opu/odata/sap/API_SALES_ORDER_SRV/A_SalesOrder('${salesOrder}')?$expand=to_Item`
17    );
18    expect(readResponse.status).toBe(200);
19    expect(readResponse.body.d.SalesOrder).toBe(salesOrder);
20
21    // READ collection with $filter
22    const listResponse = await odataClient.get(
23      `/sap/opu/odata/sap/API_SALES_ORDER_SRV/A_SalesOrder?$filter=SoldToParty eq 'CUST-1000'&$top=10`
24    );
25    expect(listResponse.status).toBe(200);
26    expect(listResponse.body.d.results.length).toBeGreaterThan(0);
27  });
28
29  it('validates OData $metadata contract', async () => {
30    const metadata = await odataClient.get(
31      '/sap/opu/odata/sap/API_SALES_ORDER_SRV/$metadata'
32    );
33    expect(metadata.status).toBe(200);
34
35    const parsedMetadata = parseEdmx(metadata.body);
36    expect(parsedMetadata.entityTypes).toContain('A_SalesOrder');
37    expect(parsedMetadata.entityTypes).toContain('A_SalesOrderItem');
38
39    // Validate required properties exist
40    const salesOrderType = parsedMetadata.getEntityType('A_SalesOrder');
41    expect(salesOrderType.properties).toContain('SalesOrder');
42    expect(salesOrderType.properties).toContain('SalesOrderType');
43    expect(salesOrderType.navigationProperties).toContain('to_Item');
44  });
45});

Fiori Launchpad Testing

javascript
1describe('Fiori Launchpad App Testing', () => {
2  it('validates Fiori tile loads and displays correct data', async () => {
3    await page.goto(`${fioriLaunchpadUrl}#SalesOrder-manage`);
4
5    // Wait for OData call to complete
6    await page.waitForResponse(resp =>
7      resp.url().includes('API_SALES_ORDER_SRV') && resp.status() === 200
8    );
9
10    // Verify smart table loaded with data
11    const tableRows = await page.locator('table tbody tr');
12    expect(await tableRows.count()).toBeGreaterThan(0);
13
14    // Verify filter bar is functional
15    await page.fill('[data-sap-ui="filterField-SalesOrder"]', '1000000');
16    await page.click('[data-sap-ui="btnGo"]');
17
18    await page.waitForResponse(resp =>
19      resp.url().includes("$filter=SalesOrder eq '1000000'")
20    );
21  });
22});

Cross-System Data Validation

javascript
1describe('Cross-System Data Consistency', () => {
2  it('SAP inventory matches WMS inventory', async () => {
3    const materials = ['MAT-100', 'MAT-200', 'MAT-300'];
4
5    for (const material of materials) {
6      // Get SAP stock
7      const sapStock = await sapClient.call('BAPI_MATERIAL_STOCK_REQ_LIST', {
8        MATERIAL: material,
9        PLANT: '1000'
10      });
11      const sapQuantity = parseFloat(sapStock.TOTAL_STOCK);
12
13      // Get WMS inventory
14      const wmsInventory = await wmsApi.get(`/inventory/${material}`);
15      const wmsQuantity = wmsInventory.body.availableQuantity;
16
17      expect(wmsQuantity).toBe(sapQuantity);
18    }
19  });
20
21  it('customer master data is consistent across systems', async () => {
22    const customerId = 'CUST-1000';
23
24    const sapCustomer = await sapClient.call('BAPI_CUSTOMER_GETDETAIL', {
25      CUSTOMERNO: customerId
26    });
27
28    const crmCustomer = await crmApi.get(`/customers/${customerId}`);
29    const wmsCustomer = await wmsApi.get(`/customers/${customerId}`);
30
31    // Core fields must match
32    expect(crmCustomer.body.name).toBe(sapCustomer.CUSTOMER_GENERAL_DATA.NAME);
33    expect(wmsCustomer.body.name).toBe(sapCustomer.CUSTOMER_GENERAL_DATA.NAME);
34    expect(crmCustomer.body.taxId).toBe(sapCustomer.CUSTOMER_GENERAL_DATA.TAX_NUMBER);
35  });
36
37  it('order status is synchronized across all systems', async () => {
38    const orderId = 'ORD-SYNC-TEST';
39
40    // Create order and wait for propagation
41    await api.post('/orders', { orderId, customerId: 'CUST-1000', items: [{ sku: 'MAT-100', qty: 5 }] });
42    await sleep(10000); // Allow for async propagation
43
44    const webStatus = (await api.get(`/orders/${orderId}`)).body.status;
45    const sapStatus = (await sapClient.call('BAPI_SALESORDER_GETDETAIL', {
46      SALESDOCUMENT: orderId
47    })).ORDER_HEADER_OUT.DOC_STATUS;
48    const wmsStatus = (await wmsApi.get(`/orders/${orderId}`)).body.status;
49
50    // All systems should reflect same logical status
51    expect(mapSapStatus(sapStatus)).toBe(webStatus);
52    expect(mapWmsStatus(wmsStatus)).toBe(webStatus);
53  });
54});

Enterprise Test Data Management

javascript
1describe('Enterprise Test Data Strategy', () => {
2  // Master data setup - reusable across test suites
3  const masterDataFixture = {
4    async setup() {
5      // Create customer in SAP (source of truth)
6      const customer = await sapClient.call('BAPI_CUSTOMER_CREATE', {
7        PI_COPYREFERENCE: { SALESORG: '1000', DISTR_CHAN: '10' },
8        PI_PERSONALDATA: { FIRSTNAME: 'Test', LASTNAME: `Customer-${Date.now()}` }
9      });
10      await sapClient.call('BAPI_TRANSACTION_COMMIT', { WAIT: 'X' });
11
12      // Wait for replication to downstream systems
13      await waitFor(async () => {
14        const wms = await wmsApi.get(`/customers/${customer.CUSTOMERNO}`);
15        return wms.status === 200;
16      }, { timeout: 60000 });
17
18      return { customerId: customer.CUSTOMERNO };
19    },
20
21    async teardown(customerId) {
22      // Mark customer for deletion (SAP does not hard delete)
23      await sapClient.call('BAPI_CUSTOMER_CHANGEFROMDATA', {
24        CUSTOMERNO: customerId,
25        PI_PERSONALDATA: { DELETION_FLAG: 'X' }
26      });
27      await sapClient.call('BAPI_TRANSACTION_COMMIT', { WAIT: 'X' });
28    }
29  };
30
31  let testCustomer;
32
33  beforeAll(async () => {
34    testCustomer = await masterDataFixture.setup();
35  });
36
37  afterAll(async () => {
38    await masterDataFixture.teardown(testCustomer.customerId);
39  });
40
41  it('uses properly replicated test customer', async () => {
42    const order = await api.post('/orders', {
43      customerId: testCustomer.customerId,
44      items: [{ sku: 'MAT-100', qty: 1 }]
45    });
46    expect(order.status).toBe(201);
47  });
48});

Environment Strategy

Enterprise Environment Matrix

javascript
1// Environment-aware test configuration
2const envConfig = {
3  INT: {
4    sapClient: '300',
5    sapHost: 'sap-int.company.com',
6    wmsHost: 'wms-int.company.com',
7    middlewareHost: 'esb-int.company.com',
8    testDataStrategy: 'synthetic', // Create and teardown
9    maxParallelTests: 5
10  },
11  QAS: {
12    sapClient: '400',
13    sapHost: 'sap-qas.company.com',
14    wmsHost: 'wms-qas.company.com',
15    middlewareHost: 'esb-qas.company.com',
16    testDataStrategy: 'reserved-sets', // Pre-allocated test data
17    maxParallelTests: 3
18  }
19};
20
21function getTestConfig() {
22  const env = process.env.TEST_ENVIRONMENT || 'INT';
23  return envConfig[env];
24}

Enterprise Quality Gates

QCSD Flags for Enterprise Systems

javascript
1const enterpriseFlags = {
2  HAS_MIDDLEWARE: true,           // ESB/middleware in the flow
3  HAS_SAP_INTEGRATION: true,     // SAP RFC/BAPI/IDoc/OData calls
4  HAS_AUTHORIZATION: true,       // SoD and role-based access
5  HAS_CROSS_SYSTEM_DATA: true,   // Data replicated across systems
6  HAS_ASYNC_PROCESSING: true,    // IDoc, message queue, batch jobs
7  HAS_LEGACY_PROTOCOL: true      // SOAP, RFC, flat-file, EDI
8};

Release Readiness Criteria

javascript
1describe('Enterprise Release Readiness', () => {
2  it('passes all enterprise quality gates', async () => {
3    const gates = [
4      {
5        name: 'Cross-System Data Consistency',
6        check: async () => {
7          const results = await runDataReconciliation(['MAT-100', 'MAT-200']);
8          return results.every(r => r.consistent);
9        }
10      },
11      {
12        name: 'IDoc Processing Success Rate',
13        check: async () => {
14          const stats = await sapClient.call('IDOC_STATUS_SUMMARY', { PERIOD: 'LAST_24H' });
15          const successRate = stats.SUCCESS / stats.TOTAL;
16          return successRate >= 0.99; // 99% threshold
17        }
18      },
19      {
20        name: 'Middleware Error Rate',
21        check: async () => {
22          const errors = await middlewareMonitor.getErrorCount({ period: '24h' });
23          return errors < 10; // Less than 10 errors in 24h
24        }
25      },
26      {
27        name: 'SoD Violations',
28        check: async () => {
29          const violations = await sodAnalyzer.scan({ scope: 'changed-roles' });
30          return violations.critical === 0;
31        }
32      },
33      {
34        name: 'E2E Order Flow',
35        check: async () => {
36          const result = await runE2EOrderFlow();
37          return result.allStepsCompleted && result.duration < 120000; // Under 2 minutes
38        }
39      }
40    ];
41
42    for (const gate of gates) {
43      const passed = await gate.check();
44      expect(passed).toBe(true);
45    }
46  });
47});

Best Practices

Do This

• Map the full E2E flow before writing any tests
• Test each integration boundary separately AND end-to-end
• Use SAP-aware test data management (create, use, teardown with BAPIs)
• Validate data consistency across all systems after each integration event
• Include IDoc status monitoring in your test assertions
• Test authorization (SoD) as part of every enterprise release gate
• Use service virtualization for systems that are hard to provision

Avoid This

• Testing SAP only through the UI (Fiori/SAP GUI) without API-level tests
• Ignoring IDoc error statuses (51, 56) and only checking happy path
• Sharing test data between teams without reservation mechanisms
• Testing enterprise flows only in sandbox environments
• Skipping BAPI_TRANSACTION_COMMIT after create/update BAPIs
• Assuming cross-system data is immediately consistent (allow for async propagation)
• Deploying without verifying SoD compliance for changed authorization roles

Agent-Assisted Enterprise Testing

typescript
1// SAP RFC/BAPI function testing
2await Task("SAP BAPI Validation", {
3  bapis: ['BAPI_SALESORDER_CREATEFROMDAT2', 'BAPI_SALESORDER_GETDETAIL'],
4  testScenarios: ['valid-input', 'missing-required', 'invalid-customer', 'commit-rollback'],
5  validateReturnStructure: true
6}, "qe-sap-rfc-tester");
7
8// IDoc processing validation
9await Task("IDoc Flow Validation", {
10  idocType: 'ORDERS05',
11  direction: 'inbound',
12  testStatuses: ['53-success', '51-application-error', '56-syntax-error'],
13  validateSapDocument: true
14}, "qe-sap-idoc-tester");
15
16// OData contract testing
17await Task("OData Service Contract Test", {
18  serviceUrl: '/sap/opu/odata/sap/API_SALES_ORDER_SRV',
19  validateMetadata: true,
20  testCrud: true,
21  testFilters: ['$filter', '$expand', '$orderby', '$top', '$skip'],
22  checkBackwardCompatibility: true
23}, "qe-odata-contract-tester");
24
25// SOAP service validation
26await Task("SOAP Service Validation", {
27  wsdl: 'services/OrderService.wsdl',
28  operations: ['CreateOrder', 'GetOrderStatus'],
29  testWsSecurity: true,
30  testFaultCodes: true
31}, "qe-soap-tester");
32
33// Middleware flow validation
34await Task("Middleware Integration Test", {
35  flow: 'order-to-cash',
36  stages: ['web-api', 'esb-routing', 'sap-rfc', 'wms-api'],
37  testDLQ: true,
38  testCompensation: true,
39  validateCorrelationIds: true
40}, "qe-middleware-validator");
41
42// Message broker testing
43await Task("Message Broker Validation", {
44  broker: 'ibm-mq',
45  queues: ['orders.inbound', 'orders.sap', 'orders.wms', 'orders.dlq'],
46  testOrdering: true,
47  testRetry: true
48}, "qe-message-broker-tester");
49
50// Segregation of Duties analysis
51await Task("SoD Conflict Analysis", {
52  scope: 'changed-roles',
53  ruleSet: 'sap-standard',
54  criticalTransactions: ['ME21N', 'ME29N', 'MIRO', 'FB60'],
55  reportFormat: 'matrix'
56}, "qe-sod-analyzer");

Agent Coordination Hints

Memory Namespace

aqe/enterprise-integration/
  flows/              - E2E flow definitions and test results
  sap/
    rfc-results/      - RFC/BAPI test outcomes
    idoc-results/     - IDoc processing validation
    odata-contracts/  - OData $metadata snapshots and diffs
  middleware/
    routing/          - ESB routing test results
    transforms/       - Transformation validation
  cross-system/
    reconciliation/   - Data consistency reports
    master-data/      - Master data sync validation
  authorization/
    sod-reports/      - SoD conflict analysis results
    role-testing/     - Role and permission test results
  quality-gates/      - Enterprise release gate results

Fleet Coordination

typescript
1const enterpriseFleet = await FleetManager.coordinate({
2  strategy: 'enterprise-integration',
3  agents: [
4    'qe-sap-rfc-tester',          // SAP function module testing
5    'qe-sap-idoc-tester',         // IDoc processing validation
6    'qe-odata-contract-tester',   // OData/Fiori service testing
7    'qe-soap-tester',             // SOAP/ESB endpoint testing
8    'qe-message-broker-tester',   // Message broker flows
9    'qe-middleware-validator',     // Middleware routing/transformation
10    'qe-sod-analyzer'             // Authorization and SoD
11  ],
12  topology: 'hierarchical'
13});
14
15await enterpriseFleet.execute({
16  flow: 'order-to-cash',
17  phases: [
18    { name: 'contract-validation', agents: ['qe-odata-contract-tester', 'qe-soap-tester'] },
19    { name: 'integration-testing', agents: ['qe-sap-rfc-tester', 'qe-sap-idoc-tester', 'qe-middleware-validator'] },
20    { name: 'e2e-validation', agents: ['qe-message-broker-tester'] },
21    { name: 'authorization-check', agents: ['qe-sod-analyzer'] }
22  ]
23});

Related Skills

• api-testing-patterns - REST/GraphQL API testing fundamentals
• contract-testing - Consumer-driven contract testing with Pact
• middleware-testing-patterns - ESB, routing, transformation, DLQ
• wms-testing-patterns - Warehouse management system testing
• chaos-engineering-resilience - Fault injection for enterprise systems
• database-testing - Database integrity and migration testing
• security-testing - Security and authorization testing

Remember

Enterprise integration testing is about verifying that independently correct systems work correctly together. No system is an island. Test each integration boundary with protocol-appropriate tools, validate cross-system data consistency, and always include authorization and SoD checks. The biggest risks are in the seams between systems, not within them.

With Agents: Use specialized agents for each integration type (RFC, IDoc, OData, SOAP, messaging). Orchestrate them hierarchically: contract validation first, then integration testing, then E2E flows, then authorization. The enterprise fleet catches cross-system inconsistencies that single-system testing misses entirely.