@durable-streams/client-conformance-tests 0.1.5 → 0.1.6

package/dist/adapters/typescript-adapter.cjs

@@ -471,12 +471,13 @@ async function handleBenchmark(command) {
 				const readPromise = (async () => {
 					const res = await ds.stream({ live: operation.live ?? `long-poll` });
 					return new Promise((resolve) => {
-						const unsubscribe = res.subscribeBytes(async (chunk) => {
+						const unsubscribe = res.subscribeBytes((chunk) => {
 							if (chunk.data.length > 0) {
 								unsubscribe();
 								res.cancel();
 								resolve(chunk.data);
 							}
+							return Promise.resolve();
 						});
 					});
 				})();

package/dist/adapters/typescript-adapter.js

@@ -469,12 +469,13 @@ async function handleBenchmark(command) {
 				const readPromise = (async () => {
 					const res = await ds.stream({ live: operation.live ?? `long-poll` });
 					return new Promise((resolve) => {
-						const unsubscribe = res.subscribeBytes(async (chunk) => {
+						const unsubscribe = res.subscribeBytes((chunk) => {
 							if (chunk.data.length > 0) {
 								unsubscribe();
 								res.cancel();
 								resolve(chunk.data);
 							}
+							return Promise.resolve();
 						});
 					});
 				})();

package/dist/{benchmark-runner-CLAR9oLd.cjs → benchmark-runner-BlKqhoXE.cjs}

@@ -352,14 +352,30 @@ async function executeOperation(op, ctx) {
 						path,
 						status: op.status,
 						count: op.count ?? 1,
-						retryAfter: op.retryAfter
+						retryAfter: op.retryAfter,
+						delayMs: op.delayMs,
+						dropConnection: op.dropConnection,
+						truncateBodyBytes: op.truncateBodyBytes,
+						probability: op.probability,
+						method: op.method,
+						corruptBody: op.corruptBody,
+						jitterMs: op.jitterMs
 					})
 				});
-				if (verbose) console.log(`  inject-error ${path} ${op.status}x${op.count ?? 1}: ${response.ok ? `ok` : `failed`}`);
-				if (!response.ok) return { error: `Failed to inject error: ${response.status}` };
+				const faultTypes = [];
+				if (op.status != null) faultTypes.push(`status=${op.status}`);
+				if (op.delayMs != null) faultTypes.push(`delay=${op.delayMs}ms`);
+				if (op.jitterMs != null) faultTypes.push(`jitter=${op.jitterMs}ms`);
+				if (op.dropConnection) faultTypes.push(`dropConnection`);
+				if (op.truncateBodyBytes != null) faultTypes.push(`truncate=${op.truncateBodyBytes}b`);
+				if (op.corruptBody) faultTypes.push(`corrupt`);
+				if (op.probability != null) faultTypes.push(`p=${op.probability}`);
+				const faultDesc = faultTypes.join(`,`) || `unknown`;
+				if (verbose) console.log(`  inject-error ${path} [${faultDesc}]x${op.count ?? 1}: ${response.ok ? `ok` : `failed`}`);
+				if (!response.ok) return { error: `Failed to inject fault: ${response.status}` };
 				return {};
 			} catch (err) {
-				return { error: `Failed to inject error: ${err instanceof Error ? err.message : String(err)}` };
+				return { error: `Failed to inject fault: ${err instanceof Error ? err.message : String(err)}` };
 			}
 		}
 		case `clear-errors`: try {

package/dist/{benchmark-runner-C_Yghc8f.js → benchmark-runner-D-YSAvRy.js}

@@ -350,14 +350,30 @@ async function executeOperation(op, ctx) {
 						path: path$1,
 						status: op.status,
 						count: op.count ?? 1,
-						retryAfter: op.retryAfter
+						retryAfter: op.retryAfter,
+						delayMs: op.delayMs,
+						dropConnection: op.dropConnection,
+						truncateBodyBytes: op.truncateBodyBytes,
+						probability: op.probability,
+						method: op.method,
+						corruptBody: op.corruptBody,
+						jitterMs: op.jitterMs
 					})
 				});
-				if (verbose) console.log(`  inject-error ${path$1} ${op.status}x${op.count ?? 1}: ${response.ok ? `ok` : `failed`}`);
-				if (!response.ok) return { error: `Failed to inject error: ${response.status}` };
+				const faultTypes = [];
+				if (op.status != null) faultTypes.push(`status=${op.status}`);
+				if (op.delayMs != null) faultTypes.push(`delay=${op.delayMs}ms`);
+				if (op.jitterMs != null) faultTypes.push(`jitter=${op.jitterMs}ms`);
+				if (op.dropConnection) faultTypes.push(`dropConnection`);
+				if (op.truncateBodyBytes != null) faultTypes.push(`truncate=${op.truncateBodyBytes}b`);
+				if (op.corruptBody) faultTypes.push(`corrupt`);
+				if (op.probability != null) faultTypes.push(`p=${op.probability}`);
+				const faultDesc = faultTypes.join(`,`) || `unknown`;
+				if (verbose) console.log(`  inject-error ${path$1} [${faultDesc}]x${op.count ?? 1}: ${response.ok ? `ok` : `failed`}`);
+				if (!response.ok) return { error: `Failed to inject fault: ${response.status}` };
 				return {};
 			} catch (err) {
-				return { error: `Failed to inject error: ${err instanceof Error ? err.message : String(err)}` };
+				return { error: `Failed to inject fault: ${err instanceof Error ? err.message : String(err)}` };
 			}
 		}
 		case `clear-errors`: try {

package/dist/cli.cjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 "use strict";
 require('./protocol-XeAOKBD-.cjs');
-const require_benchmark_runner = require('./benchmark-runner-CLAR9oLd.cjs');
+const require_benchmark_runner = require('./benchmark-runner-BlKqhoXE.cjs');
 
 //#region src/cli.ts
 const HELP = `

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import "./protocol-qb83AeUH.js";
-import { runBenchmarks, runConformanceTests } from "./benchmark-runner-C_Yghc8f.js";
+import { runBenchmarks, runConformanceTests } from "./benchmark-runner-D-YSAvRy.js";
 
 //#region src/cli.ts
 const HELP = `

package/dist/index.cjs

@@ -1,5 +1,5 @@
 const require_protocol = require('./protocol-XeAOKBD-.cjs');
-const require_benchmark_runner = require('./benchmark-runner-CLAR9oLd.cjs');
+const require_benchmark_runner = require('./benchmark-runner-BlKqhoXE.cjs');
 
 exports.ErrorCodes = require_protocol.ErrorCodes
 exports.allScenarios = require_benchmark_runner.allScenarios

package/dist/index.d.cts

@@ -212,19 +212,34 @@ interface AwaitOperation {
   expect?: ReadExpectation;
 }
 /**
-* Inject an error to be returned on the next N requests to a path.
+* Inject a fault to be triggered on the next N requests to a path.
 * Used for testing retry/resilience behavior.
+* Supports various fault types: errors, delays, connection drops, body corruption, etc.
 */
 interface InjectErrorOperation {
   action: `inject-error`;
-  /** Stream path to inject error for */
+  /** Stream path to inject fault for */
   path: string;
-  /** HTTP status code to return */
-  status: number;
-  /** Number of times to return this error (default: 1) */
+  /** HTTP status code to return (if set, returns error response) */
+  status?: number;
+  /** Number of times to trigger this fault (default: 1) */
   count?: number;
   /** Optional Retry-After header value (seconds) */
   retryAfter?: number;
+  /** Delay in milliseconds before responding */
+  delayMs?: number;
+  /** Drop the connection after sending headers (simulates network failure) */
+  dropConnection?: boolean;
+  /** Truncate response body to this many bytes */
+  truncateBodyBytes?: number;
+  /** Probability of triggering fault (0-1, default 1.0 = always) */
+  probability?: number;
+  /** Only match specific HTTP method (GET, POST, PUT, DELETE) */
+  method?: string;
+  /** Corrupt the response body by flipping random bits */
+  corruptBody?: boolean;
+  /** Add jitter to delay (random 0-jitterMs added to delayMs) */
+  jitterMs?: number;
 }
 /**
 * Clear all injected errors.

package/dist/index.d.ts

@@ -212,19 +212,34 @@ interface AwaitOperation {
   expect?: ReadExpectation;
 }
 /**
-* Inject an error to be returned on the next N requests to a path.
+* Inject a fault to be triggered on the next N requests to a path.
 * Used for testing retry/resilience behavior.
+* Supports various fault types: errors, delays, connection drops, body corruption, etc.
 */
 interface InjectErrorOperation {
   action: `inject-error`;
-  /** Stream path to inject error for */
+  /** Stream path to inject fault for */
   path: string;
-  /** HTTP status code to return */
-  status: number;
-  /** Number of times to return this error (default: 1) */
+  /** HTTP status code to return (if set, returns error response) */
+  status?: number;
+  /** Number of times to trigger this fault (default: 1) */
   count?: number;
   /** Optional Retry-After header value (seconds) */
   retryAfter?: number;
+  /** Delay in milliseconds before responding */
+  delayMs?: number;
+  /** Drop the connection after sending headers (simulates network failure) */
+  dropConnection?: boolean;
+  /** Truncate response body to this many bytes */
+  truncateBodyBytes?: number;
+  /** Probability of triggering fault (0-1, default 1.0 = always) */
+  probability?: number;
+  /** Only match specific HTTP method (GET, POST, PUT, DELETE) */
+  method?: string;
+  /** Corrupt the response body by flipping random bits */
+  corruptBody?: boolean;
+  /** Add jitter to delay (random 0-jitterMs added to delayMs) */
+  jitterMs?: number;
 }
 /**
 * Clear all injected errors.

package/dist/index.js

@@ -1,4 +1,4 @@
 import { ErrorCodes, calculateStats, decodeBase64, encodeBase64, formatStats, parseCommand, parseResult, serializeCommand, serializeResult } from "./protocol-qb83AeUH.js";
-import { allScenarios, countTests, filterByCategory, getScenarioById, getScenariosByCategory, loadEmbeddedTestSuites, loadTestSuites, runBenchmarks, runConformanceTests, scenariosByCategory } from "./benchmark-runner-C_Yghc8f.js";
+import { allScenarios, countTests, filterByCategory, getScenarioById, getScenariosByCategory, loadEmbeddedTestSuites, loadTestSuites, runBenchmarks, runConformanceTests, scenariosByCategory } from "./benchmark-runner-D-YSAvRy.js";
 
 export { ErrorCodes, allScenarios, calculateStats, countTests, decodeBase64, encodeBase64, filterByCategory, formatStats, getScenarioById, getScenariosByCategory, loadEmbeddedTestSuites, loadTestSuites, parseCommand, parseResult, runBenchmarks, runConformanceTests, scenariosByCategory, serializeCommand, serializeResult };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@durable-streams/client-conformance-tests",
   "description": "Conformance test suite for Durable Streams client implementations (producer and consumer)",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "author": "Durable Stream contributors",
   "bin": {
     "client-conformance-tests": "./dist/cli.js",
@@ -14,8 +14,8 @@
     "fast-check": "^4.4.0",
     "tsx": "^4.19.2",
     "yaml": "^2.7.1",
-    "@durable-streams/client": "0.1.2",
-    "@durable-streams/server": "0.1.3"
+    "@durable-streams/client": "0.1.3",
+    "@durable-streams/server": "0.1.4"
   },
   "devDependencies": {
     "tsdown": "^0.9.0",

package/src/adapters/typescript-adapter.ts

@@ -702,12 +702,13 @@ async function handleBenchmark(command: BenchmarkCommand): Promise<TestResult> {
 
           // Wait for data
           return new Promise<Uint8Array>((resolve) => {
-            const unsubscribe = res.subscribeBytes(async (chunk) => {
+            const unsubscribe = res.subscribeBytes((chunk) => {
               if (chunk.data.length > 0) {
                 unsubscribe()
                 res.cancel()
                 resolve(chunk.data)
               }
+              return Promise.resolve()
             })
           })
         })()

package/src/runner.ts

@@ -599,7 +599,7 @@ async function executeOperation(
     }
 
     case `inject-error`: {
-      // Inject an error via the test server's control endpoint
+      // Inject a fault via the test server's control endpoint
       const path = resolveVariables(op.path, variables)
 
       try {
@@ -611,23 +611,43 @@ async function executeOperation(
             status: op.status,
             count: op.count ?? 1,
             retryAfter: op.retryAfter,
+            // New fault injection parameters
+            delayMs: op.delayMs,
+            dropConnection: op.dropConnection,
+            truncateBodyBytes: op.truncateBodyBytes,
+            probability: op.probability,
+            method: op.method,
+            corruptBody: op.corruptBody,
+            jitterMs: op.jitterMs,
           }),
         })
 
+        // Build descriptive log message
+        const faultTypes = []
+        if (op.status != null) faultTypes.push(`status=${op.status}`)
+        if (op.delayMs != null) faultTypes.push(`delay=${op.delayMs}ms`)
+        if (op.jitterMs != null) faultTypes.push(`jitter=${op.jitterMs}ms`)
+        if (op.dropConnection) faultTypes.push(`dropConnection`)
+        if (op.truncateBodyBytes != null)
+          faultTypes.push(`truncate=${op.truncateBodyBytes}b`)
+        if (op.corruptBody) faultTypes.push(`corrupt`)
+        if (op.probability != null) faultTypes.push(`p=${op.probability}`)
+        const faultDesc = faultTypes.join(`,`) || `unknown`
+
         if (verbose) {
           console.log(
-            `  inject-error ${path} ${op.status}x${op.count ?? 1}: ${response.ok ? `ok` : `failed`}`
+            `  inject-error ${path} [${faultDesc}]x${op.count ?? 1}: ${response.ok ? `ok` : `failed`}`
           )
         }
 
         if (!response.ok) {
-          return { error: `Failed to inject error: ${response.status}` }
+          return { error: `Failed to inject fault: ${response.status}` }
         }
 
         return {}
       } catch (err) {
         return {
-          error: `Failed to inject error: ${err instanceof Error ? err.message : String(err)}`,
+          error: `Failed to inject fault: ${err instanceof Error ? err.message : String(err)}`,
         }
       }
     }

package/src/test-cases.ts

@@ -243,19 +243,34 @@ export interface AwaitOperation {
 }
 
 /**
- * Inject an error to be returned on the next N requests to a path.
+ * Inject a fault to be triggered on the next N requests to a path.
  * Used for testing retry/resilience behavior.
+ * Supports various fault types: errors, delays, connection drops, body corruption, etc.
  */
 export interface InjectErrorOperation {
   action: `inject-error`
-  /** Stream path to inject error for */
+  /** Stream path to inject fault for */
   path: string
-  /** HTTP status code to return */
-  status: number
-  /** Number of times to return this error (default: 1) */
+  /** HTTP status code to return (if set, returns error response) */
+  status?: number
+  /** Number of times to trigger this fault (default: 1) */
   count?: number
   /** Optional Retry-After header value (seconds) */
   retryAfter?: number
+  /** Delay in milliseconds before responding */
+  delayMs?: number
+  /** Drop the connection after sending headers (simulates network failure) */
+  dropConnection?: boolean
+  /** Truncate response body to this many bytes */
+  truncateBodyBytes?: number
+  /** Probability of triggering fault (0-1, default 1.0 = always) */
+  probability?: number
+  /** Only match specific HTTP method (GET, POST, PUT, DELETE) */
+  method?: string
+  /** Corrupt the response body by flipping random bits */
+  corruptBody?: boolean
+  /** Add jitter to delay (random 0-jitterMs added to delayMs) */
+  jitterMs?: number
 }
 
 /**

package/test-cases/consumer/fault-injection.yaml

@@ -0,0 +1,202 @@
+id: consumer-fault-injection
+name: Advanced Fault Injection
+description: Tests for client resilience against various network and server faults
+category: consumer
+tags:
+  - fault-injection
+  - resilience
+  - chaos
+  - advanced
+
+tests:
+  - id: delay-recovery
+    name: Client handles delayed responses
+    description: Client should successfully read data even with server delays
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "delayed-data"
+    operations:
+      # Inject a 500ms delay
+      - action: inject-error
+        path: ${streamPath}
+        delayMs: 500
+        count: 1
+      # Client should wait and succeed
+      - action: read
+        path: ${streamPath}
+        expect:
+          data: "delayed-data"
+    cleanup:
+      - action: clear-errors
+
+  - id: delay-with-jitter
+    name: Client handles delayed responses with jitter
+    description: Client should handle variable delays (delay + random jitter)
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "jittery-data"
+    operations:
+      # Inject delay with jitter (300-600ms total)
+      - action: inject-error
+        path: ${streamPath}
+        delayMs: 300
+        jitterMs: 300
+        count: 1
+      - action: read
+        path: ${streamPath}
+        expect:
+          data: "jittery-data"
+    cleanup:
+      - action: clear-errors
+
+  - id: connection-drop-recovery
+    name: Client recovers from dropped connection
+    description: Client should retry when connection is dropped mid-request
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "persistent-data"
+    operations:
+      # Drop connection once
+      - action: inject-error
+        path: ${streamPath}
+        dropConnection: true
+        count: 1
+      # Client should retry and eventually succeed
+      - action: read
+        path: ${streamPath}
+        expect:
+          data: "persistent-data"
+    cleanup:
+      - action: clear-errors
+
+  - id: multiple-connection-drops
+    name: Client recovers from multiple dropped connections
+    description: Client should retry through multiple connection failures
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "resilient-data"
+    operations:
+      # Drop connection twice
+      - action: inject-error
+        path: ${streamPath}
+        dropConnection: true
+        count: 2
+      # Client should retry multiple times and succeed
+      - action: read
+        path: ${streamPath}
+        expect:
+          data: "resilient-data"
+    cleanup:
+      - action: clear-errors
+
+  - id: method-specific-fault
+    name: Fault only affects specific HTTP method
+    description: Fault should only trigger for specified method
+    setup:
+      - action: create
+        as: streamPath
+    operations:
+      # Inject fault only for POST (append)
+      - action: inject-error
+        path: ${streamPath}
+        status: 503
+        method: POST
+        count: 1
+      # GET should work fine (no fault)
+      - action: read
+        path: ${streamPath}
+        expect:
+          data: ""
+      # POST (append) should fail first then succeed on retry
+      - action: append
+        path: ${streamPath}
+        data: "method-filtered"
+      # Verify data was appended
+      - action: read
+        path: ${streamPath}
+        expect:
+          data: "method-filtered"
+    cleanup:
+      - action: clear-errors
+
+  - id: delay-then-error
+    name: Delay followed by error
+    description: Combined delay and error response
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "combined-fault-data"
+    operations:
+      # Delay 200ms then return 503
+      - action: inject-error
+        path: ${streamPath}
+        delayMs: 200
+        status: 503
+        count: 1
+      # Client should wait, get error, retry, and succeed
+      - action: read
+        path: ${streamPath}
+        expect:
+          data: "combined-fault-data"
+    cleanup:
+      - action: clear-errors
+
+  - id: append-with-delay
+    name: Append succeeds with server delay
+    description: Append should complete successfully even with server-side delay
+    setup:
+      - action: create
+        as: streamPath
+    operations:
+      # Add 500ms delay on first append
+      - action: inject-error
+        path: ${streamPath}
+        delayMs: 500
+        count: 1
+      # Append should wait and succeed
+      - action: append
+        path: ${streamPath}
+        data: "delayed-append"
+      # Verify data was appended
+      - action: read
+        path: ${streamPath}
+        expect:
+          data: "delayed-append"
+    cleanup:
+      - action: clear-errors
+
+  - id: delay-under-timeout
+    name: Client succeeds with delay under timeout
+    description: Client should succeed when delay is less than client timeout
+    setup:
+      - action: create
+        as: streamPath
+      - action: append
+        path: ${streamPath}
+        data: "within-timeout"
+    operations:
+      # 1 second delay (should be under most client timeouts)
+      - action: inject-error
+        path: ${streamPath}
+        delayMs: 1000
+        count: 1
+      - action: read
+        path: ${streamPath}
+        expect:
+          data: "within-timeout"
+    cleanup:
+      - action: clear-errors