From bff4d6de84c3d711a9275f0ef9aa8bd61fa16576 Mon Sep 17 00:00:00 2001 From: ranxianglei Date: Fri, 16 Oct 2026 10:17:05 +0800 Subject: [PATCH] test: golden drive refuses to run on a stale kernel dist (#3325 lesson) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The storage-render golden drive renders persisted-state digests from node_modules/acp-kernel/dist (a build product) while bili runs live via tsx. A stale kernel dist silently stamps removed fields (post-#3266 it still produced metadata.effectiveConfig.imageCompression and state.stats.image* counters), so a golden regenerated from that workspace bakes digests no fresh build can reproduce — CI then fails every leg that carries the golden file. That is exactly how PR #3325 went wrong: 'master red' was verified and regenerated from a stale local workspace, while a clean fresh-install replica passed 5/5 against the committed goldens. - kernelDistStale(root): compares node_modules/acp-kernel/dist/index.js mtime against the newest kernel/src (and tsup.config.ts) source; pure, synthetic-tree testable. - driveWire() now fails fast with the rebuild instruction ('npm run build') before touching any session state. Call-time, not import-time, so the guard's own unit tests can import the module from a stale workspace. - tests/golden-kernel-dist-guard.test.ts pins both directions + the missing-dist passthrough. Verified both ways locally: stale dist -> drive refuses with the message; after npm run build -> golden-storage-render 5/5 against master's committed goldens. --- tests/golden-kernel-dist-guard.test.ts | 59 ++++++++++++++++++++++++++ tests/golden-storage-drive.ts | 57 +++++++++++++++++++++++++ 2 files changed, 116 insertions(+) create mode 100644 tests/golden-kernel-dist-guard.test.ts diff --git a/tests/golden-kernel-dist-guard.test.ts b/tests/golden-kernel-dist-guard.test.ts new file mode 100644 index 0000000000..55832fa891 --- /dev/null +++ b/tests/golden-kernel-dist-guard.test.ts @@ -0,0 +1,59 @@ +/** + * #3325: the storage-render golden drive must refuse to run on a stale kernel + * dist — a stale node_modules/acp-kernel/dist stamps removed fields into + * persisted state, so a regen from that workspace bakes digests no fresh build + * can reproduce (CI then fails every leg carrying the golden file). These tests + * pin the guard itself (kernelDistStale in golden-storage-drive.ts) using + * synthetic trees — no real dist mtime is touched. + */ +import test from "node:test"; +import assert from "node:assert/strict"; +import fs from "node:fs"; +import os from "node:os"; +import path from "node:path"; +import { kernelDistStale } from "./golden-storage-drive.ts"; + +function makeTree(distAtSrc: boolean): string { + const root = fs.mkdtempSync(path.join(os.tmpdir(), "kdist-")); + const srcDir = path.join(root, "kernel", "src", "filter"); + fs.mkdirSync(srcDir, { recursive: true }); + const distDir = path.join(root, "node_modules", "acp-kernel", "dist"); + fs.mkdirSync(distDir, { recursive: true }); + const now = Date.now(); + const oldMs = now - 10 * 60_000; + fs.writeFileSync(path.join(srcDir, "index.ts"), "export {};"); + fs.writeFileSync(path.join(root, "kernel", "tsup.config.ts"), "export {};"); + // Both source files get the same stamp; dist either older (stale) or newer. + const stamp = oldMs; + const distStamp = distAtSrc ? now : stamp - 60_000; + for (const f of [path.join(srcDir, "index.ts"), path.join(root, "kernel", "tsup.config.ts")]) fs.utimesSync(f, new Date(stamp), new Date(stamp)); + const distEntry = path.join(distDir, "index.js"); + fs.writeFileSync(distEntry, "export {};"); + fs.utimesSync(distEntry, new Date(distStamp), new Date(distStamp)); + return root; +} + +test("kernelDistStale: dist older than kernel/src is reported stale with the newest source named", () => { + const t = makeTree(false); + try { + const r = kernelDistStale(t); + assert.equal(r.stale, true); + assert.ok(r.newestSrc && r.newestSrc.length > 0); + } finally { fs.rmSync(t, { recursive: true, force: true }); } +}); + +test("kernelDistStale: dist newer than kernel/src is not stale", () => { + const t = makeTree(true); + try { + const r = kernelDistStale(t); + assert.equal(r.stale, false); + } finally { fs.rmSync(t, { recursive: true, force: true }); } +}); + +test("kernelDistStale: missing dist entry is not our error (tsx surfaces module-not-found)", () => { + const root = fs.mkdtempSync(path.join(os.tmpdir(), "kdist-")); + try { + const r = kernelDistStale(root); + assert.equal(r.stale, false); + } finally { fs.rmSync(root, { recursive: true, force: true }); } +}); diff --git a/tests/golden-storage-drive.ts b/tests/golden-storage-drive.ts index a4cc697a63..a6b14205f8 100644 --- a/tests/golden-storage-drive.ts +++ b/tests/golden-storage-drive.ts @@ -22,6 +22,62 @@ import { startServer } from "../src/server.ts"; import { SessionStore, _setStoreForTest } from "../src/persist.ts"; import { flushAllSessions, _resetSessionsForTest } from "../src/session.ts"; import type { ProxyOptions } from "../src/config.ts"; + +/** + * #3325 lesson — the drive renders digests from `node_modules/acp-kernel/dist` + * (a BUILD PRODUCT, resolved via package exports) while bili side-by-side runs + * from live TS via tsx. A stale kernel dist silently changes persisted state + * (e.g. post-#3266 it still stamped metadata.effectiveConfig.imageCompression + * + state.stats.image* fields), so a locally regenerated golden bakes digests + * no fresh build can reproduce — CI then fails every leg that runs this file. + * Fail fast with the rebuild instruction instead of letting a stale workspace + * mint bad goldens. + */ +export function kernelDistStale(root: string): { stale: boolean; distAt?: number; srcAt?: number; newestSrc?: string } { + const distEntry = path.join(root, "node_modules", "acp-kernel", "dist", "index.js"); + try { + const distAt = fs.statSync(distEntry).mtimeMs; + let srcAt = 0; + let newestSrc = ""; + const walk = (dir: string) => { + for (const e of fs.readdirSync(dir, { withFileTypes: true })) { + const p = path.join(dir, e.name); + if (e.isDirectory()) walk(p); + else if (/\.(ts|tsx|mjs)$/.test(e.name)) { + const m = fs.statSync(p).mtimeMs; + if (m > srcAt) { srcAt = m; newestSrc = p; } + } + } + }; + walk(path.join(root, "kernel", "src")); + const tsup = path.join(root, "kernel", "tsup.config.ts"); + if (fs.existsSync(tsup)) { + const m = fs.statSync(tsup).mtimeMs; + if (m > srcAt) { srcAt = m; newestSrc = tsup; } + } + return { stale: srcAt > distAt, distAt, srcAt, newestSrc }; + } catch { + // dist absent or unreadable — tsx will surface the module-not-found; not our error. + return { stale: false }; + } +} +const __goldenGuard = (() => { + // Call-time (not import-time): the guard's own unit test imports this + // module from a possibly-stale workspace; only actual drives must refuse. + let armed = false; + return () => { + if (armed) return; + armed = true; + const s = kernelDistStale(path.resolve(import.meta.dirname, "..")); + if (s.stale) { + throw new Error( + `golden drive: node_modules/acp-kernel/dist is older than kernel/src (${s.newestSrc}) — ` + + `a stale kernel dist produces digests no fresh build can reproduce (#3325). ` + + `Rebuild first: npm run build`, + ); + } + }; +})(); import { _setForTest as setRegistryForTest } from "../src/registry.ts"; import { configureLogger, closeLogger } from "../src/logger.ts"; import { rmrf } from "./tmp-rm.ts"; @@ -407,6 +463,7 @@ export async function driveWire(wire: Wire, sessionId = `golden-${wire}`, opts: storageUnified?: "shadow" | "full"; reloadAfterEdit?: "keepFile" | "dropFile"; } = {}): Promise { + __goldenGuard(); fs.mkdirSync(SCRATCH_ROOT, { recursive: true }); const tmp = fs.mkdtempSync(path.join(SCRATCH_ROOT, `${wire}-`)); const sessionsDir = path.join(tmp, "sessions");