@durable-streams/client-conformance-tests 0.2.5 → 0.2.7

package/dist/adapters/typescript-adapter.cjs

@@ -260,6 +260,66 @@ async function handleCommand(command) {
 				finalOffset = response.offset;
 				upToDate = response.upToDate;
 				streamClosed = response.streamClosed;
+			} else if (isJson) {
+				const startTime = Date.now();
+				let chunkCount = 0;
+				let done = false;
+				await new Promise((resolve, reject) => {
+					const subscriptionTimeoutId = setTimeout(() => {
+						done = true;
+						abortController.abort();
+						upToDate = response.upToDate || true;
+						finalOffset = response.offset;
+						streamClosed = response.streamClosed;
+						resolve();
+					}, timeoutMs);
+					const unsubscribe = response.subscribeJson(async (batch) => {
+						if (done || chunkCount >= maxChunks) return;
+						if (Date.now() - startTime > timeoutMs) {
+							done = true;
+							resolve();
+							return;
+						}
+						if (batch.items.length > 0) {
+							chunks.push({
+								data: JSON.stringify(batch.items),
+								offset: batch.offset
+							});
+							chunkCount++;
+						}
+						finalOffset = batch.offset;
+						upToDate = batch.upToDate;
+						streamClosed = batch.streamClosed;
+						if (command.waitForUpToDate && batch.upToDate) {
+							done = true;
+							clearTimeout(subscriptionTimeoutId);
+							resolve();
+							return;
+						}
+						if (chunkCount >= maxChunks) {
+							done = true;
+							clearTimeout(subscriptionTimeoutId);
+							resolve();
+						}
+						await Promise.resolve();
+					});
+					response.closed.then(() => {
+						if (!done) {
+							done = true;
+							clearTimeout(subscriptionTimeoutId);
+							upToDate = response.upToDate;
+							finalOffset = response.offset;
+							streamClosed = response.streamClosed;
+							resolve();
+						}
+					}).catch((err) => {
+						if (!done) {
+							done = true;
+							clearTimeout(subscriptionTimeoutId);
+							reject(err);
+						}
+					});
+				});
 			} else {
 				const decoder = new TextDecoder();
 				const startTime = Date.now();

package/dist/adapters/typescript-adapter.js

@@ -258,6 +258,66 @@ async function handleCommand(command) {
 				finalOffset = response.offset;
 				upToDate = response.upToDate;
 				streamClosed = response.streamClosed;
+			} else if (isJson) {
+				const startTime = Date.now();
+				let chunkCount = 0;
+				let done = false;
+				await new Promise((resolve, reject) => {
+					const subscriptionTimeoutId = setTimeout(() => {
+						done = true;
+						abortController.abort();
+						upToDate = response.upToDate || true;
+						finalOffset = response.offset;
+						streamClosed = response.streamClosed;
+						resolve();
+					}, timeoutMs);
+					const unsubscribe = response.subscribeJson(async (batch) => {
+						if (done || chunkCount >= maxChunks) return;
+						if (Date.now() - startTime > timeoutMs) {
+							done = true;
+							resolve();
+							return;
+						}
+						if (batch.items.length > 0) {
+							chunks.push({
+								data: JSON.stringify(batch.items),
+								offset: batch.offset
+							});
+							chunkCount++;
+						}
+						finalOffset = batch.offset;
+						upToDate = batch.upToDate;
+						streamClosed = batch.streamClosed;
+						if (command.waitForUpToDate && batch.upToDate) {
+							done = true;
+							clearTimeout(subscriptionTimeoutId);
+							resolve();
+							return;
+						}
+						if (chunkCount >= maxChunks) {
+							done = true;
+							clearTimeout(subscriptionTimeoutId);
+							resolve();
+						}
+						await Promise.resolve();
+					});
+					response.closed.then(() => {
+						if (!done) {
+							done = true;
+							clearTimeout(subscriptionTimeoutId);
+							upToDate = response.upToDate;
+							finalOffset = response.offset;
+							streamClosed = response.streamClosed;
+							resolve();
+						}
+					}).catch((err) => {
+						if (!done) {
+							done = true;
+							clearTimeout(subscriptionTimeoutId);
+							reject(err);
+						}
+					});
+				});
 			} else {
 				const decoder = new TextDecoder();
 				const startTime = Date.now();

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.2.5",
+  "version": "0.2.7",
   "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.2.3",
-    "@durable-streams/server": "0.3.1"
+    "@durable-streams/client": "0.2.4",
+    "@durable-streams/server": "0.3.3"
   },
   "devDependencies": {
     "tsdown": "^0.9.0",

package/src/adapters/typescript-adapter.ts

@@ -418,8 +418,83 @@ async function handleCommand(command: TestCommand): Promise<TestResult> {
           finalOffset = response.offset
           upToDate = response.upToDate
           streamClosed = response.streamClosed
+        } else if (isJson) {
+          const startTime = Date.now()
+          let chunkCount = 0
+          let done = false
+
+          await new Promise<void>((resolve, reject) => {
+            const subscriptionTimeoutId = setTimeout(() => {
+              done = true
+              abortController.abort()
+              upToDate = response.upToDate || true
+              finalOffset = response.offset
+              streamClosed = response.streamClosed
+              resolve()
+            }, timeoutMs)
+
+            const unsubscribe = response.subscribeJson(async (batch) => {
+              if (done || chunkCount >= maxChunks) {
+                return
+              }
+
+              if (Date.now() - startTime > timeoutMs) {
+                done = true
+                resolve()
+                return
+              }
+
+              if (batch.items.length > 0) {
+                chunks.push({
+                  data: JSON.stringify(batch.items),
+                  offset: batch.offset,
+                })
+                chunkCount++
+              }
+
+              finalOffset = batch.offset
+              upToDate = batch.upToDate
+              streamClosed = batch.streamClosed
+
+              if (command.waitForUpToDate && batch.upToDate) {
+                done = true
+                clearTimeout(subscriptionTimeoutId)
+                resolve()
+                return
+              }
+
+              if (chunkCount >= maxChunks) {
+                done = true
+                clearTimeout(subscriptionTimeoutId)
+                resolve()
+              }
+
+              await Promise.resolve()
+            })
+
+            response.closed
+              .then(() => {
+                if (!done) {
+                  done = true
+                  clearTimeout(subscriptionTimeoutId)
+                  upToDate = response.upToDate
+                  finalOffset = response.offset
+                  streamClosed = response.streamClosed
+                  resolve()
+                }
+              })
+              .catch((err) => {
+                if (!done) {
+                  done = true
+                  clearTimeout(subscriptionTimeoutId)
+                  reject(err)
+                }
+              })
+
+            void unsubscribe
+          })
         } else {
-          // For live mode, use subscribeBytes which provides per-chunk metadata
+          // For live non-JSON mode, use subscribeBytes which provides per-chunk metadata
           const decoder = new TextDecoder()
           const startTime = Date.now()
           let chunkCount = 0

package/test-cases/consumer/read-sse.yaml

@@ -294,20 +294,33 @@ tests:
       Per EventSource spec section 9.2.4: "If value starts with a
       U+0020 SPACE character, remove it from value."
       Only ONE space should be removed, preserving any additional spaces.
-      This prevents parsers from using trim() or similar which would
-      incorrectly strip all leading/trailing whitespace.
+      This test appends data after the reader reaches the tail so every client
+      receives the payload through SSE, including fetch-then-live clients.
     setup:
       - action: create
         as: streamPath
         contentType: text/plain
       - action: append
         path: ${streamPath}
-        data: "  two leading spaces"
+        data: "initial"
+        expect:
+          storeOffsetAs: tailOffset
     operations:
       - action: read
         path: ${streamPath}
+        offset: ${tailOffset}
         live: sse
-        waitForUpToDate: true
+        maxChunks: 1
+        timeoutMs: 10000
+        background: true
+        as: readOp
+      - action: wait
+        ms: 200
+      - action: server-append
+        path: ${streamPath}
+        data: "  two leading spaces"
+      - action: await
+        ref: readOp
         expect:
           data: " two leading spaces"
           minChunks: 1

package/test-cases/consumer/sse-parsing-errors.yaml

@@ -49,6 +49,8 @@ tests:
       - action: append
         path: ${streamPath}
         data: "data-before-error"
+        expect:
+          storeOffsetAs: tailOffset
     operations:
       # Inject a control event with invalid JSON
       - action: inject-error
@@ -56,10 +58,14 @@ tests:
         injectSseEvent:
           eventType: "control"
           data: "{invalid json here"
-        count: 1
+        # Fetch-then-live makes an HTTP catch-up request before opening SSE.
+        # The first injected fault is consumed by catch-up; the second is
+        # delivered on the live SSE request.
+        count: 2
       # Client should throw a parse error
       - action: read
         path: ${streamPath}
+        offset: ${tailOffset}
         live: sse
         maxChunks: 1
         expect:
@@ -77,6 +83,8 @@ tests:
       - action: append
         path: ${streamPath}
         data: "actual-data"
+        expect:
+          storeOffsetAs: tailOffset
     operations:
       # Inject a control event with empty data
       - action: inject-error
@@ -84,10 +92,14 @@ tests:
         injectSseEvent:
           eventType: "control"
           data: ""
-        count: 1
+        # Fetch-then-live makes an HTTP catch-up request before opening SSE.
+        # The first injected fault is consumed by catch-up; the second is
+        # delivered on the live SSE request.
+        count: 2
       # Client should throw because empty is not valid JSON
       - action: read
         path: ${streamPath}
+        offset: ${tailOffset}
         live: sse
         maxChunks: 1
         expect:

package/test-cases/consumer/streaming-equivalence.yaml

@@ -131,6 +131,7 @@ tests:
         path: ${streamPath}
         offset: ${initialOffset}
         live: long-poll
+        maxChunks: 1
         timeoutMs: 5000
         background: true
         as: longpollRead
@@ -164,6 +165,7 @@ tests:
         path: ${streamPath}
         offset: ${initialOffset}
         live: sse
+        maxChunks: 1
         timeoutMs: 5000
         background: true
         as: sseRead

package/test-cases/lifecycle/stream-closure.yaml

@@ -335,15 +335,28 @@ tests:
         contentType: text/plain
       - action: append
         path: ${streamPath}
-        data: "sse-data"
-      - action: close
-        path: ${streamPath}
+        data: "initial"
+        expect:
+          storeOffsetAs: tailOffset
     operations:
-      # Read via SSE - may need multiple chunks as SSE delivers data then control event
+      # Start at the tail, then close with a final body so the data is delivered
+      # as the SSE final event rather than as HTTP catch-up data.
       - action: read
         path: ${streamPath}
+        offset: ${tailOffset}
         live: sse
+        maxChunks: 1
         timeoutMs: 5000
+        background: true
+        as: readOp
+      - action: wait
+        ms: 200
+      - action: server-close
+        path: ${streamPath}
+        data: "sse-data"
+        contentType: text/plain
+      - action: await
+        ref: readOp
         expect:
           data: "sse-data"
           streamClosed: true