Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

Select browser specs for targeted PRs from an Inertia coverage map (PRD-9548) (#6725)

Andrew Mikofalvy5b3098b91976
diff --git a/packages/app/src/build/e2e-coverage-contract.test.ts b/packages/app/src/build/e2e-coverage-contract.test.ts
new file mode 100644
index 000000000..8b1954872
--- /dev/null
+++ b/packages/app/src/build/e2e-coverage-contract.test.ts
@@ -0,0 +1,147 @@
+import { describe, expect, test } from 'vitest';
+import {
+ browserScriptFile,
+ e2eCoverageDir,
+ executedOffsets,
+ recordableSource,
+ regionAt,
+ type ScriptCoverage,
+ serverScriptFiles,
+ sourceRegions,
+} from './e2e-coverage-contract';
+
+const OK_ROOT = '/work/My Repo/public/open-knowledge';
+const APP_DIR = `${OK_ROOT}/packages/app`;
+
+const script = (url: string, functions: Array<[string, number, number]>): ScriptCoverage => ({
+ url,
+ functions: functions.map(([functionName, startOffset, count]) => ({
+ functionName,
+ ranges: [{ startOffset, endOffset: startOffset + 10, count }],
+ })),
+});
+
+describe('which functions count as executed', () => {
+ test('a function that ran counts, the module body and a function that never ran do not', () => {
+ expect(
+ executedOffsets(
+ script('u', [
+ ['', 0, 1],
+ ['render', 40, 3],
+ ['unused', 90, 0],
+ ['', 120, 2],
+ ]),
+ ),
+ ).toEqual([40, 120]);
+ expect(executedOffsets(script('u', [['', 0, 1]]))).toEqual([]);
+ });
+});
+
+describe('the coverage directory switch', () => {
+ test('only a non-empty directory turns recording on', () => {
+ expect(e2eCoverageDir({})).toBeUndefined();
+ expect(e2eCoverageDir({ OK_E2E_COVERAGE_DIR: '' })).toBeUndefined();
+ expect(e2eCoverageDir({ OK_E2E_COVERAGE_DIR: '/tmp/cov' })).toBe('/tmp/cov');
+ });
+});
+
+describe('which files are recorded', () => {
+ test('source files under the root are recorded by their root-relative path', () => {
+ expect(recordableSource(`${APP_DIR}/src/editor/Tiptap.tsx`, OK_ROOT)).toBe(
+ 'packages/app/src/editor/Tiptap.tsx',
+ );
+ expect(recordableSource(`${OK_ROOT}/packages/server/src/api-extension.ts`, OK_ROOT)).toBe(
+ 'packages/server/src/api-extension.ts',
+ );
+ });
+
+ test('dependencies, build output, test helpers, tests and paths outside the root are not', () => {
+ for (const path of [
+ `${OK_ROOT}/node_modules/.pnpm/react/index.js`,
+ `${APP_DIR}/node_modules/.vite/deps/react.js`,
+ `${OK_ROOT}/packages/server/dist/index.mjs`,
+ `${APP_DIR}/tests/stress/_helpers/fixtures.ts`,
+ `${APP_DIR}/src/build/app-version.test.ts`,
+ `${OK_ROOT}/test-support/vitest.base.ts`,
+ '/tmp/ok-vite-cache/deps/yjs.js',
+ OK_ROOT,
+ ])
+ expect(recordableSource(path, OK_ROOT), path).toBeUndefined();
+ });
+});
+
+describe('mapping a browser script URL to a file', () => {
+ test('a Vite source URL resolves against the app root, and its query is dropped', () => {
+ expect(browserScriptFile('http://127.0.0.1:4100/src/main.tsx?t=171', APP_DIR)).toBe(
+ `${APP_DIR}/src/main.tsx`,
+ );
+ });
+
+ test('an /@fs/ URL is the absolute file, with its encoded spaces decoded', () => {
+ expect(
+ browserScriptFile(
+ 'http://127.0.0.1:4100/@fs/work/My%20Repo/public/open-knowledge/packages/core/src/index.ts?v=1',
+ APP_DIR,
+ ),
+ ).toBe(`${OK_ROOT}/packages/core/src/index.ts`);
+ });
+
+ test('Vite internals, optimized dependencies, the page itself and non-HTTP scripts map to nothing', () => {
+ for (const url of [
+ 'http://127.0.0.1:4100/@vite/client',
+ 'http://127.0.0.1:4100/@react-refresh',
+ 'http://127.0.0.1:4100/@id/__x00__virtual',
+ 'http://127.0.0.1:4100/node_modules/.vite/deps/react.js?v=1',
+ 'http://127.0.0.1:4100/',
+ 'chrome-extension://abc/script.js',
+ 'not a url',
+ 'http://127.0.0.1:4100/%E0%A4%A',
+ ])
+ expect(browserScriptFile(url, APP_DIR), url).toBeUndefined();
+ });
+});
+
+describe('mapping a bundled server script back to its sources', () => {
+ const bundle = [
+ 'import { x } from "y";',
+ '//#region src/a.ts',
+ 'function a() { return 1; }',
+ '//#endregion',
+ '//#region src/http/b.ts',
+ 'function b() { return 2; }',
+ '//#endregion',
+ 'export { a, b };',
+ ].join('\n');
+ const regions = sourceRegions(bundle);
+ const offsetOf = (text: string) => bundle.indexOf(text);
+
+ test('each region spans its marked source, in order', () => {
+ expect(regions.map((region) => region.path)).toEqual(['src/a.ts', 'src/http/b.ts']);
+ expect(regionAt(regions, offsetOf('function a'))?.path).toBe('src/a.ts');
+ expect(regionAt(regions, offsetOf('function b'))?.path).toBe('src/http/b.ts');
+ expect(regionAt(regions, offsetOf('import'))).toBeUndefined();
+ expect(regionAt(regions, offsetOf('export'))).toBeUndefined();
+ });
+
+ test('an executed function is attributed to its region, and an unmarked script to itself', () => {
+ const covered = script('file:///pkg/dist/index.mjs', [
+ ['', 0, 1],
+ ['b', offsetOf('function b'), 1],
+ ['a', offsetOf('function a'), 0],
+ ]);
+ expect(serverScriptFiles(covered, '/pkg/dist/index.mjs', regions, '/pkg')).toEqual([
+ '/pkg/src/http/b.ts',
+ ]);
+ expect(serverScriptFiles(covered, '/pkg/src/plain.mjs', [], '/pkg')).toEqual([
+ '/pkg/src/plain.mjs',
+ ]);
+ expect(
+ serverScriptFiles(script('file:///x', [['', 0, 1]]), '/pkg/dist/index.mjs', regions, '/pkg'),
+ ).toEqual([]);
+ });
+
+ test('an unterminated region runs to the end of the script', () => {
+ const open = sourceRegions('//#region src/tail.ts\nfunction t() {}\n');
+ expect(open).toEqual([{ start: 0, end: 38, path: 'src/tail.ts' }]);
+ });
+});
diff --git a/packages/app/src/build/e2e-coverage-contract.ts b/packages/app/src/build/e2e-coverage-contract.ts
new file mode 100644
index 000000000..2c3867d86
--- /dev/null
+++ b/packages/app/src/build/e2e-coverage-contract.ts
@@ -0,0 +1,135 @@
+import { isAbsolute, join, relative, sep } from 'node:path';
+
+const E2E_COVERAGE_DIR_ENV = 'OK_E2E_COVERAGE_DIR';
+export const E2E_COVERAGE_PATH = '/__ok-e2e-coverage';
+
+interface CoverageRange {
+ readonly startOffset: number;
+ readonly endOffset: number;
+ readonly count: number;
+}
+
+interface FunctionCoverage {
+ readonly functionName: string;
+ readonly ranges: readonly CoverageRange[];
+}
+
+export interface ScriptCoverage {
+ readonly url: string;
+ readonly functions: readonly FunctionCoverage[];
+}
+
+export interface SourceRegion {
+ readonly start: number;
+ readonly end: number;
+ readonly path: string;
+}
+
+type Env = Readonly<Record<string, string | undefined>>;
+
+export function e2eCoverageDir(env: Env): string | undefined {
+ const dir = env[E2E_COVERAGE_DIR_ENV];
+ return dir === undefined || dir === '' ? undefined : dir;
+}
+
+function isModuleBody(fn: FunctionCoverage): boolean {
+ return fn.functionName === '' && fn.ranges[0]?.startOffset === 0;
+}
+
+export function executedOffsets(script: ScriptCoverage): number[] {
+ const offsets: number[] = [];
+ for (const fn of script.functions) {
+ const whole = fn.ranges[0];
+ if (whole === undefined || whole.count <= 0 || isModuleBody(fn)) continue;
+ offsets.push(whole.startOffset);
+ }
+ return offsets;
+}
+
+const UNRECORDED_SEGMENTS = new Set(['node_modules', 'dist', '.vite', '.vite-temp']);
+const UNRECORDED_PREFIXES = ['packages/app/tests/', 'test-support/'];
+const TEST_MODULE = /\.(test|test-helper|e2e|dom\.test|browser\.test)\.[cm]?[jt]sx?$/;
+
+export function recordableSource(absPath: string, okRoot: string): string | undefined {
+ const within = relative(okRoot, absPath).split(sep).join('/');
+ if (within === '' || within.startsWith('..') || isAbsolute(within)) return undefined;
+ if (within.split('/').some((segment) => UNRECORDED_SEGMENTS.has(segment))) return undefined;
+ if (UNRECORDED_PREFIXES.some((prefix) => within.startsWith(prefix))) return undefined;
+ if (TEST_MODULE.test(within)) return undefined;
+ return within;
+}
+
+export function browserScriptFile(url: string, appDir: string): string | undefined {
+ let parsed: URL;
+ try {
+ parsed = new URL(url);
+ } catch {
+ return undefined;
+ }
+ if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') return undefined;
+ let path: string;
+ try {
+ path = decodeURIComponent(parsed.pathname);
+ } catch {
+ return undefined;
+ }
+ if (path.startsWith('/@fs/')) return path.slice('/@fs'.length);
+ if (path.startsWith('/@') || path.startsWith('/node_modules/') || path === '/') return undefined;
+ return join(appDir, path);
+}
+
+const REGION_OPEN = /^\/\/#region (.+)$/;
+const REGION_CLOSE = /^\/\/#endregion\b/;
+
+export function sourceRegions(text: string): SourceRegion[] {
+ const regions: SourceRegion[] = [];
+ let open: { start: number; path: string } | undefined;
+ let offset = 0;
+ for (const line of text.split('\n')) {
+ const opening = REGION_OPEN.exec(line);
+ if (opening !== null) {
+ if (open !== undefined) regions.push({ ...open, end: offset });
+ open = { start: offset, path: opening[1]?.trim() ?? '' };
+ } else if (REGION_CLOSE.test(line) && open !== undefined) {
+ regions.push({ ...open, end: offset + line.length });
+ open = undefined;
+ }
+ offset += line.length + 1;
+ }
+ if (open !== undefined) regions.push({ ...open, end: text.length });
+ return regions;
+}
+
+export function regionAt(
+ regions: readonly SourceRegion[],
+ offset: number,
+): SourceRegion | undefined {
+ let low = 0;
+ let high = regions.length - 1;
+ while (low <= high) {
+ const mid = (low + high) >> 1;
+ const region = regions[mid];
+ if (region === undefined) return undefined;
+ if (offset < region.start) high = mid - 1;
+ else if (offset >= region.end) low = mid + 1;
+ else return region;
+ }
+ return undefined;
+}
+
+export function serverScriptFiles(
+ script: ScriptCoverage,
+ scriptFile: string,
+ regions: readonly SourceRegion[],
+ packageDir: string,
+): string[] {
+ const offsets = executedOffsets(script);
+ if (offsets.length === 0) return [];
+ if (regions.length === 0) return [scriptFile];
+ const files = new Set<string>();
+ for (const offset of offsets) {
+ const region = regionAt(regions, offset);
+ if (region !== undefined && region.path !== '') files.add(join(packageDir, region.path));
+ }
+ return [...files];
+}
diff --git a/packages/app/src/build/e2e-coverage-plugin.test.ts b/packages/app/src/build/e2e-coverage-plugin.test.ts
new file mode 100644
index 000000000..bb522e816
--- /dev/null
+++ b/packages/app/src/build/e2e-coverage-plugin.test.ts
@@ -0,0 +1,163 @@
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+import type { ServerResponse } from 'node:http';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import type { Connect } from 'vite';
+import { afterEach, describe, expect, test } from 'vitest';
+import { E2E_COVERAGE_PATH, type ScriptCoverage } from './e2e-coverage-contract';
+import {
+ type CoverageSession,
+ coverageMiddleware,
+ diskScriptSources,
+ inspectorCoverage,
+ processCoverageFiles,
+} from './e2e-coverage-plugin';
+
+const dirs: string[] = [];
+afterEach(() => {
+ for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true });
+});
+
+function fakeRoot(): { okRoot: string; bundle: string; text: string } {
+ const okRoot = realpathSync(mkdtempSync(join(tmpdir(), 'ok-e2e-coverage-plugin-')));
+ dirs.push(okRoot);
+ const pkg = join(okRoot, 'packages', 'server');
+ mkdirSync(join(pkg, 'dist'), { recursive: true });
+ writeFileSync(join(pkg, 'package.json'), '{"name":"fake-server","type":"module"}');
+ const text = [
+ '//#region src/a.ts',
+ 'export function a() { return 1; }',
+ '//#endregion',
+ '//#region src/b.ts',
+ 'export function b() { return 2; }',
+ '//#endregion',
+ '',
+ ].join('\n');
+ const bundle = join(pkg, 'dist', 'index.mjs');
+ writeFileSync(bundle, text);
+ return { okRoot, bundle, text };
+}
+
+function call(
+ middleware: Connect.NextHandleFunction,
+ method: string,
+ url: string,
+): Promise<{ status: number; body: unknown; passed: boolean }> {
+ return new Promise((resolve) => {
+ let status = 0;
+ const response = {
+ set statusCode(code: number) {
+ status = code;
+ },
+ setHeader: () => response,
+ end: (text: string) => resolve({ status, body: JSON.parse(text), passed: false }),
+ } as unknown as ServerResponse;
+ middleware({ method, url } as Connect.IncomingMessage, response, () =>
+ resolve({ status, body: null, passed: true }),
+ );
+ });
+}
+
+describe('server coverage over a bundled dist script', () => {
+ test('an executed function maps through its region to the source file, and dependencies are skipped', () => {
+ const { okRoot, bundle, text } = fakeRoot();
+ const scripts: ScriptCoverage[] = [
+ {
+ url: pathToFileURL(bundle).href,
+ functions: [
+ { functionName: '', ranges: [{ startOffset: 0, endOffset: text.length, count: 1 }] },
+ {
+ functionName: 'b',
+ ranges: [{ startOffset: text.indexOf('export function b'), endOffset: 0, count: 2 }],
+ },
+ ],
+ },
+ {
+ url: pathToFileURL(join(okRoot, 'node_modules', 'dep', 'index.js')).href,
+ functions: [{ functionName: 'x', ranges: [{ startOffset: 5, endOffset: 9, count: 1 }] }],
+ },
+ { url: 'node:internal/fs', functions: [] },
+ ];
+ expect(processCoverageFiles(scripts, okRoot, diskScriptSources())).toEqual([
+ 'packages/server/src/b.ts',
+ ]);
+ });
+
+ test('the in-process inspector reports a function a real module ran', async () => {
+ const { okRoot, bundle } = fakeRoot();
+ const session = inspectorCoverage();
+ await session.takePreciseCoverage();
+ const loaded = (await import(pathToFileURL(bundle).href)) as { a: () => number };
+ expect(loaded.a()).toBe(1);
+ expect(
+ processCoverageFiles(await session.takePreciseCoverage(), okRoot, diskScriptSources()),
+ ).toEqual(['packages/server/src/a.ts']);
+ expect(
+ processCoverageFiles(await session.takePreciseCoverage(), okRoot, diskScriptSources()),
+ ).toEqual([]);
+ });
+});
+
+describe('the coverage endpoint', () => {
+ const session = (scripts: ScriptCoverage[]): CoverageSession & { calls: number } => {
+ const fake = {
+ calls: 0,
+ async takePreciseCoverage() {
+ fake.calls += 1;
+ return scripts;
+ },
+ };
+ return fake;
+ };
+
+ test('reset clears the counters and reports nothing; take reports what ran since', async () => {
+ const { okRoot, bundle, text } = fakeRoot();
+ const ran = session([
+ {
+ url: pathToFileURL(bundle).href,
+ functions: [
+ {
+ functionName: 'a',
+ ranges: [{ startOffset: text.indexOf('export function a'), endOffset: 0, count: 1 }],
+ },
+ ],
+ },
+ ]);
+ const middleware = coverageMiddleware(okRoot, ran, diskScriptSources());
+ expect(await call(middleware, 'POST', `${E2E_COVERAGE_PATH}?op=reset`)).toEqual({
+ status: 200,
+ body: { files: [] },
+ passed: false,
+ });
+ expect(await call(middleware, 'POST', `${E2E_COVERAGE_PATH}?op=take`)).toEqual({
+ status: 200,
+ body: { files: ['packages/server/src/a.ts'] },
+ passed: false,
+ });
+ expect(ran.calls).toBe(2);
+ });
+
+ test('other paths and methods pass through, and an unknown op is refused', async () => {
+ const quiet = session([]);
+ const middleware = coverageMiddleware('/nowhere', quiet, diskScriptSources());
+ expect((await call(middleware, 'GET', `${E2E_COVERAGE_PATH}?op=take`)).passed).toBe(true);
+ expect((await call(middleware, 'POST', '/api/config')).passed).toBe(true);
+ expect(await call(middleware, 'POST', `${E2E_COVERAGE_PATH}?op=dump`)).toMatchObject({
+ status: 400,
+ });
+ expect(quiet.calls).toBe(0);
+ });
+
+ test('a session that fails answers 500 rather than hanging the test', async () => {
+ const failing: CoverageSession = {
+ takePreciseCoverage: () => Promise.reject(new Error('inspector closed')),
+ };
+ const middleware = coverageMiddleware('/nowhere', failing, diskScriptSources());
+ expect(await call(middleware, 'POST', `${E2E_COVERAGE_PATH}?op=take`)).toEqual({
+ status: 500,
+ body: { error: 'inspector closed' },
+ passed: false,
+ });
+ });
+});
diff --git a/packages/app/src/build/e2e-coverage-plugin.ts b/packages/app/src/build/e2e-coverage-plugin.ts
new file mode 100644
index 000000000..803ad52ab
--- /dev/null
+++ b/packages/app/src/build/e2e-coverage-plugin.ts
@@ -0,0 +1,137 @@
+import { existsSync, readFileSync } from 'node:fs';
+import type { ServerResponse } from 'node:http';
+import { Session } from 'node:inspector/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import type { Connect, Plugin } from 'vite';
+import {
+ E2E_COVERAGE_PATH,
+ recordableSource,
+ type ScriptCoverage,
+ type SourceRegion,
+ serverScriptFiles,
+ sourceRegions,
+} from './e2e-coverage-contract';
+
+interface ScriptSource {
+ readonly file: string;
+ readonly packageDir: string;
+ readonly regions: readonly SourceRegion[];
+}
+
+export interface CoverageSession {
+ takePreciseCoverage(): Promise<readonly ScriptCoverage[]>;
+}
+
+function packageDirOf(file: string): string | undefined {
+ let dir = dirname(file);
+ while (dir !== dirname(dir)) {
+ if (existsSync(join(dir, 'package.json'))) return dir;
+ dir = dirname(dir);
+ }
+ return undefined;
+}
+
+export function processCoverageFiles(
+ scripts: readonly ScriptCoverage[],
+ okRoot: string,
+ sourceOf: (url: string) => ScriptSource | undefined,
+): string[] {
+ const files = new Set<string>();
+ for (const script of scripts) {
+ if (!script.url.startsWith('file://') || script.url.includes('/node_modules/')) continue;
+ const source = sourceOf(script.url);
+ if (source === undefined) continue;
+ for (const file of serverScriptFiles(script, source.file, source.regions, source.packageDir)) {
+ const recorded = recordableSource(file, okRoot);
+ if (recorded !== undefined) files.add(recorded);
+ }
+ }
+ return [...files].sort();
+}
+
+export function diskScriptSources(): (url: string) => ScriptSource | undefined {
+ const cache = new Map<string, ScriptSource | undefined>();
+ return (url) => {
+ if (cache.has(url)) return cache.get(url);
+ let source: ScriptSource | undefined;
+ try {
+ const file = fileURLToPath(url);
+ const packageDir = packageDirOf(file);
+ if (packageDir !== undefined) {
+ source = { file, packageDir, regions: sourceRegions(readFileSync(file, 'utf8')) };
+ }
+ } catch {
+ source = undefined;
+ }
+ cache.set(url, source);
+ return source;
+ };
+}
+
+export function inspectorCoverage(): CoverageSession {
+ let started: Promise<Session> | undefined;
+ const start = async (): Promise<Session> => {
+ const session = new Session();
+ session.connect();
+ await session.post('Profiler.enable');
+ await session.post('Profiler.startPreciseCoverage', { callCount: false, detailed: false });
+ return session;
+ };
+ return {
+ async takePreciseCoverage() {
+ started ??= start();
+ const session = await started;
+ const { result } = await session.post('Profiler.takePreciseCoverage');
+ return result;
+ },
+ };
+}
+
+export function coverageMiddleware(
+ okRoot: string,
+ session: CoverageSession,
+ sourceOf: (url: string) => ScriptSource | undefined,
+): Connect.NextHandleFunction {
+ return (request: Connect.IncomingMessage, response: ServerResponse, next) => {
+ const url = new URL(request.url ?? '/', 'http://localhost');
+ if (request.method !== 'POST' || url.pathname !== E2E_COVERAGE_PATH) {
+ next();
+ return;
+ }
+ const op = url.searchParams.get('op');
+ if (op !== 'reset' && op !== 'take') {
+ response.statusCode = 400;
+ response.end(JSON.stringify({ error: `op must be reset or take, not ${op}` }));
+ return;
+ }
+ session.takePreciseCoverage().then(
+ (scripts) => {
+ response.statusCode = 200;
+ response.setHeader('content-type', 'application/json');
+ response.setHeader('cache-control', 'no-store');
+ response.end(
+ JSON.stringify({
+ files: op === 'take' ? processCoverageFiles(scripts, okRoot, sourceOf) : [],
+ }),
+ );
+ },
+ (error: unknown) => {
+ response.statusCode = 500;
+ response.end(
+ JSON.stringify({ error: error instanceof Error ? error.message : String(error) }),
+ );
+ },
+ );
+ };
+}
+
+export function e2eCoveragePlugin(okRoot: string): Plugin {
+ const middleware = coverageMiddleware(okRoot, inspectorCoverage(), diskScriptSources());
+ return {
+ name: 'ok-e2e-coverage',
+ configureServer(server) {
+ server.middlewares.use(middleware);
+ },
+ };
+}
diff --git a/packages/app/tests/stress/_helpers/coverage/e2e-coverage.test.ts b/packages/app/tests/stress/_helpers/coverage/e2e-coverage.test.ts
new file mode 100644
index 000000000..4a74c2a57
--- /dev/null
+++ b/packages/app/tests/stress/_helpers/coverage/e2e-coverage.test.ts
@@ -0,0 +1,61 @@
+import { describe, expect, test } from 'vitest';
+import {
+ browserCoverageFiles,
+ COVERAGE_RECORD_SCHEMA,
+ coverageRecordLine,
+ specPath,
+} from './e2e-coverage.ts';
+
+const OK_ROOT = '/work/My Repo/public/open-knowledge';
+const APP_DIR = `${OK_ROOT}/packages/app`;
+const ran = (url: string, count = 1) => ({
+ url,
+ functions: [
+ { functionName: '', ranges: [{ startOffset: 0, endOffset: 100, count: 1 }] },
+ { functionName: 'f', ranges: [{ startOffset: 10, endOffset: 20, count }] },
+ ],
+});
+
+describe('browser coverage to recorded files', () => {
+ test('scripts whose functions ran map to their source files, once each, sorted', () => {
+ expect(
+ browserCoverageFiles(
+ [
+ ran('http://127.0.0.1:4100/src/main.tsx?t=1'),
+ ran('http://127.0.0.1:4100/src/main.tsx?t=2'),
+ ran(
+ 'http://127.0.0.1:4100/@fs/work/My%20Repo/public/open-knowledge/packages/core/src/index.ts',
+ ),
+ ran('http://127.0.0.1:4100/src/editor/Idle.tsx', 0),
+ ran('http://127.0.0.1:4100/node_modules/.vite/deps/react.js'),
+ ran('http://127.0.0.1:4100/@fs/tmp/ok-w0-vite/deps/yjs.js'),
+ ],
+ APP_DIR,
+ OK_ROOT,
+ ),
+ ).toEqual(['packages/app/src/main.tsx', 'packages/core/src/index.ts']);
+ });
+});
+
+describe('coverage records', () => {
+ test('a spec is named by its path under the Open Knowledge root', () => {
+ expect(specPath(`${APP_DIR}/tests/stress/docs-open.e2e.ts`, OK_ROOT)).toBe(
+ 'packages/app/tests/stress/docs-open.e2e.ts',
+ );
+ });
+
+ test('a record is one JSON line', () => {
+ const line = coverageRecordLine({
+ schema: COVERAGE_RECORD_SCHEMA,
+ spec: 'packages/app/tests/stress/docs-open.e2e.ts',
+ title: 'opens > a doc',
+ retry: 0,
+ status: 'passed',
+ browser: ['packages/app/src/main.tsx'],
+ server: null,
+ });
+ expect(line.endsWith('\n')).toBe(true);
+ expect(line.indexOf('\n')).toBe(line.length - 1);
+ expect(JSON.parse(line)).toMatchObject({ schema: 'ok-e2e-coverage-record/1', server: null });
+ });
+});
diff --git a/packages/app/tests/stress/_helpers/coverage/e2e-coverage.ts b/packages/app/tests/stress/_helpers/coverage/e2e-coverage.ts
new file mode 100644
index 000000000..d54278070
--- /dev/null
+++ b/packages/app/tests/stress/_helpers/coverage/e2e-coverage.ts
@@ -0,0 +1,180 @@
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+import type { Browser, BrowserContext, CDPSession, Page, TestInfo } from '@playwright/test';
+import {
+ browserScriptFile,
+ E2E_COVERAGE_PATH,
+ e2eCoverageDir,
+ executedOffsets,
+ recordableSource,
+ type ScriptCoverage,
+} from '../../../../src/build/e2e-coverage-contract.ts';
+import type { WorkerServer } from '../fixtures.ts';
+import { APP_PACKAGE_ROOT } from '../seed-key.ts';
+
+export const COVERAGE_RECORD_SCHEMA = 'ok-e2e-coverage-record/1';
+const OK_ROOT = join(APP_PACKAGE_ROOT, '..', '..');
+const SERVER_CALL_TIMEOUT_MS = 10_000;
+
+export interface CoverageRecord {
+ readonly schema: typeof COVERAGE_RECORD_SCHEMA;
+ readonly spec: string;
+ readonly title: string;
+ readonly retry: number;
+ readonly status: string;
+ readonly browser: readonly string[];
+ readonly server: readonly string[] | null;
+}
+
+export interface E2eCoverage {
+ watchPage(page: Page): Promise<void>;
+ watchContext(context: BrowserContext): void;
+ collectPage(page: Page): Promise<void>;
+}
+
+export const NO_COVERAGE: E2eCoverage = {
+ watchPage: async () => {},
+ watchContext: () => {},
+ collectPage: async () => {},
+};
+
+export function browserCoverageFiles(
+ scripts: readonly ScriptCoverage[],
+ appDir: string,
+ okRoot: string,
+): string[] {
+ const files = new Set<string>();
+ for (const script of scripts) {
+ if (executedOffsets(script).length === 0) continue;
+ const file = browserScriptFile(script.url, appDir);
+ const recorded = file === undefined ? undefined : recordableSource(file, okRoot);
+ if (recorded !== undefined) files.add(recorded);
+ }
+ return [...files].sort();
+}
+
+export function coverageRecordLine(record: CoverageRecord): string {
+ return `${JSON.stringify(record)}\n`;
+}
+
+export function specPath(testFile: string, okRoot: string = OK_ROOT): string {
+ return relative(okRoot, testFile).split(sep).join('/');
+}
+
+class TestCoverage implements E2eCoverage {
+ readonly browser = new Set<string>();
+ private readonly sessions = new Map<Page, CDPSession>();
+
+ async watchPage(page: Page): Promise<void> {
+ if (this.sessions.has(page) || page.isClosed()) return;
+ try {
+ const session = await page.context().newCDPSession(page);
+ await session.send('Profiler.enable');
+ await session.send('Profiler.startPreciseCoverage', { callCount: false, detailed: false });
+ this.sessions.set(page, session);
+ } catch {
+ return;
+ }
+ const close = page.close.bind(page);
+ page.close = async (options) => {
+ await this.collectPage(page);
+ return close(options);
+ };
+ }
+
+ watchContext(context: BrowserContext): void {
+ context.on('page', (page) => {
+ void this.watchPage(page);
+ });
+ const close = context.close.bind(context);
+ context.close = async (options) => {
+ await this.collectAll(context.pages());
+ return close(options);
+ };
+ }
+
+ async collectPage(page: Page): Promise<void> {
+ const session = this.sessions.get(page);
+ if (session === undefined) return;
+ this.sessions.delete(page);
+ try {
+ const { result } = await session.send('Profiler.takePreciseCoverage');
+ for (const file of browserCoverageFiles(result, APP_PACKAGE_ROOT, OK_ROOT))
+ this.browser.add(file);
+ await session.detach();
+ } catch {
+ return;
+ }
+ }
+
+ async collectAll(pages: readonly Page[] = [...this.sessions.keys()]): Promise<void> {
+ for (const page of pages) await this.collectPage(page);
+ }
+}
+
+async function serverCoverage(baseURL: string, op: 'reset' | 'take'): Promise<string[] | null> {
+ try {
+ const res = await fetch(`${baseURL}${E2E_COVERAGE_PATH}?op=${op}`, {
+ method: 'POST',
+ signal: AbortSignal.timeout(SERVER_CALL_TIMEOUT_MS),
+ });
+ if (!res.ok) return null;
+ const body = (await res.json()) as { files?: unknown };
+ return Array.isArray(body.files)
+ ? body.files.filter((file): file is string => typeof file === 'string')
+ : null;
+ } catch {
+ return null;
+ }
+}
+
+export async function recordingCoverage(
+ { browser, workerServer }: { browser: Browser; workerServer: WorkerServer },
+ use: (coverage: E2eCoverage) => Promise<void>,
+ testInfo: TestInfo,
+): Promise<void> {
+ const dir = e2eCoverageDir(process.env);
+ if (dir === undefined) {
+ await use(NO_COVERAGE);
+ return;
+ }
+ const coverage = new TestCoverage();
+ const newContext = browser.newContext;
+ browser.newContext = async (options) => {
+ const context = await newContext.call(browser, options);
+ coverage.watchContext(context);
+ return context;
+ };
+ const reset = await serverCoverage(workerServer.baseURL, 'reset');
+ try {
+ await use(coverage);
+ } finally {
+ browser.newContext = newContext;
+ await coverage.collectAll();
+ const server = reset === null ? null : await serverCoverage(workerServer.baseURL, 'take');
+ mkdirSync(dir, { recursive: true });
+ appendFileSync(
+ join(dir, `coverage-${process.pid}.jsonl`),
+ coverageRecordLine({
+ schema: COVERAGE_RECORD_SCHEMA,
+ spec: specPath(testInfo.file),
+ title: testInfo.titlePath.slice(1).join(' > '),
+ retry: testInfo.retry,
+ status: testInfo.status ?? 'unknown',
+ browser: [...coverage.browser].sort(),
+ server,
+ }),
+ );
+ }
+}
+
+export async function withoutCoverage(
+ // biome-ignore lint/correctness/noEmptyPattern: Playwright fixture contract
+ {}: object,
+ use: (coverage: E2eCoverage) => Promise<void>,
+): Promise<void> {
+ await use(NO_COVERAGE);
+}
+
+export const coverageFixture =
+ e2eCoverageDir(process.env) === undefined ? withoutCoverage : recordingCoverage;
diff --git a/packages/app/tests/stress/_helpers/fixtures.ts b/packages/app/tests/stress/_helpers/fixtures.ts
index 5f05eea95..4f688d778 100644
--- a/packages/app/tests/stress/_helpers/fixtures.ts
+++ b/packages/app/tests/stress/_helpers/fixtures.ts
@@ -4,6 +4,7 @@ import { join } from 'node:path';
import type { ProblemType } from '@inkeep/open-knowledge-core';
import { test as base } from '@playwright/test';
import { resetContentToFixtureBaseline } from './content-reset.ts';
+import { coverageFixture, type E2eCoverage } from './coverage/e2e-coverage.ts';
import { gotoWhileLoadProgresses, requireDeadlineAt } from './load-progress.ts';
import { type WorkerServing, workerServingFor } from './prebuilt/prebuilt-serving.ts';
import {
@@ -100,6 +101,7 @@ type WorkerFixtures = {
type TestFixtures = {
api: ApiHelpers;
serverLeaseCheck: undefined;
+ e2eCoverage: E2eCoverage;
};
export const WORKER_SERVER_BUDGET_TOTAL_MS = 240_000;
@@ -516,6 +518,13 @@ export const test = base.extend<TestFixtures, WorkerFixtures>({
workerServerEnv: [{}, { scope: 'worker', option: true }],
serverLease: [leaseWorkerServer, { scope: 'worker', timeout: WORKER_SERVER_BUDGET_TOTAL_MS }],
serverLeaseCheck: [checkServerLease, { auto: true }],
+ e2eCoverage: [coverageFixture, { auto: true }],
+ page: async ({ page, e2eCoverage }, use) => {
+ e2eCoverage.watchContext(page.context());
+ await e2eCoverage.watchPage(page);
+ await use(page);
+ await e2eCoverage.collectPage(page);
+ },
workerServer: [
async ({ workerServerEnv, browser, serverLease }, use, workerInfo) => {
if (serverLease?.kind === 'leased') {
diff --git a/packages/app/tsconfig.json b/packages/app/tsconfig.json
index 4794852b0..b54de44f3 100644
--- a/packages/app/tsconfig.json
+++ b/packages/app/tsconfig.json
@@ -94,6 +94,7 @@
"tests/stress/_helpers/boot-verdict",
"tests/stress/_helpers/card-surface.ts",
"tests/stress/_helpers/corner-stack.ts",
+ "tests/stress/_helpers/coverage",
"tests/stress/_helpers/editor-state.ts",
"tests/stress/_helpers/feedback-nudge.ts",
"tests/stress/_helpers/image.ts",
diff --git a/packages/app/vite.config.ts b/packages/app/vite.config.ts
index 764281ae0..5a29d313c 100644
--- a/packages/app/vite.config.ts
+++ b/packages/app/vite.config.ts
@@ -1,8 +1,11 @@
+import { join } from 'node:path';
import babel from '@rolldown/plugin-babel';
import react from '@vitejs/plugin-react';
import { defineConfig } from 'vite';
import { injectAppVersionEnv } from './src/build/app-version';
import { chromeTokensVitePlugin } from './src/build/chrome-tokens-vite-plugin';
+import { e2eCoverageDir } from './src/build/e2e-coverage-contract';
+import { e2eCoveragePlugin } from './src/build/e2e-coverage-plugin';
import { rejectionLoopGuardPlugin } from './src/build/rejection-loop-guard-plugin';
import { testLoopMarkerPlugin } from './src/build/test-loop-marker-plugin';
import { TEST_SERVER_STARTUP_ENV } from './src/build/test-server-startup-contract';
@@ -77,7 +80,13 @@ export default defineConfig({
hocuspocusPlugin(),
...(startupRequest === undefined
? []
- : [testServerStartupPlugin(startupRequest), testLoopMarkerPlugin()]),
+ : [
+ testServerStartupPlugin(startupRequest),
+ testLoopMarkerPlugin(),
+ ...(e2eCoverageDir(process.env) === undefined
+ ? []
+ : [e2eCoveragePlugin(join(import.meta.dirname, '../..'))]),
+ ]),
],
resolve: {
tsconfigPaths: true,
diff --git a/turbo.json b/turbo.json
index 84b5cefc0..939cc9d75 100644
--- a/turbo.json
+++ b/turbo.json
@@ -303,12 +303,12 @@
"test:e2e": {
"dependsOn": ["^build", "build"],
"cache": false,
- "passThroughEnv": ["OK_TEST_E2E_SERVING"]
+ "passThroughEnv": ["OK_TEST_E2E_SERVING", "OK_E2E_COVERAGE_DIR"]
},
"@inkeep/open-knowledge-app#test:e2e": {
"dependsOn": ["^build", "build", "@inkeep/open-knowledge#build"],
"cache": false,
- "passThroughEnv": ["OK_TEST_E2E_SERVING"]
+ "passThroughEnv": ["OK_TEST_E2E_SERVING", "OK_E2E_COVERAGE_DIR"]
},
"test:perf": {
"dependsOn": [],