@rpcbase/test 0.307.0 → 0.309.0

package/src/clearDatabase.js

@@ -1,19 +0,0 @@
-import mongoose from "mongoose"
-
-
-export async function clearDatabase(dbName) {
-  const { DB_PORT, APP_NAME } = process.env
-
-  const connectionString = `mongodb://localhost:${DB_PORT}/${APP_NAME}-${dbName}`
-
-  // console.log("will clear DB:", connectionString)
-
-  const connection = await mongoose
-    .createConnection(connectionString)
-    .asPromise()
-
-  // Drop the database
-  await connection.dropDatabase()
-
-  await connection.close()
-}

package/src/cli.js

@@ -1,501 +0,0 @@
-#!/usr/bin/env node
-
-import { spawn } 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 { createCoverageConfig } from "./coverage/config.js"
-import { 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"
-
-
-const require = createRequire(import.meta.url)
-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"
-
-if (process.env.IS_AIDER !== undefined && process.env.IS_AIDER !== "yes") {
-  console.warn("Warning: IS_AIDER is set to a value other than 'yes'.")
-}
-
-async function runTests() {
-  const userArgs = process.argv.slice(2)
-
-  const playwrightCoverage = await loadPlaywrightCoverageConfig()
-  const vitestCoverage = await loadVitestCoverageConfig()
-  const combinedCoverage = resolveCombinedCoverage(playwrightCoverage, vitestCoverage)
-
-  if (combinedCoverage?.enabled) {
-    await cleanCoverageArtifacts(combinedCoverage.config)
-  }
-
-  let testError = null
-
-  try {
-    await runVitest(vitestCoverage, combinedCoverage?.config ?? null)
-    console.log("\nRunning Playwright Tests...")
-    await runPlaywright(userArgs)
-  } catch (error) {
-    testError = error
-  }
-
-  if (combinedCoverage?.enabled) {
-    try {
-      await finalizeCoverage(combinedCoverage.config)
-    } catch (error) {
-      if (!testError) {
-        testError = error
-      }
-    }
-  }
-
-  if (testError) {
-    throw testError
-  }
-}
-
-runTests()
-  .then(() => process.exit(0))
-  .catch((error) => {
-    if (!(error instanceof CoverageThresholdError)) {
-      console.error(error?.stack ?? String(error))
-    }
-    process.exit(1)
-  })
-
-async function runVitest(coverage, combinedConfig) {
-  const vitestArgs = ["run", "--passWithNoTests"]
-  const vitestConfig = resolveVitestConfig()
-
-  if (vitestConfig) {
-    vitestArgs.push("--config", vitestConfig)
-  }
-  const launcher = resolveVitestLauncher()
-  const env = withRegisterShim(process.env)
-
-  if (coverage?.enabled) {
-    env.NODE_V8_COVERAGE = resolveNodeCoverageDir(combinedConfig ?? coverage.config)
-  }
-
-  await spawnWithLogs({
-    name: "Vitest",
-    launcher,
-    args: vitestArgs,
-    env,
-    successMessage: "Vitest suite passed!",
-    failureMessage: "Vitest failed",
-  })
-
-  if (coverage?.enabled) {
-    await convertNodeCoverage({
-      config: combinedConfig ?? coverage.config,
-      nodeCoverageDir: resolveNodeCoverageDir(combinedConfig ?? coverage.config),
-    })
-  }
-}
-
-function runPlaywright(userArgs) {
-  // Determine config file path
-  const configPath = fs.existsSync(
-    path.join(process.cwd(), "playwright.config.ts"),
-  )
-    ? path.join(process.cwd(), "playwright.config.ts")
-    : path.join(moduleDir, "playwright.config.ts")
-
-  const hasCustomConfig = userArgs.some((arg) => {
-    if (arg === "--config" || arg === "-c") {
-      return true
-    }
-
-    return arg.startsWith("--config=")
-  })
-
-  const playwrightArgs = ["test"]
-
-  if (!hasCustomConfig) {
-    playwrightArgs.push("--config", configPath)
-  }
-
-  playwrightArgs.push(...userArgs)
-
-  ensureJsxRuntimeShim(process.cwd())
-  const launcher = resolvePlaywrightLauncher()
-  const env = withRegisterShim(process.env)
-  env[COMBINED_COVERAGE_ENV_VAR] = "1"
-
-  return spawnWithLogs({
-    name: "Playwright",
-    launcher,
-    args: playwrightArgs,
-    env,
-    successMessage: "Playwright suite passed!",
-    failureMessage: "Playwright failed",
-  })
-}
-
-function resolvePlaywrightLauncher() {
-  const cliPath = resolveCliPath()
-  if (cliPath) {
-    return {
-      command: process.execPath,
-      args: [cliPath],
-    }
-  }
-
-  const localBin = path.resolve(process.cwd(), "node_modules/.bin/playwright")
-  if (fs.existsSync(localBin)) {
-    return {
-      command: localBin,
-      args: [],
-    }
-  }
-
-  return {
-    command: "playwright",
-    args: [],
-  }
-}
-
-function resolveCliPath() {
-  const searchRoots = [process.cwd(), moduleDir]
-
-  for (const base of searchRoots) {
-    try {
-      const pkgPath = require.resolve("@playwright/test/package.json", { paths: [base] })
-      const cliPath = path.join(path.dirname(pkgPath), "cli.js")
-      if (fs.existsSync(cliPath)) {
-        return cliPath
-      }
-    } catch (_error) {
-      // continue searching
-    }
-  }
-
-  return null
-}
-
-function resolveVitestLauncher() {
-  const searchRoots = [process.cwd(), moduleDir]
-
-  for (const base of searchRoots) {
-    try {
-      const pkgPath = require.resolve("vitest/package.json", { paths: [base] })
-      const pkgDir = path.dirname(pkgPath)
-      const pkgJson = JSON.parse(fs.readFileSync(pkgPath, "utf8"))
-      const binPath = typeof pkgJson.bin === "string" ? pkgJson.bin : pkgJson.bin?.vitest
-      if (binPath) {
-        return {
-          command: process.execPath,
-          args: [path.join(pkgDir, binPath)],
-        }
-      }
-    } catch (_error) {
-      // continue searching
-    }
-  }
-
-  const localBin = path.resolve(process.cwd(), "node_modules/.bin/vitest")
-  if (fs.existsSync(localBin)) {
-    return {
-      command: localBin,
-      args: [],
-    }
-  }
-
-  return {
-    command: "vitest",
-    args: [],
-  }
-}
-
-function resolveVitestConfig() {
-  const userConfig = findVitestConfig(process.cwd())
-  if (userConfig) {
-    return userConfig
-  }
-
-  const bundledConfig = path.join(moduleDir, "vitest.config.mjs")
-  return fs.existsSync(bundledConfig) ? bundledConfig : null
-}
-
-function findVitestConfig(baseDir) {
-  const candidates = [
-    "vitest.config.ts",
-    "vitest.config.js",
-    "vitest.config.mjs",
-  ]
-
-  for (const file of candidates) {
-    const fullPath = path.join(baseDir, file)
-    if (fs.existsSync(fullPath)) {
-      return fullPath
-    }
-  }
-
-  return null
-}
-
-async function loadVitestCoverageConfig() {
-  const options = await loadCoverageOptions({
-    optional: true,
-    candidates: VITEST_COVERAGE_CANDIDATES,
-    defaultTestResultsDir: "test-results-vitest",
-  })
-  if (!options) {
-    return null
-  }
-
-  const config = createCoverageConfig(options)
-
-  return {
-    config,
-    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
-
-  const entries = await fsPromises.readdir(nodeCoverageDir).catch(() => [])
-  const scripts = []
-  const scriptRoots = resolveCollectCoverageRoots(config.collectCoverageFrom, config.rootDir)
-
-  for (const entry of entries) {
-    if (!entry.endsWith(".json")) {
-      continue
-    }
-
-    const fullPath = path.join(nodeCoverageDir, entry)
-    const payload = await readJson(fullPath)
-    const results = Array.isArray(payload?.result) ? payload.result : []
-
-    for (const script of results) {
-      const normalized = normalizeNodeScriptUrl(script.url, config.rootDir)
-      if (!normalized) {
-        continue
-      }
-
-      if (isNodeModulesPath(normalized.absolutePath)) {
-        continue
-      }
-
-      if (!isInsideAnyRoot(normalized.absolutePath, scriptRoots)) {
-        continue
-      }
-
-      const source = await fsPromises.readFile(normalized.absolutePath, "utf8").catch(() => "")
-
-      scripts.push({
-        absolutePath: normalized.absolutePath,
-        relativePath: normalized.relativePath,
-        source,
-        functions: script.functions ?? [],
-        url: script.url,
-      })
-    }
-  }
-
-  if (scripts.length === 0) {
-    return
-  }
-
-  const outDir = path.join(config.testResultsRoot, "vitest")
-  await fsPromises.mkdir(outDir, { recursive: true })
-  const outputFile = path.join(outDir, config.coverageFileName)
-  await fsPromises.writeFile(outputFile, JSON.stringify({ testId: "vitest", scripts }, null, 2), "utf8")
-}
-
-async function finalizeCoverage(config) {
-  try {
-    await generateCoverageReport(config)
-  } catch (error) {
-    if (error instanceof CoverageThresholdError) {
-      console.error(error.message)
-    }
-    throw error
-  }
-}
-
-async function readJson(filePath) {
-  try {
-    const raw = await fsPromises.readFile(filePath, "utf8")
-    return JSON.parse(raw)
-  } catch {
-    return null
-  }
-}
-
-function normalizeNodeScriptUrl(rawUrl, rootDir) {
-  if (!rawUrl || rawUrl.startsWith("node:")) {
-    return null
-  }
-
-  let absolutePath = null
-
-  try {
-    if (rawUrl.startsWith("file://")) {
-      absolutePath = fileURLToPath(rawUrl)
-    }
-  } catch (_err) {
-    // ignore invalid URLs
-  }
-
-  if (!absolutePath && path.isAbsolute(rawUrl)) {
-    absolutePath = rawUrl
-  }
-
-  if (!absolutePath) {
-    return null
-  }
-
-  const normalized = path.normalize(absolutePath)
-
-  return {
-    absolutePath: normalized,
-    relativePath: path.relative(rootDir, normalized),
-  }
-}
-
-function isNodeModulesPath(filePath) {
-  return path
-    .normalize(String(filePath ?? ""))
-    .split(path.sep)
-    .includes("node_modules")
-}
-
-function spawnWithLogs({ name, launcher, args, env, successMessage, failureMessage }) {
-  return new Promise((resolve, reject) => {
-    const stdoutBuffer = []
-    const stderrBuffer = []
-
-    const child = spawn(
-      launcher.command,
-      [...(launcher.args || []), ...args],
-      {
-        shell: false,
-        env,
-      },
-    )
-
-    child.stdout.on("data", (data) => {
-      if (!isAider) {
-        process.stdout.write(data)
-      }
-      stdoutBuffer.push(data.toString())
-    })
-
-    child.stderr.on("data", (data) => {
-      if (!isAider) {
-        process.stderr.write(data)
-      }
-      stderrBuffer.push(data.toString())
-    })
-
-    child.on("close", (code) => {
-      if (code === 0) {
-        if (successMessage) {
-          console.log(successMessage)
-        }
-        resolve()
-      } else {
-        console.error(failureMessage || `${name} failed:`)
-
-        if (isAider) {
-          if (stdoutBuffer.length > 0) {
-            console.error(stdoutBuffer.join(""))
-          }
-
-          if (stderrBuffer.length > 0) {
-            console.error(stderrBuffer.join(""))
-          }
-        }
-
-        reject(new Error(`${name} failed with exit code: ${code}`))
-      }
-    })
-
-    child.on("error", (error) => {
-      console.error(`Error spawning ${name}:`, error)
-      reject(error)
-    })
-  })
-}
-
-function withRegisterShim(baseEnv) {
-  const nodeOptions = appendNodeRequire(baseEnv.NODE_OPTIONS, path.join(moduleDir, "register-tty.cjs"))
-  return {
-    ...baseEnv,
-    NODE_OPTIONS: nodeOptions,
-  }
-}
-
-function ensureJsxRuntimeShim(projectRoot) {
-  const shimDir = path.join(projectRoot, "node_modules", "playwright")
-  fs.mkdirSync(shimDir, { recursive: true })
-  const shims = [
-    { file: "jsx-runtime.js", target: "react/jsx-runtime" },
-    { file: "jsx-dev-runtime.js", target: "react/jsx-dev-runtime" },
-  ]
-
-  for (const { file, target } of shims) {
-    const filePath = path.join(shimDir, file)
-    if (!fs.existsSync(filePath)) {
-      const content = `export * from "${target}";\nexport { default } from "${target}";\n`
-      fs.writeFileSync(filePath, content, "utf8")
-    }
-  }
-}
-
-function appendNodeRequire(existing, modulePath) {
-  const flag = `--require=${modulePath}`
-  if (!existing || existing.length === 0) {
-    return flag
-  }
-  return `${existing} ${flag}`
-}

package/src/coverage/collect.js

@@ -1,134 +0,0 @@
-import path from "node:path"
-
-import picomatch from "picomatch"
-
-
-export function createCollectCoverageMatcher(patterns, rootDir) {
-  const normalizedRoot = path.resolve(String(rootDir ?? ""))
-
-  const includeMatchers = []
-  const excludeMatchers = []
-
-  if (Array.isArray(patterns)) {
-    for (const pattern of patterns) {
-      const raw = String(pattern ?? "").trim()
-      if (!raw) {
-        continue
-      }
-
-      const isExclude = raw.startsWith("!")
-      const body = toPosix(isExclude ? raw.slice(1) : raw)
-      if (!body) {
-        continue
-      }
-
-      const matcher = picomatch(body, { dot: true })
-      if (isExclude) {
-        excludeMatchers.push(matcher)
-      } else {
-        includeMatchers.push(matcher)
-      }
-    }
-  }
-
-  if (includeMatchers.length === 0) {
-    return () => false
-  }
-
-  return (absolutePath) => {
-    const normalizedAbsolute = path.resolve(String(absolutePath ?? ""))
-    if (!normalizedAbsolute) {
-      return false
-    }
-
-    const relativePosix = toPosix(path.relative(normalizedRoot, normalizedAbsolute))
-    const absolutePosix = toPosix(normalizedAbsolute)
-    const candidates = new Set([absolutePosix, relativePosix])
-
-    if (relativePosix) {
-      candidates.add(`./${relativePosix}`)
-    }
-
-    const candidateList = Array.from(candidates)
-    const included = includeMatchers.some((matcher) => candidateList.some((candidate) => matcher(candidate)))
-    if (!included) {
-      return false
-    }
-
-    return !excludeMatchers.some((matcher) => candidateList.some((candidate) => matcher(candidate)))
-  }
-}
-
-export function toPosix(input) {
-  return String(input ?? "").split(path.sep).join("/")
-}
-
-export function isInsideAnyRoot(absolutePath, roots) {
-  const normalizedAbsolute = path.resolve(String(absolutePath ?? ""))
-  return (Array.isArray(roots) ? roots : []).some((root) => {
-    const normalizedRoot = path.resolve(String(root ?? ""))
-    const relative = path.relative(normalizedRoot, normalizedAbsolute)
-    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))
-  })
-}
-
-export function resolveCollectCoverageRoots(patterns, rootDir) {
-  const resolvedRootDir = path.resolve(String(rootDir ?? ""))
-  const roots = new Set([resolvedRootDir])
-
-  if (!Array.isArray(patterns)) {
-    return Array.from(roots)
-  }
-
-  for (const pattern of patterns) {
-    const raw = String(pattern ?? "").trim()
-    if (!raw) {
-      continue
-    }
-
-    const cleaned = raw.startsWith("!") ? raw.slice(1) : raw
-    if (!cleaned) {
-      continue
-    }
-
-    const prefix = staticGlobPrefix(cleaned)
-    if (!prefix) {
-      continue
-    }
-
-    roots.add(path.resolve(resolvedRootDir, prefix))
-  }
-
-  return Array.from(roots)
-}
-
-function staticGlobPrefix(pattern) {
-  const normalized = String(pattern ?? "").trim()
-  if (!normalized) {
-    return null
-  }
-
-  const firstGlobIndex = findFirstGlobIndex(normalized)
-  const prefix = firstGlobIndex === -1 ? normalized : normalized.slice(0, firstGlobIndex)
-
-  if (!prefix) {
-    return null
-  }
-
-  if (prefix.endsWith("/") || prefix.endsWith(path.sep)) {
-    return prefix
-  }
-
-  const posix = prefix.split(path.sep).join("/")
-  return path.posix.dirname(posix)
-}
-
-function findFirstGlobIndex(value) {
-  for (let i = 0; i < value.length; i += 1) {
-    const char = value[i]
-    if (char === "*" || char === "?" || char === "[" || char === "{") {
-      return i
-    }
-  }
-  return -1
-}