@remix-run/test 0.2.0 → 0.3.0

package/src/lib/worker-process.ts

@@ -0,0 +1,69 @@
+import { runE2ETestFile } from './worker-e2e-file.ts'
+import type { TestResults } from './reporters/results.ts'
+import { runServerTestFile } from './worker-server.ts'
+import { createFailedResults } from './worker-results.ts'
+
+const workerData = await readWorkerData()
+
+const results = await runWorkerProcessFile(workerData)
+
+if (results) {
+  await sendResults(results)
+}
+
+if (process.connected) {
+  process.disconnect()
+}
+
+process.exitCode = 0
+
+function readWorkerData(): Promise<unknown> {
+  return new Promise((resolve, reject) => {
+    function cleanup() {
+      process.off('message', onMessage)
+      process.off('disconnect', onDisconnect)
+    }
+
+    function onMessage(value: unknown) {
+      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: unknown): Promise<TestResults | undefined> {
+  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: TestResults): Promise<void> {
+  if (!process.send) {
+    throw new Error('Test worker process is missing an IPC channel')
+  }
+
+  let send = process.send.bind(process)
+  await new Promise<void>((resolve, reject) => {
+    send(results, undefined, undefined, (error) => (error ? reject(error) : resolve()))
+  })
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null
+}

package/src/lib/worker-results.ts

@@ -0,0 +1,22 @@
+import type { TestResults } from './reporters/results.ts'
+
+export function createFailedResults(error: unknown): TestResults {
+  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/src/lib/worker-server.ts

@@ -0,0 +1,123 @@
+import * as mod from 'node:module'
+import { IS_RUNNING_FROM_SRC } from './config.ts'
+import { importModule } from './import-module.ts'
+import type { CoverageConfig } from './coverage.ts'
+import type { TestResults } from './reporters/results.ts'
+import { runTests } from './executor.ts'
+import { IS_BUN } from './runtime.ts'
+import { createFailedResults } from './worker-results.ts'
+
+export interface ServerTestWorkerData {
+  file: string
+  coverage?: CoverageConfig
+}
+
+export async function runServerTestFile(value: unknown): Promise<TestResults> {
+  let workerData: ServerTestWorkerData | undefined
+
+  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(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: unknown): ServerTestWorkerData {
+  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: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null
+}
+
+export function parseCoverageConfig(value: unknown): CoverageConfig | undefined {
+  if (value === undefined) {
+    return undefined
+  }
+
+  if (!isRecord(value) || typeof value.dir !== 'string') {
+    throw new Error('Invalid server test worker coverage config')
+  }
+
+  let coverage: CoverageConfig = {
+    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: unknown, name: string): string[] | undefined {
+  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: unknown, name: string): number | undefined {
+  if (value === undefined) {
+    return undefined
+  }
+
+  if (typeof value !== 'number') {
+    throw new Error(`Invalid server test worker coverage ${name}`)
+  }
+
+  return value
+}
+
+async function takeCoverage(coverage: CoverageConfig | undefined): Promise<void> {
+  if (coverage && !IS_BUN) {
+    let v8 = await import('node:v8')
+    v8.takeCoverage()
+  }
+}

package/src/lib/worker.ts

@@ -1,50 +1,10 @@
-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'
+import { runServerTestFile } from './worker-server.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)
+if (!parentPort) {
+  throw new Error('Server test worker is missing a parent port')
 }
+
+const results = await runServerTestFile(workerData)
+parentPort.postMessage(results)
+process.exit(0)