@remix-run/test 0.1.0 → 0.3.0

package/dist/lib/worker-e2e-file.js

@@ -0,0 +1,69 @@
+import { runTests } from "./executor.js";
+import { importModule } from "./import-module.js";
+import { getBrowserLauncher, getPlaywrightLaunchOptions, getPlaywrightPageOptions, } from "./playwright.js";
+import { createFailedResults } from "./worker-results.js";
+import { isRecord, parseCoverageConfig } from "./worker-server.js";
+export async function runE2ETestFile(value, onOpenResults) {
+    try {
+        let workerData = parseE2ETestWorkerData(value);
+        await importModule(workerData.file, import.meta);
+        let launcher = await getBrowserLauncher(workerData.playwrightUseOpts);
+        let opts = getPlaywrightLaunchOptions(workerData.playwrightUseOpts);
+        let browser = await launcher.launch(opts);
+        let browserClosed = false;
+        try {
+            let results = await runTests({
+                browser,
+                open: workerData.open ?? false,
+                playwrightPageOptions: getPlaywrightPageOptions(workerData.playwrightUseOpts),
+                coverage: !!workerData.coverage,
+            });
+            if (workerData.open) {
+                await onOpenResults?.(results);
+                console.log('\nBrowser is open. Press Ctrl+C to close.');
+                await new Promise((resolve) => browser.on('disconnected', () => resolve()));
+                return undefined;
+            }
+            await browser.close();
+            browserClosed = true;
+            return results;
+        }
+        finally {
+            if (!browserClosed) {
+                await browser.close();
+            }
+        }
+    }
+    catch (error) {
+        return createFailedResults(error);
+    }
+}
+function parseE2ETestWorkerData(value) {
+    if (!isRecord(value) || typeof value.file !== 'string') {
+        throw new Error('Invalid E2E test worker data');
+    }
+    return {
+        file: value.file,
+        coverage: parseCoverageConfig(value.coverage),
+        open: parseBoolean(value.open, 'open'),
+        playwrightUseOpts: parsePlaywrightUseOpts(value.playwrightUseOpts),
+    };
+}
+function parseBoolean(value, name) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'boolean') {
+        throw new Error(`Invalid E2E test worker ${name}`);
+    }
+    return value;
+}
+function parsePlaywrightUseOpts(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!isRecord(value)) {
+        throw new Error('Invalid E2E test worker playwright options');
+    }
+    return value;
+}

package/dist/lib/worker-e2e.js

@@ -1,48 +1,13 @@
-import { workerData, parentPort } from 'node:worker_threads';
-import { tsImport } from 'tsx/esm/api';
-import { createServer } from "./e2e-server.js";
-import { runTests } from "./executor.js";
-import { getBrowserLauncher, getPlaywrightLaunchOptions, getPlaywrightPageOptions, } from "./playwright.js";
-try {
-    await tsImport(workerData.file, import.meta.url);
-    let launcher = await getBrowserLauncher(workerData.playwrightUseOpts);
-    let opts = getPlaywrightLaunchOptions(workerData.playwrightUseOpts);
-    let browser = await launcher.launch(opts);
-    try {
-        let results = await runTests({
-            browser,
-            createServer,
-            open: workerData.open,
-            playwrightPageOptions: getPlaywrightPageOptions(workerData.playwrightUseOpts),
-        });
-        parentPort.postMessage(results);
-        if (workerData.open) {
-            console.log('\nBrowser is open. Press Ctrl+C to close.');
-            await new Promise((resolve) => browser.on('disconnected', () => resolve()));
-        }
-    }
-    finally {
-        await browser.close();
-    }
+import { parentPort, workerData } from 'node:worker_threads';
+import { runE2ETestFile } from "./worker-e2e-file.js";
+if (!parentPort) {
+    throw new Error('E2E test worker is missing a parent port');
 }
-catch (e) {
-    let results = {
-        passed: 0,
-        failed: 1,
-        skipped: 0,
-        todo: 0,
-        tests: [
-            {
-                name: '',
-                suiteName: '',
-                status: 'failed',
-                duration: 0,
-                error: {
-                    message: e instanceof Error ? e.message : String(e),
-                    stack: e instanceof Error ? e.stack : undefined,
-                },
-            },
-        ],
-    };
-    parentPort.postMessage(results);
+const port = parentPort;
+const results = await runE2ETestFile(workerData, (openResults) => {
+    port.postMessage(openResults);
+});
+if (results) {
+    port.postMessage(results);
 }
+process.exit(0);

package/dist/lib/worker-process.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=worker-process.d.ts.map

package/dist/lib/worker-process.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-process.d.ts","sourceRoot":"","sources":["../../src/lib/worker-process.ts"],"names":[],"mappings":""}

package/dist/lib/worker-process.js

@@ -0,0 +1,55 @@
+import { runE2ETestFile } from "./worker-e2e-file.js";
+import { runServerTestFile } from "./worker-server.js";
+import { createFailedResults } from "./worker-results.js";
+const workerData = await readWorkerData();
+const results = await runWorkerProcessFile(workerData);
+if (results) {
+    await sendResults(results);
+}
+if (process.connected) {
+    process.disconnect();
+}
+process.exitCode = 0;
+function readWorkerData() {
+    return new Promise((resolve, reject) => {
+        function cleanup() {
+            process.off('message', onMessage);
+            process.off('disconnect', onDisconnect);
+        }
+        function onMessage(value) {
+            cleanup();
+            resolve(value);
+        }
+        function onDisconnect() {
+            cleanup();
+            reject(new Error('Test worker process disconnected'));
+        }
+        process.once('message', onMessage);
+        process.once('disconnect', onDisconnect);
+    });
+}
+async function runWorkerProcessFile(value) {
+    try {
+        if (!isRecord(value) || (value.type !== 'server' && value.type !== 'e2e')) {
+            throw new Error('Invalid test worker process data');
+        }
+        return value.type === 'e2e'
+            ? await runE2ETestFile(value, sendResults)
+            : await runServerTestFile(value);
+    }
+    catch (error) {
+        return createFailedResults(error);
+    }
+}
+async function sendResults(results) {
+    if (!process.send) {
+        throw new Error('Test worker process is missing an IPC channel');
+    }
+    let send = process.send.bind(process);
+    await new Promise((resolve, reject) => {
+        send(results, undefined, undefined, (error) => (error ? reject(error) : resolve()));
+    });
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}

package/dist/lib/worker-results.d.ts

@@ -0,0 +1,3 @@
+import type { TestResults } from './reporters/results.ts';
+export declare function createFailedResults(error: unknown): TestResults;
+//# sourceMappingURL=worker-results.d.ts.map

package/dist/lib/worker-results.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-results.d.ts","sourceRoot":"","sources":["../../src/lib/worker-results.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAEzD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,CAmB/D"}

package/dist/lib/worker-results.js

@@ -0,0 +1,20 @@
+export function createFailedResults(error) {
+    return {
+        passed: 0,
+        failed: 1,
+        skipped: 0,
+        todo: 0,
+        tests: [
+            {
+                name: '',
+                suiteName: '',
+                status: 'failed',
+                duration: 0,
+                error: {
+                    message: error instanceof Error ? error.message : String(error),
+                    stack: error instanceof Error ? error.stack : undefined,
+                },
+            },
+        ],
+    };
+}

package/dist/lib/worker-server.d.ts

@@ -0,0 +1,10 @@
+import type { CoverageConfig } from './coverage.ts';
+import type { TestResults } from './reporters/results.ts';
+export interface ServerTestWorkerData {
+    file: string;
+    coverage?: CoverageConfig;
+}
+export declare function runServerTestFile(value: unknown): Promise<TestResults>;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function parseCoverageConfig(value: unknown): CoverageConfig | undefined;
+//# sourceMappingURL=worker-server.d.ts.map

package/dist/lib/worker-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-server.d.ts","sourceRoot":"","sources":["../../src/lib/worker-server.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAKzD,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,cAAc,CAAA;CAC1B;AAED,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,WAAW,CAAC,CAiC5E;AAaD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,GAAG,SAAS,CA2B9E"}

package/dist/lib/worker-server.js

@@ -0,0 +1,113 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import * as mod from 'node:module';
+import { IS_RUNNING_FROM_SRC } from "./config.js";
+import { importModule } from "./import-module.js";
+import { runTests } from "./executor.js";
+import { IS_BUN } from "./runtime.js";
+import { createFailedResults } from "./worker-results.js";
+export async function runServerTestFile(value) {
+    let workerData;
+    try {
+        workerData = parseServerTestWorkerData(value);
+        // When coverage is enabled in Node, we use a coverage-friendly TypeScript loader which
+        // replaces tsx's minified transformation with a non-minified esbuild transform
+        // so V8 coverage byte offsets align with readable source lines. This hook runs
+        // before the inherited tsx hook (hooks are LIFO), so it intercepts .ts imports and
+        // short-circuits before tsx transforms them.
+        if (workerData.coverage && !IS_BUN) {
+            // Ensure we load the right file whether we're running in the monorepo (TS) or
+            // from a published package (JS)
+            let ext = IS_RUNNING_FROM_SRC ? '.ts' : '.js';
+            mod.register(new URL(`./coverage-loader${ext}`, import.meta.url), import.meta.url);
+            await import(__rewriteRelativeImportExtension(workerData.file));
+        }
+        else {
+            await importModule(workerData.file, import.meta);
+        }
+        let results = await runTests();
+        await takeCoverage(workerData.coverage);
+        return results;
+    }
+    catch (e) {
+        try {
+            await takeCoverage(workerData?.coverage);
+        }
+        catch (coverageError) {
+            e = coverageError;
+        }
+        return createFailedResults(e);
+    }
+}
+function parseServerTestWorkerData(value) {
+    if (!isRecord(value) || typeof value.file !== 'string') {
+        throw new Error('Invalid server test worker data');
+    }
+    return {
+        file: value.file,
+        coverage: parseCoverageConfig(value.coverage),
+    };
+}
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+export function parseCoverageConfig(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!isRecord(value) || typeof value.dir !== 'string') {
+        throw new Error('Invalid server test worker coverage config');
+    }
+    let coverage = {
+        dir: value.dir,
+    };
+    let include = parseStringArray(value.include, 'include');
+    let exclude = parseStringArray(value.exclude, 'exclude');
+    let statements = parseNumber(value.statements, 'statements');
+    let lines = parseNumber(value.lines, 'lines');
+    let branches = parseNumber(value.branches, 'branches');
+    let functions = parseNumber(value.functions, 'functions');
+    if (include)
+        coverage.include = include;
+    if (exclude)
+        coverage.exclude = exclude;
+    if (statements !== undefined)
+        coverage.statements = statements;
+    if (lines !== undefined)
+        coverage.lines = lines;
+    if (branches !== undefined)
+        coverage.branches = branches;
+    if (functions !== undefined)
+        coverage.functions = functions;
+    return coverage;
+}
+function parseStringArray(value, name) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(value) || value.some((item) => typeof item !== 'string')) {
+        throw new Error(`Invalid server test worker coverage ${name}`);
+    }
+    return value;
+}
+function parseNumber(value, name) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'number') {
+        throw new Error(`Invalid server test worker coverage ${name}`);
+    }
+    return value;
+}
+async function takeCoverage(coverage) {
+    if (coverage && !IS_BUN) {
+        let v8 = await import('node:v8');
+        v8.takeCoverage();
+    }
+}

package/dist/lib/worker.js

@@ -1,29 +1,8 @@
-import { workerData, parentPort } from 'node:worker_threads';
-import { tsImport } from 'tsx/esm/api';
-import { runTests } from "./executor.js";
-try {
-    await tsImport(workerData.file, import.meta.url);
-    let results = await runTests();
-    parentPort.postMessage(results);
-}
-catch (e) {
-    let results = {
-        passed: 0,
-        failed: 1,
-        skipped: 0,
-        todo: 0,
-        tests: [
-            {
-                name: '',
-                suiteName: '',
-                status: 'failed',
-                duration: 0,
-                error: {
-                    message: e instanceof Error ? e.message : String(e),
-                    stack: e instanceof Error ? e.stack : undefined,
-                },
-            },
-        ],
-    };
-    parentPort.postMessage(results);
+import { parentPort, workerData } from 'node:worker_threads';
+import { runServerTestFile } from "./worker-server.js";
+if (!parentPort) {
+    throw new Error('Server test worker is missing a parent port');
 }
+const results = await runServerTestFile(workerData);
+parentPort.postMessage(results);
+process.exit(0);

package/dist/test/coverage/fixture.d.ts

@@ -0,0 +1,5 @@
+export declare function add(a: number, b: number): number;
+export declare function classify(n: number): string;
+export declare function uncalledFunction(): string;
+export declare function greet(name?: string): string;
+//# sourceMappingURL=fixture.d.ts.map

package/dist/test/coverage/fixture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixture.d.ts","sourceRoot":"","sources":["../../../src/test/coverage/fixture.ts"],"names":[],"mappings":"AAKA,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAEhD;AAGD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAQ1C;AAGD,wBAAgB,gBAAgB,IAAI,MAAM,CAIzC;AAGD,wBAAgB,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAK3C"}

package/dist/test/coverage/fixture.js

@@ -0,0 +1,32 @@
+// This file exists solely to validate coverage accuracy.
+// Each function has a known expected coverage profile based on
+// which paths the associated tests exercise.
+// Fully covered — both statements and the single branch
+export function add(a, b) {
+    return a + b;
+}
+// Partially covered — only the `n > 0` branch is tested
+export function classify(n) {
+    if (n > 0) {
+        return 'positive';
+    }
+    else if (n < 0) {
+        return 'negative';
+    }
+    else {
+        return 'zero';
+    }
+}
+// Never called — 0% across the board
+export function uncalledFunction() {
+    let result = 'never';
+    result += ' reached';
+    return result;
+}
+// Partially covered — only the truthy `name` branch is tested
+export function greet(name) {
+    if (name) {
+        return `Hello, ${name}!`;
+    }
+    return 'Hello, stranger!';
+}

package/dist/test/coverage/test-browser.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=test-browser.d.ts.map

package/dist/test/coverage/test-browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-browser.d.ts","sourceRoot":"","sources":["../../../src/test/coverage/test-browser.ts"],"names":[],"mappings":""}

package/dist/test/coverage/test-browser.js

@@ -0,0 +1,24 @@
+import * as assert from '@remix-run/assert';
+import { describe, it } from "../../lib/framework.js";
+import { add, classify, greet } from "./fixture.js";
+// Expected coverage for coverage-fixture.ts (same as the server/e2e fixture
+// tests):
+//
+//   add             — 100% functions, statements, lines, branches
+//   classify        — function covered, but only the `n > 0` branch is hit
+//                     (the `n < 0` and `else` branches are uncovered)
+//   uncalledFunction — 0% across the board (never imported)
+//   greet           — function covered, but only the truthy `name` branch is hit
+//                     (the fallback `Hello, stranger!` line is uncovered)
+describe('browser coverage fixture', () => {
+    it('exercises some but not all code paths in the browser', () => {
+        assert.equal(add(2, 3), 5);
+        assert.equal(add(-1, 1), 0);
+        assert.equal(classify(42), 'positive');
+        assert.equal(classify(1), 'positive');
+        // deliberately NOT testing classify(-1) or classify(0)
+        assert.equal(greet('World'), 'Hello, World!');
+        // deliberately NOT testing greet() without an argument
+        // deliberately NOT importing or calling uncalledFunction
+    });
+});

package/dist/test/coverage/test-e2e.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=test-e2e.d.ts.map

package/dist/test/coverage/test-e2e.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-e2e.d.ts","sourceRoot":"","sources":["../../../src/test/coverage/test-e2e.ts"],"names":[],"mappings":""}

package/dist/test/coverage/test-e2e.js

@@ -0,0 +1,60 @@
+import * as assert from '@remix-run/assert';
+import { createTestServer } from '@remix-run/node-fetch-server/test';
+import * as fsp from 'node:fs/promises';
+import * as path from 'node:path';
+import { describe, it } from "../../lib/framework.js";
+import { transformTypeScript } from "../../lib/ts-transform.js";
+// Expected coverage for coverage/fixture.ts (same as the server fixture test):
+//
+//   add             — 100% functions, statements, lines, branches
+//   classify        — function covered, but only the `n > 0` branch is hit
+//   uncalledFunction — 0% across the board (never called)
+//   greet           — function covered, but only the truthy `name` branch is hit
+describe('e2e coverage fixture', () => {
+    it('exercises some but not all code paths in the browser', async (t) => {
+        // Compile the fixture TypeScript to browser-ready JS
+        let fixturePath = path.resolve(import.meta.dirname, './fixture.ts');
+        let fixtureSource = await fsp.readFile(fixturePath, 'utf-8');
+        let { code: fixtureJs } = await transformTypeScript(fixtureSource, fixturePath);
+        let handler = (req) => {
+            let url = new URL(req.url);
+            if (url.pathname === '/') {
+                return new Response([
+                    `<!doctype html>`,
+                    `<html>`,
+                    `<body>`,
+                    `  <div id="result"></div>`,
+                    `  <script type="module">`,
+                    `    import { add, classify, greet } from '/src/test/coverage/fixture.ts'`,
+                    `    // Exercise the same paths as the server fixture test:`,
+                    `    // - add: fully covered`,
+                    `    // - classify: only positive branch`,
+                    `    // - greet: only with a name`,
+                    `    // - uncalledFunction: never imported`,
+                    `    let results = [`,
+                    `      add(2, 3),`,
+                    `      add(-1, 1),`,
+                    `      classify(42),`,
+                    `      classify(1),`,
+                    `      greet('World'),`,
+                    `    ]`,
+                    `    document.getElementById('result').textContent = results.join(',')`,
+                    `  </script>`,
+                    `</body>`,
+                    `</html>`,
+                ].join('\n'), { headers: { 'Content-Type': 'text/html' } });
+            }
+            // Serve the compiled fixture at the path the import expects
+            if (url.pathname === '/src/test/coverage/fixture.ts') {
+                return new Response(fixtureJs, {
+                    headers: { 'Content-Type': 'application/javascript' },
+                });
+            }
+            return new Response('Not found', { status: 404 });
+        };
+        let page = await t.serve(await createTestServer(handler));
+        await page.goto('/');
+        let result = await page.locator('#result').textContent();
+        assert.equal(result, '5,0,positive,positive,Hello, World!');
+    });
+});

package/dist/test/coverage/test-unit.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=test-unit.d.ts.map

package/dist/test/coverage/test-unit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-unit.d.ts","sourceRoot":"","sources":["../../../src/test/coverage/test-unit.ts"],"names":[],"mappings":""}

package/dist/test/coverage/test-unit.js

@@ -0,0 +1,27 @@
+import * as assert from '@remix-run/assert';
+import { describe, it } from "../../lib/framework.js";
+import { add, classify, greet } from "./fixture.js";
+// Expected coverage for coverage-fixture.ts:
+//
+//   add             — 100% functions, statements, lines, branches
+//   classify        — function covered, but only the `n > 0` branch is hit
+//                     (the `n < 0` and `else` branches are uncovered)
+//   uncalledFunction — 0% across the board (never imported)
+//   greet           — function covered, but only the truthy `name` branch is hit
+//                     (the fallback `Hello, stranger!` line is uncovered)
+describe('coverage/fixture.ts', () => {
+    it('add returns the sum', () => {
+        assert.equal(add(2, 3), 5);
+        assert.equal(add(-1, 1), 0);
+    });
+    it('classify identifies positive numbers only', () => {
+        assert.equal(classify(42), 'positive');
+        assert.equal(classify(1), 'positive');
+        // deliberately NOT testing classify(-1) or classify(0)
+    });
+    // deliberately NOT importing or calling uncalledFunction
+    it('greet with a name only', () => {
+        assert.equal(greet('World'), 'Hello, World!');
+        // deliberately NOT testing greet() without an argument
+    });
+});

package/dist/test/framework.test.browser.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=framework.test.browser.d.ts.map

package/dist/test/framework.test.browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"framework.test.browser.d.ts","sourceRoot":"","sources":["../../src/test/framework.test.browser.tsx"],"names":[],"mappings":""}