@durable-streams/server-conformance-tests 0.1.4 → 0.1.5

package/dist/index.cjs

@@ -1,3 +1,3 @@
-const require_src = require('./src-DK3GDgwo.cjs');
+const require_src = require('./src-BJQjRfnf.cjs');
 
 exports.runConformanceTests = require_src.runConformanceTests

package/dist/index.d.cts

@@ -2,6 +2,8 @@
 interface ConformanceTestOptions {
   /** Base URL of the server to test */
   baseUrl: string;
+  /** Timeout for long-poll tests in milliseconds (default: 20000) */
+  longPollTimeoutMs?: number;
 }
 /**
 * Run the full conformance test suite against a server

package/dist/index.d.ts

@@ -2,6 +2,8 @@
 interface ConformanceTestOptions {
   /** Base URL of the server to test */
   baseUrl: string;
+  /** Timeout for long-poll tests in milliseconds (default: 20000) */
+  longPollTimeoutMs?: number;
 }
 /**
 * Run the full conformance test suite against a server

package/dist/index.js

@@ -1,3 +1,3 @@
-import { runConformanceTests } from "./src-DcbQ_SIQ.js";
+import { runConformanceTests } from "./src-BtF2jQ-Q.js";
 
 export { runConformanceTests };

package/dist/{src-DK3GDgwo.cjs → src-BJQjRfnf.cjs}

@@ -84,6 +84,7 @@ function parseSSEEvents(sseText) {
 */
 function runConformanceTests(options) {
 	const getBaseUrl = () => options.baseUrl;
+	const getLongPollTestTimeoutMs = () => (options.longPollTimeoutMs ?? 2e4) + 1e3;
 	(0, vitest.describe)(`Basic Stream Operations`, () => {
 		(0, vitest.test)(`should create a stream`, async () => {
 			const streamPath = `/v1/stream/create-test-${Date.now()}`;
@@ -252,13 +253,14 @@ function runConformanceTests(options) {
 			const readPromise = (async () => {
 				const res = await stream.stream({ live: `long-poll` });
 				await new Promise((resolve) => {
-					const unsubscribe = res.subscribeBytes(async (chunk) => {
+					const unsubscribe = res.subscribeBytes((chunk) => {
 						if (chunk.data.length > 0) receivedData.push(new TextDecoder().decode(chunk.data));
 						if (receivedData.length >= 1) {
 							unsubscribe();
 							res.cancel();
 							resolve();
 						}
+						return Promise.resolve();
 					});
 				});
 			})();
@@ -266,7 +268,7 @@ function runConformanceTests(options) {
 			await stream.append(`new data`);
 			await readPromise;
 			(0, vitest.expect)(receivedData).toContain(`new data`);
-		}, 1e4);
+		}, getLongPollTestTimeoutMs());
 		(0, vitest.test)(`should return immediately if data already exists`, async () => {
 			const streamPath = `/v1/stream/longpoll-immediate-test-${Date.now()}`;
 			const stream = await __durable_streams_client.DurableStream.create({
@@ -1059,7 +1061,7 @@ function runConformanceTests(options) {
 				clearTimeout(timeoutId);
 				if (e instanceof Error && e.name !== `AbortError`) throw e;
 			}
-		}, 1e4);
+		}, getLongPollTestTimeoutMs());
 	});
 	(0, vitest.describe)(`TTL and Expiry Edge Cases`, () => {
 		(0, vitest.test)(`should reject TTL with leading zeros`, async () => {

package/dist/{src-DcbQ_SIQ.js → src-BtF2jQ-Q.js}

@@ -82,6 +82,7 @@ function parseSSEEvents(sseText) {
 */
 function runConformanceTests(options) {
 	const getBaseUrl = () => options.baseUrl;
+	const getLongPollTestTimeoutMs = () => (options.longPollTimeoutMs ?? 2e4) + 1e3;
 	describe(`Basic Stream Operations`, () => {
 		test(`should create a stream`, async () => {
 			const streamPath = `/v1/stream/create-test-${Date.now()}`;
@@ -250,13 +251,14 @@ function runConformanceTests(options) {
 			const readPromise = (async () => {
 				const res = await stream.stream({ live: `long-poll` });
 				await new Promise((resolve) => {
-					const unsubscribe = res.subscribeBytes(async (chunk) => {
+					const unsubscribe = res.subscribeBytes((chunk) => {
 						if (chunk.data.length > 0) receivedData.push(new TextDecoder().decode(chunk.data));
 						if (receivedData.length >= 1) {
 							unsubscribe();
 							res.cancel();
 							resolve();
 						}
+						return Promise.resolve();
 					});
 				});
 			})();
@@ -264,7 +266,7 @@ function runConformanceTests(options) {
 			await stream.append(`new data`);
 			await readPromise;
 			expect(receivedData).toContain(`new data`);
-		}, 1e4);
+		}, getLongPollTestTimeoutMs());
 		test(`should return immediately if data already exists`, async () => {
 			const streamPath = `/v1/stream/longpoll-immediate-test-${Date.now()}`;
 			const stream = await DurableStream.create({
@@ -1057,7 +1059,7 @@ function runConformanceTests(options) {
 				clearTimeout(timeoutId);
 				if (e instanceof Error && e.name !== `AbortError`) throw e;
 			}
-		}, 1e4);
+		}, getLongPollTestTimeoutMs());
 	});
 	describe(`TTL and Expiry Edge Cases`, () => {
 		test(`should reject TTL with leading zeros`, async () => {

package/dist/test-runner.cjs

@@ -1,5 +1,5 @@
 "use strict";
-const require_src = require('./src-DK3GDgwo.cjs');
+const require_src = require('./src-BJQjRfnf.cjs');
 
 //#region src/test-runner.ts
 const baseUrl = process.env.CONFORMANCE_TEST_URL;

package/dist/test-runner.js

@@ -1,4 +1,4 @@
-import { runConformanceTests } from "./src-DcbQ_SIQ.js";
+import { runConformanceTests } from "./src-BtF2jQ-Q.js";
 
 //#region src/test-runner.ts
 const baseUrl = process.env.CONFORMANCE_TEST_URL;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@durable-streams/server-conformance-tests",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Conformance test suite for Durable Streams server implementations",
   "author": "Durable Stream contributors",
   "license": "Apache-2.0",

package/src/index.ts

@@ -17,6 +17,8 @@ import {
 export interface ConformanceTestOptions {
   /** Base URL of the server to test */
   baseUrl: string
+  /** Timeout for long-poll tests in milliseconds (default: 20000) */
+  longPollTimeoutMs?: number
 }
 
 /**
@@ -144,6 +146,8 @@ export function runConformanceTests(options: ConformanceTestOptions): void {
   // Access options.baseUrl directly instead of destructuring to support
   // mutable config objects (needed for dynamic port assignment)
   const getBaseUrl = () => options.baseUrl
+  const getLongPollTestTimeoutMs = () =>
+    (options.longPollTimeoutMs ?? 20_000) + 1_000
 
   // ============================================================================
   // Basic Stream Operations
@@ -380,42 +384,47 @@ export function runConformanceTests(options: ConformanceTestOptions): void {
   // ============================================================================
 
   describe(`Long-Poll Operations`, () => {
-    test(`should wait for new data with long-poll`, async () => {
-      const streamPath = `/v1/stream/longpoll-test-${Date.now()}`
-      const stream = await DurableStream.create({
-        url: `${getBaseUrl()}${streamPath}`,
-        contentType: `text/plain`,
-      })
+    test(
+      `should wait for new data with long-poll`,
+      async () => {
+        const streamPath = `/v1/stream/longpoll-test-${Date.now()}`
+        const stream = await DurableStream.create({
+          url: `${getBaseUrl()}${streamPath}`,
+          contentType: `text/plain`,
+        })
 
-      const receivedData: Array<string> = []
+        const receivedData: Array<string> = []
 
-      // Start reading in long-poll mode
-      const readPromise = (async () => {
-        const res = await stream.stream({ live: `long-poll` })
-        await new Promise<void>((resolve) => {
-          const unsubscribe = res.subscribeBytes(async (chunk) => {
-            if (chunk.data.length > 0) {
-              receivedData.push(new TextDecoder().decode(chunk.data))
-            }
-            if (receivedData.length >= 1) {
-              unsubscribe()
-              res.cancel()
-              resolve()
-            }
+        // Start reading in long-poll mode
+        const readPromise = (async () => {
+          const res = await stream.stream({ live: `long-poll` })
+          await new Promise<void>((resolve) => {
+            const unsubscribe = res.subscribeBytes((chunk) => {
+              if (chunk.data.length > 0) {
+                receivedData.push(new TextDecoder().decode(chunk.data))
+              }
+              if (receivedData.length >= 1) {
+                unsubscribe()
+                res.cancel()
+                resolve()
+              }
+              return Promise.resolve()
+            })
           })
-        })
-      })()
+        })()
 
-      // Wait a bit for the long-poll to be active
-      await new Promise((resolve) => setTimeout(resolve, 500))
+        // Wait a bit for the long-poll to be active
+        await new Promise((resolve) => setTimeout(resolve, 500))
 
-      // Append data while long-poll is waiting
-      await stream.append(`new data`)
+        // Append data while long-poll is waiting
+        await stream.append(`new data`)
 
-      await readPromise
+        await readPromise
 
-      expect(receivedData).toContain(`new data`)
-    }, 10000)
+        expect(receivedData).toContain(`new data`)
+      },
+      getLongPollTestTimeoutMs()
+    )
 
     test(`should return immediately if data already exists`, async () => {
       const streamPath = `/v1/stream/longpoll-immediate-test-${Date.now()}`
@@ -1631,58 +1640,62 @@ export function runConformanceTests(options: ConformanceTestOptions): void {
       expect(parseInt(cursor2!, 10)).toBeGreaterThan(parseInt(cursor1!, 10))
     })
 
-    test(`should return Stream-Cursor, Stream-Up-To-Date and Stream-Next-Offset on 204 timeout`, async () => {
-      const streamPath = `/v1/stream/longpoll-204-headers-test-${Date.now()}`
-
-      await fetch(`${getBaseUrl()}${streamPath}`, {
-        method: `PUT`,
-        headers: { "Content-Type": `text/plain` },
-      })
-
-      // Get the current tail offset
-      const headResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
-        method: `HEAD`,
-      })
-      const tailOffset = headResponse.headers.get(STREAM_OFFSET_HEADER)
-      expect(tailOffset).toBeDefined()
+    test(
+      `should return Stream-Cursor, Stream-Up-To-Date and Stream-Next-Offset on 204 timeout`,
+      async () => {
+        const streamPath = `/v1/stream/longpoll-204-headers-test-${Date.now()}`
 
-      // Long-poll at tail offset with a short timeout
-      // We use AbortController to limit wait time on our side
-      const controller = new AbortController()
-      const timeoutId = setTimeout(() => controller.abort(), 5000)
+        await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `PUT`,
+          headers: { "Content-Type": `text/plain` },
+        })
 
-      try {
-        const response = await fetch(
-          `${getBaseUrl()}${streamPath}?offset=${tailOffset}&live=long-poll`,
-          {
-            method: `GET`,
-            signal: controller.signal,
-          }
-        )
+        // Get the current tail offset
+        const headResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `HEAD`,
+        })
+        const tailOffset = headResponse.headers.get(STREAM_OFFSET_HEADER)
+        expect(tailOffset).toBeDefined()
+
+        // Long-poll at tail offset with a short timeout
+        // We use AbortController to limit wait time on our side
+        const controller = new AbortController()
+        const timeoutId = setTimeout(() => controller.abort(), 5000)
+
+        try {
+          const response = await fetch(
+            `${getBaseUrl()}${streamPath}?offset=${tailOffset}&live=long-poll`,
+            {
+              method: `GET`,
+              signal: controller.signal,
+            }
+          )
 
-        clearTimeout(timeoutId)
+          clearTimeout(timeoutId)
 
-        // If we get a 204, verify headers
-        if (response.status === 204) {
-          expect(response.headers.get(STREAM_OFFSET_HEADER)).toBeDefined()
-          expect(response.headers.get(STREAM_UP_TO_DATE_HEADER)).toBe(`true`)
+          // If we get a 204, verify headers
+          if (response.status === 204) {
+            expect(response.headers.get(STREAM_OFFSET_HEADER)).toBeDefined()
+            expect(response.headers.get(STREAM_UP_TO_DATE_HEADER)).toBe(`true`)
 
-          // Server MUST return Stream-Cursor even on 204 timeout
-          const cursor = response.headers.get(`Stream-Cursor`)
-          expect(cursor).toBeDefined()
-          expect(/^\d+$/.test(cursor!)).toBe(true)
-        }
-        // If we get a 200 (data arrived somehow), that's also valid
-        expect([200, 204]).toContain(response.status)
-      } catch (e) {
-        clearTimeout(timeoutId)
-        // AbortError is expected if server timeout is longer than our 5s
-        if (e instanceof Error && e.name !== `AbortError`) {
-          throw e
+            // Server MUST return Stream-Cursor even on 204 timeout
+            const cursor = response.headers.get(`Stream-Cursor`)
+            expect(cursor).toBeDefined()
+            expect(/^\d+$/.test(cursor!)).toBe(true)
+          }
+          // If we get a 200 (data arrived somehow), that's also valid
+          expect([200, 204]).toContain(response.status)
+        } catch (e) {
+          clearTimeout(timeoutId)
+          // AbortError is expected if server timeout is longer than our 5s
+          if (e instanceof Error && e.name !== `AbortError`) {
+            throw e
+          }
+          // Test passes - server just has a longer timeout than our abort
         }
-        // Test passes - server just has a longer timeout than our abort
-      }
-    }, 10000)
+      },
+      getLongPollTestTimeoutMs()
+    )
   })
 
   // ============================================================================