@testspectra/react 1.1.8-rc.9 → 1.1.11-rc.3

package/dist/cli.js

@@ -1,33 +1,180 @@
 // src/cli.ts
-import { spawn } from "node:child_process";
+import { existsSync as existsSync2 } from "node:fs";
+import path2 from "node:path";
 import { fileURLToPath } from "node:url";
+import spawn from "cross-spawn";
+
+// src/config_generator.ts
+import { existsSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+function resolveEsmUrl(specifier, packageDir) {
+  const cjsPath = createRequire(path.join(packageDir, "package.json")).resolve(specifier);
+  const esmPath = cjsPath.replace(/\.cjs$/, ".js");
+  return pathToFileURL(existsSync(esmPath) ? esmPath : cjsPath).href;
+}
+function buildAutoImportManifest(root) {
+  function scanEntityDir(subdir, filePattern) {
+    const dir = path.join(root, subdir);
+    if (!existsSync(dir)) return [];
+    const entries = [];
+    for (const name of readdirSync(dir, { withFileTypes: true })) {
+      if (!name.isDirectory()) continue;
+      if (name.name.startsWith(".") || name.name === "node_modules" || name.name === "dist" || name.name === "__screenshots__" || name.name === "coverage") {
+        continue;
+      }
+      for (const platform of ["web", "common"]) {
+        for (const ext of ["tsx", "ts"]) {
+          const candidate = path.join(dir, name.name, filePattern(platform).replace(/\.tsx?$/, `.${ext}`));
+          if (existsSync(candidate)) {
+            entries.push({ name: name.name, path: candidate.replace(/\\/g, "/") });
+            break;
+          }
+        }
+        if (entries.at(-1)?.name === name.name) break;
+      }
+    }
+    return entries;
+  }
+  function scanFixtures() {
+    const dir = path.join(root, "fixtures");
+    if (!existsSync(dir)) return [];
+    return readdirSync(dir).filter((f) => f.endsWith(".json") && !f.startsWith(".")).map((f) => ({ name: f.replace(/\.json$/, ""), path: path.join(dir, f).replace(/\\/g, "/") }));
+  }
+  return {
+    pageObjects: scanEntityDir("page-objects", (p) => `${p}.tsx`),
+    steps: scanEntityDir("support/steps", (p) => `${p}.step.tsx`),
+    fixtures: scanFixtures()
+  };
+}
+function generateVitestConfig(opts) {
+  const reactPluginUrl = resolveEsmUrl("@vitejs/plugin-react", opts.packageDir);
+  const vitestConfigUrl = resolveEsmUrl("vitest/config", opts.packageDir);
+  const manifest = buildAutoImportManifest(opts.testRoot);
+  const setupFile = path.join(opts.packageDir, "dist/setup.js").replace(/\\/g, "/");
+  const reporterFile = path.join(opts.packageDir, "dist/vitest_reporter.js").replace(/\\/g, "/");
+  const reporterUrl = pathToFileURL(reporterFile).href;
+  const normalizedPackageDir = opts.packageDir.replace(/\\/g, "/");
+  const normalizedTestRoot = opts.testRoot.replace(/\\/g, "/");
+  const configContent = `import react from '${reactPluginUrl}';
+import { defineConfig } from '${vitestConfigUrl}';
+${opts.semanticReporter ? `import { SpectraVitestReporter } from '${reporterUrl}';` : ""}
+
+export default defineConfig({
+  root: ${JSON.stringify(normalizedTestRoot)},
+  plugins: [react()],
+  define: {
+    __TESTSPECTRA_AUTO_IMPORT_MANIFEST__: ${JSON.stringify(JSON.stringify(manifest))},
+    __TESTSPECTRA_STEP_DELAY_MS__: ${JSON.stringify(opts.stepDelayMs)},
+    __TESTSPECTRA_SEMANTIC_REPORTER__: ${JSON.stringify(opts.semanticReporter)},
+  },
+  optimizeDeps: {
+    include: [
+      'react',
+      'react-dom',
+      'react-dom/client',
+      '@testing-library/react',
+      '@testing-library/user-event',
+    ],
+  },
+  server: {
+    fs: {
+      allow: [
+        ${JSON.stringify(normalizedPackageDir)},
+        ${JSON.stringify(normalizedTestRoot)},
+      ],
+    },
+  },
+  test: {
+    globals: true,
+    setupFiles: [${JSON.stringify(setupFile)}],
+    reporters: ${opts.semanticReporter ? `[
+      new SpectraVitestReporter({ testRoot: ${JSON.stringify(normalizedTestRoot)} }),
+      ${opts.outputFile ? `['json', { outputFile: ${JSON.stringify(opts.outputFile)} }],` : ""}
+    ]` : opts.outputFile ? `['default', ['json', { outputFile: ${JSON.stringify(opts.outputFile)} }]]` : "'default'"},
+    dir: ${JSON.stringify(normalizedTestRoot)},
+    include: [
+      'specs/**/web.test.tsx',
+      'specs/**/*.test.tsx',
+      'specs/**/web.test.ts',
+      'specs/**/*.test.ts',
+    ],
+    exclude: [
+      '**/node_modules/**',
+      '**/dist/**',
+      '**/__screenshots__/**',
+      '**/.testspectra/**',
+      '**/.git/**',
+      '**/coverage/**',
+    ],
+    browser: {
+      enabled: true,
+      provider: 'playwright',
+      name: 'chromium',
+      headless: ${opts.headless},
+      fileParallelism: ${opts.fileParallelism},
+      ${opts.browserExecutable ? `providerOptions: { launch: { executablePath: ${JSON.stringify(opts.browserExecutable)} } },` : ""}
+    },
+  },
+});
+`;
+  const tmpDir = mkdtempSync(path.join(os.tmpdir(), "testspectra-react-"));
+  const configPath = path.join(tmpDir, "vitest.config.mjs");
+  writeFileSync(configPath, configContent, "utf-8");
+  return {
+    configPath,
+    cleanup: () => {
+      try {
+        rmSync(tmpDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  };
+}
+
+// src/cli.ts
 async function runComponentTests(options = {}) {
-  const cwd = options.cwd ?? process.cwd();
-  const configPath = fileURLToPath(new URL("../vitest.config.ts", import.meta.url));
+  const runner = options.runner ?? "vitest";
+  if (runner === "spectra") {
+    console.log("TestSpectra native component testing is orchestrated by the Rust Core Engine.");
+    console.log("Use `spectra test` to run tests with full parallel CDP orchestration.");
+    return true;
+  }
+  const rawCwd = options.cwd ?? process.cwd();
+  const cwd = path2.resolve(rawCwd);
+  const packageDir = fileURLToPath(new URL("..", import.meta.url));
   const ext = process.platform === "win32" ? ".cmd" : "";
-  const vitestBin = fileURLToPath(new URL(`../node_modules/.bin/vitest${ext}`, import.meta.url));
+  const localVitestBin = fileURLToPath(new URL(`../node_modules/.bin/vitest${ext}`, import.meta.url));
+  const consumerVitestBin = path2.join(cwd, `node_modules/.bin/vitest${ext}`);
+  const vitestBin = existsSync2(localVitestBin) ? localVitestBin : consumerVitestBin;
+  const semanticReporter = Boolean(options.onLine);
+  const { configPath, cleanup } = generateVitestConfig({
+    packageDir,
+    testRoot: cwd,
+    headless: options.headless !== false,
+    stepDelayMs: options.stepDelayMs ?? 0,
+    semanticReporter,
+    fileParallelism: options.concurrency !== 1,
+    browserExecutable: options.browserExecutablePath,
+    outputFile: options.outputFile
+  });
   const args = ["run", "--config", configPath];
-  if (options.outputFile) {
-    args.push("--reporter=default", "--reporter=json", `--outputFile.json=${options.outputFile}`);
-  }
   if (options.spec) {
-    args.push(options.spec);
+    let specPattern = options.spec.replace(/\\/g, "/");
+    if (path2.isAbsolute(options.spec)) {
+      specPattern = path2.relative(cwd, options.spec).replace(/\\/g, "/");
+    }
+    args.push(specPattern);
   }
-  const semanticReporter = Boolean(options.onLine);
   return new Promise((resolve) => {
     const child = spawn(vitestBin, args, {
       stdio: semanticReporter ? ["inherit", "pipe", "pipe"] : "inherit",
       cwd,
       env: {
-        ...process.env,
-        TESTSPECTRA_TEST_ROOT: cwd,
-        TESTSPECTRA_HEADLESS: options.headless === false ? "false" : "true",
-        TESTSPECTRA_STEP_DELAY: String(options.stepDelayMs ?? 0),
-        TESTSPECTRA_FILE_PARALLELISM: options.concurrency === 1 ? "false" : "true",
-        ...options.browserExecutablePath ? { TESTSPECTRA_BROWSER_EXECUTABLE: options.browserExecutablePath } : {},
-        TESTSPECTRA_SEMANTIC_REPORTER: semanticReporter ? "1" : "0"
-      },
-      shell: process.platform === "win32"
+        ...process.env
+      }
     });
     if (semanticReporter) {
       const handleData = (buf) => {
@@ -38,16 +185,30 @@ async function runComponentTests(options = {}) {
       child.stdout?.on("data", handleData);
       child.stderr?.on("data", handleData);
     }
-    child.on("exit", (code) => resolve(code === 0));
+    child.on("exit", (code) => {
+      cleanup();
+      resolve(code === 0);
+    });
     child.on("error", (err) => {
+      cleanup();
       console.error(err);
       resolve(false);
     });
   });
 }
 function getFlagValue(argv, ...names) {
-  const index = argv.findIndex((a) => names.includes(a));
-  return index !== -1 ? argv[index + 1] : void 0;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    for (const name of names) {
+      if (arg === name) {
+        return argv[i + 1];
+      }
+      if (arg.startsWith(`${name}=`)) {
+        return arg.slice(name.length + 1);
+      }
+    }
+  }
+  return void 0;
 }
 async function runCli(argv = process.argv.slice(2)) {
   const [command] = argv;
@@ -58,13 +219,40 @@ async function runCli(argv = process.argv.slice(2)) {
   let headless = true;
   if (argv.includes("--headed") || argv.includes("--no-headless")) headless = false;
   else if (argv.includes("--headless")) headless = true;
-  const rawDelay = getFlagValue(argv, "--step-delay", "--delay");
+  const rawRunner = getFlagValue(argv, "--runner", "-r");
+  const runner = rawRunner === "vitest" ? "vitest" : "spectra";
+  const rawDelay = getFlagValue(argv, "--step-delay", "--delay", "-d");
   let stepDelayMs;
   if (rawDelay !== void 0) {
     const parsed = parseInt(String(rawDelay), 10);
     if (!isNaN(parsed) && parsed >= 0) stepDelayMs = parsed;
   }
-  const spec = getFlagValue(argv, "--spec", "-s");
+  let spec = getFlagValue(argv, "--spec", "-s");
+  if (!spec) {
+    const flagsWithValues = /* @__PURE__ */ new Set([
+      "--runner",
+      "-r",
+      "--step-delay",
+      "--delay",
+      "-d",
+      "--spec",
+      "-s",
+      "--output",
+      "-o",
+      "--concurrency",
+      "-c",
+      "--browser-executable"
+    ]);
+    for (let i = 1; i < argv.length; i++) {
+      const arg = argv[i];
+      if (arg.startsWith("-")) {
+        if (flagsWithValues.has(arg)) i++;
+      } else {
+        spec = arg;
+        break;
+      }
+    }
+  }
   const outputFile = getFlagValue(argv, "--output", "-o");
   const rawConcurrency = getFlagValue(argv, "--concurrency", "-c");
   let concurrency;
@@ -73,7 +261,15 @@ async function runCli(argv = process.argv.slice(2)) {
     if (!isNaN(parsed) && parsed >= 1) concurrency = parsed;
   }
   const browserExecutablePath = getFlagValue(argv, "--browser-executable");
-  const ok = await runComponentTests({ headless, stepDelayMs, spec, outputFile, concurrency, browserExecutablePath });
+  const ok = await runComponentTests({
+    runner,
+    headless,
+    stepDelayMs,
+    spec,
+    outputFile,
+    concurrency,
+    browserExecutablePath
+  });
   process.exit(ok ? 0 : 1);
 }
 export {

package/dist/index.d.ts

@@ -7,6 +7,7 @@ export declare class DomDriverBridge implements PlatformDriverBridge {
 export declare function mount<P = any>(element: any): Promise<any>;
 
 export interface RunComponentTestsOptions {
+  runner?: 'spectra' | 'vitest';
   cwd?: string;
   headless?: boolean;
   stepDelayMs?: number;
@@ -17,6 +18,23 @@ export interface RunComponentTestsOptions {
   onLine?: (line: string) => void;
 }
 
+export interface BundleServer {
+  url: string;
+  stop(): void;
+}
+
+export interface BundleServerOptions {
+  testRoot?: string;
+  packageDir?: string;
+  manifest?: any;
+  stepDelayMs?: number;
+}
+
+export declare function startBundleServer(opts?: BundleServerOptions): Promise<BundleServer>;
 export declare function runComponentTests(options?: RunComponentTestsOptions): Promise<boolean>;
 export declare function runCli(argv?: string[]): Promise<void>;
-export type { ExpectStatic } from 'vitest';
+export declare function sanitizeError(err: unknown): string;
+export declare function sanitizeErrorMessage(msg: string): string;
+export declare function sanitizeViteUrl(text: string): string;
+export declare function sanitizeStackTrace(stack: string): string;
+export declare function isVitestNoise(line: string): boolean;