@durable-streams/server-conformance-tests 0.1.1 → 0.1.3

package/dist/{src-DRIMnUPk.js → src-DcbQ_SIQ.js}

@@ -1210,6 +1210,153 @@ function runConformanceTests(options) {
 			if (expiresHeader) expect(expiresHeader).toBeDefined();
 		});
 	});
+	describe(`TTL Expiration Behavior`, () => {
+		const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+		const uniquePath = (prefix) => `/v1/stream/${prefix}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+		test.concurrent(`should return 404 on HEAD after TTL expires`, async () => {
+			const streamPath = uniquePath(`ttl-expire-head`);
+			const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `1`
+				}
+			});
+			expect(createResponse.status).toBe(201);
+			const headBefore = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
+			expect(headBefore.status).toBe(200);
+			await sleep(1500);
+			const headAfter = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
+			expect(headAfter.status).toBe(404);
+		});
+		test.concurrent(`should return 404 on GET after TTL expires`, async () => {
+			const streamPath = uniquePath(`ttl-expire-get`);
+			const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `1`
+				},
+				body: `test data`
+			});
+			expect(createResponse.status).toBe(201);
+			const getBefore = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			expect(getBefore.status).toBe(200);
+			await sleep(1500);
+			const getAfter = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			expect(getAfter.status).toBe(404);
+		});
+		test.concurrent(`should return 404 on POST append after TTL expires`, async () => {
+			const streamPath = uniquePath(`ttl-expire-post`);
+			const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `1`
+				}
+			});
+			expect(createResponse.status).toBe(201);
+			const postBefore = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `appended data`
+			});
+			expect([200, 204]).toContain(postBefore.status);
+			await sleep(1500);
+			const postAfter = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `more data`
+			});
+			expect(postAfter.status).toBe(404);
+		});
+		test.concurrent(`should return 404 on HEAD after Expires-At passes`, async () => {
+			const streamPath = uniquePath(`expires-at-head`);
+			const expiresAt = new Date(Date.now() + 1e3).toISOString();
+			const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-Expires-At": expiresAt
+				}
+			});
+			expect(createResponse.status).toBe(201);
+			const headBefore = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
+			expect(headBefore.status).toBe(200);
+			await sleep(1500);
+			const headAfter = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
+			expect(headAfter.status).toBe(404);
+		});
+		test.concurrent(`should return 404 on GET after Expires-At passes`, async () => {
+			const streamPath = uniquePath(`expires-at-get`);
+			const expiresAt = new Date(Date.now() + 1e3).toISOString();
+			const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-Expires-At": expiresAt
+				},
+				body: `test data`
+			});
+			expect(createResponse.status).toBe(201);
+			const getBefore = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			expect(getBefore.status).toBe(200);
+			await sleep(1500);
+			const getAfter = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			expect(getAfter.status).toBe(404);
+		});
+		test.concurrent(`should return 404 on POST append after Expires-At passes`, async () => {
+			const streamPath = uniquePath(`expires-at-post`);
+			const expiresAt = new Date(Date.now() + 1e3).toISOString();
+			const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-Expires-At": expiresAt
+				}
+			});
+			expect(createResponse.status).toBe(201);
+			const postBefore = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `appended data`
+			});
+			expect([200, 204]).toContain(postBefore.status);
+			await sleep(1500);
+			const postAfter = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `more data`
+			});
+			expect(postAfter.status).toBe(404);
+		});
+		test.concurrent(`should allow recreating stream after TTL expires`, async () => {
+			const streamPath = uniquePath(`ttl-recreate`);
+			const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `text/plain`,
+					"Stream-TTL": `1`
+				},
+				body: `original data`
+			});
+			expect(createResponse.status).toBe(201);
+			await sleep(1500);
+			const recreateResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `PUT`,
+				headers: {
+					"Content-Type": `application/json`,
+					"Stream-TTL": `3600`
+				},
+				body: `["new data"]`
+			});
+			expect(recreateResponse.status).toBe(201);
+			const getResponse = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			expect(getResponse.status).toBe(200);
+			const body = await getResponse.text();
+			expect(body).toContain(`new data`);
+		});
+	});
 	describe(`Caching and ETag`, () => {
 		test(`should generate ETag on GET responses`, async () => {
 			const streamPath = `/v1/stream/etag-generate-test-${Date.now()}`;

package/dist/test-runner.cjs

@@ -0,0 +1,9 @@
+"use strict";
+const require_src = require('./src-DK3GDgwo.cjs');
+
+//#region src/test-runner.ts
+const baseUrl = process.env.CONFORMANCE_TEST_URL;
+if (!baseUrl) throw new Error("CONFORMANCE_TEST_URL environment variable is required. Use the CLI: npx @durable-streams/server-conformance-tests --run <url>");
+require_src.runConformanceTests({ baseUrl });
+
+//#endregion

package/dist/test-runner.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/test-runner.js

@@ -1,4 +1,4 @@
-import { runConformanceTests } from "./src-DRIMnUPk.js";
+import { runConformanceTests } from "./src-DcbQ_SIQ.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.1",
+  "version": "0.1.3",
   "description": "Conformance test suite for Durable Streams server implementations",
   "author": "Durable Stream contributors",
   "license": "Apache-2.0",
@@ -19,7 +19,8 @@
     "typescript"
   ],
   "type": "module",
-  "main": "./dist/index.js",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "bin": {
     "durable-streams-server-conformance": "./dist/cli.js",
@@ -27,25 +28,33 @@
   },
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
   },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src",
+    "bin"
+  ],
   "dependencies": {
     "fast-check": "^4.4.0",
     "vitest": "^3.2.4",
-    "@durable-streams/client": "0.1.1"
+    "@durable-streams/client": "0.1.2"
   },
   "devDependencies": {
     "tsdown": "^0.9.0",
     "tsx": "^4.19.2",
     "typescript": "^5.0.0"
   },
-  "files": [
-    "dist",
-    "src",
-    "bin"
-  ],
   "engines": {
     "node": ">=18.0.0"
   },

package/src/index.ts

@@ -1898,6 +1898,260 @@ export function runConformanceTests(options: ConformanceTestOptions): void {
     })
   })
 
+  // ============================================================================
+  // TTL Expiration Behavior Tests
+  // ============================================================================
+
+  describe(`TTL Expiration Behavior`, () => {
+    // Helper function to wait for a specified duration
+    const sleep = (ms: number) =>
+      new Promise((resolve) => setTimeout(resolve, ms))
+
+    // Helper to generate unique stream paths for concurrent tests
+    const uniquePath = (prefix: string) =>
+      `/v1/stream/${prefix}-${Date.now()}-${Math.random().toString(36).slice(2)}`
+
+    // Run tests concurrently to avoid 6x 1.5s wait time
+    test.concurrent(`should return 404 on HEAD after TTL expires`, async () => {
+      const streamPath = uniquePath(`ttl-expire-head`)
+
+      // Create stream with 1 second TTL
+      const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+        method: `PUT`,
+        headers: {
+          "Content-Type": `text/plain`,
+          "Stream-TTL": `1`,
+        },
+      })
+      expect(createResponse.status).toBe(201)
+
+      // Verify stream exists immediately
+      const headBefore = await fetch(`${getBaseUrl()}${streamPath}`, {
+        method: `HEAD`,
+      })
+      expect(headBefore.status).toBe(200)
+
+      // Wait for TTL to expire (1 second + buffer)
+      await sleep(1500)
+
+      // Stream should no longer exist
+      const headAfter = await fetch(`${getBaseUrl()}${streamPath}`, {
+        method: `HEAD`,
+      })
+      expect(headAfter.status).toBe(404)
+    })
+
+    test.concurrent(`should return 404 on GET after TTL expires`, async () => {
+      const streamPath = uniquePath(`ttl-expire-get`)
+
+      // Create stream with 1 second TTL and some data
+      const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+        method: `PUT`,
+        headers: {
+          "Content-Type": `text/plain`,
+          "Stream-TTL": `1`,
+        },
+        body: `test data`,
+      })
+      expect(createResponse.status).toBe(201)
+
+      // Verify stream is readable immediately
+      const getBefore = await fetch(`${getBaseUrl()}${streamPath}`, {
+        method: `GET`,
+      })
+      expect(getBefore.status).toBe(200)
+
+      // Wait for TTL to expire
+      await sleep(1500)
+
+      // Stream should no longer exist
+      const getAfter = await fetch(`${getBaseUrl()}${streamPath}`, {
+        method: `GET`,
+      })
+      expect(getAfter.status).toBe(404)
+    })
+
+    test.concurrent(
+      `should return 404 on POST append after TTL expires`,
+      async () => {
+        const streamPath = uniquePath(`ttl-expire-post`)
+
+        // Create stream with 1 second TTL
+        const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `PUT`,
+          headers: {
+            "Content-Type": `text/plain`,
+            "Stream-TTL": `1`,
+          },
+        })
+        expect(createResponse.status).toBe(201)
+
+        // Verify append works immediately
+        const postBefore = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `POST`,
+          headers: { "Content-Type": `text/plain` },
+          body: `appended data`,
+        })
+        expect([200, 204]).toContain(postBefore.status)
+
+        // Wait for TTL to expire
+        await sleep(1500)
+
+        // Append should fail - stream no longer exists
+        const postAfter = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `POST`,
+          headers: { "Content-Type": `text/plain` },
+          body: `more data`,
+        })
+        expect(postAfter.status).toBe(404)
+      }
+    )
+
+    test.concurrent(
+      `should return 404 on HEAD after Expires-At passes`,
+      async () => {
+        const streamPath = uniquePath(`expires-at-head`)
+
+        // Create stream that expires in 1 second
+        const expiresAt = new Date(Date.now() + 1000).toISOString()
+        const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `PUT`,
+          headers: {
+            "Content-Type": `text/plain`,
+            "Stream-Expires-At": expiresAt,
+          },
+        })
+        expect(createResponse.status).toBe(201)
+
+        // Verify stream exists immediately
+        const headBefore = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `HEAD`,
+        })
+        expect(headBefore.status).toBe(200)
+
+        // Wait for expiry time to pass
+        await sleep(1500)
+
+        // Stream should no longer exist
+        const headAfter = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `HEAD`,
+        })
+        expect(headAfter.status).toBe(404)
+      }
+    )
+
+    test.concurrent(
+      `should return 404 on GET after Expires-At passes`,
+      async () => {
+        const streamPath = uniquePath(`expires-at-get`)
+
+        // Create stream that expires in 1 second
+        const expiresAt = new Date(Date.now() + 1000).toISOString()
+        const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `PUT`,
+          headers: {
+            "Content-Type": `text/plain`,
+            "Stream-Expires-At": expiresAt,
+          },
+          body: `test data`,
+        })
+        expect(createResponse.status).toBe(201)
+
+        // Verify stream is readable immediately
+        const getBefore = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `GET`,
+        })
+        expect(getBefore.status).toBe(200)
+
+        // Wait for expiry time to pass
+        await sleep(1500)
+
+        // Stream should no longer exist
+        const getAfter = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `GET`,
+        })
+        expect(getAfter.status).toBe(404)
+      }
+    )
+
+    test.concurrent(
+      `should return 404 on POST append after Expires-At passes`,
+      async () => {
+        const streamPath = uniquePath(`expires-at-post`)
+
+        // Create stream that expires in 1 second
+        const expiresAt = new Date(Date.now() + 1000).toISOString()
+        const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `PUT`,
+          headers: {
+            "Content-Type": `text/plain`,
+            "Stream-Expires-At": expiresAt,
+          },
+        })
+        expect(createResponse.status).toBe(201)
+
+        // Verify append works immediately
+        const postBefore = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `POST`,
+          headers: { "Content-Type": `text/plain` },
+          body: `appended data`,
+        })
+        expect([200, 204]).toContain(postBefore.status)
+
+        // Wait for expiry time to pass
+        await sleep(1500)
+
+        // Append should fail - stream no longer exists
+        const postAfter = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `POST`,
+          headers: { "Content-Type": `text/plain` },
+          body: `more data`,
+        })
+        expect(postAfter.status).toBe(404)
+      }
+    )
+
+    test.concurrent(
+      `should allow recreating stream after TTL expires`,
+      async () => {
+        const streamPath = uniquePath(`ttl-recreate`)
+
+        // Create stream with 1 second TTL
+        const createResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `PUT`,
+          headers: {
+            "Content-Type": `text/plain`,
+            "Stream-TTL": `1`,
+          },
+          body: `original data`,
+        })
+        expect(createResponse.status).toBe(201)
+
+        // Wait for TTL to expire
+        await sleep(1500)
+
+        // Recreate stream with different config - should succeed (201)
+        const recreateResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `PUT`,
+          headers: {
+            "Content-Type": `application/json`,
+            "Stream-TTL": `3600`,
+          },
+          body: `["new data"]`,
+        })
+        expect(recreateResponse.status).toBe(201)
+
+        // Verify the new stream is accessible
+        const getResponse = await fetch(`${getBaseUrl()}${streamPath}`, {
+          method: `GET`,
+        })
+        expect(getResponse.status).toBe(200)
+        const body = await getResponse.text()
+        expect(body).toContain(`new data`)
+      }
+    )
+  })
+
   // ============================================================================
   // Caching and ETag Tests
   // ============================================================================