Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

fix(ok): key the e2e warm cache on the lockfile that exists (#4189)

Nick Gomez1e2026f576a0
diff --git a/packages/app/tests/meta/warm-cache-seed-key.test.ts b/packages/app/tests/meta/warm-cache-seed-key.test.ts
new file mode 100644
index 000000000..ccbd34c1b
--- /dev/null
+++ b/packages/app/tests/meta/warm-cache-seed-key.test.ts
@@ -0,0 +1,103 @@
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { describe, expect, onTestFinished, test, vi } from 'vitest';
+import { APP_PACKAGE_ROOT, computeSeedKey, seedKeyInputs } from '../stress/_helpers/seed-key.ts';
+import { withTempDir } from '../temp-dir.test-helper.ts';
+
+const TEMP_DIR_PREFIX = 'ok-warm-cache-seed-key-';
+const WORKSPACE_ROOT_FILE_NAMES = ['pnpm-lock.yaml'];
+const APP_PACKAGE_FILE_NAMES = [
+ 'vite.config.ts',
+ 'vite.dedupe.ts',
+ 'vite.react-babel.ts',
+ 'package.json',
+];
+
+const HASHED_FILES = [
+ ...WORKSPACE_ROOT_FILE_NAMES.map((name) => ({ name, inAppPackage: false })),
+ ...APP_PACKAGE_FILE_NAMES.map((name) => ({ name, inAppPackage: true })),
+];
+
+function buildWorkspaceFixture(workspaceRoot: string): string {
+ const appPackageRoot = join(workspaceRoot, 'packages', 'app');
+ mkdirSync(appPackageRoot, { recursive: true });
+ for (const name of APP_PACKAGE_FILE_NAMES) {
+ writeFileSync(join(appPackageRoot, name), `fixture stand-in for ${name}\n`, 'utf-8');
+ }
+ for (const name of WORKSPACE_ROOT_FILE_NAMES) {
+ writeFileSync(join(workspaceRoot, name), `fixture stand-in for ${name}\n`, 'utf-8');
+ }
+ return appPackageRoot;
+}
+
+describe('warm-cache seed key', () => {
+ test('every hashed input resolves in this checkout', () => {
+ expect(
+ seedKeyInputs(APP_PACKAGE_ROOT).filter((file) => !existsSync(file)),
+ "computeSeedKey substitutes the constant 'absent' for a missing input, so a hashed path that no longer resolves freezes that leg and the warm Vite seed stops responding to it",
+ ).toEqual([]);
+ });
+
+ test('every hashed input has a sensitivity row', () => {
+ const workspaceRoot = join(APP_PACKAGE_ROOT, '..', '..');
+ const rowTargets = HASHED_FILES.map(({ name, inAppPackage }) =>
+ join(inAppPackage ? APP_PACKAGE_ROOT : workspaceRoot, name),
+ );
+
+ expect(
+ seedKeyInputs(APP_PACKAGE_ROOT).toSorted(),
+ 'a leg added to seedKeyInputs without a HASHED_FILES row is never checked for actually moving the key',
+ ).toEqual(rowTargets.toSorted());
+ });
+
+ test('a hashed input that does not resolve warns and still returns a key', async () => {
+ await withTempDir(TEMP_DIR_PREFIX, async (workspaceRoot) => {
+ const appPackageRoot = buildWorkspaceFixture(workspaceRoot);
+ const deadLeg = join(appPackageRoot, 'vite.config.ts');
+ rmSync(deadLeg);
+ const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+ onTestFinished(() => warn.mockRestore());
+
+ const key = computeSeedKey(appPackageRoot);
+
+ expect(
+ warn,
+ 'a warn on every leg is indistinguishable from the dead-leg warn it exists to be, which degrades the only out-of-tier signal to per-run noise',
+ ).toHaveBeenCalledTimes(1);
+ expect(
+ String(warn.mock.calls[0]?.[0]),
+ 'a dead leg must name itself: tiers that never run this file have the warn as their only signal',
+ ).toContain(deadLeg);
+ expect(
+ key,
+ 'computeSeedKey stays fail-open on a dead leg because it is called outside the warm-cache retry, so throwing would fail globalSetup outright',
+ ).toHaveLength(64);
+ });
+ });
+
+ test.each(HASHED_FILES)('rewriting $name moves the key', async ({ name, inAppPackage }) => {
+ await withTempDir(TEMP_DIR_PREFIX, async (workspaceRoot) => {
+ const appPackageRoot = buildWorkspaceFixture(workspaceRoot);
+ const target = join(inAppPackage ? appPackageRoot : workspaceRoot, name);
+ const beforeRewrite = computeSeedKey(appPackageRoot);
+
+ writeFileSync(target, `rewritten ${name}\n`, 'utf-8');
+
+ expect(
+ computeSeedKey(appPackageRoot),
+ `the seed key must respond to ${name}: an unchanged key means that leg is not hashed, so a persistent checkout reuses a warm Vite seed built against the old inputs`,
+ ).not.toBe(beforeRewrite);
+ });
+ });
+
+ test('an unchanged workspace yields the same key on every call', async () => {
+ await withTempDir(TEMP_DIR_PREFIX, async (workspaceRoot) => {
+ const appPackageRoot = buildWorkspaceFixture(workspaceRoot);
+
+ expect(
+ computeSeedKey(appPackageRoot),
+ 'the seed key must be deterministic for an unchanged workspace, so a matching seed is reused instead of rebuilt on every run',
+ ).toBe(computeSeedKey(appPackageRoot));
+ });
+ });
+});
diff --git a/packages/app/tests/stress/_helpers/global-warm-cache.ts b/packages/app/tests/stress/_helpers/global-warm-cache.ts
index 25049c696..0d1ac8769 100644
--- a/packages/app/tests/stress/_helpers/global-warm-cache.ts
+++ b/packages/app/tests/stress/_helpers/global-warm-cache.ts
@@ -1,5 +1,4 @@
import { spawn } from 'node:child_process';
-import { createHash } from 'node:crypto';
import {
existsSync,
mkdirSync,
@@ -14,8 +13,8 @@ import {
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { setTimeout as wait } from 'node:timers/promises';
+import { APP_PACKAGE_ROOT, computeSeedKey } from './seed-key.ts';
import {
- APP_PACKAGE_ROOT,
closeServerLog,
getFreePort,
killGracefully,
@@ -30,22 +29,6 @@ const SEED_KEY_FILENAME = '.seed-key';
const OPTIMIZER_SETTLE_BUDGET_MS = 90_000;
const WARM_ATTEMPTS = 2;
-function computeSeedKey(): string {
- const inputs = [
- join(APP_PACKAGE_ROOT, '..', '..', 'bun.lock'),
- join(APP_PACKAGE_ROOT, 'vite.config.ts'),
- join(APP_PACKAGE_ROOT, 'vite.dedupe.ts'),
- join(APP_PACKAGE_ROOT, 'vite.react-babel.ts'),
- join(APP_PACKAGE_ROOT, 'package.json'),
- ];
- const hash = createHash('sha256');
- for (const file of inputs) {
- hash.update(file);
- hash.update(existsSync(file) ? readFileSync(file) : 'absent');
- }
- return hash.digest('hex');
-}
-
function depsDirSignature(depsDir: string): string {
try {
return readdirSync(depsDir)
@@ -136,7 +119,7 @@ async function buildSeedOnce(key: string): Promise<void> {
}
export default async function globalWarmViteCache(): Promise<void> {
- const key = computeSeedKey();
+ const key = computeSeedKey(APP_PACKAGE_ROOT);
const keyPath = join(VITE_E2E_SEED_DIR, SEED_KEY_FILENAME);
const metaPath = join(VITE_E2E_SEED_DIR, 'deps', '_metadata.json');
if (existsSync(keyPath) && existsSync(metaPath) && readFileSync(keyPath, 'utf-8') === key) {
diff --git a/packages/app/tests/stress/_helpers/seed-key.ts b/packages/app/tests/stress/_helpers/seed-key.ts
new file mode 100644
index 000000000..b17cd0ea9
--- /dev/null
+++ b/packages/app/tests/stress/_helpers/seed-key.ts
@@ -0,0 +1,33 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const APP_PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..', '..');
+
+export function seedKeyInputs(appPackageRoot: string): string[] {
+ return [
+ join(appPackageRoot, '..', '..', 'pnpm-lock.yaml'),
+ join(appPackageRoot, 'vite.config.ts'),
+ join(appPackageRoot, 'vite.dedupe.ts'),
+ join(appPackageRoot, 'vite.react-babel.ts'),
+ join(appPackageRoot, 'package.json'),
+ ];
+}
+
+export function computeSeedKey(appPackageRoot: string): string {
+ const hash = createHash('sha256');
+ for (const file of seedKeyInputs(appPackageRoot)) {
+ hash.update(file);
+ if (existsSync(file)) {
+ hash.update(readFileSync(file));
+ } else {
+ console.warn(
+ `[e2e warm-cache] seed key input does not resolve, so its leg is frozen and a persistent` +
+ ` checkout can reuse a warm seed built against stale inputs: ${file}`,
+ );
+ hash.update('absent');
+ }
+ }
+ return hash.digest('hex');
+}
diff --git a/packages/app/tests/stress/_helpers/server-process.ts b/packages/app/tests/stress/_helpers/server-process.ts
index 06d1b7146..0e5229c6a 100644
--- a/packages/app/tests/stress/_helpers/server-process.ts
+++ b/packages/app/tests/stress/_helpers/server-process.ts
@@ -9,15 +9,14 @@ import {
readFileSync,
} from 'node:fs';
import { tmpdir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
+import { join } from 'node:path';
import { setTimeout as wait } from 'node:timers/promises';
-import { fileURLToPath } from 'node:url';
import { HocuspocusProvider } from '@hocuspocus/provider';
import { SYSTEM_DOC_NAME } from '@inkeep/open-knowledge-core';
import * as Y from 'yjs';
+import { APP_PACKAGE_ROOT } from './seed-key.ts';
-const HELPERS_DIR = dirname(fileURLToPath(import.meta.url));
-export const APP_PACKAGE_ROOT = resolve(HELPERS_DIR, '..', '..', '..');
+export { APP_PACKAGE_ROOT };
export const VITE_E2E_SEED_DIR = join(APP_PACKAGE_ROOT, 'node_modules', '.vite-e2e-seed');
diff --git a/turbo.json b/turbo.json
index c87e1b597..8aeec8b76 100644
--- a/turbo.json
+++ b/turbo.json
@@ -177,7 +177,10 @@
"playwright.config.ts",
"vitest.integration.config.ts",
"vitest.config.ts",
+ "vite.config.ts",
"vite.dedupe.ts",
+ "vite.react-babel.ts",
+ "../../pnpm-lock.yaml",
"../../test-support/*.ts",
"../server/src/**/*.ts",
"../core/src/**/*.ts",
@@ -200,7 +203,10 @@
"playwright.config.ts",
"vitest.integration.config.ts",
"vitest.config.ts",
+ "vite.config.ts",
"vite.dedupe.ts",
+ "vite.react-babel.ts",
+ "../../pnpm-lock.yaml",
"../../test-support/*.ts",
"../server/src/**/*.ts",
"../core/src/**/*.ts",
@@ -223,7 +229,10 @@
"playwright.config.ts",
"vitest.integration.config.ts",
"vitest.config.ts",
+ "vite.config.ts",
"vite.dedupe.ts",
+ "vite.react-babel.ts",
+ "../../pnpm-lock.yaml",
"../../test-support/*.ts",
"../server/src/**/*.ts",
"../core/src/**/*.ts",
@@ -246,7 +255,10 @@
"playwright.config.ts",
"vitest.integration.config.ts",
"vitest.config.ts",
+ "vite.config.ts",
"vite.dedupe.ts",
+ "vite.react-babel.ts",
+ "../../pnpm-lock.yaml",
"../../test-support/*.ts",
"../server/src/**/*.ts",
"../core/src/**/*.ts",