chore: import upstream snapshot with attribution

2026-07-13 13:32:57 +08:00
commit cd420f9332
4811 changed files with 884702 additions and 0 deletions
@@ -0,0 +1,237 @@
+import { describe, expect, it } from "vitest";
+import {
+  ControlPlaneCache,
+  type ResolvedAuthenticatedEnv,
+  type ResolvedEnv,
+  type ResolvedRunLockedWorker,
+  type ResolvedWorkerVersion,
+} from "./controlPlaneCache.server";
+
+// Minimal, structurally-irrelevant stand-ins: the cache stores and returns opaque values by
+// reference, so these only need to be distinguishable objects — the slot types are exercised for
+// key routing, not field shape.
+const anEnv = { id: "env_1", organizationId: "org_1" } as unknown as ResolvedEnv;
+const aVersion = { worker: { id: "bw_1" } } as unknown as ResolvedWorkerVersion;
+const anAuthEnv = {
+  id: "env_1",
+  slug: "prod",
+  organizationId: "org_1",
+} as unknown as ResolvedAuthenticatedEnv;
+const aLockedWorker = { lockedBy: null, lockedToVersion: null } as ResolvedRunLockedWorker;
+
+describe("ControlPlaneCache", () => {
+  it("round-trips a value through every slot", () => {
+    const cache = new ControlPlaneCache({ ttlMs: 60_000, maxEntries: 100 });
+
+    cache.setEnv("env_1", anEnv);
+    cache.setWorkerVersion("env_1:current", aVersion);
+    cache.setEnvExists("env_1", true);
+    cache.setAuthEnv("env_1", anAuthEnv);
+    cache.setLockedWorker("bw_1:v_1", aLockedWorker);
+
+    expect(cache.getEnv("env_1")).toBe(anEnv);
+    expect(cache.getWorkerVersion("env_1:current")).toBe(aVersion);
+    expect(cache.getEnvExists("env_1")).toBe(true);
+    expect(cache.getAuthEnv("env_1")).toBe(anAuthEnv);
+    expect(cache.getLockedWorker("bw_1:v_1")).toBe(aLockedWorker);
+  });
+
+  it("returns undefined for a key that was never set, in every slot", () => {
+    const cache = new ControlPlaneCache({ ttlMs: 60_000, maxEntries: 100 });
+
+    expect(cache.getEnv("missing")).toBeUndefined();
+    expect(cache.getWorkerVersion("missing")).toBeUndefined();
+    expect(cache.getEnvExists("missing")).toBeUndefined();
+    expect(cache.getAuthEnv("missing")).toBeUndefined();
+    expect(cache.getLockedWorker("missing")).toBeUndefined();
+  });
+
+  it("distinguishes a cached null (confirmed absence) from an unset miss", () => {
+    const cache = new ControlPlaneCache({ ttlMs: 60_000, maxEntries: 100 });
+
+    expect(cache.getEnv("env_2")).toBeUndefined();
+    cache.setEnv("env_2", null);
+    expect(cache.getEnv("env_2")).toBeNull();
+
+    expect(cache.getAuthEnv("env_2")).toBeUndefined();
+    cache.setAuthEnv("env_2", null);
+    expect(cache.getAuthEnv("env_2")).toBeNull();
+
+    expect(cache.getWorkerVersion("env_2:current")).toBeUndefined();
+    cache.setWorkerVersion("env_2:current", null);
+    expect(cache.getWorkerVersion("env_2:current")).toBeNull();
+
+    expect(cache.getLockedWorker("_:_")).toBeUndefined();
+    cache.setLockedWorker("_:_", null);
+    expect(cache.getLockedWorker("_:_")).toBeNull();
+  });
+
+  it("caches a false env-existence result distinctly from an unset miss", () => {
+    const cache = new ControlPlaneCache({ ttlMs: 60_000, maxEntries: 100 });
+
+    expect(cache.getEnvExists("env_3")).toBeUndefined();
+    cache.setEnvExists("env_3", false);
+    expect(cache.getEnvExists("env_3")).toBe(false);
+  });
+
+  it("invalidateEnv forces the next getEnv to miss", () => {
+    const cache = new ControlPlaneCache({ ttlMs: 60_000, maxEntries: 100 });
+
+    cache.setEnv("env_4", anEnv);
+    expect(cache.getEnv("env_4")).toBe(anEnv);
+
+    cache.invalidateEnv("env_4");
+    expect(cache.getEnv("env_4")).toBeUndefined();
+  });
+
+  it("makes a re-setEnv after invalidation readable again", () => {
+    const cache = new ControlPlaneCache({ ttlMs: 60_000, maxEntries: 100 });
+    const replacement = { id: "env_5b" } as unknown as ResolvedEnv;
+
+    cache.setEnv("env_5", anEnv);
+    cache.invalidateEnv("env_5");
+    expect(cache.getEnv("env_5")).toBeUndefined();
+
+    cache.setEnv("env_5", replacement);
+    expect(cache.getEnv("env_5")).toBe(replacement);
+  });
+
+  it("invalidateEnv is scoped to its own id", () => {
+    const cache = new ControlPlaneCache({ ttlMs: 60_000, maxEntries: 100 });
+    const other = { id: "env_keep" } as unknown as ResolvedEnv;
+
+    cache.setEnv("env_drop", anEnv);
+    cache.setEnv("env_keep", other);
+    cache.invalidateEnv("env_drop");
+
+    expect(cache.getEnv("env_drop")).toBeUndefined();
+    expect(cache.getEnv("env_keep")).toBe(other);
+  });
+
+  it("does not collide keys across slots for the same id", () => {
+    const cache = new ControlPlaneCache({ ttlMs: 60_000, maxEntries: 100 });
+
+    cache.setEnv("x", anEnv);
+    cache.setEnvExists("x", true);
+    cache.setAuthEnv("x", anAuthEnv);
+
+    expect(cache.getEnv("x")).toBe(anEnv);
+    expect(cache.getEnvExists("x")).toBe(true);
+    expect(cache.getAuthEnv("x")).toBe(anAuthEnv);
+
+    // Invalidating the env slot leaves the sibling slots for the same id intact.
+    cache.invalidateEnv("x");
+    expect(cache.getEnv("x")).toBeUndefined();
+    expect(cache.getEnvExists("x")).toBe(true);
+    expect(cache.getAuthEnv("x")).toBe(anAuthEnv);
+  });
+
+  it("evicts the oldest entry once maxEntries is exceeded", () => {
+    const cache = new ControlPlaneCache({ ttlMs: 60_000, maxEntries: 2 });
+
+    cache.setEnv("first", { id: "first" } as unknown as ResolvedEnv);
+    cache.setEnv("second", { id: "second" } as unknown as ResolvedEnv);
+    cache.setEnv("third", { id: "third" } as unknown as ResolvedEnv);
+
+    expect(cache.getEnv("first")).toBeUndefined();
+    expect(cache.getEnv("second")).toMatchObject({ id: "second" });
+    expect(cache.getEnv("third")).toMatchObject({ id: "third" });
+  });
+
+  it("treats a zero-TTL entry as immediately expired", () => {
+    const cache = new ControlPlaneCache({ ttlMs: 0, maxEntries: 100 });
+
+    cache.setEnv("env_ttl", anEnv);
+    expect(cache.getEnv("env_ttl")).toBeUndefined();
+  });
+
+  it("invalidateEnvironment forces the next env/authEnv/envExists read to miss", () => {
+    const cache = new ControlPlaneCache({ ttlMs: 60_000, maxEntries: 100 });
+
+    cache.setEnv("env_6", anEnv);
+    cache.setAuthEnv("env_6", anAuthEnv);
+    cache.setEnvExists("env_6", true);
+    expect(cache.getEnv("env_6")).toBe(anEnv);
+    expect(cache.getAuthEnv("env_6")).toBe(anAuthEnv);
+    expect(cache.getEnvExists("env_6")).toBe(true);
+
+    cache.invalidateEnvironment("env_6");
+
+    expect(cache.getEnv("env_6")).toBeUndefined();
+    expect(cache.getAuthEnv("env_6")).toBeUndefined();
+    expect(cache.getEnvExists("env_6")).toBeUndefined();
+  });
+
+  it("invalidateEnvironment is scoped to its own id", () => {
+    const cache = new ControlPlaneCache({ ttlMs: 60_000, maxEntries: 100 });
+    const keepEnv = { id: "env_keep", organizationId: "org_1" } as unknown as ResolvedEnv;
+
+    cache.setEnv("env_drop", anEnv);
+    cache.setEnv("env_keep", keepEnv);
+    cache.invalidateEnvironment("env_drop");
+
+    expect(cache.getEnv("env_drop")).toBeUndefined();
+    expect(cache.getEnv("env_keep")).toBe(keepEnv);
+  });
+
+  it("invalidateOrganization drops env/authEnv rows for that org across every env id", () => {
+    const cache = new ControlPlaneCache({ ttlMs: 60_000, maxEntries: 100 });
+    const envA = { id: "env_a", organizationId: "org_1" } as unknown as ResolvedEnv;
+    const envB = { id: "env_b", organizationId: "org_1" } as unknown as ResolvedEnv;
+    const authA = {
+      id: "env_a",
+      slug: "a",
+      organizationId: "org_1",
+    } as unknown as ResolvedAuthenticatedEnv;
+
+    cache.setEnv("env_a", envA);
+    cache.setEnv("env_b", envB);
+    cache.setAuthEnv("env_a", authA);
+    expect(cache.getEnv("env_a")).toBe(envA);
+    expect(cache.getEnv("env_b")).toBe(envB);
+    expect(cache.getAuthEnv("env_a")).toBe(authA);
+
+    cache.invalidateOrganization("org_1");
+
+    // Every env/authEnv row for org_1 misses — no reverse org->env index required.
+    expect(cache.getEnv("env_a")).toBeUndefined();
+    expect(cache.getEnv("env_b")).toBeUndefined();
+    expect(cache.getAuthEnv("env_a")).toBeUndefined();
+  });
+
+  it("invalidateOrganization does not affect a different org's cached envs", () => {
+    const cache = new ControlPlaneCache({ ttlMs: 60_000, maxEntries: 100 });
+    const otherOrgEnv = { id: "env_other", organizationId: "org_2" } as unknown as ResolvedEnv;
+
+    cache.setEnv("env_1", anEnv); // org_1
+    cache.setEnv("env_other", otherOrgEnv); // org_2
+
+    cache.invalidateOrganization("org_1");
+
+    expect(cache.getEnv("env_1")).toBeUndefined();
+    expect(cache.getEnv("env_other")).toBe(otherOrgEnv);
+  });
+
+  it("re-setting an env after an org invalidation makes it readable again", () => {
+    const cache = new ControlPlaneCache({ ttlMs: 60_000, maxEntries: 100 });
+
+    cache.setEnv("env_1", anEnv);
+    cache.invalidateOrganization("org_1");
+    expect(cache.getEnv("env_1")).toBeUndefined();
+
+    // A write after the bump stamps the new org epoch, so it reads back.
+    cache.setEnv("env_1", anEnv);
+    expect(cache.getEnv("env_1")).toBe(anEnv);
+  });
+
+  it("a cached null env survives an org invalidation (a confirmed absence carries no org)", () => {
+    const cache = new ControlPlaneCache({ ttlMs: 60_000, maxEntries: 100 });
+
+    cache.setEnv("env_absent", null);
+    expect(cache.getEnv("env_absent")).toBeNull();
+
+    cache.invalidateOrganization("org_1");
+
+    expect(cache.getEnv("env_absent")).toBeNull();
+  });
+});