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

package/dist/index.cjs

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

package/dist/index.js

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

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

@@ -1212,6 +1212,153 @@ function runConformanceTests(options) {
 			if (expiresHeader) (0, vitest.expect)(expiresHeader).toBeDefined();
 		});
 	});
+	(0, vitest.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)}`;
+		vitest.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`
+				}
+			});
+			(0, vitest.expect)(createResponse.status).toBe(201);
+			const headBefore = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
+			(0, vitest.expect)(headBefore.status).toBe(200);
+			await sleep(1500);
+			const headAfter = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
+			(0, vitest.expect)(headAfter.status).toBe(404);
+		});
+		vitest.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`
+			});
+			(0, vitest.expect)(createResponse.status).toBe(201);
+			const getBefore = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			(0, vitest.expect)(getBefore.status).toBe(200);
+			await sleep(1500);
+			const getAfter = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			(0, vitest.expect)(getAfter.status).toBe(404);
+		});
+		vitest.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`
+				}
+			});
+			(0, vitest.expect)(createResponse.status).toBe(201);
+			const postBefore = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `appended data`
+			});
+			(0, vitest.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`
+			});
+			(0, vitest.expect)(postAfter.status).toBe(404);
+		});
+		vitest.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
+				}
+			});
+			(0, vitest.expect)(createResponse.status).toBe(201);
+			const headBefore = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
+			(0, vitest.expect)(headBefore.status).toBe(200);
+			await sleep(1500);
+			const headAfter = await fetch(`${getBaseUrl()}${streamPath}`, { method: `HEAD` });
+			(0, vitest.expect)(headAfter.status).toBe(404);
+		});
+		vitest.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`
+			});
+			(0, vitest.expect)(createResponse.status).toBe(201);
+			const getBefore = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			(0, vitest.expect)(getBefore.status).toBe(200);
+			await sleep(1500);
+			const getAfter = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			(0, vitest.expect)(getAfter.status).toBe(404);
+		});
+		vitest.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
+				}
+			});
+			(0, vitest.expect)(createResponse.status).toBe(201);
+			const postBefore = await fetch(`${getBaseUrl()}${streamPath}`, {
+				method: `POST`,
+				headers: { "Content-Type": `text/plain` },
+				body: `appended data`
+			});
+			(0, vitest.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`
+			});
+			(0, vitest.expect)(postAfter.status).toBe(404);
+		});
+		vitest.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`
+			});
+			(0, vitest.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"]`
+			});
+			(0, vitest.expect)(recreateResponse.status).toBe(201);
+			const getResponse = await fetch(`${getBaseUrl()}${streamPath}`, { method: `GET` });
+			(0, vitest.expect)(getResponse.status).toBe(200);
+			const body = await getResponse.text();
+			(0, vitest.expect)(body).toContain(`new data`);
+		});
+	});
 	(0, vitest.describe)(`Caching and ETag`, () => {
 		(0, vitest.test)(`should generate ETag on GET responses`, async () => {
 			const streamPath = `/v1/stream/etag-generate-test-${Date.now()}`;

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

@@ -1,5 +1,5 @@
 "use strict";
-const require_src = require('./src-mPjxiipV.cjs');
+const require_src = require('./src-DK3GDgwo.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-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.2",
+  "version": "0.1.3",
   "description": "Conformance test suite for Durable Streams server implementations",
   "author": "Durable Stream contributors",
   "license": "Apache-2.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
   // ============================================================================