@rpcbase/test 0.307.0 → 0.308.0

package/README.md

@@ -24,10 +24,10 @@ Only `RB_DISABLE_COVERAGE=1` skips the hooks; every other option lives inside th
 
 If you omit `collectCoverageFrom`, `rb-test` uses a reasonable default:
 
-- `src/**/*.{ts,tsx,js,jsx,mts,cts,mjs,cjs}` when `src/` exists
+- `src/**/*.{ts,tsx,js,jsx,mjs,cjs}` when `src/` exists
 - if `src/` is missing, `rb-test` throws unless you set `collectCoverageFrom`
 
-Unit test files are excluded by default: `!**/*.test.{ts,tsx,js,jsx,mts,cts,mjs,cjs}`.
+Unit test files are excluded by default: `!**/*.test.{ts,tsx,js,jsx,mjs,cjs}`.
 
 `collectCoverageFrom` supports negated globs (prefix with `!`) to exclude files.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpcbase/test",
-  "version": "0.307.0",
+  "version": "0.308.0",
   "type": "module",
   "files": [
     "src",

package/src/cli.js

@@ -1,17 +1,19 @@
 #!/usr/bin/env node
 
-import { spawn } from "child_process"
+import { spawn, spawnSync } 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 fg from "fast-glob"
+
 import { createCoverageConfig } from "./coverage/config.js"
-import { isInsideAnyRoot, resolveCollectCoverageRoots } from "./coverage/collect.js"
+import { createCollectCoverageMatcher, isInsideAnyRoot, resolveCollectCoverageRoots } from "./coverage/collect.js"
 import { loadCoverageOptions } from "./coverage/config-loader.js"
 import { removeCoverageFiles } from "./coverage/files.js"
-import { CoverageThresholdError, generateCoverageReport } from "./coverage/report.js"
+import { collectCoveredFiles, CoverageThresholdError, generateCoverageReport } from "./coverage/report.js"
 
 
 const require = createRequire(import.meta.url)
@@ -30,26 +32,60 @@ if (process.env.IS_AIDER !== undefined && process.env.IS_AIDER !== "yes") {
 
 async function runTests() {
   const userArgs = process.argv.slice(2)
+  const buildSpecsMap = userArgs.includes("--build-specs-map")
+  const auto = userArgs.includes("--auto")
+  const showMapping = userArgs.includes("--show-mapping")
+  const filteredArgs = userArgs.filter((arg) => arg !== "--build-specs-map" && arg !== "--auto" && arg !== "--show-mapping")
+
+  if (buildSpecsMap && auto) {
+    throw new Error("[rb-test] --auto cannot be combined with --build-specs-map")
+  }
+
+  if (showMapping && !auto) {
+    throw new Error("[rb-test] --show-mapping requires --auto")
+  }
 
   const playwrightCoverage = await loadPlaywrightCoverageConfig()
   const vitestCoverage = await loadVitestCoverageConfig()
   const combinedCoverage = resolveCombinedCoverage(playwrightCoverage, vitestCoverage)
 
-  if (combinedCoverage?.enabled) {
+  if (buildSpecsMap) {
+    await buildSpecsMapFromCoverage({
+      userArgs: filteredArgs,
+      playwrightCoverage,
+      vitestCoverage,
+      combinedCoverage,
+    })
+    return
+  }
+
+  const shouldGenerateCoverageReport = combinedCoverage?.enabled && !auto
+
+  if (shouldGenerateCoverageReport) {
     await cleanCoverageArtifacts(combinedCoverage.config)
   }
 
   let testError = null
 
   try {
-    await runVitest(vitestCoverage, combinedCoverage?.config ?? null)
+    await runVitest(vitestCoverage, combinedCoverage?.config ?? null, { disableCoverage: auto })
     console.log("\nRunning Playwright Tests...")
-    await runPlaywright(userArgs)
+    const playwrightArgs = auto
+      ? await resolveAutoPlaywrightArgs({
+        userArgs: filteredArgs,
+        playwrightCoverage,
+        vitestCoverage,
+        showMapping,
+      })
+      : userArgs
+    if (playwrightArgs) {
+      await runPlaywright(playwrightArgs, { disableCoverage: auto })
+    }
   } catch (error) {
     testError = error
   }
 
-  if (combinedCoverage?.enabled) {
+  if (shouldGenerateCoverageReport) {
     try {
       await finalizeCoverage(combinedCoverage.config)
     } catch (error) {
@@ -73,7 +109,7 @@ runTests()
     process.exit(1)
   })
 
-async function runVitest(coverage, combinedConfig) {
+async function runVitest(coverage, combinedConfig, { disableCoverage = false } = {}) {
   const vitestArgs = ["run", "--passWithNoTests"]
   const vitestConfig = resolveVitestConfig()
 
@@ -83,7 +119,11 @@ async function runVitest(coverage, combinedConfig) {
   const launcher = resolveVitestLauncher()
   const env = withRegisterShim(process.env)
 
-  if (coverage?.enabled) {
+  if (disableCoverage) {
+    env.RB_DISABLE_COVERAGE = "1"
+  }
+
+  if (coverage?.enabled && !disableCoverage) {
     env.NODE_V8_COVERAGE = resolveNodeCoverageDir(combinedConfig ?? coverage.config)
   }
 
@@ -96,7 +136,7 @@ async function runVitest(coverage, combinedConfig) {
     failureMessage: "Vitest failed",
   })
 
-  if (coverage?.enabled) {
+  if (coverage?.enabled && !disableCoverage) {
     await convertNodeCoverage({
       config: combinedConfig ?? coverage.config,
       nodeCoverageDir: resolveNodeCoverageDir(combinedConfig ?? coverage.config),
@@ -104,7 +144,411 @@ async function runVitest(coverage, combinedConfig) {
   }
 }
 
-function runPlaywright(userArgs) {
+async function buildSpecsMapFromCoverage({ userArgs, combinedCoverage }) {
+  if (!combinedCoverage?.enabled) {
+    throw new Error("[specs-map] Coverage must be enabled to build the specs map.")
+  }
+
+  const config = combinedCoverage.config
+  const workspaceRoot = findWorkspaceRoot(process.cwd())
+
+  const specSourceFiles = await findSpecSourceFiles(config.rootDir)
+  if (specSourceFiles.length === 0) {
+    throw new Error("[specs-map] No spec files found under spec/**/*.spec.ts")
+  }
+
+  const filesMapDir = path.join(config.testResultsRoot, "files-map")
+  await fsPromises.rm(filesMapDir, { recursive: true, force: true })
+  await fsPromises.mkdir(filesMapDir, { recursive: true })
+
+  for (const specSourceFile of specSourceFiles) {
+    const specProjectPath = path.relative(config.rootDir, specSourceFile)
+    const specWorkspacePath = toPosixPath(path.relative(workspaceRoot, specSourceFile))
+    const testFile = resolvePlaywrightSpecFile(specProjectPath)
+
+    console.log(`\n[specs-map] Running ${specWorkspacePath}`)
+
+    await removeCoverageFiles(config)
+
+    let error = null
+    let failed = false
+    try {
+      await runPlaywright([...userArgs, testFile])
+    } catch (runError) {
+      error = runError
+      failed = true
+      console.error(`[specs-map] Failed: ${specWorkspacePath}`)
+      console.error(runError?.stack ?? String(runError))
+    }
+
+    const coveredFiles = await collectCoveredFiles(config)
+    const impactedFiles = coveredFiles
+      .map((filePath) => toPosixPath(path.relative(workspaceRoot, filePath)))
+      .filter((relativePath) => relativePath && !relativePath.startsWith("../") && relativePath !== "..")
+      .sort()
+
+    const outputFile = path.join(filesMapDir, `${specProjectPath}.json`)
+    await fsPromises.mkdir(path.dirname(outputFile), { recursive: true })
+    await fsPromises.writeFile(
+      outputFile,
+      JSON.stringify(
+        {
+          spec: specWorkspacePath,
+          files: impactedFiles,
+          failed,
+        },
+        null,
+        2,
+      ),
+      "utf8",
+    )
+
+    if (failed) {
+      throw error
+    }
+  }
+}
+
+async function resolveAutoPlaywrightArgs({ userArgs, playwrightCoverage, vitestCoverage, showMapping = false }) {
+  const config = playwrightCoverage?.config ?? vitestCoverage?.config ?? null
+  if (!config) {
+    console.warn("[auto] Coverage config not found; running full Playwright suite.")
+    return userArgs
+  }
+
+  const filesMapDir = path.join(config.testResultsRoot, "files-map")
+  const mapFiles = await findFilesMapJson(filesMapDir)
+  if (mapFiles.length === 0) {
+    console.warn("[auto] Specs map not found; running full Playwright suite.")
+    return userArgs
+  }
+
+  const workspaceRoot = findWorkspaceRoot(process.cwd())
+  const gitChanges = getGitChanges(workspaceRoot)
+  const renameMap = new Map(gitChanges.filter((change) => change.kind === "rename").map((change) => [change.oldPath, change.newPath]))
+
+  const specRootAbs = path.join(config.rootDir, "spec")
+  const matchesCollectCoverageFrom = createCollectCoverageMatcher(config.collectCoverageFrom, config.rootDir)
+
+  const directSpecChanges = new Set()
+  const sourceChanges = []
+
+  for (const change of gitChanges) {
+    if (change.kind === "rename") {
+      const oldAbs = path.join(workspaceRoot, change.oldPath)
+      const newAbs = path.join(workspaceRoot, change.newPath)
+
+      if (isSpecSourceFile(newAbs, specRootAbs) && fs.existsSync(newAbs)) {
+        directSpecChanges.add(change.newPath)
+      }
+
+      const oldMatches = matchesCollectCoverageFrom(oldAbs)
+      const newMatches = matchesCollectCoverageFrom(newAbs)
+      if (oldMatches || newMatches) {
+        sourceChanges.push(change)
+      }
+      continue
+    }
+
+    const abs = path.join(workspaceRoot, change.path)
+
+    if (isSpecSourceFile(abs, specRootAbs) && fs.existsSync(abs)) {
+      directSpecChanges.add(change.path)
+    }
+
+    if (matchesCollectCoverageFrom(abs)) {
+      sourceChanges.push(change)
+    }
+  }
+
+  if (directSpecChanges.size === 0 && sourceChanges.length === 0) {
+    console.log("[auto] No relevant git changes.")
+    return null
+  }
+
+  const parsedMaps = []
+  for (const file of mapFiles) {
+    const json = await readJson(file)
+    if (!json) {
+      continue
+    }
+
+    if (json.failed === true) {
+      console.warn("[auto] Specs map contains failed entries; running full Playwright suite.")
+      return userArgs
+    }
+
+    const spec = typeof json?.spec === "string" ? json.spec : null
+    if (!spec) {
+      continue
+    }
+
+    const files = Array.isArray(json?.files) ? json.files.filter((entry) => typeof entry === "string") : []
+    parsedMaps.push({ spec, files })
+  }
+
+  if (parsedMaps.length === 0) {
+    console.warn("[auto] Specs map is empty; running full Playwright suite.")
+    return userArgs
+  }
+
+  const specsByImpactedFile = new Map()
+
+  for (const entry of parsedMaps) {
+    const resolvedSpec = resolveRenamedPath(entry.spec, renameMap)
+    for (const file of entry.files) {
+      const list = specsByImpactedFile.get(file) ?? []
+      list.push(resolvedSpec)
+      specsByImpactedFile.set(file, list)
+    }
+  }
+
+  const unmappedSourceChanges = sourceChanges.filter((change) => {
+    if (change.kind === "path") {
+      return !specsByImpactedFile.has(change.path)
+    }
+    return !specsByImpactedFile.has(change.oldPath) && !specsByImpactedFile.has(change.newPath)
+  })
+
+  if (unmappedSourceChanges.length > 0) {
+    console.warn("[auto] Unmapped source changes detected:")
+    for (const change of unmappedSourceChanges) {
+      if (change.kind === "path") {
+        console.warn(`  - ${change.path}`)
+      } else {
+        console.warn(`  - ${change.oldPath} -> ${change.newPath}`)
+      }
+    }
+  }
+
+  const selectedSpecs = new Set(directSpecChanges)
+  const triggersBySpec = new Map()
+
+  for (const spec of directSpecChanges) {
+    if (showMapping) {
+      triggersBySpec.set(spec, new Set([spec]))
+    }
+  }
+
+  for (const change of sourceChanges) {
+    if (change.kind === "path") {
+      const specs = specsByImpactedFile.get(change.path) ?? []
+      specs.forEach((spec) => selectedSpecs.add(spec))
+      if (showMapping) {
+        for (const spec of specs) {
+          const current = triggersBySpec.get(spec) ?? new Set()
+          current.add(change.path)
+          triggersBySpec.set(spec, current)
+        }
+      }
+      continue
+    }
+
+    const oldSpecs = specsByImpactedFile.get(change.oldPath) ?? []
+    oldSpecs.forEach((spec) => selectedSpecs.add(spec))
+    const newSpecs = specsByImpactedFile.get(change.newPath) ?? []
+    newSpecs.forEach((spec) => selectedSpecs.add(spec))
+    if (showMapping) {
+      const key = `${change.oldPath} -> ${change.newPath}`
+      const allSpecs = new Set([...oldSpecs, ...newSpecs])
+      for (const spec of allSpecs) {
+        const current = triggersBySpec.get(spec) ?? new Set()
+        current.add(key)
+        triggersBySpec.set(spec, current)
+      }
+    }
+  }
+
+  const missingSpecs = []
+  const specsToRun = Array.from(selectedSpecs)
+    .filter((spec) => {
+      const abs = path.join(workspaceRoot, spec)
+      if (fs.existsSync(abs)) {
+        return true
+      }
+      missingSpecs.push(spec)
+      return false
+    })
+    .sort()
+  if (missingSpecs.length > 0) {
+    console.warn(`[auto] Ignoring ${missingSpecs.length} missing spec file(s):`)
+    for (const spec of missingSpecs.sort()) {
+      console.warn(`  - ${spec}`)
+    }
+  }
+
+  if (specsToRun.length === 0) {
+    console.log("[auto] No impacted specs.")
+    return null
+  }
+
+  if (showMapping) {
+    console.log("[auto] Mapping:")
+    for (const spec of specsToRun) {
+      const triggers = Array.from(triggersBySpec.get(spec) ?? []).sort()
+      if (triggers.length === 0) {
+        continue
+      }
+      console.log(`  - ${spec}`)
+      for (const trigger of triggers) {
+        console.log(`    <- ${trigger}`)
+      }
+    }
+  }
+
+  const playwrightFiles = specsToRun
+    .map((specWorkspacePath) => path.join(workspaceRoot, specWorkspacePath))
+    .filter((specAbs) => isSubpath(specAbs, config.rootDir))
+    .map((specAbs) => {
+      const specProjectPath = path.relative(config.rootDir, specAbs)
+      return resolvePlaywrightSpecFile(specProjectPath)
+    })
+
+  const totalSpecFiles = (await findSpecSourceFiles(config.rootDir)).length
+  console.log(`[auto] Running ${playwrightFiles.length}/${totalSpecFiles} spec file(s).`)
+  return [...userArgs, ...playwrightFiles]
+}
+
+async function findFilesMapJson(filesMapDir) {
+  const patterns = ["spec/**/*.spec.ts.json", "spec/**/*.spec.tsx.json"]
+  const matches = await fg(patterns, { cwd: filesMapDir, absolute: true, onlyFiles: true }).catch(() => [])
+  return matches.sort()
+}
+
+function getGitChanges(workspaceRoot) {
+  const result = spawnSync("git", ["status", "--porcelain=1", "-z"], {
+    cwd: workspaceRoot,
+    encoding: "utf8",
+  })
+
+  if (result.status !== 0) {
+    throw new Error(`[auto] Failed to read git status: ${result.stderr || "unknown error"}`)
+  }
+
+  const tokens = String(result.stdout ?? "").split("\0").filter(Boolean)
+  const changes = []
+
+  for (let i = 0; i < tokens.length; i += 1) {
+    const record = tokens[i]
+    if (record.length < 4) {
+      continue
+    }
+
+    const status = record.slice(0, 2)
+    const pathPart = toPosixPath(record.slice(3))
+
+    if (isRenameOrCopyStatus(status)) {
+      const next = tokens[i + 1]
+      if (typeof next !== "string") {
+        continue
+      }
+      changes.push({
+        kind: "rename",
+        oldPath: pathPart,
+        newPath: toPosixPath(next),
+      })
+      i += 1
+      continue
+    }
+
+    changes.push({
+      kind: "path",
+      path: pathPart,
+    })
+  }
+
+  return changes
+}
+
+function isRenameOrCopyStatus(status) {
+  return status.includes("R") || status.includes("C")
+}
+
+function resolveRenamedPath(original, renameMap) {
+  let current = original
+  const visited = new Set()
+
+  while (renameMap.has(current) && !visited.has(current)) {
+    visited.add(current)
+    current = renameMap.get(current)
+  }
+
+  return current
+}
+
+function isSubpath(candidate, root) {
+  const relative = path.relative(root, candidate)
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))
+}
+
+function isSpecSourceFile(absolutePath, specRootAbsolute) {
+  if (!isSubpath(absolutePath, specRootAbsolute)) {
+    return false
+  }
+
+  return absolutePath.endsWith(".spec.ts")
+    || absolutePath.endsWith(".spec.tsx")
+}
+
+async function findSpecSourceFiles(projectRoot) {
+  const patterns = ["spec/**/*.spec.ts", "spec/**/*.spec.tsx"]
+  const matches = await fg(patterns, { cwd: projectRoot, absolute: true, onlyFiles: true })
+  return matches.sort()
+}
+
+function resolvePlaywrightSpecFile(specProjectPath) {
+  const buildSpecRoot = path.join(process.cwd(), "build", "spec")
+  const isBuildSpecProject = fs.existsSync(buildSpecRoot)
+
+  if (!isBuildSpecProject) {
+    return specProjectPath
+  }
+
+  const builtCandidate = normalizeBuiltSpecPath(path.join("build", specProjectPath))
+  const builtAbsolute = path.resolve(process.cwd(), builtCandidate)
+  if (!fs.existsSync(builtAbsolute)) {
+    throw new Error(`[specs-map] Missing built spec file: ${builtCandidate}`)
+  }
+
+  return builtCandidate
+}
+
+function normalizeBuiltSpecPath(filePath) {
+  if (filePath.endsWith(".ts") || filePath.endsWith(".tsx")) {
+    return `${filePath.replace(/\.tsx?$/, "")}.js`
+  }
+  return filePath
+}
+
+function toPosixPath(input) {
+  return String(input ?? "").split(path.sep).join("/")
+}
+
+function findWorkspaceRoot(projectRoot) {
+  let dir = path.resolve(projectRoot)
+
+  while (true) {
+    const pkgPath = path.join(dir, "package.json")
+    try {
+      if (fs.existsSync(pkgPath)) {
+        const parsed = JSON.parse(fs.readFileSync(pkgPath, "utf8"))
+        if (parsed && typeof parsed === "object" && parsed.workspaces) {
+          return dir
+        }
+      }
+    } catch {
+      //
+    }
+
+    const parent = path.dirname(dir)
+    if (parent === dir) {
+      return path.resolve(projectRoot)
+    }
+    dir = parent
+  }
+}
+
+function runPlaywright(userArgs, { disableCoverage = false } = {}) {
   // Determine config file path
   const configPath = fs.existsSync(
     path.join(process.cwd(), "playwright.config.ts"),
@@ -132,6 +576,9 @@ function runPlaywright(userArgs) {
   const launcher = resolvePlaywrightLauncher()
   const env = withRegisterShim(process.env)
   env[COMBINED_COVERAGE_ENV_VAR] = "1"
+  if (disableCoverage) {
+    env.RB_DISABLE_COVERAGE = "1"
+  }
 
   return spawnWithLogs({
     name: "Playwright",

package/src/coverage/config-loader.js

@@ -9,8 +9,6 @@ import { build } from "esbuild"
 
 const DEFAULT_COVERAGE_CANDIDATES = [
   "spec/coverage.config.ts",
-  "spec/coverage.config.mts",
-  "spec/coverage.config.cts",
   "spec/coverage.config.js",
   "spec/coverage.config.mjs",
   "spec/coverage.config.cjs",
@@ -19,8 +17,6 @@ const DEFAULT_COVERAGE_CANDIDATES = [
 
 const LEGACY_COVERAGE_CANDIDATES = [
   "spec/coverage.ts",
-  "spec/coverage.mts",
-  "spec/coverage.cts",
   "spec/coverage.js",
   "spec/coverage.mjs",
   "spec/coverage.cjs",
@@ -78,7 +74,7 @@ async function importCoverageModule(filePath) {
     return JSON.parse(raw)
   }
 
-  if ([".ts", ".mts", ".cts"].includes(ext)) {
+  if (ext === ".ts") {
     const compiledUrl = await compileTsModule(filePath)
     return loadModule(compiledUrl)
   }
@@ -120,7 +116,7 @@ async function loadModule(url) {
   return imported
 }
 
-const DEFAULT_COLLECT_COVERAGE_EXTENSIONS = "ts,tsx,js,jsx,mts,cts,mjs,cjs"
+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) {

package/src/coverage/report.js

@@ -91,6 +91,30 @@ export async function generateCoverageReport(config) {
   }
 }
 
+export async function collectCoveredFiles(config) {
+  const coverageFiles = await findCoverageFiles(config)
+  if (coverageFiles.length === 0) {
+    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)
+    }
+  }
+
+  return coverageMap.files().sort()
+}
+
 async function mergeScriptCoverage(coverageMap, script, config, matchesCollectCoverageFrom) {
   const scriptPath = script.absolutePath
   if (!scriptPath) {