@rpcbase/test 0.307.0 → 0.309.0

package/src/coverage/report.js

@@ -1,600 +0,0 @@
-import fs from "node:fs/promises"
-import path from "node:path"
-import { fileURLToPath } from "node:url"
-
-import * as libCoverage from "istanbul-lib-coverage"
-import * as libInstrument from "istanbul-lib-instrument"
-import { createContext } from "istanbul-lib-report"
-import reports from "istanbul-reports"
-import fg from "fast-glob"
-import picomatch from "picomatch"
-import v8ToIstanbul from "v8-to-istanbul"
-
-import { createCollectCoverageMatcher, toPosix } from "./collect.js"
-import { findCoverageFiles } from "./files.js"
-
-
-const TEXT_REPORT_FILENAME = "coverage.txt"
-
-export class CoverageThresholdError extends Error {
-  constructor(message) {
-    super(message)
-    this.name = "CoverageThresholdError"
-  }
-}
-
-export async function generateCoverageReport(config) {
-  const coverageFiles = await findCoverageFiles(config)
-
-  if (coverageFiles.length === 0) {
-    console.warn("[coverage] no V8 coverage artifacts were generated")
-    return
-  }
-
-  const coverageLib = resolveCoverageLib()
-  const coverageMap = coverageLib.createCoverageMap({})
-  const matchesCollectCoverageFrom = createCollectCoverageMatcher(config.collectCoverageFrom, config.rootDir)
-
-  for (const file of coverageFiles) {
-    const payload = await readCoverageFile(file)
-    if (!payload) {
-      continue
-    }
-
-    for (const script of payload.scripts) {
-      await mergeScriptCoverage(coverageMap, script, config, matchesCollectCoverageFrom)
-    }
-  }
-
-  if (config.includeAllFiles) {
-    await includeUntestedFiles(coverageMap, config, matchesCollectCoverageFrom)
-  }
-
-  if (coverageMap.files().length === 0) {
-    console.warn("[coverage] no library files matched the coverage filters")
-    return
-  }
-
-  await fs.rm(config.coverageReportDir, { recursive: true, force: true })
-  await fs.mkdir(config.coverageReportDir, { recursive: true })
-
-  const context = createContext({
-    dir: config.coverageReportDir,
-    coverageMap,
-    defaultSummarizer: "pkg",
-  })
-
-  reports.create("text", { maxCols: process.stdout.columns ?? 120 }).execute(context)
-  reports.create("text", { file: TEXT_REPORT_FILENAME }).execute(context)
-
-  console.log(`[coverage] Full text report saved to ${path.join(config.coverageReportDir, TEXT_REPORT_FILENAME)}`)
-
-  const summary = coverageMap.getCoverageSummary()
-  enforceThresholds(summary, config.thresholds, "global")
-
-  const targets = Array.isArray(config.thresholdTargets) ? config.thresholdTargets : []
-  if (targets.length > 0) {
-    const fileSummaries = buildFileSummaries(coverageMap, config.rootDir)
-    for (const target of targets) {
-      const matcher = createGlobMatcher(target.pattern)
-      const matchResult = collectTargetSummary(fileSummaries, matcher, coverageLib)
-
-      if (matchResult.matched === 0) {
-        console.warn(
-          `[coverage] threshold pattern "${target.pattern}" did not match any files — skipping`,
-        )
-        continue
-      }
-
-      enforceThresholds(matchResult.summary, target.thresholds, target.pattern)
-    }
-  }
-}
-
-async function mergeScriptCoverage(coverageMap, script, config, matchesCollectCoverageFrom) {
-  const scriptPath = script.absolutePath
-  if (!scriptPath) {
-    return
-  }
-
-  if (isNodeModulesPath(scriptPath)) {
-    return
-  }
-
-  if (isViteVirtualModulePath(scriptPath)) {
-    return
-  }
-
-  let source = script.source && script.source.length > 0
-    ? script.source
-    : ""
-
-  if (!source) {
-    try {
-      source = await fs.readFile(scriptPath, "utf8")
-    } catch (error) {
-      const base = path.basename(scriptPath)
-      if (error?.code === "ENOENT" && base && !base.includes(".")) {
-        return
-      }
-      throw error
-    }
-  }
-
-  const sourceMap = await loadSourceMapForScript(scriptPath, source)
-  const converter = v8ToIstanbul(
-    scriptPath,
-    0,
-    sourceMap ? { source, sourceMap: { sourcemap: sourceMap } } : { source },
-  )
-  await converter.load()
-  converter.applyCoverage(script.functions)
-
-  const filtered = filterCoverageMap(converter.toIstanbul(), config, matchesCollectCoverageFrom)
-  if (Object.keys(filtered).length > 0) {
-    coverageMap.merge(filtered)
-  }
-}
-
-async function readCoverageFile(file) {
-  try {
-    const raw = await fs.readFile(file, "utf8")
-    return JSON.parse(raw)
-  } catch (error) {
-    console.warn(`[coverage] failed to parse ${file}:`, error)
-    return null
-  }
-}
-
-function enforceThresholds(summary, thresholds, label = "global") {
-  const failures = []
-
-  for (const metric of Object.keys(thresholds)) {
-    const minimum = thresholds[metric]
-    const actual = summary[metric]?.pct ?? 0
-    if (actual < minimum) {
-      failures.push({ metric, actual, minimum })
-    }
-  }
-
-  if (failures.length === 0) {
-    return
-  }
-
-  const details = failures
-    .map(({ metric, actual, minimum }) => `${metric}: ${actual.toFixed(2)}% < ${minimum}%`)
-    .join("; ")
-
-  throw new CoverageThresholdError(`[coverage] thresholds not met (target: ${label}) — ${details}`)
-}
-
-function resolveCoverageLib() {
-  const candidate = libCoverage
-  if (typeof candidate.createCoverageMap === "function") {
-    return candidate
-  }
-
-  if (candidate.default && typeof candidate.default.createCoverageMap === "function") {
-    return candidate.default
-  }
-
-  throw new Error("istanbul-lib-coverage exports are unavailable")
-}
-
-function resolveInstrumentLib() {
-  const candidate = libInstrument
-  if (typeof candidate.createInstrumenter === "function") {
-    return candidate
-  }
-
-  if (candidate.default && typeof candidate.default.createInstrumenter === "function") {
-    return candidate.default
-  }
-
-  throw new Error("istanbul-lib-instrument exports are unavailable")
-}
-
-async function includeUntestedFiles(coverageMap, config, matchesCollectCoverageFrom) {
-  const existing = new Set(
-    coverageMap.files().map((filePath) => path.resolve(String(filePath ?? ""))),
-  )
-
-  const candidates = await findCollectCoverageFiles(config, matchesCollectCoverageFrom)
-  if (candidates.length === 0) {
-    return
-  }
-
-  const instrumentLib = resolveInstrumentLib()
-  const instrumenter = instrumentLib.createInstrumenter({
-    esModules: true,
-    parserPlugins: [
-      "typescript",
-      "jsx",
-      "classProperties",
-      "classPrivateProperties",
-      "classPrivateMethods",
-      "decorators-legacy",
-      "importMeta",
-      "topLevelAwait",
-    ],
-  })
-
-  for (const filePath of candidates) {
-    const normalized = path.resolve(filePath)
-    if (existing.has(normalized)) {
-      continue
-    }
-
-    const source = await fs.readFile(normalized, "utf8").catch(() => null)
-    if (source === null) {
-      continue
-    }
-
-    try {
-      instrumenter.instrumentSync(source, normalized)
-      const fileCoverage = instrumenter.lastFileCoverage()
-      if (!fileCoverage) {
-        continue
-      }
-      coverageMap.addFileCoverage(fileCoverage)
-      existing.add(normalized)
-    } catch (error) {
-      const relative = path.relative(config.rootDir, normalized)
-      console.warn(
-        `[coverage] failed to instrument ${relative && !relative.startsWith("..") ? relative : normalized}:`,
-        error,
-      )
-    }
-  }
-}
-
-const DEFAULT_COLLECT_COVERAGE_IGNORES = [
-  "**/.git/**",
-  "**/.next/**",
-  "**/.turbo/**",
-  "**/.vite/**",
-  "**/.vitest/**",
-  "**/build/**",
-  "**/coverage/**",
-  "**/dist/**",
-  "**/node_modules/**",
-  "**/playwright-report/**",
-  "**/spec/**",
-  "**/test/**",
-  "**/test-results/**",
-  "**/tests/**",
-  "**/__tests__/**",
-  "**/*.d.ts",
-  "**/*.map",
-]
-
-async function findCollectCoverageFiles(config, matchesCollectCoverageFrom) {
-  const patterns = Array.isArray(config.collectCoverageFrom)
-    ? config.collectCoverageFrom
-    : []
-
-  if (patterns.length === 0) {
-    return []
-  }
-
-  const rawFiles = await fg(patterns, {
-    cwd: config.rootDir,
-    absolute: true,
-    dot: true,
-    onlyFiles: true,
-    unique: true,
-    followSymbolicLinks: false,
-    ignore: DEFAULT_COLLECT_COVERAGE_IGNORES,
-  }).catch(() => [])
-
-  const collected = new Set()
-
-  for (const file of rawFiles) {
-    const normalized = path.resolve(String(file ?? ""))
-    if (!normalized) {
-      continue
-    }
-
-    if (normalized.endsWith(".d.ts") || normalized.endsWith(".map")) {
-      continue
-    }
-
-    if (isNodeModulesPath(normalized)) {
-      continue
-    }
-
-    if (isViteVirtualModulePath(normalized)) {
-      continue
-    }
-
-    if (!matchesCollectCoverageFrom(normalized)) {
-      continue
-    }
-
-    collected.add(normalized)
-  }
-
-  return Array.from(collected).sort()
-}
-
-function buildFileSummaries(coverageMap, rootDir) {
-  const normalizedRoot = path.resolve(rootDir)
-  return coverageMap.files().map((filePath) => {
-    const normalizedAbsolute = path.resolve(filePath)
-    const summary = coverageMap.fileCoverageFor(filePath).toSummary()
-    const relativePath = path.relative(normalizedRoot, normalizedAbsolute)
-    const candidates = new Set()
-
-    if (relativePath) {
-      const relativePosix = toPosix(relativePath)
-      candidates.add(relativePosix)
-      candidates.add(`./${relativePosix}`)
-    } else {
-      candidates.add(toPosix(path.basename(normalizedAbsolute)))
-    }
-
-    return {
-      summary,
-      candidates: Array.from(candidates),
-    }
-  })
-}
-
-function collectTargetSummary(fileSummaries, matcher, coverageLib) {
-  const summary = coverageLib.createCoverageSummary()
-  let matched = 0
-
-  for (const file of fileSummaries) {
-    if (file.candidates.some((candidate) => matcher(candidate))) {
-      summary.merge(file.summary)
-      matched += 1
-    }
-  }
-
-  return { summary, matched }
-}
-
-function createGlobMatcher(pattern) {
-  const normalized = toPosix(String(pattern ?? "")).trim()
-  if (!normalized) {
-    return () => false
-  }
-  if (isAbsoluteGlobPattern(normalized)) {
-    throw new Error(`[coverage] threshold patterns must be relative (absolute paths are not supported): "${pattern}"`)
-  }
-  return picomatch(normalized, { dot: true })
-}
-
-function isAbsoluteGlobPattern(pattern) {
-  const normalized = String(pattern ?? "").trim()
-  if (!normalized) {
-    return false
-  }
-
-  if (normalized.startsWith("/")) {
-    return true
-  }
-
-  if (normalized.startsWith("file://")) {
-    return true
-  }
-
-  return /^[A-Za-z]:\//.test(normalized)
-}
-
-function stripQuery(url) {
-  const queryIndex = url.indexOf("?")
-  const hashIndex = url.indexOf("#")
-
-  const endIndex = Math.min(
-    queryIndex === -1 ? Number.POSITIVE_INFINITY : queryIndex,
-    hashIndex === -1 ? Number.POSITIVE_INFINITY : hashIndex,
-  )
-
-  if (!Number.isFinite(endIndex)) {
-    return url
-  }
-
-  return url.slice(0, endIndex)
-}
-
-function extractSourceMappingUrl(source) {
-  const regex = /\/\/[#@]\s*sourceMappingURL=([^\s]+)/g
-
-  let last = null
-  let match = null
-
-  while ((match = regex.exec(source)) !== null) {
-    last = match[1]
-  }
-
-  return typeof last === "string" && last.length > 0 ? last : null
-}
-
-function resolveSourceMapPath(scriptPath, mappingUrl) {
-  const cleaned = stripQuery(mappingUrl)
-
-  if (cleaned.startsWith("file://")) {
-    return fileURLToPath(cleaned)
-  }
-
-  if (path.isAbsolute(cleaned)) {
-    return cleaned
-  }
-
-  return path.resolve(path.dirname(scriptPath), cleaned)
-}
-
-function filterCoverageMap(map, config, matchesCollectCoverageFrom) {
-  if (!map || typeof map !== "object") {
-    return {}
-  }
-
-  const filtered = {}
-
-  for (const [filePath, fileCoverage] of Object.entries(map)) {
-    const absolutePath = resolveCoveragePath(filePath, config.rootDir)
-    if (!absolutePath) {
-      continue
-    }
-
-    if (absolutePath.endsWith(".d.ts") || absolutePath.endsWith(".map")) {
-      continue
-    }
-
-    if (isNodeModulesPath(absolutePath)) {
-      continue
-    }
-
-    if (isViteVirtualModulePath(absolutePath)) {
-      continue
-    }
-
-    if (!matchesCollectCoverageFrom(absolutePath)) {
-      continue
-    }
-
-    if (fileCoverage && typeof fileCoverage === "object") {
-      filtered[absolutePath] = { ...fileCoverage, path: absolutePath }
-    } else {
-      filtered[absolutePath] = fileCoverage
-    }
-  }
-
-  return filtered
-}
-
-function resolveCoveragePath(filePath, rootDir) {
-  const raw = String(filePath ?? "").trim()
-  if (!raw) {
-    return null
-  }
-
-  const cleaned = stripQuery(raw)
-
-  if (cleaned.startsWith("file://")) {
-    try {
-      return path.normalize(fileURLToPath(cleaned))
-    } catch {
-      return null
-    }
-  }
-
-  if (path.isAbsolute(cleaned)) {
-    return path.normalize(cleaned)
-  }
-
-  if (cleaned.includes("://")) {
-    return null
-  }
-
-  return path.normalize(path.resolve(rootDir, cleaned))
-}
-
-function isNodeModulesPath(filePath) {
-  return path
-    .normalize(String(filePath ?? ""))
-    .split(path.sep)
-    .includes("node_modules")
-}
-
-function isViteVirtualModulePath(filePath) {
-  const normalized = path.normalize(String(filePath ?? ""))
-  const baseName = path.basename(normalized)
-  return baseName === "__vite-browser-external"
-    || baseName.startsWith("__vite-browser-external:")
-    || baseName.startsWith("__vite-")
-}
-
-function parseSourceMapPayload(raw) {
-  if (!raw || typeof raw !== "object") {
-    return null
-  }
-
-  const sources = raw.sources
-  if (!Array.isArray(sources) || sources.length === 0) {
-    return null
-  }
-
-  return raw
-}
-
-function normalizeSourceMap(sourceMap, scriptPath) {
-  const root = typeof sourceMap.sourceRoot === "string"
-    ? sourceMap.sourceRoot.replace("file://", "")
-    : ""
-
-  const dir = path.dirname(scriptPath)
-  const fixedSources = sourceMap.sources.map((source) => {
-    const raw = String(source ?? "")
-    const cleaned = stripQuery(raw)
-
-    if (cleaned.startsWith("file://")) {
-      try {
-        return path.normalize(fileURLToPath(cleaned))
-      } catch {
-        return cleaned
-      }
-    }
-
-    const withoutWebpack = cleaned.replace(/^webpack:\/\//, "")
-    const candidate = path.join(root, withoutWebpack)
-
-    if (path.isAbsolute(candidate)) {
-      return path.normalize(candidate)
-    }
-
-    const normalizedCandidate = candidate.split("/").join(path.sep)
-
-    if (dir.endsWith(`${path.sep}dist`) && !normalizedCandidate.startsWith(`..${path.sep}`)) {
-      if (normalizedCandidate.startsWith(`src${path.sep}`) || normalizedCandidate.startsWith(`lib${path.sep}`)) {
-        return path.normalize(path.resolve(dir, "..", normalizedCandidate))
-      }
-    }
-
-    return path.normalize(path.resolve(dir, normalizedCandidate))
-  })
-
-  return {
-    ...sourceMap,
-    sources: fixedSources,
-  }
-}
-
-async function loadSourceMapForScript(scriptPath, source) {
-  const mappingUrl = extractSourceMappingUrl(source)
-  if (!mappingUrl) {
-    return null
-  }
-
-  const cleaned = stripQuery(mappingUrl)
-
-  if (cleaned.startsWith("data:")) {
-    const commaIndex = cleaned.indexOf(",")
-    if (commaIndex === -1) {
-      return null
-    }
-
-    const meta = cleaned.slice(0, commaIndex)
-    const payload = cleaned.slice(commaIndex + 1)
-    const raw = meta.includes(";base64")
-      ? Buffer.from(payload, "base64").toString("utf8")
-      : decodeURIComponent(payload)
-
-    try {
-      const parsed = parseSourceMapPayload(JSON.parse(raw))
-      return parsed ? normalizeSourceMap(parsed, scriptPath) : null
-    } catch {
-      return null
-    }
-  }
-
-  try {
-    const mapPath = resolveSourceMapPath(scriptPath, cleaned)
-    const raw = await fs.readFile(mapPath, "utf8")
-    const parsed = parseSourceMapPayload(JSON.parse(raw))
-    return parsed ? normalizeSourceMap(parsed, scriptPath) : null
-  } catch {
-    return null
-  }
-}

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
-  }
-}