@rpcbase/test 0.304.0 → 0.305.0

package/package.json

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

package/src/cli.js

@@ -19,6 +19,7 @@ const moduleDir = path.dirname(fileURLToPath(import.meta.url))
 
 const VITEST_COVERAGE_CANDIDATES = ["src/coverage.json"]
 
+const COMBINED_COVERAGE_ENV_VAR = "RB_TEST_COMBINED_COVERAGE"
 
 const isAider = process.env.IS_AIDER === "yes"
 
@@ -29,25 +30,27 @@ if (process.env.IS_AIDER !== undefined && process.env.IS_AIDER !== "yes") {
 async function runTests() {
   const userArgs = process.argv.slice(2)
 
+  const playwrightCoverage = await loadPlaywrightCoverageConfig()
   const vitestCoverage = await loadVitestCoverageConfig()
+  const combinedCoverage = resolveCombinedCoverage(playwrightCoverage, vitestCoverage)
 
-  if (vitestCoverage?.enabled) {
-    await cleanCoverageArtifacts(vitestCoverage.config)
+  if (combinedCoverage?.enabled) {
+    await cleanCoverageArtifacts(combinedCoverage.config)
   }
 
   let testError = null
 
   try {
-    await runVitest(vitestCoverage)
+    await runVitest(vitestCoverage, combinedCoverage?.config ?? null)
     console.log("\nRunning Playwright Tests...")
     await runPlaywright(userArgs)
   } catch (error) {
     testError = error
   }
 
-  if (vitestCoverage?.enabled) {
+  if (combinedCoverage?.enabled) {
     try {
-      await finalizeCoverage(vitestCoverage.config)
+      await finalizeCoverage(combinedCoverage.config)
     } catch (error) {
       if (!testError) {
         testError = error
@@ -64,7 +67,7 @@ runTests()
   .then(() => process.exit(0))
   .catch(() => process.exit(1))
 
-async function runVitest(coverage) {
+async function runVitest(coverage, combinedConfig) {
   const vitestArgs = ["run", "--passWithNoTests"]
   const vitestConfig = resolveVitestConfig()
 
@@ -75,7 +78,7 @@ async function runVitest(coverage) {
   const env = withRegisterShim(process.env)
 
   if (coverage?.enabled) {
-    env.NODE_V8_COVERAGE = coverage.nodeCoverageDir
+    env.NODE_V8_COVERAGE = resolveNodeCoverageDir(combinedConfig ?? coverage.config)
   }
 
   await spawnWithLogs({
@@ -88,7 +91,10 @@ async function runVitest(coverage) {
   })
 
   if (coverage?.enabled) {
-    await convertNodeCoverage(coverage)
+    await convertNodeCoverage({
+      config: combinedConfig ?? coverage.config,
+      nodeCoverageDir: resolveNodeCoverageDir(combinedConfig ?? coverage.config),
+    })
   }
 }
 
@@ -119,6 +125,7 @@ function runPlaywright(userArgs) {
   ensureJsxRuntimeShim(process.cwd())
   const launcher = resolvePlaywrightLauncher()
   const env = withRegisterShim(process.env)
+  env[COMBINED_COVERAGE_ENV_VAR] = "1"
 
   return spawnWithLogs({
     name: "Playwright",
@@ -246,17 +253,46 @@ async function loadVitestCoverageConfig() {
 
   return {
     config,
-    nodeCoverageDir: path.join(config.testResultsRoot, "node-coverage"),
     enabled: config.coverageEnabled,
   }
 }
 
+async function loadPlaywrightCoverageConfig() {
+  const options = await loadCoverageOptions({ optional: true })
+  if (!options) {
+    return null
+  }
+
+  const config = createCoverageConfig(options)
+
+  return {
+    config,
+    enabled: config.coverageEnabled,
+  }
+}
+
+function resolveCombinedCoverage(playwrightCoverage, vitestCoverage) {
+  if (playwrightCoverage?.enabled) {
+    return playwrightCoverage
+  }
+
+  if (vitestCoverage?.enabled) {
+    return vitestCoverage
+  }
+
+  return null
+}
+
 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 })
 }
 
+function resolveNodeCoverageDir(config) {
+  return path.join(config.testResultsRoot, "node-coverage", "vitest")
+}
+
 async function convertNodeCoverage(coverage) {
   const { config, nodeCoverageDir } = coverage
 

package/src/coverage/global-setup.js

@@ -5,6 +5,10 @@ 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
     }

package/src/coverage/report.js

@@ -1,5 +1,6 @@
 import fs from "node:fs/promises"
 import path from "node:path"
+import { fileURLToPath } from "node:url"
 
 import * as libCoverage from "istanbul-lib-coverage"
 import { createContext } from "istanbul-lib-report"
@@ -37,7 +38,7 @@ export async function generateCoverageReport(config) {
     }
 
     for (const script of payload.scripts) {
-      await mergeScriptCoverage(coverageMap, script)
+      await mergeScriptCoverage(coverageMap, script, config)
     }
   }
 
@@ -82,20 +83,37 @@ export async function generateCoverageReport(config) {
   }
 }
 
-async function mergeScriptCoverage(coverageMap, script) {
+async function mergeScriptCoverage(coverageMap, script, config) {
   const scriptPath = script.absolutePath
   if (!scriptPath) {
     return
   }
 
+  if (isNodeModulesPath(scriptPath)) {
+    return
+  }
+
+  if (isViteVirtualModulePath(scriptPath)) {
+    return
+  }
+
   const source = script.source && script.source.length > 0
     ? script.source
     : await fs.readFile(scriptPath, "utf8")
 
-  const converter = v8ToIstanbul(scriptPath, 0, { source })
+  const sourceMap = await loadSourceMapForScript(scriptPath, source)
+  const converter = v8ToIstanbul(
+    scriptPath,
+    0,
+    sourceMap ? { source, sourceMap: { sourcemap: sourceMap } } : { source },
+  )
   await converter.load()
   converter.applyCoverage(script.functions)
-  coverageMap.merge(converter.toIstanbul())
+
+  const filtered = filterCoverageMap(converter.toIstanbul(), config)
+  if (Object.keys(filtered).length > 0) {
+    coverageMap.merge(filtered)
+  }
 }
 
 async function readCoverageFile(file) {
@@ -190,3 +208,222 @@ function createGlobMatcher(pattern) {
 function toPosix(input) {
   return input.split(path.sep).join("/")
 }
+
+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) {
+  if (!map || typeof map !== "object") {
+    return {}
+  }
+
+  const filtered = {}
+
+  for (const [filePath, fileCoverage] of Object.entries(map)) {
+    if (!isLibraryFile(filePath, config)) {
+      continue
+    }
+    filtered[filePath] = fileCoverage
+  }
+
+  return filtered
+}
+
+function isLibraryFile(filePath, config) {
+  const absolutePath = resolveCoveragePath(filePath, config.workspaceRoot)
+  if (!absolutePath) {
+    return false
+  }
+
+  if (isNodeModulesPath(absolutePath)) {
+    return false
+  }
+
+  if (isViteVirtualModulePath(absolutePath)) {
+    return false
+  }
+
+  return isInsideLib(absolutePath, config.libRoots)
+}
+
+function resolveCoveragePath(filePath, workspaceRoot) {
+  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(workspaceRoot, 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 isInsideLib(absolutePath, libRoots) {
+  return libRoots.some((libRoot) => {
+    const relative = path.relative(libRoot, absolutePath)
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))
+  })
+}
+
+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

@@ -13,6 +13,10 @@ class CoverageReporter {
   }
 
   async onBegin() {
+    if (process.env.RB_TEST_COMBINED_COVERAGE === "1") {
+      return
+    }
+
     if (!this.config.coverageEnabled) {
       return
     }
@@ -22,6 +26,10 @@ class CoverageReporter {
   }
 
   async onEnd(result) {
+    if (process.env.RB_TEST_COMBINED_COVERAGE === "1") {
+      return
+    }
+
     if (!this.config.coverageEnabled) {
       return
     }

package/src/coverage/v8-tracker.js

@@ -4,6 +4,11 @@ import path from "node:path"
 
 const VITE_FS_PREFIX = "/@fs/"
 
+function sanitizePathSegment(input) {
+  const value = String(input ?? "").trim()
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "_") || "unknown"
+}
+
 export async function createCoverageTracker(page, config) {
   const session = await page.context().newCDPSession(page)
   const scriptMeta = new Map()
@@ -40,7 +45,7 @@ export async function createCoverageTracker(page, config) {
           return
         }
 
-        const outputFile = testInfo.outputPath(config.coverageFileName)
+        const outputFile = resolveCoverageOutputFile(config, testInfo)
         await fs.mkdir(path.dirname(outputFile), { recursive: true })
         await fs.writeFile(outputFile, JSON.stringify(payload, null, 2), "utf8")
       } finally {
@@ -50,6 +55,13 @@ export async function createCoverageTracker(page, config) {
   }
 }
 
+function resolveCoverageOutputFile(config, testInfo) {
+  const projectName = sanitizePathSegment(testInfo.project?.name)
+  const testId = sanitizePathSegment(testInfo.testId)
+  const outputDir = path.join(config.testResultsRoot, "playwright", projectName, testId)
+  return path.join(outputDir, config.coverageFileName)
+}
+
 async function collectCoveragePayload(session, scriptMeta, sourceCache, testInfo, config) {
   const { result } = await session.send("Profiler.takePreciseCoverage")
   await session.send("Profiler.stopPreciseCoverage")
@@ -128,7 +140,7 @@ function normalizeScriptUrl(rawUrl, config) {
   if (decoded.startsWith(VITE_FS_PREFIX)) {
     absolutePath = path.normalize(decoded.slice(VITE_FS_PREFIX.length))
   } else if (decoded.startsWith("/")) {
-    absolutePath = path.resolve(config.workspaceRoot, `.${decoded}`)
+    absolutePath = path.resolve(process.cwd(), `.${decoded}`)
   } else {
     return null
   }

package/src/index.js

@@ -17,7 +17,7 @@ export function defineConfig(userConfig = {}) {
   const normalized = { ...userConfig }
   const reporters = ensureReporterArray(normalized.reporter)
 
-  if (coverageHarness?.config.coverageEnabled) {
+  if (coverageHarness?.config.coverageEnabled && process.env.RB_TEST_COMBINED_COVERAGE !== "1") {
     const coverageReporter = coverageHarness.reporterEntry()
     if (!reporters.some(([name]) => name === coverageReporter[0])) {
       reporters.push(coverageReporter)