@rpcbase/test 0.308.0 → 0.310.0

package/src/coverage/v8-tracker.js

@@ -1,205 +0,0 @@
-import fs from "node:fs/promises"
-import path from "node:path"
-
-import { isInsideAnyRoot, resolveCollectCoverageRoots } from "./collect.js"
-
-
-const VITE_FS_PREFIX = "/@fs/"
-
-function sanitizePathSegment(input) {
-  const value = String(input ?? "").trim()
-  return value.replace(/[^a-zA-Z0-9._-]+/g, "_") || "unknown"
-}
-
-function urlPathLooksLikeFile(pathname) {
-  const base = path.posix.basename(String(pathname ?? ""))
-  return base.length > 0 && base.includes(".")
-}
-
-export async function createCoverageTracker(page, config) {
-  const session = await page.context().newCDPSession(page)
-  const scriptMeta = new Map()
-  const sourceCache = new Map()
-  const scriptRoots = resolveCollectCoverageRoots(config.collectCoverageFrom, config.rootDir)
-
-  await session.send("Debugger.enable")
-  session.on("Debugger.scriptParsed", (event) => {
-    if (!event.url) {
-      return
-    }
-
-    const normalized = normalizeScriptUrl(event.url, config)
-    const trackable = normalized
-      && !isNodeModulesPath(normalized.absolutePath)
-      && isInsideAnyRoot(normalized.absolutePath, scriptRoots)
-
-    scriptMeta.set(event.scriptId, {
-      normalized: trackable ? normalized : null,
-      url: event.url,
-    })
-  })
-
-  await session.send("Profiler.enable")
-  await session.send("Profiler.startPreciseCoverage", { callCount: false, detailed: true })
-
-  return {
-    async stop(testInfo) {
-      try {
-        const payload = await collectCoveragePayload(session, scriptMeta, sourceCache, testInfo, config)
-
-        if (payload.scripts.length === 0) {
-          return
-        }
-
-        const outputFile = resolveCoverageOutputFile(config, testInfo)
-        await fs.mkdir(path.dirname(outputFile), { recursive: true })
-        await fs.writeFile(outputFile, JSON.stringify(payload, null, 2), "utf8")
-      } finally {
-        await shutdownSession(session)
-      }
-    },
-  }
-}
-
-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")
-
-  const scripts = []
-
-  for (const script of result) {
-    const meta = scriptMeta.get(script.scriptId)
-    if (!meta || !meta.normalized) {
-      continue
-    }
-
-    const source = await resolveScriptSource(session, sourceCache, script.scriptId)
-    scripts.push({
-      absolutePath: meta.normalized.absolutePath,
-      relativePath: meta.normalized.relativePath,
-      source,
-      functions: script.functions,
-      url: meta.url,
-    })
-  }
-
-  return {
-    testId: testInfo.titlePath.join(" › "),
-    scripts,
-  }
-}
-
-async function resolveScriptSource(session, cache, scriptId) {
-  const cached = cache.get(scriptId)
-  if (cached) {
-    return cached
-  }
-
-  const promise = fetchScriptSource(session, scriptId)
-  cache.set(scriptId, promise)
-  return promise
-}
-
-async function fetchScriptSource(session, scriptId) {
-  try {
-    const sourceResponse = await session.send("Debugger.getScriptSource", { scriptId })
-    return sourceResponse?.scriptSource ?? ""
-  } catch (error) {
-    const message = String(error?.message ?? error)
-    if (message.includes("Debugger agent is not enabled")) {
-      try {
-        await session.send("Debugger.enable")
-        const sourceResponse = await session.send("Debugger.getScriptSource", { scriptId })
-        return sourceResponse?.scriptSource ?? ""
-      } catch {
-        return ""
-      }
-    }
-
-    return ""
-  }
-}
-
-async function shutdownSession(session) {
-  await Promise.allSettled([
-    session.send("Profiler.stopPreciseCoverage").catch(() => undefined),
-    session.send("Profiler.disable").catch(() => undefined),
-    session.send("Debugger.disable").catch(() => undefined),
-  ])
-  await session.detach().catch(() => undefined)
-}
-
-function normalizeScriptUrl(rawUrl, config) {
-  if (!rawUrl || rawUrl.startsWith("node:")) {
-    return null
-  }
-
-  const cleaned = stripQuery(rawUrl)
-  let pathname = cleaned
-
-  try {
-    const parsed = new URL(cleaned)
-    pathname = parsed.pathname
-  } catch {
-    // keep as-is for relative paths
-  }
-
-  if (!pathname) {
-    return null
-  }
-
-  let absolutePath
-
-  const decoded = decodeURIComponent(pathname)
-  if (decoded.startsWith(VITE_FS_PREFIX)) {
-    absolutePath = path.normalize(decoded.slice(VITE_FS_PREFIX.length))
-  } else if (decoded.startsWith("/")) {
-    if (!urlPathLooksLikeFile(decoded)) {
-      return null
-    }
-    absolutePath = path.resolve(process.cwd(), `.${decoded}`)
-  } else {
-    return null
-  }
-
-  return createNormalizedPath(absolutePath, config.rootDir)
-}
-
-function createNormalizedPath(absolutePath, rootDir) {
-  const normalizedAbsolute = path.normalize(absolutePath)
-  const relativePath = path.relative(rootDir, normalizedAbsolute)
-  return {
-    absolutePath: normalizedAbsolute,
-    relativePath,
-  }
-}
-
-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 isNodeModulesPath(filePath) {
-  return path
-    .normalize(String(filePath ?? ""))
-    .split(path.sep)
-    .includes("node_modules")
-}

package/src/defineConfig.js

@@ -1,129 +0,0 @@
-import fs from "fs"
-import path from "path"
-import { fileURLToPath } from "url"
-import { cpus } from "os"
-
-import _ from "lodash"
-import { defineConfig, devices } from "@playwright/test"
-
-
-function mergeConfig(base, override) {
-  return _.merge({}, base, override)
-}
-
-function getCallerConfigDir() {
-  const stack = new Error().stack?.split("\n") ?? []
-  const frame = stack.find(line =>
-    line.includes("playwright.config") &&
-    !line.includes("defineConfig.js")
-  )
-  if (!frame) return null
-  const match = frame.match(/(file:[^):]+|\/[^):]+):\d+:\d+/)
-  if (!match) return null
-  return path.dirname(fileURLToPath(match[1]))
-}
-
-const hasPassedAllPreviousTests = (data) => {
-  function checkSuite(suite) {
-    if (suite.specs && suite.specs.length > 0) {
-      for (const spec of suite.specs) {
-        if (!checkSpec(spec)) return false
-      }
-    }
-    if (suite.suites && suite.suites.length > 0) {
-      for (const innerSuite of suite.suites) {
-        if (!checkSuite(innerSuite)) return false
-      }
-    }
-    return true
-  }
-
-  function checkSpec(spec) {
-    if (spec.tests && spec.tests.length > 0) {
-      for (const test of spec.tests) {
-        if (!checkTest(test)) return false
-      }
-    }
-    return true
-  }
-
-  function checkTest(test) {
-    if (test.results && test.results.length > 0) {
-      for (const result of test.results) {
-        if (!["passed", "skipped"].includes(result.status)) return false
-      }
-    }
-    return true
-  }
-
-  if (data.suites && data.suites.length > 0) {
-    for (const suite of data.suites) {
-      if (!checkSuite(suite)) return false
-    }
-  }
-
-  return true
-}
-
-
-const isHeadless = () => {
-  if (process.env.CI) return true
-  try {
-    const lastResults = JSON.parse(fs.readFileSync("./build/playwright/results.json", "utf8"))
-    const hasPassed = hasPassedAllPreviousTests(lastResults)
-    return hasPassed
-  } catch (_err) {
-    // console.log("Error reading last results", err)
-    // Default to show if no previous results or error reading file
-    return false
-  }
-}
-
-
-// https://playwright.dev/docs/test-configuration
-export default function(config) {
-  const expected = getCallerConfigDir()
-  if (expected && process.cwd() !== expected) {
-    throw new Error(
-      `Playwright must be run from ${expected}. Current cwd: ${process.cwd()}.`
-    )
-  }
-
-  const baseConfig = {
-    globalSetup: ["./spec/helpers/globalSetup.ts"],
-    testDir: "./build/spec",
-    fullyParallel: false,
-    /* Fail the build on CI if you accidentally left test.only in the source code. */
-    forbidOnly: !!process.env.CI,
-    /* Retry on CI only */
-    retries: process.env.CI ? 4 : 0,
-    /* Opt out of parallel tests on CI. */
-    workers: process.env.CI ? 1 : cpus().length,
-    /* Reporter to use. See https://playwright.dev/docs/test-reporters */
-    reporter: [
-      ["html", {open: "never", outputFolder: "./build/playwright/report"}],
-      ["blob", {outputFile: "./build/playwright/blob"}],
-      ["list", {outputFile: "./build/playwright/results.txt"}],
-      ["json", { outputFile: "./build/playwright/results.json" }]
-    ],
-    outputDir: "./build/playwright/test-results",
-    /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
-    use: {
-      baseURL: "http://localhost:8080",
-      /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
-      trace: "on",
-      video: "on",
-      launchOptions: {
-        headless: isHeadless(),
-      },
-    },
-    projects: [
-      {
-        name: "chromium",
-        use: { ...devices["Desktop Chrome"] },
-      },
-    ],
-  }
-
-  return defineConfig(mergeConfig(baseConfig, config))
-}

package/src/index.js

@@ -1,49 +0,0 @@
-import { test as baseTest, expect as baseExpect, defineConfig as playwrightDefineConfig, devices } from "@playwright/test"
-
-import { loadCoverageOptions } from "./coverage/config-loader.js"
-import { createCoverageHarness } from "./coverage/index.js"
-
-
-export { clearDatabase } from "./clearDatabase.js"
-export * from "./coverage/index.js"
-
-const coverageOptions = await loadCoverageOptions({ optional: true })
-const coverageHarness = coverageOptions ? createCoverageHarness(coverageOptions) : null
-export const test = coverageHarness ? coverageHarness.extendTest(baseTest) : baseTest
-export const expect = baseExpect
-export { devices }
-
-export function defineConfig(userConfig = {}) {
-  const normalized = { ...userConfig }
-  const reporters = ensureReporterArray(normalized.reporter)
-
-  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)
-    }
-  }
-
-  normalized.reporter = reporters
-
-  return playwrightDefineConfig(normalized)
-}
-
-function ensureReporterArray(reporter) {
-  if (!reporter) {
-    return [["list"]]
-  }
-
-  if (!Array.isArray(reporter)) {
-    return [normalizeReporterEntry(reporter)]
-  }
-
-  return reporter.map((entry) => normalizeReporterEntry(entry))
-}
-
-function normalizeReporterEntry(entry) {
-  if (Array.isArray(entry)) {
-    return entry
-  }
-  return [entry]
-}

package/src/vitest.config.mjs

@@ -1,107 +0,0 @@
-import path from "node:path"
-import fs from "node:fs"
-import { createRequire } from "node:module"
-
-import { defineConfig } from "vitest/config"
-
-
-const require = createRequire(import.meta.url)
-
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
-}
-
-function loadTsconfig() {
-  let ts
-  try {
-    ts = require("typescript")
-  } catch (_err) {
-    throw new Error(
-      "@rpcbase/test: TypeScript is required to resolve path aliases. Please add it as a devDependency.",
-    )
-  }
-
-  const cwd = process.cwd()
-  const configPath =
-    ts.findConfigFile(cwd, ts.sys.fileExists, "tsconfig.json") ||
-    ts.findConfigFile(cwd, ts.sys.fileExists, "tsconfig.base.json")
-
-  if (!configPath) {
-    throw new Error("@rpcbase/test: no tsconfig found for alias resolution")
-  }
-
-  const configFile = ts.readConfigFile(configPath, ts.sys.readFile)
-  if (configFile.error) {
-    throw new Error(`@rpcbase/test: unable to read tsconfig at ${configPath}`)
-  }
-
-  const parsed = ts.parseJsonConfigFileContent(
-    configFile.config,
-    ts.sys,
-    path.dirname(configPath),
-  )
-
-  return {
-    path: configPath,
-    baseUrl: parsed.options?.baseUrl
-      ? path.resolve(path.dirname(configPath), parsed.options.baseUrl)
-      : path.dirname(configPath),
-    paths: parsed.options?.paths,
-  }
-}
-
-function pathsToAlias(tsconfig) {
-  const paths = tsconfig?.paths
-  if (!paths) return []
-
-  const baseUrl = tsconfig.baseUrl || path.dirname(tsconfig.path)
-  const alias = []
-
-  for (const [key, targets] of Object.entries(paths)) {
-    if (!Array.isArray(targets)) continue
-
-    for (const target of targets) {
-      if (key.includes("*") && target.includes("*")) {
-        const wildcardPattern = target.endsWith("*") ? "(.+)" : "([^/]+)"
-        const find = new RegExp(
-          `^${escapeRegex(key).split("\\*").join(wildcardPattern)}$`,
-        )
-        let groupIndex = 0
-        const replacedTarget = target.replace(/\*/g, () => `$${++groupIndex}`)
-        const replacement = path.resolve(baseUrl, replacedTarget)
-        const checkPath = replacement.replace(/\$\\d+/g, "")
-        if (
-          checkPath.includes(`${path.sep}node_modules${path.sep}`) &&
-          !fs.existsSync(checkPath)
-        ) {
-          continue
-        }
-        alias.push({ find, replacement })
-        continue
-      }
-
-      const find = key.replace(/\*$/, "")
-      const cleanTarget = target.replace(/\*$/, "")
-      const replacement = path.resolve(baseUrl, cleanTarget)
-      if (
-        replacement.includes(`${path.sep}node_modules${path.sep}`) &&
-        !fs.existsSync(replacement)
-      ) {
-        continue
-      }
-      alias.push({ find, replacement })
-    }
-  }
-
-  return alias
-}
-
-const tsconfig = loadTsconfig()
-const alias = pathsToAlias(tsconfig)
-
-export default defineConfig({
-  test: {
-    include: ["{src,lib}/**/*.test.{js,ts,tsx}"],
-  },
-  resolve: alias.length > 0 ? { alias } : undefined,
-})