@tokenoftrust/storefront-runner 2.4.7 → 2.4.9

package/apps/storefront/test/pipeline/pool-config.cjs

@@ -0,0 +1,78 @@
+// The workerd pool both pipeline suites run in (@cloudflare/vitest-pool-workers): the TenantPipeline
+// Durable Object is exercised with real SQLite storage, real alarms and real eviction
+// (`ctx.abort()`). The Node unit suite (vitest.config.cts) never picks these tests up.
+//
+// The object lives in its own Worker, `pipeline-host`, not in the test runner's isolate: an
+// eviction must restart the object without touching its callers, as in production. Auxiliary
+// Workers take plain modules, so the host is bundled here, in memory, with esbuild.
+//
+//   vitest.workers.config.cts  test/pipeline/**         the hand-written harness tests, one at a time
+//   vitest.faults.config.cts   test/pipeline-faults/**  the systematic fault matrix, cells concurrent
+const { defineWorkersConfig } = require("@cloudflare/vitest-pool-workers/config");
+const esbuild = require("esbuild");
+const path = require("node:path");
+
+const compatibilityDate = "2024-11-01";
+const compatibilityFlags = ["nodejs_compat"];
+const HOST = "pipeline-host";
+
+/**
+ * @param {{ root: string; name: string; include: string[]; maxConcurrency?: number; testTimeout?: number }} options
+ */
+function pipelinePoolConfig({ root, name, include, maxConcurrency, testTimeout = 60_000 }) {
+  const hostModule = esbuild.buildSync({
+    entryPoints: [path.join(root, "test/pipeline/pipeline-host.ts")],
+    bundle: true,
+    format: "esm",
+    platform: "neutral",
+    target: "es2022",
+    external: ["cloudflare:*"],
+    write: false,
+  }).outputFiles[0].text;
+
+  const pipelineBinding = { TENANT_PIPELINE: { className: "TenantPipeline", scriptName: HOST } };
+
+  return defineWorkersConfig({
+    // The source tree's `@/` import alias (tsconfig `paths`), for modules the tests import directly.
+    resolve: { alias: { "@": path.join(root, "src") } },
+    test: {
+      name,
+      include,
+      cache: false,
+      testTimeout,
+      hookTimeout: 60_000,
+      ...(maxConcurrency ? { maxConcurrency } : {}),
+      poolOptions: {
+        workers: {
+          isolatedStorage: false,
+          singleWorker: true,
+          miniflare: {
+            compatibilityDate,
+            compatibilityFlags,
+            durableObjects: pipelineBinding,
+            serviceBindings: { PIPELINE_HOST: HOST, INTAKE_B: "pipeline-intake-b" },
+            workers: [
+              {
+                name: HOST,
+                modules: [{ type: "ESModule", path: "pipeline-host.mjs", contents: hostModule }],
+                compatibilityDate,
+                compatibilityFlags,
+                durableObjects: { TENANT_PIPELINE: { className: "TenantPipeline", useSQLite: true } },
+              },
+              {
+                name: "pipeline-intake-b",
+                modules: true,
+                scriptPath: path.join(root, "test/pipeline/intake-worker.mjs"),
+                compatibilityDate,
+                compatibilityFlags,
+                durableObjects: pipelineBinding,
+              },
+            ],
+          },
+        },
+      },
+    },
+  });
+}
+
+module.exports = { pipelinePoolConfig };

package/apps/storefront/test/pipeline/publish-kinds.ts

@@ -26,18 +26,27 @@ import {
   movePreview,
   standInPublishEnvironment,
   testVersionStore,
+  type CiDispatch,
   type TestKv,
+  type WorldDesignation,
 } from "../../src/lib/pipeline/publish/publish-test-support";
+import type { Landed } from "./matrix-faults";
 
 type SiteVersionStore = ReturnType<typeof testVersionStore>;
 type PointerWriter = NonNullable<Parameters<typeof testVersionStore>[1]>;
+type PointerRecord = Awaited<ReturnType<PointerWriter["read"]>>;
 
+/**
+ * Production's ratios, in seconds: a CI window (45 min) outlasts the lease an evicted object waits
+ * out before it resumes (10 min, here `leaseMs`), so a job resumed after an eviction is still inside
+ * its window — as in production.
+ */
 export const PUBLISH_HARNESS_TIMING: PublishTiming = {
-  awaitWindowMs: 1_500,
+  awaitWindowMs: 4_000,
   runGraceMs: 500,
   proofDelayMs: 30,
   proofProbes: { synchronous: 3, asynchronous: 5 },
-  stageWindowMs: 1_500,
+  stageWindowMs: 4_000,
   stageChecks: 3,
 };
 
@@ -64,25 +73,6 @@ function tables(state: DurableObjectState): void {
   sql.exec(`CREATE TABLE IF NOT EXISTS harness_kv (key TEXT PRIMARY KEY, value TEXT NOT NULL)`);
   sql.exec(`CREATE TABLE IF NOT EXISTS harness_publish_faults (id INTEGER PRIMARY KEY AUTOINCREMENT, step TEXT, at TEXT, mode TEXT, remaining INTEGER, version_id TEXT)`);
   sql.exec(`CREATE TABLE IF NOT EXISTS harness_publish_fired (seq INTEGER PRIMARY KEY AUTOINCREMENT, step TEXT, at TEXT, mode TEXT)`);
-  sql.exec(`CREATE TABLE IF NOT EXISTS harness_publish_armed (seq INTEGER PRIMARY KEY AUTOINCREMENT, step TEXT, at TEXT, armed INTEGER)`);
-}
-
-/** At each fired fault: how many compensations the engine held armed for jobs not yet terminal. */
-export function armedAtFaults(state: DurableObjectState): { step: string; at: string; armed: number }[] {
-  tables(state);
-  return state.storage.sql.exec<{ step: string; at: string; armed: number }>(`SELECT step, at, armed FROM harness_publish_armed ORDER BY seq`).toArray();
-}
-
-function armedCompensations(state: DurableObjectState): number {
-  try {
-    return state.storage.sql
-      .exec<{ n: number }>(
-        `SELECT COUNT(*) AS n FROM terminal_hooks h JOIN jobs j ON j.job_id = h.job_id WHERE j.state NOT IN ('succeeded', 'needs-developer', 'stuck')`,
-      )
-      .one().n;
-  } catch {
-    return -1;
-  }
 }
 
 /** A KV over the object's SQLite: durable across evictions, visible to every later execution. */
@@ -133,7 +123,6 @@ async function maybeFault(state: DurableObjectState, step: string, at: "before"
   if (!fault) return;
   sql.exec(`UPDATE harness_publish_faults SET remaining = remaining - 1 WHERE id = ?`, fault.id);
   sql.exec(`INSERT INTO harness_publish_fired (step, at, mode) VALUES (?, ?, ?)`, step, at, fault.mode);
-  sql.exec(`INSERT INTO harness_publish_armed (step, at, armed) VALUES (?, ?, ?)`, step, at, armedCompensations(state));
   // Everything written so far — including a step's own effect, for an `after` fault — is made
   // durable first, exactly as a real crash after the write would leave it.
   await state.storage.sync();
@@ -182,11 +171,104 @@ export function publishWorldOf(state: DurableObjectState): { kv: TestKv; world:
   return { kv, world: new PublishWorld(kv) };
 }
 
-/** Register the publish kinds (fault-wrapped, over the stand-in world) into `registry`; `pointers` is the object's authority. */
-export function registerHarnessPublishKinds(state: DurableObjectState, registry: JobKindRegistry, pointers: PointerWriter): JobKindRegistry {
-  const { kv, world } = publishWorldOf(state);
-  const store = testVersionStore(kv, pointers);
-  const environment = standInPublishEnvironment({ kv, world, store, now: () => Date.now(), timing: PUBLISH_HARNESS_TIMING });
+/** The world's logs that record an external effect, by the effect name the fault matrix uses. */
+const NOTED_EFFECTS: Record<string, string> = {
+  "hotfix-merges": "forge:merge-to-main",
+  "forward-integrations": "forge:forward-integrate",
+  "staged-originals": "r2:stage-originals",
+  "went-live": "notice:went-live",
+};
+
+/** The publish world, reporting every external effect a job makes to the fault matrix. */
+class EffectWorld extends PublishWorld {
+  constructor(
+    kv: TestKv,
+    private readonly landed: Landed,
+  ) {
+    super(kv);
+  }
+
+  override async dispatch(dispatch: CiDispatch, at = 0): Promise<void> {
+    const before = (await this.dispatches()).length;
+    let lost: unknown = null;
+    try {
+      await super.dispatch(dispatch, at);
+    } catch (thrown) {
+      // A refused dispatch recorded nothing (no run exists); a lost response came after the run did.
+      if ((await this.dispatches()).length === before) throw thrown;
+      lost = thrown;
+    }
+    await this.landed(`ci:${dispatch.workflow}`);
+    if (lost) throw lost;
+  }
+
+  override async recordDesignation(entry: WorldDesignation): Promise<void> {
+    await super.recordDesignation(entry);
+    await this.landed("mcp:designate");
+  }
+
+  override async note(key: string, value: unknown): Promise<void> {
+    await super.note(key, value);
+    const effect = NOTED_EFFECTS[key];
+    if (effect) await this.landed(effect);
+  }
+}
+
+/** The object's pointer writer, reporting each write that moved a channel (`pointer:<channel>`). */
+function effectPointers(inner: PointerWriter, landed: Landed): PointerWriter {
+  return {
+    read: (tenantId) => inner.read(tenantId),
+    ...(inner.peek ? { peek: (tenantId: string) => inner.peek!(tenantId) } : {}),
+    async update(tenantId, apply) {
+      let before: PointerRecord | null = null;
+      const after = await inner.update(tenantId, (current) => {
+        before = current;
+        return apply(current);
+      });
+      const prior = before as PointerRecord | null;
+      for (const channel of ["live", "preview"] as const) {
+        if (prior?.channels?.[channel] !== after.channels?.[channel] || prior?.channelRevs?.[channel] !== after.channelRevs?.[channel]) {
+          await landed(`pointer:${channel}`);
+        }
+      }
+      return after;
+    },
+  };
+}
+
+/** The job's KV, reporting each write of the assets pointer (`assets:live`). */
+function effectKv(kv: TestKv, landed: Landed): TestKv {
+  return {
+    get: (key) => kv.get(key),
+    put: async (key, value) => {
+      await kv.put(key, value);
+      if (key.startsWith("cust:assets-pointer:")) await landed("assets:live");
+    },
+    ...(kv.delete ? { delete: (key: string) => kv.delete!(key) } : {}),
+  };
+}
+
+const noEffects: Landed = async () => {};
+
+/**
+ * Register the publish kinds (fault-wrapped, over the stand-in world) into `registry`; `pointers` is
+ * the object's authority. `landed` hears every external effect the jobs make (the fault matrix).
+ */
+export function registerHarnessPublishKinds(
+  state: DurableObjectState,
+  registry: JobKindRegistry,
+  pointers: PointerWriter,
+  landed: Landed = noEffects,
+): JobKindRegistry {
+  const { kv } = publishWorldOf(state);
+  const store = testVersionStore(kv, effectPointers(pointers, landed));
+  const environment = standInPublishEnvironment({
+    kv: effectKv(kv, landed),
+    world: new EffectWorld(kv, landed),
+    store,
+    now: () => Date.now(),
+    timing: PUBLISH_HARNESS_TIMING,
+  });
   const kinds = registerPublishJobKinds(new JobKindRegistry(), async () => environment, PUBLISH_HARNESS_TUNING);
   for (const name of kinds.list()) registry.register(withFaults(state, kinds.get(name)!, store));
   return registry;