Mock Server latency simulation inconsistent in parallel execution

Answer the Question First

To get consistent, measurable latency in a Karate mock server when tests run in parallel, avoid the global configure delay setting. Instead, apply a per‑request delay inside the mock response or in the scenario using * delay(ms). Verify the delay with Karate’s built‑in responseTime variable and keep each parallel worker on its own mock server instance.

1. Per‑Request Latency Injection

• Define the delay in the mock response JSON:

  {
    "status": 200,
    "body": {"ok": true},
    "delay": 500
  }

• Or, in the scenario, before the call, add:

  * delay(500)
  * def res = call read('classpath:mock/endpoint.feature')
  

• Both approaches apply the delay server‑side, before the response is sent.

2. Isolate Global State for Parallel Execution

• Do not use configure delay in a shared Background or BeforeAll block – it is JVM‑wide for the mock server instance.
• Start a dedicated mock server per parallel worker:

  Background:
    * def port = karate.get('mock.port')
    * karate.startMockServer(port)
  

• Assign a unique port to each worker (e.g., via system property or a simple port‑range algorithm).
• Stop the server in an After hook to avoid port leaks.

3. Verify the Simulated Latency

• After the request, Karate exposes responseTime in milliseconds.

  * assert responseTime >= 500 - 50
  

• Use a small tolerance (e.g., 50 ms) to account for scheduling jitter.
• Log responseTime in parallel runs to confirm consistency.

Likely Explanation for Inconsistency

The most common cause is concurrent modification of the global configure delay value. Because the mock server instance is shared across threads, one scenario can overwrite the delay used by another, leading to unpredictable timings.

Confirmed Facts

• Karate’s delay(ms) and delay field inject latency server‑side.
• Global configure delay is JVM‑wide and not thread‑safe.
• Built‑in responseTime can be asserted to validate the delay.

Practical Steps for Your Case

1. Remove any configure delay from shared hooks.
2. Add * delay(500) before each mock call or set "delay": 500 in the mock JSON.
3. Start a per‑worker mock server with a unique port (e.g., karate.startMockServer(8081 + workerId)).
4. Assert responseTime >= 450 after each call.
5. Collect and compare responseTime across parallel workers to confirm stability.

Missing Diagnostic Detail

To fine‑tune the recommendation, could you share the Karate version you’re using? Different releases have subtle changes in mock server threading.