@remix-run/test 0.0.0 → 0.1.0

package/src/lib/reporters/spec.ts

@@ -0,0 +1,173 @@
+import { colors, normalizeLine, type Counts } from '../utils.ts'
+import type { TestResult, TestResults } from '../executor.ts'
+import type { Reporter } from './index.ts'
+
+export class SpecReporter implements Reporter {
+  #failures: { suiteName: string; name: string; error: TestResult['error'] }[] = []
+
+  onSectionStart(label: string) {
+    console.log(label)
+  }
+
+  onResult(results: TestResults, env?: string) {
+    let suiteMap = new Map<string, TestResult[]>()
+    for (let test of results.tests) {
+      let suite = test.suiteName || 'Global'
+      if (!suiteMap.has(suite)) suiteMap.set(suite, [])
+      suiteMap.get(suite)!.push(test)
+    }
+
+    let envLabel = env ? ` ${colors.dim(`[${env}]`)}` : ''
+    let lastParts: string[] = []
+
+    // Pre-compute aggregate test results for each path prefix so non-leaf
+    // suite headings can be colored the same way as leaf headings.
+    let prefixTests = new Map<string, TestResult[]>()
+    for (let [suiteName, tests] of suiteMap) {
+      let parts = suiteName.split(' > ')
+      for (let i = 0; i < parts.length; i++) {
+        let prefix = parts.slice(0, i + 1).join(' > ')
+        if (!prefixTests.has(prefix)) prefixTests.set(prefix, [])
+        prefixTests.get(prefix)!.push(...tests)
+      }
+    }
+
+    for (let [suiteName, suiteTests] of suiteMap) {
+      let parts = suiteName.split(' > ')
+
+      // Find where this path diverges from the last rendered path
+      let commonLen = 0
+      while (
+        commonLen < lastParts.length &&
+        commonLen < parts.length &&
+        lastParts[commonLen] === parts[commonLen]
+      ) {
+        commonLen++
+      }
+
+      // Print each new path component
+      for (let i = commonLen; i < parts.length; i++) {
+        let indent = '  '.repeat(i)
+        let isLeaf = i === parts.length - 1
+
+        if (isLeaf) {
+          let totalDuration = suiteTests.reduce((sum, t) => sum + t.duration, 0)
+          let suiteHasFailed = suiteTests.some((t) => t.status === 'failed')
+          let suiteAllSkipped = suiteTests.every((t) => t.status === 'skipped')
+          let suiteAllTodo = suiteTests.every((t) => t.status === 'todo')
+          let label = suiteHasFailed
+            ? colors.red(parts[i])
+            : suiteAllSkipped
+              ? colors.dim(parts[i])
+              : suiteAllTodo
+                ? colors.yellow(parts[i])
+                : colors.green(parts[i])
+          let suiteComment = suiteAllSkipped
+            ? colors.dim(' # skipped')
+            : suiteAllTodo
+              ? colors.yellow(' # todo')
+              : ''
+          let duration = suiteComment ? '' : ` (${totalDuration.toFixed(2)}ms)`
+          let label2 = envLabel
+          console.log(`${indent}${colors.dim('▶')} ${label}${duration}${suiteComment}${label2}`)
+        } else {
+          let prefix = parts.slice(0, i + 1).join(' > ')
+          let prefixTestList = prefixTests.get(prefix) ?? []
+          let prefixHasFailed = prefixTestList.some((t) => t.status === 'failed')
+          let prefixAllSkipped =
+            prefixTestList.length > 0 && prefixTestList.every((t) => t.status === 'skipped')
+          let prefixAllTodo =
+            prefixTestList.length > 0 && prefixTestList.every((t) => t.status === 'todo')
+          let nameColor = prefixHasFailed
+            ? colors.red
+            : prefixAllSkipped
+              ? colors.dim
+              : prefixAllTodo
+                ? colors.yellow
+                : colors.green
+          let prefixDuration = prefixTestList.reduce((sum, t) => sum + t.duration, 0)
+          let prefixComment = prefixAllSkipped
+            ? colors.dim(' # skipped')
+            : prefixAllTodo
+              ? colors.yellow(' # todo')
+              : ''
+          let prefixDurationStr = prefixComment ? '' : ` (${prefixDuration.toFixed(2)}ms)`
+          console.log(
+            `${indent}${colors.dim('▶')} ${nameColor(parts[i])}${prefixDurationStr}${prefixComment}${envLabel}`,
+          )
+        }
+      }
+
+      lastParts = parts
+
+      // Print tests indented to the suite's depth
+      let testIndent = '  '.repeat(parts.length)
+      for (let test of suiteTests) {
+        if (test.status === 'passed') {
+          console.log(
+            `${testIndent}${colors.green('✓')} ${test.name} (${test.duration.toFixed(2)}ms)`,
+          )
+        } else if (test.status === 'failed') {
+          console.log(
+            `${testIndent}${colors.red('✗')} ${test.name} (${test.duration.toFixed(2)}ms)`,
+          )
+          if (test.error) {
+            console.log(`${testIndent}  ${colors.red(`Error: ${test.error.message}`)}`)
+            if (test.error.stack) {
+              let stack = test.error.stack
+                .split('\n')
+                .map((line) => normalizeLine(line))
+                .join('\n')
+              console.log(
+                `${testIndent}    ${stack.split('\n').slice(1, 5).join(`\n${testIndent}    `)}`,
+              )
+            }
+          }
+          this.#failures.push({ suiteName: test.suiteName, name: test.name, error: test.error })
+        } else if (test.status === 'skipped') {
+          if (test.name)
+            console.log(`${testIndent}${colors.dim('↓')} ${colors.dim(`${test.name} # skipped`)}`)
+        } else if (test.status === 'todo') {
+          if (test.name)
+            console.log(
+              `${testIndent}${colors.yellow('…')} ${colors.yellow(`${test.name} # todo`)}`,
+            )
+        }
+      }
+    }
+  }
+
+  onSummary(counts: Counts, durationMs: number) {
+    if (this.#failures.length > 0) {
+      console.log()
+      console.log(colors.red('Failed tests:'))
+      for (let i = 0; i < this.#failures.length; i++) {
+        let { suiteName, name, error } = this.#failures[i]
+        let fullName = name ? `${suiteName} > ${name}` : suiteName
+        console.log(`\n  ${colors.red(`${i + 1})`)} ${fullName}`)
+        if (error) {
+          console.log(`     ${colors.red(error.message)}`)
+          if (error.stack) {
+            let frames = error.stack
+              .split('\n')
+              .slice(1, 4)
+              .map((l) => `     ${normalizeLine(l).trim()}`)
+              .join('\n')
+            console.log(frames)
+          }
+        }
+      }
+    }
+
+    let { passed, failed, skipped, todo } = counts
+    let info = colors.cyan('ℹ')
+    console.log()
+    console.log(`${info} tests ${passed + failed + skipped + todo}`)
+    console.log(`${info} pass ${passed}`)
+    console.log(`${info} fail ${failed}`)
+    if (skipped > 0) console.log(`${info} skipped ${skipped}`)
+    if (todo > 0) console.log(`${info} todo ${todo}`)
+    console.log(`${info} duration_ms ${durationMs.toFixed(5)}`)
+    console.log()
+  }
+}

package/src/lib/reporters/tap.ts

@@ -0,0 +1,58 @@
+import { normalizeLine, type Counts } from '../utils.ts'
+import type { TestResults } from '../executor.ts'
+import type { Reporter } from './index.ts'
+
+export class TapReporter implements Reporter {
+  #counter = 0
+  #total = 0
+
+  onSectionStart(_label: string) {}
+
+  onResult(results: TestResults, env?: string) {
+    if (this.#counter === 0) {
+      console.log('TAP version 14')
+    }
+
+    let envComment = env ? ` # ${env}` : ''
+
+    for (let test of results.tests) {
+      this.#counter++
+      this.#total++
+      let fullName = test.name
+        ? `${test.suiteName} > ${test.name}${envComment}`
+        : `${test.suiteName}${envComment}`
+
+      if (test.status === 'passed') {
+        console.log(`ok ${this.#counter} - ${fullName}`)
+      } else if (test.status === 'skipped') {
+        console.log(`ok ${this.#counter} - ${fullName} # SKIP`)
+      } else if (test.status === 'todo') {
+        console.log(`ok ${this.#counter} - ${fullName} # TODO`)
+      } else {
+        console.log(`not ok ${this.#counter} - ${fullName}`)
+        console.log('  ---')
+        console.log(`  message: ${test.error?.message ?? 'unknown error'}`)
+        if (test.error?.stack) {
+          let frames = test.error.stack
+            .split('\n')
+            .slice(1, 4)
+            .map((l) => normalizeLine(l).trim())
+            .join('\n    ')
+          console.log(`  stack: |\n    ${frames}`)
+        }
+        console.log('  ...')
+      }
+    }
+  }
+
+  onSummary(counts: Counts, durationMs: number) {
+    let { passed, failed, skipped, todo } = counts
+    console.log(`1..${this.#total}`)
+    console.log(`# tests ${passed + failed + skipped + todo}`)
+    console.log(`# pass ${passed}`)
+    console.log(`# fail ${failed}`)
+    if (skipped > 0) console.log(`# skipped ${skipped}`)
+    if (todo > 0) console.log(`# todo ${todo}`)
+    console.log(`# duration_ms ${durationMs.toFixed(5)}`)
+  }
+}

package/src/lib/runner.ts

@@ -0,0 +1,137 @@
+import * as path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { Worker } from 'node:worker_threads'
+import type { TestResults } from './executor.ts'
+import { type PlaywrightUseOpts } from './playwright.ts'
+import type { Reporter } from './reporters/index.ts'
+import type { Counts } from './utils.ts'
+
+const ext = path.extname(import.meta.url)
+const workerUrl = new URL(`./worker${ext}`, import.meta.url)
+const workerE2EUrl = new URL(`./worker-e2e${ext}`, import.meta.url)
+
+export async function runServerTests(
+  files: string[],
+  reporter: Reporter,
+  concurrency: number,
+  type: 'server' | 'e2e',
+  options: {
+    open?: boolean
+    playwrightUseOpts?: PlaywrightUseOpts
+    projectName?: string
+  } = {},
+): Promise<Counts> {
+  let counts: Counts = { passed: 0, failed: 0, skipped: 0, todo: 0 }
+  let envLabel = options.projectName ? `${type}:${options.projectName}` : type
+
+  function accumulate(results: TestResults, file: string) {
+    reporter.onResult(
+      { ...results, tests: results.tests.map((t) => ({ ...t, filePath: file })) },
+      envLabel,
+    )
+    counts.passed += results.passed
+    counts.failed += results.failed
+    counts.skipped += results.skipped
+    counts.todo += results.todo
+  }
+
+  if (type === 'e2e') {
+    await runInConcurrentWorkers(
+      files,
+      concurrency,
+      (file) =>
+        runFileInWorker(file, type, (results) => accumulate(results, file), {
+          ...options,
+          playwrightUseOpts: options.playwrightUseOpts,
+        }),
+      () => counts.failed++,
+    )
+  } else {
+    await runInConcurrentWorkers(
+      files,
+      concurrency,
+      (file) => runFileInWorker(file, type, (results) => accumulate(results, file)),
+      () => counts.failed++,
+    )
+  }
+
+  return { ...counts }
+}
+
+async function runInConcurrentWorkers(
+  files: string[],
+  concurrency: number,
+  runFile: (file: string) => Promise<void>,
+  onError: () => void,
+): Promise<void> {
+  let index = 0
+  let active = 0
+
+  await new Promise<void>((resolve) => {
+    function dispatch() {
+      while (active < concurrency && index < files.length) {
+        let file = files[index]
+        index++
+        active++
+
+        runFile(file).then(
+          () => {
+            active--
+            if (index < files.length) {
+              dispatch()
+            } else if (active === 0) {
+              resolve()
+            }
+          },
+          (err) => {
+            console.error(`Error running ${file}:`, err.message)
+            console.error(err)
+            onError()
+            active--
+            if (active === 0 && index >= files.length) resolve()
+            else dispatch()
+          },
+        )
+      }
+
+      if (index >= files.length && active === 0) resolve()
+    }
+
+    dispatch()
+  })
+}
+
+function runFileInWorker(
+  file: string,
+  type: 'server' | 'e2e',
+  onResults: (results: TestResults) => void,
+  options: {
+    open?: boolean
+    playwrightUseOpts?: PlaywrightUseOpts
+  } = {},
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    let worker =
+      type === 'e2e'
+        ? new Worker(workerE2EUrl, {
+            workerData: {
+              file: pathToFileURL(file).href,
+              type,
+              open: options.open,
+              playwrightUseOpts: options.playwrightUseOpts,
+            },
+          })
+        : new Worker(workerUrl, {
+            workerData: {
+              file: pathToFileURL(file).href,
+              type,
+            },
+          })
+    worker.once('message', (msg: TestResults) => onResults(msg))
+    worker.once('error', reject)
+    worker.once('exit', (code) => {
+      if (code !== 0) reject(new Error(`Worker exited with code ${code}`))
+      else resolve()
+    })
+  })
+}

package/src/lib/utils.ts

@@ -0,0 +1,40 @@
+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 =
+    path
+      .replace(/^\/scripts\/@pkg\/([^):]+)/g, (...args) => args[1])
+      .replace(/^\/scripts\/@test\/([^):]+)/g, (...args) => args[1])
+      .replace(/^\/scripts\/([^):]+)/g, (...args) => args[1])
+      .replace(/^\s+/, '  ') + locSuffix
+
+  return path.includes('/@test/') ? `./${normalized}` : normalized
+}
+
+export function normalizeLine(line: string): string {
+  let match = line.match(/ \(.*\)$/)
+  if (match) {
+    let filepath = match[0].slice(2, -1)
+    filepath = filepath.replace(/https?:\/\/localhost:\d+\//g, '/')
+    return line.slice(0, match.index) + ' (' + normalizeFilePath(filepath) + ')'
+  }
+
+  return line
+}

package/src/lib/watcher.ts

@@ -0,0 +1,46 @@
+import * as fs from 'node:fs'
+
+function getFileModTime(file: string): number {
+  try {
+    return fs.statSync(file).mtimeMs
+  } catch {
+    return 0
+  }
+}
+
+export function createWatcher(onChange: (file: string) => void) {
+  let watchers = new Set<fs.FSWatcher>()
+  let fileModTimes = new Map<string, number>()
+
+  function update(files: string[]) {
+    for (let watcher of watchers) {
+      watcher.close()
+    }
+    watchers.clear()
+
+    for (let file of files) {
+      fileModTimes.set(file, getFileModTime(file))
+      watchers.add(
+        fs.watch(file, () => {
+          // macOS FSEvents can fire multiple callbacks per save (e.g. write +
+          // metadata flush). Guard with mtime so only a real content change
+          // triggers a rerun instead of every duplicate event.
+          let mtime = getFileModTime(file)
+          if (mtime !== fileModTimes.get(file)) {
+            fileModTimes.set(file, mtime)
+            onChange(file)
+          }
+        }),
+      )
+    }
+  }
+
+  function close() {
+    for (let watcher of watchers) {
+      watcher.close()
+    }
+    watchers.clear()
+  }
+
+  return { update, close }
+}

package/src/lib/worker-e2e.ts

@@ -0,0 +1,52 @@
+import { workerData, parentPort } from 'node:worker_threads'
+import { tsImport } from 'tsx/esm/api'
+import { createServer } from './e2e-server.ts'
+import { runTests, type TestResults } from './executor.ts'
+import {
+  getBrowserLauncher,
+  getPlaywrightLaunchOptions,
+  getPlaywrightPageOptions,
+} from './playwright.ts'
+
+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<void>((resolve) => browser.on('disconnected', () => resolve()))
+    }
+  } finally {
+    await browser.close()
+  }
+} 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)
+}

package/src/lib/worker.ts

@@ -0,0 +1,30 @@
+import { workerData, parentPort } from 'node:worker_threads'
+import { tsImport } from 'tsx/esm/api'
+import { runTests, type TestResults } from './executor.ts'
+
+try {
+  await tsImport(workerData.file, import.meta.url)
+
+  let results = await runTests()
+  parentPort!.postMessage(results)
+} 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)
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "lib": ["ES2024", "DOM", "DOM.Iterable"],
+    "module": "ES2022",
+    "moduleResolution": "Bundler",
+    "target": "ESNext",
+    "allowImportingTsExtensions": true,
+    "rewriteRelativeImportExtensions": true,
+    "verbatimModuleSyntax": true,
+    "jsx": "react-jsx",
+    "jsxImportSource": "@remix-run/component"
+  }
+}