@remix-run/test 0.0.0 → 0.2.0

package/src/lib/worker-e2e.ts

@@ -0,0 +1,54 @@
+import { workerData, parentPort } from 'node:worker_threads'
+import { runTests } from './executor.ts'
+import { importModule } from './import-module.ts'
+import {
+  getBrowserLauncher,
+  getPlaywrightLaunchOptions,
+  getPlaywrightPageOptions,
+} from './playwright.ts'
+import type { TestResults } from './reporters/results.ts'
+
+try {
+  await importModule(workerData.file, import.meta)
+
+  let launcher = await getBrowserLauncher(workerData.playwrightUseOpts)
+  let opts = getPlaywrightLaunchOptions(workerData.playwrightUseOpts)
+  let browser = await launcher.launch(opts)
+  try {
+    let results = await runTests({
+      browser,
+      open: workerData.open,
+      playwrightPageOptions: getPlaywrightPageOptions(workerData.playwrightUseOpts),
+      coverage: workerData.coverage,
+    })
+    parentPort!.postMessage(results)
+    if (workerData.open) {
+      console.log('\nBrowser is open. Press Ctrl+C to close.')
+      await new Promise<void>((resolve) => browser.on('disconnected', () => resolve()))
+    }
+  } finally {
+    await browser.close()
+  }
+  process.exit(0)
+} catch (e) {
+  let results: TestResults = {
+    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)
+  process.exit(0)
+}

package/src/lib/worker.ts

@@ -0,0 +1,50 @@
+import * as mod from 'node:module'
+import * as path from 'node:path'
+import { parentPort, workerData } from 'node:worker_threads'
+import { runTests } from './executor.ts'
+import { importModule } from './import-module.ts'
+import type { TestResults } from './reporters/results.ts'
+import { IS_BUN } from './runtime.ts'
+import { IS_RUNNING_FROM_SRC } from './config.ts'
+
+try {
+  // 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(workerData.file)
+  } else {
+    await importModule(workerData.file, import.meta)
+  }
+
+  let results = await runTests()
+  parentPort!.postMessage(results)
+  process.exit(0)
+} catch (e) {
+  let results: TestResults = {
+    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)
+  process.exit(0)
+}

package/src/test/coverage/fixture.ts

@@ -0,0 +1,34 @@
+// 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: number, b: number): number {
+  return a + b
+}
+
+// Partially covered — only the `n > 0` branch is tested
+export function classify(n: number): string {
+  if (n > 0) {
+    return 'positive'
+  } else if (n < 0) {
+    return 'negative'
+  } else {
+    return 'zero'
+  }
+}
+
+// Never called — 0% across the board
+export function uncalledFunction(): string {
+  let result = 'never'
+  result += ' reached'
+  return result
+}
+
+// Partially covered — only the truthy `name` branch is tested
+export function greet(name?: string): string {
+  if (name) {
+    return `Hello, ${name}!`
+  }
+  return 'Hello, stranger!'
+}

package/src/test/coverage/test-browser.ts

@@ -0,0 +1,29 @@
+import * as assert from '@remix-run/assert'
+import { describe, it } from '../../lib/framework.ts'
+import { add, classify, greet } from './fixture.ts'
+
+// 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/src/test/coverage/test-e2e.ts

@@ -0,0 +1,70 @@
+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.ts'
+import { transformTypeScript } from '../../lib/ts-transform.ts'
+
+// 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: (request: Request) => Response = (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/src/test/coverage/test-unit.ts

@@ -0,0 +1,32 @@
+import * as assert from '@remix-run/assert'
+import { describe, it } from '../../lib/framework.ts'
+import { add, classify, greet } from './fixture.ts'
+
+// 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/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "lib": ["ES2024", "DOM", "DOM.Iterable"],
+    "types": ["node", "dom-navigation"],
+    "module": "ES2022",
+    "moduleResolution": "Bundler",
+    "target": "ESNext",
+    "allowImportingTsExtensions": true,
+    "rewriteRelativeImportExtensions": true,
+    "verbatimModuleSyntax": true,
+    "skipLibCheck": true,
+    "jsx": "react-jsx",
+    "jsxImportSource": "@remix-run/ui"
+  }
+}