Initial Commit

packages/api-stack/api/api-tenant/tests/property.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "@suaveplan/testing/runner";
+import fc from "fast-check";
+import { Hono } from "hono";
+import { headerResolver, type Tenant, TenantCache } from "../src/index.js";
+
+function makeTenant(id: string): Tenant {
+    return {
+        id,
+        name: id,
+        slug: id,
+        status: "active",
+        settings: {},
+        enabledPlugins: [],
+        domains: [],
+        createdAt: new Date(0),
+        updatedAt: new Date(0),
+    };
+}
+
+describe("property — cache TTL boundary invariant", () => {
+    it("entry expires strictly after ttlMs boundary (fast-check 200 runs)", {
+        timeout: 30000,
+    }, async () => {
+        await fc.assert(
+            fc.asyncProperty(
+                fc.integer({ min: 10, max: 10_000 }),
+                fc.integer({ min: 0, max: 100_000 }),
+                async (ttlMs, baseNow) => {
+                    let calls = 0;
+                    const inner = headerResolver("x-tenant-id", async (id) => {
+                        calls += 1;
+                        return makeTenant(id);
+                    });
+                    let now = baseNow;
+                    const cached = TenantCache.wrap(inner, {
+                        ttlMs,
+                        clock: () => now,
+                    });
+                    const app = new Hono();
+                    app.get("/", async (c) => {
+                        await cached.resolve(c);
+                        return c.text("ok");
+                    });
+                    const hit = (): Promise<unknown> =>
+                        app.request("/", {
+                            headers: { "x-tenant-id": "k", host: "x" },
+                        });
+
+                    await hit(); // populate
+                    expect(calls).toBe(1);
+
+                    // Strictly inside TTL → cached.
+                    now = baseNow + ttlMs - 1;
+                    await hit();
+                    expect(calls).toBe(1);
+
+                    // At the boundary (expiresAt > now is false when equal) → re-lookup.
+                    now = baseNow + ttlMs;
+                    await hit();
+                    expect(calls).toBe(2);
+                }
+            ),
+            { numRuns: 200 }
+        );
+    });
+});