@remix-run/test 0.1.0 → 0.2.0

package/src/lib/coverage.ts

@@ -0,0 +1,320 @@
+import type { createCoverageMap as CreateCoverageMap } from 'istanbul-lib-coverage'
+import type { createContext as CreateContext } from 'istanbul-lib-report'
+import type IstanbulReports from 'istanbul-reports'
+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.ts'
+import { transformTypeScript } from './ts-transform.ts'
+
+// 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:
+  | {
+      V8ToIstanbul: any
+      createCoverageMap: typeof CreateCoverageMap
+      createContext: typeof CreateContext
+      reports: typeof IstanbulReports
+    }
+  | undefined
+
+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') as { createCoverageMap: typeof CreateCoverageMap }
+      ).createCoverageMap,
+      createContext: (require('istanbul-lib-report') as { createContext: typeof CreateContext })
+        .createContext,
+      reports: require('istanbul-reports') as typeof IstanbulReports,
+    }
+  }
+  return _istanbul
+}
+
+export interface CoverageConfig {
+  dir: string
+  include?: string[]
+  exclude?: string[]
+  statements?: number
+  lines?: number
+  branches?: number
+  functions?: number
+}
+
+export interface V8CoverageEntry {
+  url: string
+  source?: string
+  functions: Array<{
+    functionName: string
+    isBlockCoverage: boolean
+    ranges: Array<{ startOffset: number; endOffset: number; count: number }>
+  }>
+}
+
+export type CoverageMap = ReturnType<typeof CreateCoverageMap>
+
+function matchesGlobs(filePath: string, globs: string[]): boolean {
+  return globs.some((glob) => path.matchesGlob(filePath, glob))
+}
+
+function filterCoverageMap(
+  coverageMap: CoverageMap,
+  cwd: string,
+  config: CoverageConfig,
+): CoverageMap {
+  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) as any
+    filtered.addFileCoverage({ ...fc.toJSON(), path: relative })
+  }
+  return filtered
+}
+
+function checkThresholds(coverageMap: CoverageMap, config: CoverageConfig): boolean {
+  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: CoverageMap, cwd: string, outDir: string) {
+  await fsp.mkdir(outDir, { recursive: true })
+  let { createContext, reports } = getIstanbul()
+  let ctx = createContext({ coverageMap, dir: outDir } as any)
+  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: CoverageMap,
+  filePath: string,
+  functions: V8CoverageEntry['functions'],
+  source: string,
+): Promise<boolean> {
+  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: string,
+  rootDir: string,
+  testFiles: Set<string>,
+): boolean {
+  return (
+    !filePath.startsWith(rootDir + path.sep) ||
+    filePath.includes(`${path.sep}node_modules${path.sep}`) ||
+    testFiles.has(filePath)
+  )
+}
+
+export async function collectServerCoverageMap(
+  coverageDataDir: string,
+  cwd: string,
+  testFiles: Set<string>,
+): Promise<CoverageMap | null> {
+  let { createCoverageMap } = getIstanbul()
+  let coverageMap = createCoverageMap({})
+  let converted = 0
+
+  let files: string[]
+  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: Array<{ url: string; functions: any[] }> = data.result ?? []
+
+    for (let entry of scriptCoverages) {
+      if (!entry.url.startsWith('file://')) continue
+
+      let filePath: string
+      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: V8CoverageEntry[],
+  rootDir: string,
+  testFiles: Set<string>,
+  resolveRelativePath: (url: string) => Promise<string | null>,
+): Promise<CoverageMap | null> {
+  let { createCoverageMap } = getIstanbul()
+  let coverageMap = createCoverageMap({})
+  let converted = 0
+
+  for (let entry of entries) {
+    let filePath: string
+    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: (CoverageMap | null | undefined)[],
+  cwd: string,
+  config: CoverageConfig,
+): Promise<boolean> {
+  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/src/lib/executor.ts

@@ -1,34 +1,12 @@
-import type { Browser, BrowserContextOptions } from 'playwright'
-import { createTestContext } from './context.ts'
-import type { CreateServerFunction } from './e2e-server.ts'
-
-export interface TestResult {
-  name: string
-  suiteName: string
-  filePath?: string
-  status: 'passed' | 'failed' | 'skipped' | 'todo'
-  error?: {
-    message: string
-    stack?: string
-  }
-  duration: number
-}
-
-export interface TestResults {
-  passed: number
-  failed: number
-  skipped: number
-  todo: number
-  tests: TestResult[]
-}
+import { createTestContext, type CreateTestContextOptions } from './context.ts'
+import type { V8CoverageEntry } from './coverage.ts'
+import type { TestResult, TestResults } from './reporters/results.ts'
 
-export async function runTests(options?: {
-  createServer?: CreateServerFunction
-  browser?: Browser
-  open?: boolean
-  playwrightPageOptions?: BrowserContextOptions
-}): Promise<TestResults> {
+export async function runTests(
+  options?: Omit<CreateTestContextOptions, 'addE2ECoverageEntries'>,
+): Promise<TestResults> {
   let suites = (globalThis as any).__testSuites || []
+  let e2eCoverageEntries: Array<{ entries: V8CoverageEntry[]; baseUrl: string }> = []
   let results: TestResults = {
     passed: 0,
     failed: 0,
@@ -107,12 +85,13 @@ export async function runTests(options?: {
         duration: 0,
       }
 
-      let { testContext, cleanup } = createTestContext({
-        createServer: options?.createServer,
-        browser: options?.browser,
-        open: options?.open,
-        playwrightPageOptions: options?.playwrightPageOptions,
-      })
+      let contextOpts: CreateTestContextOptions | undefined = options
+        ? {
+            ...options,
+            addE2ECoverageEntries: (e) => e2eCoverageEntries.push(e),
+          }
+        : undefined
+      let { testContext, cleanup } = createTestContext(contextOpts)
 
       try {
         if (suite.beforeEach) {
@@ -158,5 +137,9 @@ export async function runTests(options?: {
   // 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/src/lib/fake-timers.ts

@@ -0,0 +1,64 @@
+import { mock } from './mock.ts'
+
+export interface FakeTimers {
+  advance(ms: number): void
+  restore(): void
+}
+
+export function createFakeTimers(): FakeTimers {
+  let currentTime = 0
+  let nextId = 1
+  let pending: Array<{ id: number; fn: () => void; time: number; repeatMs?: number }> = []
+
+  function schedule(fn: () => void, delay: number, repeatMs?: number): number {
+    let id = nextId++
+    pending.push({ id, fn, time: currentTime + Math.max(0, delay), repeatMs })
+    return id
+  }
+
+  function cancel(id: number) {
+    pending = pending.filter((t) => t.id !== id)
+  }
+
+  let setTimeoutMock = mock.method(globalThis, 'setTimeout', ((fn: () => void, delay = 0) =>
+    schedule(fn, delay)) as unknown as typeof setTimeout)
+  let clearTimeoutMock = mock.method(
+    globalThis,
+    'clearTimeout',
+    cancel as unknown as typeof clearTimeout,
+  )
+  let setIntervalMock = mock.method(globalThis, 'setInterval', ((fn: () => void, delay = 0) =>
+    schedule(fn, delay, Math.max(0, delay))) as unknown as typeof setInterval)
+  let clearIntervalMock = mock.method(
+    globalThis,
+    'clearInterval',
+    cancel as unknown as typeof clearInterval,
+  )
+
+  return {
+    advance(ms: number) {
+      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/src/lib/import-module.ts

@@ -0,0 +1,29 @@
+import { tsImport } from 'tsx/esm/api'
+import { IS_BUN } from './runtime.ts'
+
+interface ImportMetaWithResolve extends ImportMeta {
+  resolve(specifier: string, parent?: string | URL): string
+}
+
+function hasImportMetaResolve(meta: ImportMeta): meta is ImportMetaWithResolve {
+  return 'resolve' in meta && typeof meta.resolve === 'function'
+}
+
+/*
+ * Loads a module specifier relative to the caller's module context.
+ *
+ * @param specifier The module specifier or file path to load.
+ * @param meta The caller's `import.meta`, used as the context for resolution.
+ * @returns The imported module namespace.
+ */
+export async function importModule(specifier: string, meta: ImportMeta): Promise<any> {
+  if (IS_BUN) {
+    if (!hasImportMetaResolve(meta)) {
+      throw new Error('importModule() requires import.meta.resolve() in Bun')
+    }
+
+    return import(meta.resolve(specifier, meta.url))
+  }
+
+  return tsImport(specifier, meta.url)
+}

package/src/lib/{utils.ts → normalize.ts}

@@ -1,21 +1,3 @@
-export type Counts = {
-  passed: number
-  failed: number
-  skipped: number
-  todo: number
-}
-
-const noColor = process.env.CI === 'true' || !!process.env.NO_COLOR
-
-export const colors = {
-  reset: noColor ? '' : '\x1b[0m',
-  dim: noColor ? (s: string) => s : (s: string) => `\x1b[2m${s}\x1b[0m`,
-  green: noColor ? (s: string) => s : (s: string) => `\x1b[32m${s}\x1b[0m`,
-  red: noColor ? (s: string) => s : (s: string) => `\x1b[31m${s}\x1b[0m`,
-  cyan: noColor ? (s: string) => s : (s: string) => `\x1b[36m${s}\x1b[0m`,
-  yellow: noColor ? (s: string) => s : (s: string) => `\x1b[2m\x1b[33m${s}\x1b[0m`,
-}
-
 function normalizeFilePath(path: string): string {
   let locSuffix = path.match(/(:\d+:\d+)$/)?.[0] || ''
   let normalized =

package/src/lib/playwright.ts

@@ -3,24 +3,22 @@ import * as fs from 'node:fs/promises'
 import { chromium, firefox, webkit } from 'playwright'
 import type { BrowserContextOptions, LaunchOptions } from 'playwright'
 import type { PlaywrightTestConfig } from 'playwright/test'
-import { tsImport } from 'tsx/esm/api'
+import { importModule } from './import-module.ts'
 
 export type PlaywrightUseOpts = PlaywrightTestConfig['use']
 
 export async function loadPlaywrightConfig(
   input: string | undefined,
+  cwd = process.cwd(),
 ): Promise<PlaywrightTestConfig | undefined> {
   let candidates = input
-    ? [path.resolve(process.cwd(), input)]
-    : [
-        path.join(process.cwd(), 'playwright.config.ts'),
-        path.join(process.cwd(), 'playwright.config.js'),
-      ]
+    ? [path.resolve(cwd, input)]
+    : [path.join(cwd, 'playwright.config.ts'), path.join(cwd, 'playwright.config.js')]
 
   for (let configPath of candidates) {
     try {
       await fs.access(configPath)
-      let mod = await tsImport(configPath, { parentURL: import.meta.url })
+      let mod = await importModule(configPath, import.meta)
       return mod.default ?? mod
     } catch {
       // not found or failed to load — try next

package/src/lib/reporters/dot.ts

@@ -1,6 +1,7 @@
-import { colors, normalizeLine, type Counts } from '../utils.ts'
-import type { TestResult, TestResults } from '../executor.ts'
+import { colors } from '../colors.ts'
+import { normalizeLine } from '../normalize.ts'
 import type { Reporter } from './index.ts'
+import type { Counts, TestResult, TestResults } from './results.ts'
 
 export class DotReporter implements Reporter {
   #failures: { name: string; error: TestResult['error'] }[] = []

package/src/lib/reporters/files.ts

@@ -1,7 +1,8 @@
 import * as path from 'node:path'
-import { colors, normalizeLine, type Counts } from '../utils.ts'
-import type { TestResult, TestResults } from '../executor.ts'
+import { colors } from '../colors.ts'
+import { normalizeLine } from '../normalize.ts'
 import type { Reporter } from './index.ts'
+import type { Counts, TestResult, TestResults } from './results.ts'
 
 export class FilesReporter implements Reporter {
   #failures: { suiteName: string; name: string; error: TestResult['error'] }[] = []

package/src/lib/reporters/index.ts

@@ -1,9 +1,8 @@
-import type { Counts } from '../utils.ts'
-import type { TestResults } from '../executor.ts'
-import { SpecReporter } from './spec.ts'
-import { TapReporter } from './tap.ts'
 import { DotReporter } from './dot.ts'
 import { FilesReporter } from './files.ts'
+import type { Counts, TestResults } from './results.ts'
+import { SpecReporter } from './spec.ts'
+import { TapReporter } from './tap.ts'
 
 export interface Reporter {
   onResult(results: TestResults, env?: string): void
@@ -11,7 +10,7 @@ export interface Reporter {
   onSectionStart(label: string): void
 }
 
-export { SpecReporter, TapReporter, DotReporter, FilesReporter }
+export { DotReporter, FilesReporter, SpecReporter, TapReporter }
 
 export function createReporter(type: string): Reporter {
   switch (type) {

package/src/lib/reporters/results.ts

@@ -0,0 +1,29 @@
+import type { V8CoverageEntry } from '../coverage'
+
+export interface TestResult {
+  name: string
+  suiteName: string
+  filePath?: string
+  status: 'passed' | 'failed' | 'skipped' | 'todo'
+  error?: {
+    message: string
+    stack?: string
+  }
+  duration: number
+}
+
+export interface TestResults {
+  passed: number
+  failed: number
+  skipped: number
+  todo: number
+  tests: TestResult[]
+  e2eBrowserCoverageEntries?: Array<{ entries: V8CoverageEntry[]; baseUrl: string }>
+}
+
+export type Counts = {
+  passed: number
+  failed: number
+  skipped: number
+  todo: number
+}

package/src/lib/reporters/spec.ts

@@ -1,6 +1,7 @@
-import { colors, normalizeLine, type Counts } from '../utils.ts'
-import type { TestResult, TestResults } from '../executor.ts'
+import { colors } from '../colors.ts'
+import { normalizeLine } from '../normalize.ts'
 import type { Reporter } from './index.ts'
+import type { Counts, TestResult, TestResults } from './results.ts'
 
 export class SpecReporter implements Reporter {
   #failures: { suiteName: string; name: string; error: TestResult['error'] }[] = []

package/src/lib/reporters/tap.ts

@@ -1,6 +1,6 @@
-import { normalizeLine, type Counts } from '../utils.ts'
-import type { TestResults } from '../executor.ts'
+import { normalizeLine } from '../normalize.ts'
 import type { Reporter } from './index.ts'
+import type { Counts, TestResults } from './results.ts'
 
 export class TapReporter implements Reporter {
   #counter = 0