@rpcbase/test 0.337.0 → 0.339.0

package/dist/cli.js

@@ -1,28 +1,48 @@
 #!/usr/bin/env node
-import { spawnSync, spawn } from "node:child_process";
+import { spawnSync } from "node:child_process";
 import fs$1 from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
 import fg from "fast-glob";
 import { createCoverageConfig } from "./coverage/config.js";
-import { createCollectCoverageMatcher, resolveCollectCoverageRoots, isInsideAnyRoot } from "./coverage/collect.js";
+import { createCollectCoverageMatcher } from "./coverage/collect.js";
 import { loadCoverageOptions } from "./coverage/config-loader.js";
 import { removeCoverageFiles } from "./coverage/files.js";
 import { CoverageThresholdError, collectCoveredFiles, generateCoverageReport } from "./coverage/report.js";
+import { runPlaywright } from "./runners/playwright.js";
+import { runVitest, resolveNodeCoverageDir } from "./runners/vitest.js";
 const require$1 = createRequire(import.meta.url);
-const moduleDir = path.dirname(fileURLToPath(import.meta.url));
 const shouldForceTty = !process.stdout.isTTY && process.env.FORCE_COLOR === "true";
 if (shouldForceTty) {
   require$1("./register-tty.cjs");
 }
 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 !== void 0 && process.env.IS_AIDER !== "yes") {
   console.warn("Warning: IS_AIDER is set to a value other than 'yes'.");
 }
+const RB_CLI_OPTIONS = ["build-specs-map", "auto", "full", "show-mapping", "list"];
+function isRbCliOption(arg) {
+  const normalized = arg.toLowerCase();
+  return RB_CLI_OPTIONS.some((option) => normalized === `--${option}` || normalized.startsWith(`--${option}=`));
+}
+function parseBooleanCliArg(rawArgs, option) {
+  const optionPrefix = `--${option}`;
+  const optionWithValuePrefix = `${optionPrefix}=`;
+  return rawArgs.some((arg) => {
+    if (arg === optionPrefix) {
+      return true;
+    }
+    if (!arg.startsWith(optionWithValuePrefix)) {
+      return false;
+    }
+    const value = arg.slice(optionWithValuePrefix.length).toLowerCase();
+    if (value === "false" || value === "0") {
+      return false;
+    }
+    return value.length > 0;
+  });
+}
 function parseCliArgs(rawArgs) {
   const yargs = require$1("yargs/yargs");
   const parsed = yargs(rawArgs).help(false).version(false).strict(false).exitProcess(false).parserConfiguration({
@@ -46,27 +66,22 @@ function parseCliArgs(rawArgs) {
     type: "boolean",
     default: false
   }).parseSync();
-  const full = Boolean(parsed.full);
-  const auto = Boolean(parsed.auto) && !full;
-  const passthroughArgs = [...Array.isArray(parsed._) ? parsed._ : [], ...Array.isArray(parsed["--"]) ? parsed["--"] : []].map((entry) => String(entry));
+  const passthroughArgs = [...Array.isArray(parsed._) ? parsed._ : [], ...Array.isArray(parsed["--"]) ? parsed["--"] : []].map((entry) => String(entry)).filter((arg) => !isRbCliOption(arg));
   return {
-    buildSpecsMap: Boolean(parsed.buildSpecsMap),
-    auto,
-    showMapping: Boolean(parsed.showMapping),
-    list: Boolean(parsed.list),
+    buildSpecsMap: parseBooleanCliArg(rawArgs, "build-specs-map"),
+    auto: parseBooleanCliArg(rawArgs, "auto") && !parseBooleanCliArg(rawArgs, "full"),
+    showMapping: parseBooleanCliArg(rawArgs, "show-mapping"),
+    list: parseBooleanCliArg(rawArgs, "list"),
     passthroughArgs
   };
 }
 async function runTests() {
   const args = parseCliArgs(process.argv.slice(2));
   const buildSpecsMap = args.buildSpecsMap;
-  const auto = args.auto;
+  const auto = args.auto && !buildSpecsMap;
   const showMapping = args.showMapping;
   const list = args.list;
   const filteredArgs = args.passthroughArgs;
-  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");
   }
@@ -139,48 +154,6 @@ runTests().then(() => process.exit(0)).catch((error) => {
   }
   process.exit(1);
 });
-async function runVitest(coverage, combinedConfig, userArgs, {
-  disableCoverage = false
-} = {}) {
-  const vitestArgs = ["run", "--passWithNoTests"];
-  const vitestConfig = resolveVitestConfig();
-  const hasCustomConfig = userArgs.some((arg) => {
-    if (arg === "--config" || arg === "-c") {
-      return true;
-    }
-    return arg.startsWith("--config=");
-  });
-  if (vitestConfig && !hasCustomConfig) {
-    vitestArgs.push("--config", vitestConfig);
-  }
-  vitestArgs.push(...userArgs);
-  const launcher = resolveVitestLauncher();
-  const env = withRegisterShim(process.env);
-  if (disableCoverage) {
-    env.RB_DISABLE_COVERAGE = "1";
-  }
-  if (coverage?.enabled && !disableCoverage) {
-    const nodeCoverageDir = resolveNodeCoverageDir(combinedConfig ?? coverage.config);
-    await fs.mkdir(nodeCoverageDir, {
-      recursive: true
-    });
-    env.NODE_V8_COVERAGE = nodeCoverageDir;
-  }
-  await spawnWithLogs({
-    name: "Vitest",
-    launcher,
-    args: vitestArgs,
-    env,
-    successMessage: "Vitest suite passed!",
-    failureMessage: "Vitest failed"
-  });
-  if (coverage?.enabled && !disableCoverage) {
-    await convertNodeCoverage({
-      config: combinedConfig ?? coverage.config,
-      nodeCoverageDir: resolveNodeCoverageDir(combinedConfig ?? coverage.config)
-    });
-  }
-}
 async function buildSpecsMapFromCoverage({
   userArgs,
   combinedCoverage
@@ -568,122 +541,6 @@ function findWorkspaceRoot(projectRoot) {
     dir = parent;
   }
 }
-function runPlaywright(userArgs, {
-  disableCoverage = false
-} = {}) {
-  const configPath = fs$1.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";
-  if (disableCoverage) {
-    env.RB_DISABLE_COVERAGE = "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$1.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$1.resolve("@playwright/test/package.json", {
-        paths: [base]
-      });
-      const cliPath = path.join(path.dirname(pkgPath), "cli.js");
-      if (fs$1.existsSync(cliPath)) {
-        return cliPath;
-      }
-    } catch (_error) {
-    }
-  }
-  return null;
-}
-function resolveVitestLauncher() {
-  const searchRoots = [process.cwd(), moduleDir];
-  for (const base of searchRoots) {
-    try {
-      const pkgPath = require$1.resolve("vitest/package.json", {
-        paths: [base]
-      });
-      const pkgDir = path.dirname(pkgPath);
-      const pkgJson = JSON.parse(fs$1.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) {
-    }
-  }
-  const localBin = path.resolve(process.cwd(), "node_modules/.bin/vitest");
-  if (fs$1.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.js");
-  return fs$1.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$1.existsSync(fullPath)) {
-      return fullPath;
-    }
-  }
-  return null;
-}
 async function loadVitestCoverageConfig() {
   const options = await loadCoverageOptions({
     optional: true,
@@ -731,58 +588,6 @@ async function cleanCoverageArtifacts(config) {
     force: true
   });
 }
-function resolveNodeCoverageDir(config) {
-  return path.join(config.rootDir, "build", "vitest", "test-results", "node-coverage");
-}
-async function convertNodeCoverage(coverage) {
-  const {
-    config,
-    nodeCoverageDir
-  } = coverage;
-  const entries = await fs.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 fs.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.rootDir, "build", "vitest", "coverage");
-  await fs.mkdir(outDir, {
-    recursive: true
-  });
-  const outputFile = path.join(outDir, config.coverageFileName);
-  await fs.writeFile(outputFile, JSON.stringify({
-    testId: "vitest",
-    scripts
-  }, null, 2), "utf8");
-}
 async function finalizeCoverage(config) {
   try {
     await generateCoverageReport(config);
@@ -801,121 +606,4 @@ async function readJson(filePath) {
     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) {
-  }
-  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$1.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$1.existsSync(filePath)) {
-      const content = `export * from "${target}";
-export { default } from "${target}";
-`;
-      fs$1.writeFileSync(filePath, content, "utf8");
-    }
-  }
-}
-function appendNodeRequire(existing, modulePath) {
-  const flag = `--require=${modulePath}`;
-  if (!existing || existing.length === 0) {
-    return flag;
-  }
-  return `${existing} ${flag}`;
-}
 //# sourceMappingURL=cli.js.map