@durable-streams/server-conformance-tests 0.1.8 → 0.2.0

package/dist/index.cjs

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

package/dist/index.js

@@ -1,3 +1,3 @@
-import { runConformanceTests } from "./src-GWuAOela.js";
+import { runConformanceTests } from "./src-Pd7PHJOG.js";
 
 export { runConformanceTests };

package/dist/{src-CfXXlBaO.cjs → src-CMFxsR_X.cjs}

@@ -894,6 +894,8 @@ function runConformanceTests(options) {
 			(0, vitest.expect)(text).toBe(``);
 			(0, vitest.expect)(response.headers.get(__durable_streams_client.STREAM_UP_TO_DATE_HEADER)).toBe(`true`);
 			(0, vitest.expect)(response.headers.get(__durable_streams_client.STREAM_OFFSET_HEADER)).toBeDefined();
+			const cacheControl = response.headers.get(`cache-control`);
+			(0, vitest.expect)(cacheControl).toContain(`no-store`);
 		});
 		(0, vitest.test)(`should return correct tail offset for offset=now`, async () => {
 			const streamPath = `/v1/stream/offset-now-tail-test-${Date.now()}`;
@@ -1014,7 +1016,7 @@ function runConformanceTests(options) {
 			const tailOffset = readResponse.headers.get(__durable_streams_client.STREAM_OFFSET_HEADER);
 			const { response, received } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=now&live=sse`, { untilContent: `"upToDate"` });
 			(0, vitest.expect)(response.status).toBe(200);
-			const controlMatch = received.match(/event: control\s*\n\s*data: ({[^}]+})/);
+			const controlMatch = received.match(/event: control\s*\n\s*data:({[^}]+})/);
 			(0, vitest.expect)(controlMatch).toBeDefined();
 			if (controlMatch && controlMatch[1]) {
 				const controlData = JSON.parse(controlMatch[1]);
@@ -1066,7 +1068,7 @@ function runConformanceTests(options) {
 			});
 			const { response, received } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=now&live=sse`, { untilContent: `"upToDate"` });
 			(0, vitest.expect)(response.status).toBe(200);
-			const controlMatch = received.match(/event: control\s*\n\s*data: ({[^}]+})/);
+			const controlMatch = received.match(/event: control\s*\n\s*data:({[^}]+})/);
 			(0, vitest.expect)(controlMatch).toBeDefined();
 			if (controlMatch && controlMatch[1]) {
 				const controlData = JSON.parse(controlMatch[1]);
@@ -1343,6 +1345,20 @@ function runConformanceTests(options) {
 			(0, vitest.expect)(cursor).not.toBeNull();
 			(0, vitest.expect)(/^\d+$/.test(cursor)).toBe(true);
 		});
+		(0, vitest.test)(`should return immediately with Stream-Up-To-Date when data exists at offset`, async () => {
+			const streamPath = `/v1/stream/longpoll-immediate-uptodate-test-${Date.now()}`;
+			await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: { "Content-Type": `text/plain` },
+				body: `existing data`
+			});
+			const response = await fetch(`${getBaseUrl()}${streamPath}?offset=-1&live=long-poll`, { method: `GET` });
+			(0, vitest.expect)(response.status).toBe(200);
+			const text = await response.text();
+			(0, vitest.expect)(text).toBe(`existing data`);
+			(0, vitest.expect)(response.headers.get(__durable_streams_client.STREAM_UP_TO_DATE_HEADER)).toBe(`true`);
+			(0, vitest.expect)(response.headers.get(__durable_streams_client.STREAM_OFFSET_HEADER)).toBeDefined();
+		});
 		(0, vitest.test)(`should echo cursor and handle collision with jitter`, async () => {
 			const streamPath = `/v1/stream/longpoll-cursor-collision-test-${Date.now()}`;
 			await fetch(`${getBaseUrl()}${streamPath}`, {
@@ -1969,7 +1985,7 @@ function runConformanceTests(options) {
 			});
 			const { response, received } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `streamCursor` });
 			(0, vitest.expect)(response.status).toBe(200);
-			const controlMatch = received.match(/event: control\s*\ndata: ({[^}]+})/);
+			const controlMatch = received.match(/event: control\s*\ndata:({[^}]+})/);
 			(0, vitest.expect)(controlMatch).toBeDefined();
 			const controlData = JSON.parse(controlMatch[1]);
 			(0, vitest.expect)(controlData.streamCursor).toBeDefined();
@@ -1983,11 +1999,11 @@ function runConformanceTests(options) {
 				body: `test data`
 			});
 			const { received: received1 } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `streamCursor` });
-			const controlMatch1 = received1.match(/event: control\s*\ndata: ({[^}]+})/);
+			const controlMatch1 = received1.match(/event: control\s*\ndata:({[^}]+})/);
 			(0, vitest.expect)(controlMatch1).toBeDefined();
 			const cursor1 = JSON.parse(controlMatch1[1]).streamCursor;
 			const { received: received2 } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse&cursor=${cursor1}`, { untilContent: `streamCursor` });
-			const controlMatch2 = received2.match(/event: control\s*\ndata: ({[^}]+})/);
+			const controlMatch2 = received2.match(/event: control\s*\ndata:({[^}]+})/);
 			(0, vitest.expect)(controlMatch2).toBeDefined();
 			const cursor2 = JSON.parse(controlMatch2[1]).streamCursor;
 			(0, vitest.expect)(parseInt(cursor2, 10)).toBeGreaterThan(parseInt(cursor1, 10));
@@ -2027,9 +2043,9 @@ function runConformanceTests(options) {
 			const { response, received } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `event: control` });
 			(0, vitest.expect)(response.status).toBe(200);
 			(0, vitest.expect)(received).toContain(`event: control`);
-			const controlLine = received.split(`\n`).find((l) => l.startsWith(`data: `) && l.includes(`streamNextOffset`));
+			const controlLine = received.split(`\n`).find((l) => l.startsWith(`data:`) && l.includes(`streamNextOffset`));
 			(0, vitest.expect)(controlLine).toBeDefined();
-			const controlPayload = controlLine.slice(`data: `.length);
+			const controlPayload = controlLine.slice(`data:`.length);
 			const controlData = JSON.parse(controlPayload);
 			(0, vitest.expect)(controlData[`streamNextOffset`]).toBe(httpOffset);
 		});
@@ -2042,9 +2058,9 @@ function runConformanceTests(options) {
 			});
 			const { response, received } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `"upToDate"` });
 			(0, vitest.expect)(response.status).toBe(200);
-			const controlLine = received.split(`\n`).find((l) => l.startsWith(`data: `) && l.includes(`streamNextOffset`));
+			const controlLine = received.split(`\n`).find((l) => l.startsWith(`data:`) && l.includes(`streamNextOffset`));
 			(0, vitest.expect)(controlLine).toBeDefined();
-			const controlPayload = controlLine.slice(`data: `.length);
+			const controlPayload = controlLine.slice(`data:`.length);
 			const controlData = JSON.parse(controlPayload);
 			(0, vitest.expect)(controlData.upToDate).toBe(true);
 		});
@@ -2072,9 +2088,9 @@ function runConformanceTests(options) {
 			const { response, received } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `event: control` });
 			(0, vitest.expect)(response.status).toBe(200);
 			(0, vitest.expect)(received).toContain(`event: data`);
-			(0, vitest.expect)(received).toContain(`data: line1`);
-			(0, vitest.expect)(received).toContain(`data: line2`);
-			(0, vitest.expect)(received).toContain(`data: line3`);
+			(0, vitest.expect)(received).toContain(`data:line1`);
+			(0, vitest.expect)(received).toContain(`data:line2`);
+			(0, vitest.expect)(received).toContain(`data:line3`);
 		});
 		(0, vitest.test)(`should prevent CRLF injection in payloads - embedded event boundaries become literal data`, async () => {
 			const streamPath = `/v1/stream/sse-crlf-injection-test-${Date.now()}`;
@@ -2171,10 +2187,10 @@ function runConformanceTests(options) {
 			});
 			const { response, received } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `event: control` });
 			(0, vitest.expect)(response.status).toBe(200);
-			const controlLines = received.split(`\n`).filter((l) => l.startsWith(`data: `) && l.includes(`streamNextOffset`));
+			const controlLines = received.split(`\n`).filter((l) => l.startsWith(`data:`) && l.includes(`streamNextOffset`));
 			const offsets = [];
 			for (const line of controlLines) {
-				const payload = line.slice(`data: `.length);
+				const payload = line.slice(`data:`.length);
 				const data = JSON.parse(payload);
 				offsets.push(data[`streamNextOffset`]);
 			}
@@ -2195,8 +2211,8 @@ function runConformanceTests(options) {
 			let lastOffset = null;
 			const { response: response1, received: received1 } = await fetchSSE(`${getBaseUrl()}${streamPath}?offset=-1&live=sse`, { untilContent: `event: control` });
 			(0, vitest.expect)(response1.status).toBe(200);
-			const controlLine = received1.split(`\n`).find((l) => l.startsWith(`data: `) && l.includes(`streamNextOffset`));
-			const controlPayload = controlLine.slice(`data: `.length);
+			const controlLine = received1.split(`\n`).find((l) => l.startsWith(`data:`) && l.includes(`streamNextOffset`));
+			const controlPayload = controlLine.slice(`data:`.length);
 			lastOffset = JSON.parse(controlPayload)[`streamNextOffset`];
 			(0, vitest.expect)(lastOffset).toBeDefined();
 			await fetch(`${getBaseUrl()}${streamPath}`, {
@@ -2260,7 +2276,7 @@ function runConformanceTests(options) {
 				url: `${getBaseUrl()}${streamPath}`,
 				contentType: `application/json`
 			});
-			await stream.append({ message: `hello` });
+			await stream.append(JSON.stringify({ message: `hello` }));
 			const response = await fetch(`${getBaseUrl()}${streamPath}`);
 			const data = await response.json();
 			(0, vitest.expect)(Array.isArray(data)).toBe(true);
@@ -2272,11 +2288,11 @@ function runConformanceTests(options) {
 				url: `${getBaseUrl()}${streamPath}`,
 				contentType: `application/json`
 			});
-			await stream.append([
+			await stream.append(JSON.stringify([
 				{ id: 1 },
 				{ id: 2 },
 				{ id: 3 }
-			]);
+			]));
 			const response = await fetch(`${getBaseUrl()}${streamPath}`);
 			const data = await response.json();
 			(0, vitest.expect)(Array.isArray(data)).toBe(true);
@@ -2292,9 +2308,9 @@ function runConformanceTests(options) {
 				url: `${getBaseUrl()}${streamPath}`,
 				contentType: `application/json`
 			});
-			await stream.append({ event: `first` });
-			await stream.append({ event: `second` });
-			await stream.append({ event: `third` });
+			await stream.append(JSON.stringify({ event: `first` }));
+			await stream.append(JSON.stringify({ event: `second` }));
+			await stream.append(JSON.stringify({ event: `third` }));
 			const response = await fetch(`${getBaseUrl()}${streamPath}`);
 			const data = await response.json();
 			(0, vitest.expect)(Array.isArray(data)).toBe(true);
@@ -2310,15 +2326,15 @@ function runConformanceTests(options) {
 				url: `${getBaseUrl()}${streamPath}`,
 				contentType: `application/json`
 			});
-			await stream.append({ type: `single` });
-			await stream.append([{
+			await stream.append(JSON.stringify({ type: `single` }));
+			await stream.append(JSON.stringify([{
 				type: `array`,
 				id: 1
 			}, {
 				type: `array`,
 				id: 2
-			}]);
-			await stream.append({ type: `single-again` });
+			}]));
+			await stream.append(JSON.stringify({ type: `single-again` }));
 			const response = await fetch(`${getBaseUrl()}${streamPath}`);
 			const data = await response.json();
 			(0, vitest.expect)(data).toEqual([
@@ -2353,16 +2369,16 @@ function runConformanceTests(options) {
 				url: `${getBaseUrl()}${streamPath}`,
 				contentType: `application/json`
 			});
-			await stream.append(`string value`);
-			await stream.append(42);
-			await stream.append(true);
-			await stream.append(null);
-			await stream.append({ object: `value` });
-			await stream.append([
+			await stream.append(JSON.stringify(`string value`));
+			await stream.append(JSON.stringify(42));
+			await stream.append(JSON.stringify(true));
+			await stream.append(JSON.stringify(null));
+			await stream.append(JSON.stringify({ object: `value` }));
+			await stream.append(JSON.stringify([
 				1,
 				2,
 				3
-			]);
+			]));
 			const response = await fetch(`${getBaseUrl()}${streamPath}`);
 			const data = await response.json();
 			(0, vitest.expect)(data).toEqual([
@@ -2384,14 +2400,14 @@ function runConformanceTests(options) {
 				url: `${getBaseUrl()}${streamPath}`,
 				contentType: `application/json`
 			});
-			await stream.append({
+			await stream.append(JSON.stringify({
 				user: {
 					id: 123,
 					name: `Alice`,
 					tags: [`admin`, `verified`]
 				},
 				timestamp: `2024-01-01T00:00:00Z`
-			});
+			}));
 			const response = await fetch(`${getBaseUrl()}${streamPath}`);
 			const data = await response.json();
 			(0, vitest.expect)(data).toEqual([{
@@ -2409,9 +2425,9 @@ function runConformanceTests(options) {
 				url: `${getBaseUrl()}${streamPath}`,
 				contentType: `application/json`
 			});
-			await stream.append({ id: 1 });
-			await stream.append({ id: 2 });
-			await stream.append({ id: 3 });
+			await stream.append(JSON.stringify({ id: 1 }));
+			await stream.append(JSON.stringify({ id: 2 }));
+			await stream.append(JSON.stringify({ id: 3 }));
 			const res = await stream.stream({ live: false });
 			const items = await res.json();
 			(0, vitest.expect)(items).toEqual([
@@ -2440,7 +2456,7 @@ function runConformanceTests(options) {
 				url: `${getBaseUrl()}${streamPath}`,
 				contentType: `application/json`
 			});
-			await stream.append([[1, 2], [3, 4]]);
+			await stream.append(JSON.stringify([[1, 2], [3, 4]]));
 			const response = await fetch(`${getBaseUrl()}${streamPath}`);
 			const data = await response.json();
 			(0, vitest.expect)(data).toEqual([[[1, 2], [3, 4]]]);
@@ -2451,11 +2467,11 @@ function runConformanceTests(options) {
 				url: `${getBaseUrl()}${streamPath}`,
 				contentType: `application/json`
 			});
-			await stream.append([[
+			await stream.append(JSON.stringify([[
 				1,
 				2,
 				3
-			]]);
+			]]));
 			const response = await fetch(`${getBaseUrl()}${streamPath}`);
 			const data = await response.json();
 			(0, vitest.expect)(data).toEqual([[[
@@ -2471,16 +2487,16 @@ function runConformanceTests(options) {
 				url: `${getBaseUrl()}${streamPath}`,
 				contentType: `application/json`
 			});
-			await stream.append([
+			await stream.append(JSON.stringify([
 				1,
 				2,
 				3
-			]);
-			await stream.append([
+			]));
+			await stream.append(JSON.stringify([
 				`a`,
 				`b`,
 				`c`
-			]);
+			]));
 			const response = await fetch(`${getBaseUrl()}${streamPath}`);
 			const data = await response.json();
 			(0, vitest.expect)(data).toEqual([[
@@ -2499,10 +2515,10 @@ function runConformanceTests(options) {
 				url: `${getBaseUrl()}${streamPath}`,
 				contentType: `application/json`
 			});
-			await stream.append({ single: 1 });
-			await stream.append([{ batch: 2 }, { batch: 3 }]);
-			await stream.append([[`nested`, `array`]]);
-			await stream.append(42);
+			await stream.append(JSON.stringify({ single: 1 }));
+			await stream.append(JSON.stringify([{ batch: 2 }, { batch: 3 }]));
+			await stream.append(JSON.stringify([[`nested`, `array`]]));
+			await stream.append(JSON.stringify(42));
 			const response = await fetch(`${getBaseUrl()}${streamPath}`);
 			const data = await response.json();
 			(0, vitest.expect)(data).toEqual([
@@ -2516,7 +2532,25 @@ function runConformanceTests(options) {
 	});
 	(0, vitest.describe)(`Property-Based Tests (fast-check)`, () => {
 		(0, vitest.describe)(`Byte-Exactness Property`, () => {
-			(0, vitest.test)(`arbitrary byte sequences are preserved exactly`, async () => {
+			const NUM_CONCURRENT_READERS = 7;
+			async function readEntireStream(streamPath) {
+				const accumulated = [];
+				let currentOffset = null;
+				for (let i = 0; i < 100; i++) {
+					const url = currentOffset ? `${getBaseUrl()}${streamPath}?offset=${encodeURIComponent(currentOffset)}` : `${getBaseUrl()}${streamPath}`;
+					const response = await fetch(url, { method: `GET` });
+					(0, vitest.expect)(response.status).toBe(200);
+					const data = new Uint8Array(await response.arrayBuffer());
+					accumulated.push(...data);
+					const nextOffset = response.headers.get(__durable_streams_client.STREAM_OFFSET_HEADER);
+					const upToDate = response.headers.get(__durable_streams_client.STREAM_UP_TO_DATE_HEADER);
+					if (upToDate === `true` && data.length === 0) break;
+					if (nextOffset === currentOffset) break;
+					currentOffset = nextOffset;
+				}
+				return new Uint8Array(accumulated);
+			}
+			(0, vitest.test)(`concurrent readers see consistent data during writes`, async () => {
 				await fast_check.assert(fast_check.asyncProperty(
 					// Generate 1-10 chunks of arbitrary bytes (1-500 bytes each)
 					fast_check.array(fast_check.uint8Array({
@@ -2537,46 +2571,40 @@ function runConformanceTests(options) {
 							201,
 							204
 						]).toContain(createResponse.status);
-						for (const chunk of chunks) {
-							const response = await fetch(`${getBaseUrl()}${streamPath}`, {
-								method: `POST`,
-								headers: { "Content-Type": `application/octet-stream` },
-								body: chunk
-							});
-							(0, vitest.expect)(response.status).toBe(204);
-						}
-						const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-						const expected = new Uint8Array(totalLength);
-						let offset = 0;
-						for (const chunk of chunks) {
-							expected.set(chunk, offset);
-							offset += chunk.length;
-						}
-						const accumulated = [];
-						let currentOffset = null;
-						let iterations = 0;
-						while (iterations < 100) {
-							iterations++;
-							const url = currentOffset ? `${getBaseUrl()}${streamPath}?offset=${encodeURIComponent(currentOffset)}` : `${getBaseUrl()}${streamPath}`;
-							const response = await fetch(url, { method: `GET` });
-							(0, vitest.expect)(response.status).toBe(200);
-							const buffer = await response.arrayBuffer();
-							const data = new Uint8Array(buffer);
-							if (data.length > 0) accumulated.push(...Array.from(data));
-							const nextOffset = response.headers.get(__durable_streams_client.STREAM_OFFSET_HEADER);
-							const upToDate = response.headers.get(__durable_streams_client.STREAM_UP_TO_DATE_HEADER);
-							if (upToDate === `true` && data.length === 0) break;
-							if (nextOffset === currentOffset) break;
-							currentOffset = nextOffset;
+						const expected = Uint8Array.from(chunks.flatMap((c) => [...c]));
+						let writesComplete = false;
+						const readerPromises = Array.from({ length: NUM_CONCURRENT_READERS }, async () => {
+							const snapshots = [];
+							while (!writesComplete) {
+								const response = await fetch(`${getBaseUrl()}${streamPath}`);
+								snapshots.push(new Uint8Array(await response.arrayBuffer()));
+								await new Promise((r) => setTimeout(r, Math.random() * 3));
+							}
+							return snapshots;
+						});
+						const writerPromise = (async () => {
+							for (const chunk of chunks) {
+								await new Promise((r) => setTimeout(r, Math.random() * 5));
+								const response = await fetch(`${getBaseUrl()}${streamPath}`, {
+									method: `POST`,
+									headers: { "Content-Type": `application/octet-stream` },
+									body: chunk
+								});
+								(0, vitest.expect)(response.status).toBe(204);
+							}
+							writesComplete = true;
+						})();
+						const [readerResults] = await Promise.all([Promise.all(readerPromises), writerPromise]);
+						for (const snapshots of readerResults) for (const snapshot of snapshots) {
+							(0, vitest.expect)(snapshot.length).toBeLessThanOrEqual(expected.length);
+							for (let i = 0; i < snapshot.length; i++) (0, vitest.expect)(snapshot[i]).toBe(expected[i]);
 						}
-						const result = new Uint8Array(accumulated);
-						(0, vitest.expect)(result.length).toBe(expected.length);
-						for (let i = 0; i < expected.length; i++) (0, vitest.expect)(result[i]).toBe(expected[i]);
-						return true;
+						const finalResult = await readEntireStream(streamPath);
+						(0, vitest.expect)(finalResult).toEqual(expected);
 					}
 ), { numRuns: 20 });
 			});
-			(0, vitest.test)(`single byte values cover full range (0-255)`, async () => {
+			(0, vitest.test)(`single byte values cover full range (0-255) with concurrent readers during write`, async () => {
 				await fast_check.assert(fast_check.asyncProperty(
 					// Generate a byte value from 0-255
 					fast_check.integer({
@@ -2589,18 +2617,24 @@ function runConformanceTests(options) {
 							method: `PUT`,
 							headers: { "Content-Type": `application/octet-stream` }
 						});
-						const chunk = new Uint8Array([byteValue]);
-						await fetch(`${getBaseUrl()}${streamPath}`, {
+						const expected = new Uint8Array([byteValue]);
+						const readerPromises = Array.from({ length: NUM_CONCURRENT_READERS }, async () => {
+							await new Promise((r) => setTimeout(r, Math.random() * 5));
+							const response = await fetch(`${getBaseUrl()}${streamPath}`);
+							return new Uint8Array(await response.arrayBuffer());
+						});
+						const writerPromise = fetch(`${getBaseUrl()}${streamPath}`, {
 							method: `POST`,
 							headers: { "Content-Type": `application/octet-stream` },
-							body: chunk
+							body: new Uint8Array([byteValue])
 						});
-						const response = await fetch(`${getBaseUrl()}${streamPath}`);
-						const buffer = await response.arrayBuffer();
-						const result = new Uint8Array(buffer);
-						(0, vitest.expect)(result.length).toBe(1);
-						(0, vitest.expect)(result[0]).toBe(byteValue);
-						return true;
+						const [readerResults] = await Promise.all([Promise.all(readerPromises), writerPromise]);
+						for (const result of readerResults) {
+							(0, vitest.expect)(result.length).toBeLessThanOrEqual(1);
+							if (result.length === 1) (0, vitest.expect)(result[0]).toBe(byteValue);
+						}
+						const finalResult = await readEntireStream(streamPath);
+						(0, vitest.expect)(finalResult).toEqual(expected);
 					}
 ), { numRuns: 50 });
 			});