@rpcbase/test 0.177.0 → 0.179.0

package/README.md

@@ -27,6 +27,37 @@ export default {
 
 Only `RB_DISABLE_COVERAGE=1` skips the hooks; every other option lives inside this config file.
 
+### Per-folder thresholds
+
+Need stricter coverage in a sub-tree? Extend the same `thresholds` object with glob keys (mirroring Jest's `coverageThreshold` syntax):
+
+```ts
+export default {
+  workspaceRoot,
+  thresholds: {
+    global: {
+      statements: 90,
+      lines: 85,
+      functions: 85,
+      branches: 70,
+    },
+    "lib/core/**": {
+      statements: 98,
+      lines: 95,
+    },
+    "lib/components/**": {
+      functions: 92,
+    },
+  },
+}
+```
+
+- When `thresholds` only has metric keys, it behaves exactly like before.
+- Adding `thresholds.global` lets you keep a default floor while overriding specific directories.
+- Globs run against POSIX-style paths relative to `workspaceRoot`, but absolute paths work too if you prefer.
+- Metrics you omit inside an override inherit from the global thresholds (or the 75/75/75/60 defaults).
+- If a glob matches no files you'll get a warning and the override is skipped, so typos are easy to spot.
+
 ## 2. Import `test` / `expect` directly
 
 ```ts

package/index.d.ts

@@ -7,6 +7,19 @@ interface CoverageThresholds {
   statements: number
 }
 
+type CoverageThresholdMap = {
+  global?: Partial<CoverageThresholds>
+  [pattern: string]: Partial<CoverageThresholds> | number | undefined
+}
+
+type CoverageThresholdOption = Partial<CoverageThresholds> | CoverageThresholdMap
+
+interface CoverageThresholdTarget {
+  id: string
+  pattern: string
+  thresholds: CoverageThresholds
+}
+
 interface CoverageHarnessOptions {
   workspaceRoot: string
   libDirs?: string[]
@@ -14,7 +27,7 @@ interface CoverageHarnessOptions {
   coverageReportSubdir?: string
   coverageFileName?: string
   envPrefix?: string
-  thresholds?: Partial<CoverageThresholds>
+  thresholds?: CoverageThresholdOption
   disabledEnvVar?: string
 }
 
@@ -24,6 +37,7 @@ interface CoverageConfig extends CoverageHarnessOptions {
   coverageReportDir: string
   coverageFileName: string
   thresholds: CoverageThresholds
+  thresholdTargets: CoverageThresholdTarget[]
   coverageEnabled: boolean
   disabledEnvVar: string
 }
@@ -44,4 +58,6 @@ export type {
   CoverageHarnessOptions,
   CoverageConfig,
   CoverageThresholds,
+  CoverageThresholdOption,
+  CoverageThresholdTarget,
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpcbase/test",
-  "version": "0.177.0",
+  "version": "0.179.0",
   "type": "module",
   "types": "./index.d.ts",
   "exports": {
@@ -51,6 +51,7 @@
     "istanbul-reports": "3.1.6",
     "lodash": "4.17.21",
     "mongoose": "8.18.0",
+    "picomatch": "2.3.1",
     "v8-to-istanbul": "9.2.0"
   },
   "peerDependencies": {},

package/src/coverage/config.js

@@ -8,6 +8,8 @@ const DEFAULT_THRESHOLDS = {
   statements: 75,
 }
 
+const THRESHOLD_KEYS = Object.keys(DEFAULT_THRESHOLDS)
+
 function resolveDir(root, target, fallback) {
   if (!target) {
     return path.resolve(root, fallback)
@@ -42,10 +44,7 @@ export function createCoverageConfig(options = {}) {
   const disabledEnvVar = options.disabledEnvVar ?? "RB_DISABLE_COVERAGE"
   const coverageEnabled = process.env[disabledEnvVar] !== "1"
 
-  const thresholds = {
-    ...DEFAULT_THRESHOLDS,
-    ...(options.thresholds ?? {}),
-  }
+  const { global: thresholds, targets: thresholdTargets } = normalizeThresholdOptions(options.thresholds)
 
   return {
     workspaceRoot: resolvedWorkspaceRoot,
@@ -54,7 +53,78 @@ export function createCoverageConfig(options = {}) {
     coverageReportDir,
     coverageFileName,
     thresholds,
+    thresholdTargets,
     coverageEnabled,
     disabledEnvVar,
   }
 }
+
+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/report.js

@@ -4,6 +4,7 @@ import path from "node:path"
 import * as libCoverage from "istanbul-lib-coverage"
 import { createContext } from "istanbul-lib-report"
 import reports from "istanbul-reports"
+import picomatch from "picomatch"
 import v8ToIstanbul from "v8-to-istanbul"
 
 import { findCoverageFiles } from "./files.js"
@@ -11,6 +12,13 @@ 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)
 
@@ -19,7 +27,8 @@ export async function generateCoverageReport(config) {
     return
   }
 
-  const coverageMap = resolveCoverageLib().createCoverageMap({})
+  const coverageLib = resolveCoverageLib()
+  const coverageMap = coverageLib.createCoverageMap({})
 
   for (const file of coverageFiles) {
     const payload = await readCoverageFile(file)
@@ -52,7 +61,25 @@ export async function generateCoverageReport(config) {
   console.log(`[coverage] Full text report saved to ${path.join(config.coverageReportDir, TEXT_REPORT_FILENAME)}`)
 
   const summary = coverageMap.getCoverageSummary()
-  enforceThresholds(summary, config.thresholds)
+  enforceThresholds(summary, config.thresholds, "global")
+
+  const targets = Array.isArray(config.thresholdTargets) ? config.thresholdTargets : []
+  if (targets.length > 0) {
+    const fileSummaries = buildFileSummaries(coverageMap, config.workspaceRoot)
+    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) {
@@ -81,7 +108,7 @@ async function readCoverageFile(file) {
   }
 }
 
-function enforceThresholds(summary, thresholds) {
+function enforceThresholds(summary, thresholds, label = "global") {
   const failures = []
 
   for (const metric of Object.keys(thresholds)) {
@@ -100,7 +127,7 @@ function enforceThresholds(summary, thresholds) {
     .map(({ metric, actual, minimum }) => `${metric}: ${actual.toFixed(2)}% < ${minimum}%`)
     .join("; ")
 
-  throw new Error(`[coverage] thresholds not met — ${details}`)
+  throw new CoverageThresholdError(`[coverage] thresholds not met (target: ${label}) — ${details}`)
 }
 
 function resolveCoverageLib() {
@@ -115,3 +142,51 @@ function resolveCoverageLib() {
 
   throw new Error("istanbul-lib-coverage exports are unavailable")
 }
+
+function buildFileSummaries(coverageMap, workspaceRoot) {
+  const normalizedRoot = path.resolve(workspaceRoot)
+  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([toPosix(normalizedAbsolute)])
+
+    if (relativePath && !relativePath.startsWith("..")) {
+      const relativePosix = toPosix(relativePath)
+      candidates.add(relativePosix)
+      candidates.add(`./${relativePosix}`)
+      candidates.add(`/${relativePosix}`)
+    }
+
+    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
+  }
+  return picomatch(normalized, { dot: true })
+}
+
+function toPosix(input) {
+  return input.split(path.sep).join("/")
+}

package/src/coverage/reporter.js

@@ -1,6 +1,6 @@
 import fs from "node:fs/promises"
 
-import { generateCoverageReport } from "./report.js"
+import { CoverageThresholdError, generateCoverageReport } from "./report.js"
 import { removeCoverageFiles } from "./files.js"
 
 
@@ -21,14 +21,37 @@ class CoverageReporter {
     await fs.rm(this.config.coverageReportDir, { recursive: true, force: true })
   }
 
-  async onEnd() {
+  async onEnd(result) {
     if (!this.config.coverageEnabled) {
       return
     }
 
-    await generateCoverageReport(this.config)
+    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
+  }
+}