@remix-run/test 0.0.0 → 0.2.0

package/dist/lib/coverage.js

@@ -0,0 +1,212 @@
+import * as fsp from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { colors } from "./colors.js";
+import { transformTypeScript } from "./ts-transform.js";
+// Istanbul packages are loaded lazily so that FORCE_COLOR can be set based on
+// the actual TTY state before supports-color caches its detection result.
+let _istanbul;
+function getIstanbul() {
+    if (!_istanbul) {
+        process.env.FORCE_COLOR ??= process.stdout.isTTY ? '1' : '0';
+        let require = createRequire(import.meta.url);
+        _istanbul = {
+            V8ToIstanbul: require('v8-to-istanbul'),
+            createCoverageMap: require('istanbul-lib-coverage').createCoverageMap,
+            createContext: require('istanbul-lib-report')
+                .createContext,
+            reports: require('istanbul-reports'),
+        };
+    }
+    return _istanbul;
+}
+function matchesGlobs(filePath, globs) {
+    return globs.some((glob) => path.matchesGlob(filePath, glob));
+}
+function filterCoverageMap(coverageMap, cwd, config) {
+    let filtered = getIstanbul().createCoverageMap({});
+    for (let filePath of coverageMap.files()) {
+        let relative = path.relative(cwd, filePath);
+        if (config.include && config.include.length > 0) {
+            if (!matchesGlobs(relative, config.include))
+                continue;
+        }
+        if (config.exclude && config.exclude.length > 0) {
+            if (matchesGlobs(relative, config.exclude))
+                continue;
+        }
+        let fc = coverageMap.fileCoverageFor(filePath);
+        filtered.addFileCoverage({ ...fc.toJSON(), path: relative });
+    }
+    return filtered;
+}
+function checkThresholds(coverageMap, config) {
+    let { statements, lines, branches, functions } = config;
+    if (statements === undefined &&
+        lines === undefined &&
+        branches === undefined &&
+        functions === undefined)
+        return true;
+    let summary = coverageMap.getCoverageSummary();
+    let passed = true;
+    if (statements !== undefined) {
+        let pct = summary.statements.pct;
+        if (pct < statements) {
+            console.error(colors.red(`\nError: Coverage threshold not met (statements ${pct.toFixed(2)}% < ${statements}%)`));
+            passed = false;
+        }
+    }
+    if (lines !== undefined) {
+        let pct = summary.lines.pct;
+        if (pct < lines) {
+            console.error(colors.red(`\nError: Coverage threshold not met (lines ${pct.toFixed(2)}% < ${lines}%)`));
+            passed = false;
+        }
+    }
+    if (branches !== undefined) {
+        let pct = summary.branches.pct;
+        if (pct < branches) {
+            console.error(colors.red(`\nError: Coverage threshold not met (branches ${pct.toFixed(2)}% < ${branches}%)`));
+            passed = false;
+        }
+    }
+    if (functions !== undefined) {
+        let pct = summary.functions.pct;
+        if (pct < functions) {
+            console.error(colors.red(`\nError: Coverage threshold not met (functions ${pct.toFixed(2)}% < ${functions}%)`));
+            passed = false;
+        }
+    }
+    return passed;
+}
+async function writeIstanbulReports(coverageMap, cwd, outDir) {
+    await fsp.mkdir(outDir, { recursive: true });
+    let { createContext, reports } = getIstanbul();
+    let ctx = createContext({ coverageMap, dir: outDir });
+    console.log('\nCoverage report:');
+    reports.create('text').execute(ctx);
+    reports.create('lcovonly').execute(ctx);
+    console.log(`\nLCOV coverage written to ${path.relative(cwd, path.join(outDir, 'lcov.info'))}`);
+}
+// Convert a single V8 coverage entry to Istanbul format and merge it into the
+// coverage map.
+//
+// V8 reports byte offsets against the JS bytes it actually instrumented. When
+// the entry already carries that source (Playwright's `coverage.stopJSCoverage`
+// returns it on each entry, including the inline source map), we hand it
+// straight to v8-to-istanbul so the offsets line up exactly. The server path
+// uses Node's `NODE_V8_COVERAGE` JSON, which doesn't include source — there we
+// re-derive by re-running our esbuild transform on the original TS file.
+async function addV8EntryToCoverageMap(coverageMap, filePath, functions, source) {
+    let { V8ToIstanbul } = getIstanbul();
+    let converter = new V8ToIstanbul(filePath, undefined, { source });
+    await converter.load();
+    converter.applyCoverage(functions);
+    coverageMap.merge(converter.toIstanbul());
+    return true;
+}
+function shouldExcludeFromCoverage(filePath, rootDir, testFiles) {
+    return (!filePath.startsWith(rootDir + path.sep) ||
+        filePath.includes(`${path.sep}node_modules${path.sep}`) ||
+        testFiles.has(filePath));
+}
+export async function collectServerCoverageMap(coverageDataDir, cwd, testFiles) {
+    let { createCoverageMap } = getIstanbul();
+    let coverageMap = createCoverageMap({});
+    let converted = 0;
+    let files;
+    try {
+        files = (await fsp.readdir(coverageDataDir)).filter((f) => f.startsWith('coverage-') && f.endsWith('.json'));
+    }
+    catch {
+        return null;
+    }
+    for (let file of files) {
+        let data = JSON.parse(await fsp.readFile(path.join(coverageDataDir, file), 'utf-8'));
+        let scriptCoverages = data.result ?? [];
+        for (let entry of scriptCoverages) {
+            if (!entry.url.startsWith('file://'))
+                continue;
+            let filePath;
+            try {
+                filePath = fileURLToPath(entry.url);
+            }
+            catch {
+                continue;
+            }
+            if (!filePath ||
+                !['.ts', '.tsx'].includes(path.extname(filePath)) ||
+                shouldExcludeFromCoverage(filePath, cwd, testFiles)) {
+                continue;
+            }
+            try {
+                // For server unit tests, we transform the TS with a module loader and V8 tracks
+                // coverage using byte offsets from the transformed JS. Re-transform with the
+                // same `esbuild` call here so offsets align, then pass the result with its
+                // inline source map to v8-to-istanbul.
+                let tsSource = await fsp.readFile(filePath, 'utf-8');
+                let { code } = await transformTypeScript(tsSource, filePath);
+                let success = await addV8EntryToCoverageMap(coverageMap, filePath, entry.functions, code);
+                if (success)
+                    converted++;
+            }
+            catch (e) {
+                // Skip files that can't be converted
+            }
+        }
+    }
+    // Clean up raw V8 coverage JSON files now that we've processed them
+    //await Promise.all(files.map((f) => fsp.rm(path.join(coverageDataDir, f), { force: true })))
+    return converted > 0 ? coverageMap : null;
+}
+export async function collectCoverageMapFromPlaywright(entries, rootDir, testFiles, resolveRelativePath) {
+    let { createCoverageMap } = getIstanbul();
+    let coverageMap = createCoverageMap({});
+    let converted = 0;
+    for (let entry of entries) {
+        let filePath;
+        try {
+            let relativePath = await resolveRelativePath(new URL(entry.url).pathname);
+            if (!relativePath)
+                continue;
+            // Ignore entries outside the root dir, entries in node_modules, and test files
+            filePath = path.resolve(rootDir, relativePath);
+            if (shouldExcludeFromCoverage(filePath, rootDir, testFiles)) {
+                continue;
+            }
+            // Ensure file exists
+            await fsp.access(filePath);
+        }
+        catch {
+            continue;
+        }
+        if (!entry.source) {
+            throw new Error(`Entry for ${entry.url} is missing source, cannot convert coverage. Ensure the browser launched with Playwright's JS coverage enabled.`);
+        }
+        try {
+            let success = await addV8EntryToCoverageMap(coverageMap, filePath, entry.functions, entry.source);
+            if (success)
+                converted++;
+        }
+        catch {
+            // Skip files that can't be converted
+        }
+    }
+    return converted > 0 ? coverageMap : null;
+}
+export async function generateCombinedCoverageReport(maps, cwd, config) {
+    let { createCoverageMap } = getIstanbul();
+    let combined = createCoverageMap({});
+    for (let map of maps) {
+        if (map)
+            combined.merge(map);
+    }
+    if (combined.files().length === 0) {
+        console.log('No coverage data collected.');
+        return true;
+    }
+    let filtered = filterCoverageMap(combined, cwd, config);
+    await writeIstanbulReports(filtered, cwd, config.dir);
+    return checkThresholds(filtered, config);
+}

package/dist/lib/executor.d.ts

@@ -0,0 +1,4 @@
+import { type CreateTestContextOptions } from './context.ts';
+import type { TestResults } from './reporters/results.ts';
+export declare function runTests(options?: Omit<CreateTestContextOptions, 'addE2ECoverageEntries'>): Promise<TestResults>;
+//# sourceMappingURL=executor.d.ts.map

package/dist/lib/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/lib/executor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,wBAAwB,EAAE,MAAM,cAAc,CAAA;AAE/E,OAAO,KAAK,EAAc,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAErE,wBAAsB,QAAQ,CAC5B,OAAO,CAAC,EAAE,IAAI,CAAC,wBAAwB,EAAE,uBAAuB,CAAC,GAChE,OAAO,CAAC,WAAW,CAAC,CA0ItB"}

package/dist/lib/executor.js

@@ -0,0 +1,128 @@
+import { createTestContext } from "./context.js";
+export async function runTests(options) {
+    let suites = globalThis.__testSuites || [];
+    let e2eCoverageEntries = [];
+    let results = {
+        passed: 0,
+        failed: 0,
+        skipped: 0,
+        todo: 0,
+        tests: [],
+    };
+    let hasOnlySuites = suites.some((s) => s.only);
+    for (let suite of suites) {
+        // If any suite uses .only, skip all non-only suites
+        if (hasOnlySuites && !suite.only) {
+            for (let test of suite.tests) {
+                results.tests.push({
+                    name: test.name,
+                    suiteName: suite.name,
+                    status: 'skipped',
+                    duration: 0,
+                });
+                results.skipped++;
+            }
+            continue;
+        }
+        if (suite.skip || suite.todo) {
+            let status = suite.todo ? 'todo' : 'skipped';
+            for (let test of suite.tests) {
+                results.tests.push({ name: test.name, suiteName: suite.name, status, duration: 0 });
+                results[status]++;
+            }
+            // describe.todo('name') with no tests — add placeholder so suite appears in output
+            if (suite.tests.length === 0) {
+                results.tests.push({ name: '', suiteName: suite.name, status, duration: 0 });
+                results[status]++;
+            }
+            continue;
+        }
+        if (suite.beforeAll) {
+            try {
+                await suite.beforeAll();
+            }
+            catch (error) {
+                console.error(`beforeAll failed in suite "${suite.name}":`, error);
+                continue;
+            }
+        }
+        let hasOnlyTests = suite.tests.some((t) => t.only);
+        for (let test of suite.tests) {
+            // If any test uses .only, skip all non-only tests in this suite
+            if (hasOnlyTests && !test.only) {
+                results.tests.push({
+                    name: test.name,
+                    suiteName: suite.name,
+                    status: 'skipped',
+                    duration: 0,
+                });
+                results.skipped++;
+                continue;
+            }
+            if (test.skip || test.todo) {
+                let status = test.todo ? 'todo' : 'skipped';
+                results.tests.push({ name: test.name, suiteName: suite.name, status, duration: 0 });
+                results[status]++;
+                continue;
+            }
+            let startTime = performance.now();
+            let result = {
+                name: test.name,
+                suiteName: suite.name,
+                status: 'passed',
+                duration: 0,
+            };
+            let contextOpts = options
+                ? {
+                    ...options,
+                    addE2ECoverageEntries: (e) => e2eCoverageEntries.push(e),
+                }
+                : undefined;
+            let { testContext, cleanup } = createTestContext(contextOpts);
+            try {
+                if (suite.beforeEach) {
+                    await suite.beforeEach();
+                }
+                await test.fn(testContext);
+                result.status = 'passed';
+                results.passed++;
+            }
+            catch (error) {
+                result.status = 'failed';
+                result.error = {
+                    message: error.message || String(error),
+                    stack: error.stack,
+                };
+                results.failed++;
+            }
+            finally {
+                await cleanup();
+                if (suite.afterEach) {
+                    try {
+                        await suite.afterEach();
+                    }
+                    catch (error) {
+                        console.error('afterEach failed:', error);
+                    }
+                }
+                result.duration = performance.now() - startTime;
+                results.tests.push(result);
+            }
+        }
+        if (suite.afterAll) {
+            try {
+                await suite.afterAll();
+            }
+            catch (error) {
+                console.error(`afterAll failed in suite "${suite.name}":`, error);
+            }
+        }
+    }
+    // Clear suites in-place so the shared framework module is reset
+    // for the next test file (which reuses the same cached module instance)
+    suites.length = 0;
+    if (e2eCoverageEntries.length > 0) {
+        results.e2eBrowserCoverageEntries = e2eCoverageEntries;
+    }
+    return results;
+}

package/dist/lib/fake-timers.d.ts

@@ -0,0 +1,6 @@
+export interface FakeTimers {
+    advance(ms: number): void;
+    restore(): void;
+}
+export declare function createFakeTimers(): FakeTimers;
+//# sourceMappingURL=fake-timers.d.ts.map

package/dist/lib/fake-timers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-timers.d.ts","sourceRoot":"","sources":["../../src/lib/fake-timers.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,UAAU;IACzB,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,OAAO,IAAI,IAAI,CAAA;CAChB;AAED,wBAAgB,gBAAgB,IAAI,UAAU,CAwD7C"}

package/dist/lib/fake-timers.js

@@ -0,0 +1,45 @@
+import { mock } from "./mock.js";
+export function createFakeTimers() {
+    let currentTime = 0;
+    let nextId = 1;
+    let pending = [];
+    function schedule(fn, delay, repeatMs) {
+        let id = nextId++;
+        pending.push({ id, fn, time: currentTime + Math.max(0, delay), repeatMs });
+        return id;
+    }
+    function cancel(id) {
+        pending = pending.filter((t) => t.id !== id);
+    }
+    let setTimeoutMock = mock.method(globalThis, 'setTimeout', ((fn, delay = 0) => schedule(fn, delay)));
+    let clearTimeoutMock = mock.method(globalThis, 'clearTimeout', cancel);
+    let setIntervalMock = mock.method(globalThis, 'setInterval', ((fn, delay = 0) => schedule(fn, delay, Math.max(0, delay))));
+    let clearIntervalMock = mock.method(globalThis, 'clearInterval', cancel);
+    return {
+        advance(ms) {
+            let targetTime = currentTime + ms;
+            while (true) {
+                let next = pending.filter((t) => t.time <= targetTime).sort((a, b) => a.time - b.time)[0];
+                if (!next)
+                    break;
+                currentTime = next.time;
+                pending = pending.filter((t) => t.id !== next.id);
+                // Requeue intervals before running the callback so that calling
+                // clearInterval(id) from inside the callback can cancel the next firing.
+                if (next.repeatMs !== undefined) {
+                    pending.push({ ...next, time: next.time + Math.max(1, next.repeatMs) });
+                }
+                next.fn();
+            }
+            currentTime = targetTime;
+        },
+        restore() {
+            setTimeoutMock.mock.restore?.();
+            clearTimeoutMock.mock.restore?.();
+            setIntervalMock.mock.restore?.();
+            clearIntervalMock.mock.restore?.();
+            pending = [];
+            currentTime = 0;
+        },
+    };
+}

package/dist/lib/framework.d.ts

@@ -0,0 +1,107 @@
+import type { TestContext } from './context.ts';
+/**
+ * Groups related tests into a named suite. Suites can be nested snd will be displayed
+ * as such or joined with ` > ` in reporter output. Lifecycle hooks registered inside
+ * a `describe` block apply only to tests within that block.
+ *
+ * @example
+ * describe('auth', () => {
+ *   it('logs in', async () => { ... })
+ * })
+ *
+ * // Modifiers
+ * describe.skip('skipped suite', () => { ... })
+ * describe.only('focused suite', () => { ... })
+ * describe.todo('planned suite')
+ *
+ * @param name - The suite name shown in reporter output.
+ * @param fn - A function that registers the tests and lifecycle hooks in this suite.
+ */
+export declare const describe: ((name: string, metaOrFn: SuiteMeta | (() => void), fn?: (() => void) | undefined) => void) & {
+    skip: (name: string, fn: () => void) => void;
+    only: (name: string, fn: () => void) => void;
+    todo: (name: string) => void;
+};
+type SuiteMeta = {
+    skip?: boolean;
+    only?: boolean;
+};
+type TestMeta = {
+    skip?: boolean;
+    only?: boolean;
+};
+type TestFn = (t: TestContext) => void | Promise<void>;
+/**
+ * Defines a single test case. The optional `TestContext` argument `t` provides
+ * mock helpers and per-test cleanup registration.
+ *
+ * @example
+ * it('returns 200 for the home route', async () => {
+ *   const res = await router.fetch('/')
+ *   assert.equal(res.status, 200)
+ * })
+ *
+ * // Modifiers
+ * it.skip('not ready yet', () => { ... })
+ * it.only('focused test', () => { ... })
+ * it.todo('coming soon')
+ *
+ * @param name - The test name shown in reporter output.
+ * @param fn - The test body, receiving a {@link TestContext} as its first argument.
+ */
+export declare const it: ((name: string, metaOrFn: TestFn | TestMeta, fn?: TestFn | undefined) => void) & {
+    skip: (name: string, fn?: TestFn | undefined) => void;
+    only: (name: string, fn: TestFn) => void;
+    todo: (name: string) => void;
+};
+/** Alias for {@link describe}. */
+export declare const suite: ((name: string, metaOrFn: SuiteMeta | (() => void), fn?: (() => void) | undefined) => void) & {
+    skip: (name: string, fn: () => void) => void;
+    only: (name: string, fn: () => void) => void;
+    todo: (name: string) => void;
+};
+/** Alias for {@link it}. */
+export declare const test: ((name: string, metaOrFn: TestFn | TestMeta, fn?: TestFn | undefined) => void) & {
+    skip: (name: string, fn?: TestFn | undefined) => void;
+    only: (name: string, fn: TestFn) => void;
+    todo: (name: string) => void;
+};
+/**
+ * Registers a hook that runs before **each** test in the current suite (or
+ * globally if called outside a `describe`). Multiple calls are chained in
+ * registration order.
+ *
+ * @param fn - The setup function to run before each test.
+ */
+export declare function beforeEach(fn: () => void | Promise<void>): void;
+/**
+ * Registers a hook that runs after **each** test in the current suite (or
+ * globally if called outside a `describe`). Multiple calls are chained in
+ * reverse registration order.  To run logic after a singular test, use
+ * `t.after()` from the {@link TestContext}
+ *
+ * @param fn - The teardown function to run after each test.
+ */
+export declare function afterEach(fn: () => void | Promise<void>): void;
+/**
+ * Registers a hook that runs once before **all** tests in the current suite
+ * (or globally if called outside a `describe`). Multiple calls are chained in
+ * registration order.
+ *
+ * @param fn - The setup function to run once before all tests in the suite.
+ */
+export declare function beforeAll(fn: () => void | Promise<void>): void;
+/**
+ * Registers a hook that runs once after **all** tests in the current suite (or
+ * globally if called outside a `describe`). Multiple calls are chained in
+ * reverse registration order.
+ *
+ * @param fn - The teardown function to run once after all tests in the suite.
+ */
+export declare function afterAll(fn: () => void | Promise<void>): void;
+/** Alias for {@link beforeAll} — matches the `node:test` API. */
+export declare const before: typeof beforeAll;
+/** Alias for {@link afterAll} — matches the `node:test` API. */
+export declare const after: typeof afterAll;
+export {};
+//# sourceMappingURL=framework.d.ts.map

package/dist/lib/framework.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"framework.d.ts","sourceRoot":"","sources":["../../src/lib/framework.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAkF/C;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,QAAQ;;;;CAiBpB,CAAA;AAED,KAAK,SAAS,GAAG;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,CAAA;AACnD,KAAK,QAAQ,GAAG;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,CAAA;AAClD,KAAK,MAAM,GAAG,CAAC,CAAC,EAAE,WAAW,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AAUtD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,EAAE;;;;CAiBd,CAAA;AAED,kCAAkC;AAClC,eAAO,MAAM,KAAK;;;;CAAW,CAAA;AAC7B,4BAA4B;AAC5B,eAAO,MAAM,IAAI;;;;CAAK,CAAA;AA2BtB;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,QAGxD;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,QAGvD;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,QAGvD;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,QAGtD;AAED,mEAAiE;AACjE,eAAO,MAAM,MAAM,kBAAY,CAAA;AAC/B,kEAAgE;AAChE,eAAO,MAAM,KAAK,iBAAW,CAAA"}