API Workflow Testing

Overview

API Workflow Testing validates complex sequences of API calls that represent real-world business processes. It ensures APIs work correctly together, handling state management, data dependencies, and business logic across multiple integrated calls.

🔗 Sequential API Flows

API Workflow Testing validates:

• Multi-step API sequences

• Data dependencies between calls

• State management across requests

• Error handling in workflows

• Business process completion

• Service integration correctness

---

When to Use API Workflow Testing

✅ Good Use Cases

Scenario	Why API Workflow
Microservices	Complex service interactions
Order processing	Multi-step business process
User onboarding	Sequential account setup
Payment workflows	Payment + order + notification
Data transformations	Multiple API calls with data flow
Business processes	Real-world sequential logic

❌ Anti-Patterns (Don't Do)

• ❌ Test individual API calls (use API tests)

• ❌ Skip state verification between calls

• ❌ Ignore data dependencies

• ❌ Test without proper sequencing

• ❌ Forget to verify side effects

---

API Workflow Patterns

Sequential Pattern

Call 1 → Call 2 → Call 3 → Call 4 → Result

Example: User registration workflow
[Create user] → [Set preferences] → [Send email] → [Update status]

Request-Response Pattern

Request 1 → Response 1 (used in) → Request 2 → Response 2 → ...

Data flows forward:
user_id from Response 1 → used in Request 2
order_id from Response 2 → used in Request 3

Validation Pattern

Call → Response → Verify → Next Call

Each response verified:
[Make call]
[Check response format]
[Check response data]
[Continue if valid]
[Stop if invalid]

Conditional Pattern

Decision point in workflow:
[Call 1] → Result?
           ├─ Success → [Call 2]
           └─ Failure → [Call 3]

Sequential Pattern

Multiple calls run in sequence:
[Call A] → [Call B] → [Aggregate] → [Final call]

---

Practical Examples

Example 1: Complete Order Processing Workflow

Workflow: Full order lifecycle via APIs

Services:
- Order Service
- Payment Service
- Inventory Service
- Shipping Service
- Notification Service

Step 1: Create Order
[POST /orders]
Input:
{
  "customer_id": "cust_123",
  "items": [
    {"sku": "PROD-001", "qty": 2},
    {"sku": "PROD-002", "qty": 1}
  ],
  "shipping_address": {...}
}

Output:
{
  "order_id": "ord_456",
  "status": "pending",
  "total": 99.99,
  "created_at": "2024-01-15T14:00:00Z"
}

Verify:
✓ Order created
✓ Status is "pending"
✓ Total calculated correctly
✓ order_id returned for next calls

Step 2: Process Payment
[POST /payments/process]
Input:
{
  "order_id": "ord_456",
  "amount": 99.99,
  "payment_method": "card",
  "card_token": "tok_visa"
}

Output:
{
  "transaction_id": "txn_789",
  "status": "succeeded",
  "amount": 99.99,
  "timestamp": "2024-01-15T14:01:00Z"
}

Verify:
✓ Payment succeeded
✓ Amount matches order
✓ transaction_id returned
✓ Status is "succeeded"

Step 3: Reserve Inventory
[POST /inventory/reserve]
Input:
{
  "order_id": "ord_456",
  "items": [
    {"sku": "PROD-001", "qty": 2},
    {"sku": "PROD-002", "qty": 1}
  ]
}

Output:
{
  "reservation_id": "res_111",
  "status": "reserved",
  "reserved_at": "2024-01-15T14:02:00Z"
}

Verify:
✓ Inventory reserved
✓ All items available
✓ reservation_id returned

Step 4: Create Shipment
[POST /shipping/shipments]
Input:
{
  "order_id": "ord_456",
  "items": [
    {"sku": "PROD-001", "qty": 2},
    {"sku": "PROD-002", "qty": 1}
  ],
  "address": {...}
}

Output:
{
  "shipment_id": "ship_222",
  "tracking_number": "TRK123456789",
  "carrier": "FedEx",
  "status": "ready_to_ship"
}

Verify:
✓ Shipment created
✓ Tracking number generated
✓ Carrier assigned

Step 5: Update Order Status
[PATCH /orders/ord_456]
Input:
{
  "status": "confirmed",
  "transaction_id": "txn_789",
  "shipment_id": "ship_222"
}

Output:
{
  "order_id": "ord_456",
  "status": "confirmed",
  "updated_at": "2024-01-15T14:03:00Z"
}

Verify:
✓ Order status updated
✓ All references linked

Step 6: Send Confirmation Email
[POST /notifications/email]
Input:
{
  "order_id": "ord_456",
  "customer_id": "cust_123",
  "template": "order_confirmation",
  "data": {
    "tracking_number": "TRK123456789",
    "estimated_delivery": "2024-01-18"
  }
}

Output:
{
  "notification_id": "notif_333",
  "status": "sent",
  "sent_at": "2024-01-15T14:04:00Z"
}

Verify:
✓ Email sent
✓ Correct template used
✓ Tracking in email

Complete Workflow Verification:
✓ Order created and confirmed
✓ Payment processed
✓ Inventory reserved
✓ Shipment created with tracking
✓ Customer notified
✓ All steps completed successfully

Result: ✅ Complete order processing successful

Example 2: User Onboarding Workflow

Workflow: Complete user registration and setup

Services:
- User Service
- Account Service
- Email Service
- Analytics Service

Step 1: Register User
[POST /users/register]
Input:
{
  "email": "[email protected]",
  "password": "hashed_password",
  "first_name": "John",
  "last_name": "Doe"
}

Output:
{
  "user_id": "usr_100",
  "email": "[email protected]",
  "created_at": "2024-01-15T15:00:00Z"
}

Verify:
✓ User created
✓ user_id generated
✓ Email set correctly

Step 2: Create User Account
[POST /accounts]
Input:
{
  "user_id": "usr_100",
  "account_type": "individual",
  "timezone": "America/New_York"
}

Output:
{
  "account_id": "acc_200",
  "user_id": "usr_100",
  "status": "active"
}

Verify:
✓ Account created
✓ Linked to user
✓ Status is active

Step 3: Send Verification Email
[POST /emails/send]
Input:
{
  "to": "[email protected]",
  "template": "email_verification",
  "user_id": "usr_100",
  "verification_token": "token_abc123"
}

Output:
{
  "email_id": "email_300",
  "status": "sent"
}

Verify:
✓ Email sent
✓ Correct template

Step 4: Simulate Email Click
[GET /verify-email?token=token_abc123]

Output:
{
  "status": "verified",
  "user_id": "usr_100"
}

Verify:
✓ Email verified
✓ User confirmed

Step 5: Update User Status
[PATCH /users/usr_100]
Input:
{
  "status": "email_verified"
}

Output:
{
  "user_id": "usr_100",
  "status": "email_verified",
  "verified_at": "2024-01-15T15:05:00Z"
}

Verify:
✓ User status updated

Step 6: Send Welcome Email
[POST /emails/send]
Input:
{
  "to": "[email protected]",
  "template": "welcome",
  "user_id": "usr_100"
}

Output:
{
  "email_id": "email_400",
  "status": "sent"
}

Verify:
✓ Welcome email sent

Step 7: Record Analytics Event
[POST /analytics/events]
Input:
{
  "event_type": "user_onboarded",
  "user_id": "usr_100",
  "timestamp": "2024-01-15T15:05:00Z"
}

Output:
{
  "event_id": "evt_500"
}

Verify:
✓ Event recorded

Complete Workflow Verification:
✓ User registered
✓ Account created
✓ Email verified
✓ User confirmed
✓ Welcome notification sent
✓ Event recorded
✓ User ready to use platform

Result: ✅ User onboarding complete

Example 3: Payment Processing with Retry Logic

Workflow: Payment with error handling and retry

Services:
- Order Service
- Payment Service
- Retry Service

Step 1: Initial Payment Attempt
[POST /payments/process]
Input:
{
  "order_id": "ord_789",
  "amount": 199.99,
  "card": {...}
}

Response: HTTP 503 (Service Unavailable)
Error: Payment processor temporarily down

Verify:
✓ Error detected
✗ Payment not processed

Step 2: Queue Retry
[POST /retry/queue]
Input:
{
  "order_id": "ord_789",
  "retry_count": 1,
  "retry_after": 5
}

Output:
{
  "retry_id": "retry_001",
  "scheduled_at": "2024-01-15T15:10:00Z"
}

Verify:
✓ Retry queued

Step 3: Wait and Retry
[Wait 5 seconds]

[POST /payments/process]
Input:
{
  "order_id": "ord_789",
  "amount": 199.99,
  "card": {...}
}

Response: HTTP 200
Output:
{
  "transaction_id": "txn_111",
  "status": "succeeded"
}

Verify:
✓ Retry successful
✓ Payment processed

Step 4: Update Order
[PATCH /orders/ord_789]
Input:
{
  "status": "paid",
  "transaction_id": "txn_111"
}

Output:
{
  "order_id": "ord_789",
  "status": "paid"
}

Verify:
✓ Order updated

Complete Workflow Verification:
✓ Initial attempt failed
✓ Retry queued
✓ Retry succeeded
✓ Order marked paid
✓ Resilience working

Result: ✅ Resilient payment processing

Example 4: Conditional Workflow

Workflow: Conditional API flow (multi-path)

Step 1: Check Order Status
[GET /orders/ord_999]

Output:
{
  "order_id": "ord_999",
  "status": "pending",
  "payment_status": "pending"
}

Decision: payment_status == "pending" ?

Path A: Payment Required
Step 2A: Process Payment
[POST /payments/process]
  → Payment succeeds

Step 3A: Update Status
[PATCH /orders/ord_999]
  → Status: confirmed

Path B: Already Paid (if payment_status == "paid")
Step 2B: Skip payment
[PATCH /orders/ord_999]
  → Status: confirmed (already paid)

Result:
✓ Order processed
✓ Correct path taken based on status

Example 5: Sequential API Calls

Workflow: Sequential API execution

Step 1: Create Order
[POST /orders]
→ order_id = "ord_555"

Step 2: Run in Sequence
[Sequential execution]

Call A: Reserve Inventory
[POST /inventory/reserve]
{order_id: "ord_555"}

Call B: Prepare Shipment
[POST /shipping/prepare]
{order_id: "ord_555"}

Call C: Update Analytics
[POST /analytics/order]
{order_id: "ord_555"}

Each completes before next

Step 3: Aggregate Results
[Collect results from A, B, C]
[Verify all succeeded]

Step 4: Final Confirmation
[PATCH /orders/ord_555]
{status: "ready_to_process"}

Result:
✓ All sequential calls completed
✓ Each verified individually
✓ Reliable execution flow

---

Data Flow Management

Extracting Data Between Calls

Call 1 Response:
{
  "user_id": "usr_123",
  "email": "[email protected]"
}

Extract and Store:
user_id = "usr_123"
email = "[email protected]"

Use in Call 2:
[POST /profiles]
{
  "user_id": "usr_123",  ← from Call 1
  "email": "[email protected]"  ← from Call 1
}

State Management

Workflow State:
{
  "user_id": null,
  "order_id": null,
  "transaction_id": null,
  "tracking_number": null
}

After Call 1: user_id = "usr_123"
After Call 2: order_id = "ord_456"
After Call 3: transaction_id = "txn_789"
After Call 4: tracking_number = "TRK999"

Final State: All values populated

Error Cascading

Workflow:
Step 1: Call A succeeds → state updated
Step 2: Call B fails → STOP
Step 3: Call C not executed
Step 4: Call D not executed

Result: Partial completion
→ Rollback or recovery needed
→ Test handles this correctly

---

Best Practices

✅ Do

• Test real sequences - Mirror actual workflows

• Verify each step - Don't assume intermediate calls work

• Extract and reuse data - Pass data between calls

• Test error recovery - What if step fails

• Use unique test data - Each run independent

• Document workflow - Show the business process

• Test state changes - Verify persistence

• Handle timing - Wait for async operations

❌ Don't

• Test API in isolation - Test workflows

• Skip intermediate verification - Verify each step

• Hardcode IDs - Extract from responses

• Ignore failures - Test error cases

• Use production data - Test data only

• Assume sequential safe - Test proper call sequencing

• Ignore side effects - Verify all changes

• Test UI logic - That's E2E

---

Troubleshooting

Issue: Data ID not available for next call

Symptoms:

• Second API call fails with wrong ID

• Can't extract needed data

Causes:

• Previous call failed silently

• Unexpected response format

• Data field not in response

Solutions:

1. Verify previous call succeeded

2. Check response structure

3. Extract right field

4. Add explicit verification

Issue: Workflow timing issues

Symptoms:

• Calls succeed individually but fail in sequence

• Timing-dependent failures

Causes:

• Async operations not complete

• Eventual consistency issues

• Database replication lag

Solutions:

1. Add explicit waits

2. Poll for completion

3. Wait for status changes

4. Add retry logic

Issue: Complex workflow is slow

Symptoms:

• Workflow test takes too long

• Sequential calls slow

Solutions:

1. Optimize where possible

2. Use mock for slow services

3. Reduce test data

4. Simplify workflow

---

Realistic Scenarios

E-Commerce: Complete Purchase

1. Create cart
2. Add items
3. Calculate shipping
4. Apply coupon
5. Calculate tax
6. Process payment
7. Create order
8. Create shipment
9. Send confirmation
10. Record analytics

SaaS: Trial Account Setup

1. Register user
2. Create account
3. Verify email
4. Set up workspace
5. Invite team members
6. Configure settings
7. Start trial period
8. Send welcome email
9. Record analytics

Banking: Transfer Process

1. Verify source account
2. Verify destination account
3. Check available funds
4. Create transaction
5. Process transfer
6. Update source balance
7. Update destination balance
8. Create audit log
9. Send confirmation
10. Monitor for fraud

---

Related Topics

• Integration Testing - Service integration

• End-to-End Testing - User journeys

• Error Handling - Error scenarios

• Best Practices - Professional standards

• Workflow Patterns - Common patterns

---

Summary

• API Workflow Testing validates multi-step processes

• Mirror real business flows - Test complete workflows

• Extract and pass data - State management critical

• Test error cases - What if steps fail

• Optimize when possible - Improve efficiency

• Verify each step - Don't skip validation

---

Next: Explore the Advanced Topics section for deeper technical knowledge.