@rpcbase/test 0.227.0 → 0.229.0

package/README.md

@@ -98,6 +98,13 @@ Whenever coverage is enabled, the wrapper appends the shared reporter so Istanbu
 
 ## 4. Run tests with `rb-test`
 
-Each package keeps its `npm test` script as `tsc --noEmit && rb-test`. The CLI wraps Playwright’s binary, applies the repo defaults, and prints failures cleanly inside the Codex harness.
+Each package uses its `npm test` script as `tsc --noEmit && rb-test`. The CLI runs two stages:
 
-Need to debug without coverage? Set `RB_DISABLE_COVERAGE=1 npm test` and the hooks short-circuit.
+- Playwright, with any CLI flags you pass through untouched; repo defaults are applied unless you provide your own `--config`.
+
+Coverage is enforced separately:
+
+- Playwright uses `spec/coverage.*` via the shared reporter and will fail the run if thresholds aren’t met.
+- Vitest only reads `src/coverage.json` (JSON object). If that file is missing, Vitest coverage is skipped.
+
+Need to debug without coverage? Set `RB_DISABLE_COVERAGE=1 npm test` and the Playwright hooks short-circuit.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpcbase/test",
-  "version": "0.227.0",
+  "version": "0.229.0",
   "type": "module",
   "types": "./index.d.ts",
   "exports": {
@@ -53,7 +53,8 @@
     "istanbul-reports": "3.2.0",
     "lodash": "4.17.21",
     "picomatch": "2.3.1",
-    "v8-to-istanbul": "9.3.0"
+    "v8-to-istanbul": "9.3.0",
+    "vitest": "4.0.15"
   },
   "devDependencies": {
     "mongoose": "8.20.0"

package/src/cli.js

@@ -2,113 +2,129 @@
 
 import { spawn } from "child_process"
 import fs from "fs"
+import fsPromises from "fs/promises"
 import path from "path"
 import { createRequire } from "module"
 import { fileURLToPath } from "url"
 
+import { createCoverageConfig } from "./coverage/config.js"
+import { loadCoverageOptions } from "./coverage/config-loader.js"
+import { removeCoverageFiles } from "./coverage/files.js"
+import { CoverageThresholdError, generateCoverageReport } from "./coverage/report.js"
+
 
 const require = createRequire(import.meta.url)
 const moduleDir = path.dirname(fileURLToPath(import.meta.url))
 
 
+const TEST_GLOB = "{src,lib}/**/*.test.{js,ts,tsx}"
+const VITEST_COVERAGE_CANDIDATES = ["src/coverage.json"]
+
+
 const isAider = process.env.IS_AIDER === "yes"
 
 if (process.env.IS_AIDER !== undefined && process.env.IS_AIDER !== "yes") {
   console.warn("Warning: IS_AIDER is set to a value other than 'yes'.")
 }
 
-function runTests() {
-  return new Promise((resolve, reject) => {
-    const userArgs = process.argv.slice(2)
+async function runTests() {
+  const userArgs = process.argv.slice(2)
 
-    // Determine config file path
-    const configPath = fs.existsSync(
-      path.join(process.cwd(), "playwright.config.ts"),
-    )
-      ? path.join(process.cwd(), "playwright.config.ts")
-      : path.join(moduleDir, "playwright.config.ts")
+  const vitestCoverage = await loadVitestCoverageConfig()
 
-    const hasCustomConfig = userArgs.some((arg) => {
-      if (arg === "--config" || arg === "-c") {
-        return true
-      }
+  if (vitestCoverage?.enabled) {
+    await cleanCoverageArtifacts(vitestCoverage.config)
+  }
 
-      return arg.startsWith("--config=")
-    })
+  let testError = null
 
-    const playwrightArgs = ["test"]
+  try {
+    await runVitest(vitestCoverage)
+    await runPlaywright(userArgs)
+  } catch (error) {
+    testError = error
+  }
 
-    if (!hasCustomConfig) {
-      playwrightArgs.push("--config", configPath)
+  if (vitestCoverage?.enabled) {
+    try {
+      await finalizeCoverage(vitestCoverage.config)
+    } catch (error) {
+      if (!testError) {
+        testError = error
+      }
     }
+  }
 
-    playwrightArgs.push(...userArgs)
+  if (testError) {
+    throw testError
+  }
+}
 
-    const stdoutBuffer = []
-    const stderrBuffer = []
+runTests()
+  .then(() => process.exit(0))
+  .catch(() => process.exit(1))
 
-    ensureJsxRuntimeShim(process.cwd())
-    const launcher = resolvePlaywrightLauncher()
-    const nodeOptions = appendNodeRequire(process.env.NODE_OPTIONS, path.join(moduleDir, "register-tty.cjs"))
-    const env = {
-      ...process.env,
-      NODE_OPTIONS: nodeOptions,
-    }
-    const playwright = spawn(
-      launcher.command,
-      [...launcher.args, ...playwrightArgs],
-      {
-        shell: false,
-        env,
-      },
-    )
+async function runVitest(coverage) {
+  const vitestArgs = ["run", TEST_GLOB, "--passWithNoTests"]
+  const launcher = resolveVitestLauncher()
+  const env = withRegisterShim(process.env)
 
-    playwright.stdout.on("data", (data) => {
-      if (!isAider) {
-        process.stdout.write(data)
-      }
-      stdoutBuffer.push(data.toString())
-    })
+  if (coverage?.enabled) {
+    env.NODE_V8_COVERAGE = coverage.nodeCoverageDir
+  }
 
-    playwright.stderr.on("data", (data) => {
-      if (!isAider) {
-        process.stderr.write(data)
-      }
-      stderrBuffer.push(data.toString())
-    })
+  await spawnWithLogs({
+    name: "Vitest",
+    launcher,
+    args: vitestArgs,
+    env,
+    successMessage: "Vitest suite passed!",
+    failureMessage: "Vitest failed",
+  })
 
-    playwright.on("close", (code) => {
-      if (code === 0) {
-        console.log("All tests passed!")
-        resolve()
-      } else {
-        console.error("Tests failed:")
+  if (coverage?.enabled) {
+    await convertNodeCoverage(coverage)
+  }
+}
 
-        if (isAider) {
-          if (stdoutBuffer.length > 0) {
-            console.error(stdoutBuffer.join(""))
-          }
+function runPlaywright(userArgs) {
+  // Determine config file path
+  const configPath = fs.existsSync(
+    path.join(process.cwd(), "playwright.config.ts"),
+  )
+    ? path.join(process.cwd(), "playwright.config.ts")
+    : path.join(moduleDir, "playwright.config.ts")
+
+  const hasCustomConfig = userArgs.some((arg) => {
+    if (arg === "--config" || arg === "-c") {
+      return true
+    }
 
-          if (stderrBuffer.length > 0) {
-            console.error(stderrBuffer.join(""))
-          }
-        }
+    return arg.startsWith("--config=")
+  })
 
-        reject(new Error(`Tests failed with exit code: ${code}`))
-      }
-    })
+  const playwrightArgs = ["test"]
 
-    playwright.on("error", (error) => {
-      console.error("Error spawning Playwright:", error)
-      reject(error)
-    })
+  if (!hasCustomConfig) {
+    playwrightArgs.push("--config", configPath)
+  }
+
+  playwrightArgs.push(...userArgs)
+
+  ensureJsxRuntimeShim(process.cwd())
+  const launcher = resolvePlaywrightLauncher()
+  const env = withRegisterShim(process.env)
+
+  return spawnWithLogs({
+    name: "Playwright",
+    launcher,
+    args: playwrightArgs,
+    env,
+    successMessage: "Playwright suite passed!",
+    failureMessage: "Playwright failed",
   })
 }
 
-runTests()
-  .then(() => process.exit(0))
-  .catch(() => process.exit(1))
-
 function resolvePlaywrightLauncher() {
   const cliPath = resolveCliPath()
   if (cliPath) {
@@ -150,6 +166,239 @@ function resolveCliPath() {
   return null
 }
 
+function resolveVitestLauncher() {
+  const searchRoots = [process.cwd(), moduleDir]
+
+  for (const base of searchRoots) {
+    try {
+      const pkgPath = require.resolve("vitest/package.json", { paths: [base] })
+      const pkgDir = path.dirname(pkgPath)
+      const pkgJson = JSON.parse(fs.readFileSync(pkgPath, "utf8"))
+      const binPath = typeof pkgJson.bin === "string" ? pkgJson.bin : pkgJson.bin?.vitest
+      if (binPath) {
+        return {
+          command: process.execPath,
+          args: [path.join(pkgDir, binPath)],
+        }
+      }
+    } catch (_error) {
+      // continue searching
+    }
+  }
+
+  const localBin = path.resolve(process.cwd(), "node_modules/.bin/vitest")
+  if (fs.existsSync(localBin)) {
+    return {
+      command: localBin,
+      args: [],
+    }
+  }
+
+  return {
+    command: "vitest",
+    args: [],
+  }
+}
+
+async function loadVitestCoverageConfig() {
+  const options = await loadCoverageOptions({
+    optional: true,
+    candidates: VITEST_COVERAGE_CANDIDATES,
+    defaultTestResultsDir: "test-results-vitest",
+  })
+  if (!options) {
+    return null
+  }
+
+  const config = createCoverageConfig(options)
+
+  return {
+    config,
+    nodeCoverageDir: path.join(config.testResultsRoot, "node-coverage"),
+    enabled: config.coverageEnabled,
+  }
+}
+
+async function cleanCoverageArtifacts(config) {
+  await removeCoverageFiles(config)
+  await fsPromises.rm(config.coverageReportDir, { recursive: true, force: true })
+  await fsPromises.rm(path.join(config.testResultsRoot, "node-coverage"), { recursive: true, force: true })
+}
+
+async function convertNodeCoverage(coverage) {
+  const { config, nodeCoverageDir } = coverage
+
+  const entries = await fsPromises.readdir(nodeCoverageDir).catch(() => [])
+  const scripts = []
+
+  for (const entry of entries) {
+    if (!entry.endsWith(".json")) {
+      continue
+    }
+
+    const fullPath = path.join(nodeCoverageDir, entry)
+    const payload = await readJson(fullPath)
+    const results = Array.isArray(payload?.result) ? payload.result : []
+
+    for (const script of results) {
+      const normalized = normalizeNodeScriptUrl(script.url, config.workspaceRoot)
+      if (!normalized) {
+        continue
+      }
+
+      if (!isInsideLib(normalized.absolutePath, config.libRoots)) {
+        continue
+      }
+
+      const source = await fsPromises.readFile(normalized.absolutePath, "utf8").catch(() => "")
+
+      scripts.push({
+        absolutePath: normalized.absolutePath,
+        relativePath: normalized.relativePath,
+        source,
+        functions: script.functions ?? [],
+        url: script.url,
+      })
+    }
+  }
+
+  if (scripts.length === 0) {
+    return
+  }
+
+  const outDir = path.join(config.testResultsRoot, "vitest")
+  await fsPromises.mkdir(outDir, { recursive: true })
+  const outputFile = path.join(outDir, config.coverageFileName)
+  await fsPromises.writeFile(outputFile, JSON.stringify({ testId: "vitest", scripts }, null, 2), "utf8")
+}
+
+async function finalizeCoverage(config) {
+  try {
+    await generateCoverageReport(config)
+  } catch (error) {
+    if (error instanceof CoverageThresholdError) {
+      console.error(error.message)
+    }
+    throw error
+  }
+}
+
+async function readJson(filePath) {
+  try {
+    const raw = await fsPromises.readFile(filePath, "utf8")
+    return JSON.parse(raw)
+  } catch {
+    return null
+  }
+}
+
+function normalizeNodeScriptUrl(rawUrl, workspaceRoot) {
+  if (!rawUrl || rawUrl.startsWith("node:")) {
+    return null
+  }
+
+  let absolutePath = null
+
+  try {
+    if (rawUrl.startsWith("file://")) {
+      absolutePath = fileURLToPath(rawUrl)
+    }
+  } catch (_err) {
+    // ignore invalid URLs
+  }
+
+  if (!absolutePath && path.isAbsolute(rawUrl)) {
+    absolutePath = rawUrl
+  }
+
+  if (!absolutePath) {
+    return null
+  }
+
+  const normalized = path.normalize(absolutePath)
+  if (!normalized.startsWith(workspaceRoot)) {
+    return null
+  }
+
+  return {
+    absolutePath: normalized,
+    relativePath: path.relative(workspaceRoot, normalized),
+  }
+}
+
+function isInsideLib(absolutePath, libRoots) {
+  return libRoots.some((libRoot) => {
+    const relative = path.relative(libRoot, absolutePath)
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))
+  })
+}
+
+function spawnWithLogs({ name, launcher, args, env, successMessage, failureMessage }) {
+  return new Promise((resolve, reject) => {
+    const stdoutBuffer = []
+    const stderrBuffer = []
+
+    const child = spawn(
+      launcher.command,
+      [...(launcher.args || []), ...args],
+      {
+        shell: false,
+        env,
+      },
+    )
+
+    child.stdout.on("data", (data) => {
+      if (!isAider) {
+        process.stdout.write(data)
+      }
+      stdoutBuffer.push(data.toString())
+    })
+
+    child.stderr.on("data", (data) => {
+      if (!isAider) {
+        process.stderr.write(data)
+      }
+      stderrBuffer.push(data.toString())
+    })
+
+    child.on("close", (code) => {
+      if (code === 0) {
+        if (successMessage) {
+          console.log(successMessage)
+        }
+        resolve()
+      } else {
+        console.error(failureMessage || `${name} failed:`)
+
+        if (isAider) {
+          if (stdoutBuffer.length > 0) {
+            console.error(stdoutBuffer.join(""))
+          }
+
+          if (stderrBuffer.length > 0) {
+            console.error(stderrBuffer.join(""))
+          }
+        }
+
+        reject(new Error(`${name} failed with exit code: ${code}`))
+      }
+    })
+
+    child.on("error", (error) => {
+      console.error(`Error spawning ${name}:`, error)
+      reject(error)
+    })
+  })
+}
+
+function withRegisterShim(baseEnv) {
+  const nodeOptions = appendNodeRequire(baseEnv.NODE_OPTIONS, path.join(moduleDir, "register-tty.cjs"))
+  return {
+    ...baseEnv,
+    NODE_OPTIONS: nodeOptions,
+  }
+}
+
 function ensureJsxRuntimeShim(projectRoot) {
   const shimDir = path.join(projectRoot, "node_modules", "playwright")
   fs.mkdirSync(shimDir, { recursive: true })

package/src/coverage/config-loader.js

@@ -7,7 +7,7 @@ import { pathToFileURL } from "node:url"
 import { build } from "esbuild"
 
 
-const COVERAGE_CANDIDATES = [
+const DEFAULT_COVERAGE_CANDIDATES = [
   "spec/coverage.ts",
   "spec/coverage.mts",
   "spec/coverage.cts",
@@ -17,9 +17,9 @@ const COVERAGE_CANDIDATES = [
   "spec/coverage.json",
 ]
 
-export async function loadCoverageOptions({ optional = false } = {}) {
+export async function loadCoverageOptions({ optional = false, candidates = DEFAULT_COVERAGE_CANDIDATES, defaultTestResultsDir } = {}) {
   const projectRoot = process.cwd()
-  const resolved = await findCoverageFile(projectRoot)
+  const resolved = await findCoverageFile(projectRoot, candidates)
 
   if (!resolved) {
     if (optional) {
@@ -35,11 +35,11 @@ export async function loadCoverageOptions({ optional = false } = {}) {
     throw new Error(`Coverage config at ${resolved} must export an object.`)
   }
 
-  return normalizeOptions(raw, resolved)
+  return normalizeOptions(raw, resolved, defaultTestResultsDir)
 }
 
-async function findCoverageFile(root) {
-  for (const relative of COVERAGE_CANDIDATES) {
+async function findCoverageFile(root, candidates) {
+  for (const relative of candidates) {
     const candidate = path.resolve(root, relative)
     try {
       await fs.access(candidate)
@@ -101,7 +101,7 @@ async function loadModule(url) {
   return imported
 }
 
-function normalizeOptions(rawOptions, filePath) {
+function normalizeOptions(rawOptions, filePath, defaultTestResultsDir) {
   const options = { ...rawOptions }
   const configDir = path.dirname(filePath)
 
@@ -116,9 +116,11 @@ function normalizeOptions(rawOptions, filePath) {
   return {
     workspaceRoot,
     libDirs,
-    testResultsDir: options.testResultsDir ?? "test-results",
+    testResultsDir: options.testResultsDir ?? defaultTestResultsDir ?? "test-results",
     coverageReportSubdir: options.coverageReportSubdir ?? "coverage",
     coverageFileName: options.coverageFileName ?? "v8-coverage.json",
     thresholds: options.thresholds ?? {},
   }
 }
+
+export { DEFAULT_COVERAGE_CANDIDATES }