@rpcbase/test 0.308.0 → 0.310.0

package/src/coverage/collect.js

@@ -1,134 +0,0 @@
-import path from "node:path"
-
-import picomatch from "picomatch"
-
-
-export function createCollectCoverageMatcher(patterns, rootDir) {
-  const normalizedRoot = path.resolve(String(rootDir ?? ""))
-
-  const includeMatchers = []
-  const excludeMatchers = []
-
-  if (Array.isArray(patterns)) {
-    for (const pattern of patterns) {
-      const raw = String(pattern ?? "").trim()
-      if (!raw) {
-        continue
-      }
-
-      const isExclude = raw.startsWith("!")
-      const body = toPosix(isExclude ? raw.slice(1) : raw)
-      if (!body) {
-        continue
-      }
-
-      const matcher = picomatch(body, { dot: true })
-      if (isExclude) {
-        excludeMatchers.push(matcher)
-      } else {
-        includeMatchers.push(matcher)
-      }
-    }
-  }
-
-  if (includeMatchers.length === 0) {
-    return () => false
-  }
-
-  return (absolutePath) => {
-    const normalizedAbsolute = path.resolve(String(absolutePath ?? ""))
-    if (!normalizedAbsolute) {
-      return false
-    }
-
-    const relativePosix = toPosix(path.relative(normalizedRoot, normalizedAbsolute))
-    const absolutePosix = toPosix(normalizedAbsolute)
-    const candidates = new Set([absolutePosix, relativePosix])
-
-    if (relativePosix) {
-      candidates.add(`./${relativePosix}`)
-    }
-
-    const candidateList = Array.from(candidates)
-    const included = includeMatchers.some((matcher) => candidateList.some((candidate) => matcher(candidate)))
-    if (!included) {
-      return false
-    }
-
-    return !excludeMatchers.some((matcher) => candidateList.some((candidate) => matcher(candidate)))
-  }
-}
-
-export function toPosix(input) {
-  return String(input ?? "").split(path.sep).join("/")
-}
-
-export function isInsideAnyRoot(absolutePath, roots) {
-  const normalizedAbsolute = path.resolve(String(absolutePath ?? ""))
-  return (Array.isArray(roots) ? roots : []).some((root) => {
-    const normalizedRoot = path.resolve(String(root ?? ""))
-    const relative = path.relative(normalizedRoot, normalizedAbsolute)
-    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))
-  })
-}
-
-export function resolveCollectCoverageRoots(patterns, rootDir) {
-  const resolvedRootDir = path.resolve(String(rootDir ?? ""))
-  const roots = new Set([resolvedRootDir])
-
-  if (!Array.isArray(patterns)) {
-    return Array.from(roots)
-  }
-
-  for (const pattern of patterns) {
-    const raw = String(pattern ?? "").trim()
-    if (!raw) {
-      continue
-    }
-
-    const cleaned = raw.startsWith("!") ? raw.slice(1) : raw
-    if (!cleaned) {
-      continue
-    }
-
-    const prefix = staticGlobPrefix(cleaned)
-    if (!prefix) {
-      continue
-    }
-
-    roots.add(path.resolve(resolvedRootDir, prefix))
-  }
-
-  return Array.from(roots)
-}
-
-function staticGlobPrefix(pattern) {
-  const normalized = String(pattern ?? "").trim()
-  if (!normalized) {
-    return null
-  }
-
-  const firstGlobIndex = findFirstGlobIndex(normalized)
-  const prefix = firstGlobIndex === -1 ? normalized : normalized.slice(0, firstGlobIndex)
-
-  if (!prefix) {
-    return null
-  }
-
-  if (prefix.endsWith("/") || prefix.endsWith(path.sep)) {
-    return prefix
-  }
-
-  const posix = prefix.split(path.sep).join("/")
-  return path.posix.dirname(posix)
-}
-
-function findFirstGlobIndex(value) {
-  for (let i = 0; i < value.length; i += 1) {
-    const char = value[i]
-    if (char === "*" || char === "?" || char === "[" || char === "{") {
-      return i
-    }
-  }
-  return -1
-}

package/src/coverage/config-loader.js

@@ -1,202 +0,0 @@
-import fs from "node:fs/promises"
-import path from "node:path"
-import os from "node:os"
-import crypto from "node:crypto"
-import { pathToFileURL } from "node:url"
-
-import { build } from "esbuild"
-
-
-const DEFAULT_COVERAGE_CANDIDATES = [
-  "spec/coverage.config.ts",
-  "spec/coverage.config.js",
-  "spec/coverage.config.mjs",
-  "spec/coverage.config.cjs",
-  "spec/coverage.config.json",
-]
-
-const LEGACY_COVERAGE_CANDIDATES = [
-  "spec/coverage.ts",
-  "spec/coverage.js",
-  "spec/coverage.mjs",
-  "spec/coverage.cjs",
-  "spec/coverage.json",
-]
-
-export async function loadCoverageOptions({ optional = false, candidates = DEFAULT_COVERAGE_CANDIDATES, defaultTestResultsDir } = {}) {
-  const projectRoot = process.cwd()
-  const legacy = await findCoverageFile(projectRoot, LEGACY_COVERAGE_CANDIDATES)
-  if (legacy) {
-    const ext = path.extname(legacy)
-    const suggested = path.join("spec", `coverage.config${ext}`)
-    throw new Error(
-      `Legacy coverage config detected (${path.relative(projectRoot, legacy)}). Rename it to ${suggested}.`,
-    )
-  }
-
-  const resolved = await findCoverageFile(projectRoot, candidates)
-
-  if (!resolved) {
-    if (optional) {
-      return null
-    }
-    throw new Error(
-      "Coverage config not found. Create `spec/coverage.config.{ts,js,json}` with your coverage settings.",
-    )
-  }
-
-  const raw = await importCoverageModule(resolved)
-  if (!raw || typeof raw !== "object") {
-    throw new Error(`Coverage config at ${resolved} must export an object.`)
-  }
-
-  return await normalizeOptions(raw, resolved, defaultTestResultsDir)
-}
-
-async function findCoverageFile(root, candidates) {
-  for (const relative of candidates) {
-    const candidate = path.resolve(root, relative)
-    try {
-      await fs.access(candidate)
-      return candidate
-    } catch {
-      // continue
-    }
-  }
-  return null
-}
-
-async function importCoverageModule(filePath) {
-  const ext = path.extname(filePath)
-
-  if (ext === ".json") {
-    const raw = await fs.readFile(filePath, "utf8")
-    return JSON.parse(raw)
-  }
-
-  if (ext === ".ts") {
-    const compiledUrl = await compileTsModule(filePath)
-    return loadModule(compiledUrl)
-  }
-
-  const moduleUrl = pathToFileURL(filePath).href
-  return loadModule(moduleUrl)
-}
-
-async function compileTsModule(filePath) {
-  const stat = await fs.stat(filePath)
-  const hash = crypto
-    .createHash("sha1")
-    .update(filePath)
-    .update(String(stat.mtimeMs))
-    .digest("hex")
-
-  const outDir = path.join(os.tmpdir(), "rpcbase-test")
-  await fs.mkdir(outDir, { recursive: true })
-  const outfile = path.join(outDir, `coverage-${hash}.mjs`)
-
-  await build({
-    entryPoints: [filePath],
-    outfile,
-    platform: "node",
-    format: "esm",
-    bundle: false,
-    sourcemap: "inline",
-    logLevel: "silent",
-  })
-
-  return pathToFileURL(outfile).href
-}
-
-async function loadModule(url) {
-  const imported = await import(url)
-  if (imported && typeof imported.default === "object") {
-    return imported.default
-  }
-  return imported
-}
-
-const DEFAULT_COLLECT_COVERAGE_EXTENSIONS = "ts,tsx,js,jsx,mjs,cjs"
-const DEFAULT_COLLECT_COVERAGE_TEST_EXCLUDE = `!**/*.test.{${DEFAULT_COLLECT_COVERAGE_EXTENSIONS}}`
-
-async function resolveCollectCoverageFrom(rawPatterns, rootDir) {
-  const resolvedRootDir = path.resolve(String(rootDir ?? ""))
-
-  const normalized = Array.isArray(rawPatterns)
-    ? rawPatterns
-        .map((pattern) => String(pattern ?? "").trim())
-        .filter((pattern) => pattern.length > 0)
-    : []
-
-  const excludes = normalized.filter((pattern) => pattern.startsWith("!"))
-  const hasIncludes = normalized.some((pattern) => !pattern.startsWith("!"))
-  if (hasIncludes) {
-    return withDefaultExcludes(normalized)
-  }
-
-  const defaults = await inferDefaultCollectCoverageFrom(resolvedRootDir)
-  if (defaults.length === 0) {
-    throw new Error(
-      "Coverage config: couldn't infer a default `collectCoverageFrom` (src/ directory missing). Provide `collectCoverageFrom` with at least one positive glob pattern.",
-    )
-  }
-
-  return withDefaultExcludes([...defaults, ...excludes])
-}
-
-async function inferDefaultCollectCoverageFrom(rootDir) {
-  const srcDir = path.join(rootDir, "src")
-  if (await isDirectory(srcDir)) {
-    return [`src/**/*.{${DEFAULT_COLLECT_COVERAGE_EXTENSIONS}}`]
-  }
-
-  return []
-}
-
-function withDefaultExcludes(patterns) {
-  if (!Array.isArray(patterns) || patterns.length === 0) {
-    return patterns
-  }
-
-  const hasTestExclude = patterns.some((pattern) => {
-    const raw = String(pattern ?? "")
-    if (!raw.startsWith("!")) {
-      return false
-    }
-    return /\.test(?:\.|\{|$)/.test(raw.slice(1))
-  })
-  if (hasTestExclude) {
-    return patterns
-  }
-
-  return [...patterns, DEFAULT_COLLECT_COVERAGE_TEST_EXCLUDE]
-}
-
-async function isDirectory(filePath) {
-  try {
-    const stat = await fs.stat(filePath)
-    return stat.isDirectory()
-  } catch {
-    return false
-  }
-}
-
-async function normalizeOptions(rawOptions, filePath, defaultTestResultsDir) {
-  const options = { ...rawOptions }
-  const configDir = path.dirname(filePath)
-  const rootDir = path.resolve(configDir, "..")
-
-  const collectCoverageFrom = await resolveCollectCoverageFrom(options.collectCoverageFrom, rootDir)
-
-  return {
-    rootDir,
-    collectCoverageFrom,
-    testResultsDir: options.testResultsDir ?? defaultTestResultsDir ?? "test-results",
-    coverageReportSubdir: options.coverageReportSubdir ?? "coverage",
-    coverageFileName: options.coverageFileName ?? "v8-coverage.json",
-    includeAllFiles: options.includeAllFiles,
-    thresholds: options.thresholds ?? {},
-  }
-}
-
-export { DEFAULT_COVERAGE_CANDIDATES }

package/src/coverage/config.js

@@ -1,134 +0,0 @@
-import path from "node:path"
-
-
-const DEFAULT_THRESHOLDS = {
-  branches: 60,
-  functions: 75,
-  lines: 75,
-  statements: 75,
-}
-
-const THRESHOLD_KEYS = Object.keys(DEFAULT_THRESHOLDS)
-
-function resolveDir(root, target, fallback) {
-  if (!target) {
-    return path.resolve(root, fallback)
-  }
-
-  if (path.isAbsolute(target)) {
-    return target
-  }
-
-  return path.resolve(root, target)
-}
-
-export function createCoverageConfig(options = {}) {
-  const { rootDir } = options
-  if (!rootDir) {
-    throw new Error("createCoverageConfig requires a rootDir")
-  }
-
-  const resolvedRootDir = path.resolve(rootDir)
-  const includeAllFiles = options.includeAllFiles !== false
-
-  const collectCoverageFrom = Array.isArray(options.collectCoverageFrom)
-    ? options.collectCoverageFrom
-        .map((pattern) => String(pattern ?? "").trim())
-        .filter((pattern) => pattern.length > 0)
-    : []
-
-  if (collectCoverageFrom.length === 0) {
-    throw new Error("createCoverageConfig requires a collectCoverageFrom option")
-  }
-
-  const testResultsRoot = resolveDir(resolvedRootDir, options.testResultsDir, "test-results")
-  const coverageReportDir = resolveDir(testResultsRoot, options.coverageReportSubdir, "coverage")
-  const coverageFileName = options.coverageFileName ?? "v8-coverage.json"
-  const disabledEnvVar = options.disabledEnvVar ?? "RB_DISABLE_COVERAGE"
-  const coverageEnabled = process.env[disabledEnvVar] !== "1"
-
-  const { global: thresholds, targets: thresholdTargets } = normalizeThresholdOptions(options.thresholds)
-
-  return {
-    rootDir: resolvedRootDir,
-    collectCoverageFrom,
-    testResultsRoot,
-    coverageReportDir,
-    coverageFileName,
-    thresholds,
-    thresholdTargets,
-    coverageEnabled,
-    disabledEnvVar,
-    includeAllFiles,
-  }
-}
-
-function normalizeThresholdOptions(rawThresholds) {
-  const globalThresholds = { ...DEFAULT_THRESHOLDS }
-  const targets = []
-
-  if (!isPlainObject(rawThresholds)) {
-    return { global: globalThresholds, targets }
-  }
-
-  for (const key of THRESHOLD_KEYS) {
-    const value = rawThresholds[key]
-    if (isThresholdValue(value)) {
-      globalThresholds[key] = value
-    }
-  }
-
-  if (Object.prototype.hasOwnProperty.call(rawThresholds, "global")) {
-    if (!isPlainObject(rawThresholds.global)) {
-      throw new Error("coverage thresholds: the `global` override must be an object of metric values")
-    }
-    Object.assign(globalThresholds, pickThresholdOverrides(rawThresholds.global))
-  }
-
-  for (const [pattern, overrides] of Object.entries(rawThresholds)) {
-    if (pattern === "global" || THRESHOLD_KEYS.includes(pattern)) {
-      continue
-    }
-
-    if (!isPlainObject(overrides)) {
-      throw new Error(
-        `coverage thresholds: override for "${pattern}" must be an object containing coverage metrics`,
-      )
-    }
-
-    targets.push({
-      id: pattern,
-      pattern,
-      thresholds: {
-        ...globalThresholds,
-        ...pickThresholdOverrides(overrides),
-      },
-    })
-  }
-
-  return { global: globalThresholds, targets }
-}
-
-function pickThresholdOverrides(source) {
-  const overrides = {}
-  if (!isPlainObject(source)) {
-    return overrides
-  }
-
-  for (const key of THRESHOLD_KEYS) {
-    const value = source[key]
-    if (isThresholdValue(value)) {
-      overrides[key] = value
-    }
-  }
-
-  return overrides
-}
-
-function isPlainObject(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value)
-}
-
-function isThresholdValue(value) {
-  return typeof value === "number" && Number.isFinite(value)
-}

package/src/coverage/files.js

@@ -1,55 +0,0 @@
-import fs from "node:fs/promises"
-import path from "node:path"
-
-
-export async function findCoverageFiles(config, root = config.testResultsRoot) {
-  const files = []
-
-  async function walk(current) {
-    const entries = await fs.readdir(current, { withFileTypes: true })
-    await Promise.all(
-      entries.map(async (entry) => {
-        const entryPath = path.join(current, entry.name)
-        if (entry.isDirectory()) {
-          await walk(entryPath)
-        } else if (entry.isFile() && entry.name === config.coverageFileName) {
-          files.push(entryPath)
-        }
-      }),
-    )
-  }
-
-  try {
-    const stats = await fs.stat(root)
-    if (!stats.isDirectory()) {
-      return []
-    }
-  } catch {
-    return []
-  }
-
-  await walk(root)
-  return files.sort()
-}
-
-export async function removeCoverageFiles(config, root = config.testResultsRoot) {
-  async function walk(current) {
-    const entries = await fs.readdir(current, { withFileTypes: true })
-    await Promise.all(
-      entries.map(async (entry) => {
-        const entryPath = path.join(current, entry.name)
-        if (entry.isDirectory()) {
-          await walk(entryPath)
-        } else if (entry.isFile() && entry.name === config.coverageFileName) {
-          await fs.rm(entryPath, { force: true })
-        }
-      }),
-    )
-  }
-
-  try {
-    await walk(root)
-  } catch {
-    // ignore cleanup errors
-  }
-}

package/src/coverage/fixtures.js

@@ -1,37 +0,0 @@
-import { createCoverageTracker } from "./v8-tracker.js"
-
-
-function noopTracker() {
-  return {
-    async stop() {
-      // no-op
-    },
-  }
-}
-
-export function createCoverageFixtures(baseTest, config) {
-  return baseTest.extend({
-    page: async ({ page }, use, testInfo) => {
-      let tracker = noopTracker()
-
-      if (config.coverageEnabled) {
-        try {
-          tracker = await createCoverageTracker(page, config)
-        } catch (error) {
-          console.warn("[coverage] failed to initialize V8 coverage:", error)
-        }
-      }
-
-      try {
-        // eslint-disable-next-line react-hooks/rules-of-hooks
-        await use(page)
-      } finally {
-        try {
-          await tracker.stop(testInfo)
-        } catch (error) {
-          console.warn("[coverage] failed to record V8 coverage:", error)
-        }
-      }
-    },
-  })
-}

package/src/coverage/global-setup.js

@@ -1,19 +0,0 @@
-import fs from "node:fs/promises"
-
-import { removeCoverageFiles } from "./files.js"
-
-
-export function createCoverageGlobalSetup(config) {
-  return async function globalSetup() {
-    if (process.env.RB_TEST_COMBINED_COVERAGE === "1") {
-      return
-    }
-
-    if (!config.coverageEnabled) {
-      return
-    }
-
-    await removeCoverageFiles(config)
-    await fs.rm(config.coverageReportDir, { recursive: true, force: true })
-  }
-}

package/src/coverage/index.js

@@ -1,30 +0,0 @@
-import { fileURLToPath } from "node:url"
-
-import { createCoverageConfig } from "./config.js"
-import { createCoverageGlobalSetup } from "./global-setup.js"
-import { createCoverageFixtures } from "./fixtures.js"
-
-
-export function createCoverageHarness(options = {}) {
-  const config = createCoverageConfig(options)
-  const globalSetup = createCoverageGlobalSetup(config)
-
-  return {
-    config,
-    globalSetup,
-    extendTest(baseTest) {
-      return createCoverageFixtures(baseTest, config)
-    },
-    reporterEntry() {
-      const reporterPath = fileURLToPath(new URL("./reporter.js", import.meta.url))
-      return [reporterPath, { coverageConfig: config }]
-    },
-  }
-}
-
-export { CoverageReporter } from "./reporter.js"
-export { createCoverageConfig } from "./config.js"
-export { generateCoverageReport } from "./report.js"
-export { createCoverageFixtures } from "./fixtures.js"
-export { createCoverageGlobalSetup } from "./global-setup.js"
-export { findCoverageFiles, removeCoverageFiles } from "./files.js"

package/src/coverage/reporter.js

@@ -1,65 +0,0 @@
-import fs from "node:fs/promises"
-
-import { CoverageThresholdError, generateCoverageReport } from "./report.js"
-import { removeCoverageFiles } from "./files.js"
-
-
-class CoverageReporter {
-  constructor(options = {}) {
-    this.config = options.coverageConfig
-    if (!this.config) {
-      throw new Error("CoverageReporter requires a coverageConfig option")
-    }
-  }
-
-  async onBegin() {
-    if (process.env.RB_TEST_COMBINED_COVERAGE === "1") {
-      return
-    }
-
-    if (!this.config.coverageEnabled) {
-      return
-    }
-
-    await removeCoverageFiles(this.config)
-    await fs.rm(this.config.coverageReportDir, { recursive: true, force: true })
-  }
-
-  async onEnd(result) {
-    if (process.env.RB_TEST_COMBINED_COVERAGE === "1") {
-      return
-    }
-
-    if (!this.config.coverageEnabled) {
-      return
-    }
-
-    try {
-      await generateCoverageReport(this.config)
-    } catch (error) {
-      if (error instanceof CoverageThresholdError) {
-        console.error(error.message)
-        setFailureExitCode(result)
-        return
-      }
-
-      throw error
-    }
-  }
-}
-
-export { CoverageReporter }
-export default CoverageReporter
-
-function setFailureExitCode(result) {
-  if (result && typeof result === "object") {
-    result.status = "failed"
-    if (typeof result.exitCode !== "number" || result.exitCode === 0) {
-      result.exitCode = 1
-    }
-  }
-
-  if (!process.exitCode || process.exitCode === 0) {
-    process.exitCode = 1
-  }
-}