@testspectra/react 1.1.8-rc.3 → 1.1.8-rc.30

package/dist/vitest_reporter.js

@@ -0,0 +1,227 @@
+// src/vitest_reporter.ts
+import path from "node:path";
+
+// src/sanitizer.ts
+var VITE_FS_URL_PATTERN = /https?:\/\/(?:localhost|127\.0\.0\.1|\[::1\]):\d+\/@fs\/([A-Za-z]:\/)/g;
+var VITE_FS_UNIX_URL_PATTERN = /https?:\/\/(?:localhost|127\.0\.0\.1|\[::1\]):\d+\/@fs\//g;
+var VITE_ROOT_URL_PATTERN = /https?:\/\/(?:localhost|127\.0\.0\.1|\[::1\]):\d+\//g;
+var URL_QUERY_PATTERN = /(\.[a-zA-Z0-9]+)\?[^:\s'")]*/g;
+var INTERNAL_FRAME_PATTERNS = [
+  /node_modules[\\/]vitest[\\/]/i,
+  /node_modules[\\/]@vitest[\\/]/i,
+  /node_modules[\\/]vite[\\/]/i,
+  /node_modules[\\/]@vitejs[\\/]/i,
+  /node_modules[\\/]playwright[\\/]/i,
+  /node_modules[\\/]@playwright[\\/]/i,
+  /node:internal[\\/]/i,
+  /dist[\\/]setup\.js/i,
+  /dist[\\/]vitest_reporter\.js/i,
+  /tools[\\/]react[\\/]/i,
+  /[\\/]vitest\.config\./i,
+  /@vitest/i,
+  /__vitest__/i
+];
+function sanitizeViteUrl(text) {
+  if (!text) return "";
+  let result = text.replace(VITE_FS_URL_PATTERN, "$1");
+  result = result.replace(VITE_FS_UNIX_URL_PATTERN, "/");
+  result = result.replace(VITE_ROOT_URL_PATTERN, "./");
+  result = result.replace(URL_QUERY_PATTERN, "$1");
+  return result;
+}
+function sanitizeErrorMessage(msg) {
+  if (!msg) return "";
+  let sanitized = sanitizeViteUrl(msg);
+  sanitized = sanitized.replace(/Failed to fetch dynamically imported module:\s*/gi, "Failed to load module: ");
+  sanitized = sanitized.replace(/\[vite\]\s*(?:Internal server error:\s*)?/gi, "[TestSpectra] ");
+  sanitized = sanitized.replace(/@vitest\/browser/gi, "TestSpectra Browser");
+  sanitized = sanitized.replace(/@vitest\/runner/gi, "TestSpectra Runner");
+  sanitized = sanitized.replace(/\bvitest\.config\.[a-z0-9]+/gi, "spectra.config.ts");
+  sanitized = sanitized.replace(/\bVitest\b/g, "TestSpectra");
+  sanitized = sanitized.replace(/\bvitest\b/g, "testspectra");
+  return sanitized;
+}
+function sanitizeStackTrace(stack) {
+  if (!stack) return "";
+  const lines = stack.split("\n");
+  const filtered = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (i === 0) {
+      filtered.push(sanitizeErrorMessage(line));
+      continue;
+    }
+    const isInternal = INTERNAL_FRAME_PATTERNS.some((pattern) => pattern.test(line));
+    if (isInternal) {
+      continue;
+    }
+    filtered.push(sanitizeErrorMessage(line));
+  }
+  return filtered.join("\n").trim();
+}
+function sanitizeError(err) {
+  if (!err) return "";
+  if (typeof err === "string") {
+    return sanitizeStackTrace(err);
+  }
+  if (typeof err === "object") {
+    const errorObj = err;
+    const stack = errorObj.stack;
+    const message = errorObj.message || String(err);
+    if (stack && typeof stack === "string") {
+      const sanitizedStack = sanitizeStackTrace(stack);
+      if (sanitizedStack) return sanitizedStack;
+    }
+    return sanitizeErrorMessage(message);
+  }
+  return sanitizeErrorMessage(String(err));
+}
+function isVitestNoise(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return true;
+  if (/^RUN\s+v\d+/i.test(trimmed)) return true;
+  if (/^DEV\s+v\d+/i.test(trimmed)) return true;
+  if (/^Test Files\s+\d+/i.test(trimmed)) return true;
+  if (/^Tests\s+\d+/i.test(trimmed)) return true;
+  if (/^Start at\s+\d+/i.test(trimmed)) return true;
+  if (/^Duration\s+[\d.]+/i.test(trimmed)) return true;
+  if (/^⎯{3,}/.test(trimmed)) return true;
+  if (/^Re-optimizing dependencies/i.test(trimmed)) return true;
+  if (/^JSON report written to/i.test(trimmed)) return true;
+  if (/^\(?transform \d+ms/i.test(trimmed)) return true;
+  if (/^[·✓❯⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]\s+/.test(trimmed)) return true;
+  if (/vite-cjs-node-api-deprecated/i.test(trimmed)) return true;
+  if (/CJS build of Vite's Node API is deprecated/i.test(trimmed)) return true;
+  if (/^\[?vite\]?\s*(deprecation|warning)/i.test(trimmed)) return true;
+  return false;
+}
+
+// src/vitest_reporter.ts
+var SpectraVitestReporter = class {
+  testRoot;
+  /** taskId -> minimal task descriptor, populated in `onCollected` so `onTaskUpdate` can resolve names. */
+  tasks = /* @__PURE__ */ new Map();
+  /** taskIds seen in the native stream — used to tell "test ran but failed" from "file never loaded". */
+  started = /* @__PURE__ */ new Set();
+  finished = /* @__PURE__ */ new Set();
+  reportedFileFailures = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.testRoot = path.resolve(options.testRoot);
+  }
+  onInit(_ctx) {
+  }
+  /**
+   * Vitest has collected the full task tree. Index every task so `onTaskUpdate` (which only carries
+   * task ids) can map back to a human name.
+   */
+  onCollected(files = []) {
+    const index = (task) => {
+      this.tasks.set(task.id, { name: task.name, type: task.type });
+      const children = task.tasks;
+      if (Array.isArray(children)) children.forEach(index);
+    };
+    for (const file of files) index(file);
+  }
+  /**
+   * The native task-result stream. Each pack is `[taskId, result]`; a test's `result.state` moves
+   * to `pass` / `fail` exactly once, carrying its `errors` and `duration`. (`TEST_START` is still
+   * emitted in-page by setup.ts's `beforeEach` so it is guaranteed to precede that test's step
+   * events on the wire.)
+   */
+  onTaskUpdate(packs) {
+    for (const pack of packs) {
+      const id = pack[0];
+      const result = pack[1];
+      if (!result) continue;
+      const task = this.tasks.get(id);
+      if (!task || task.type !== "test") continue;
+      this.started.add(id);
+      const state = result.state;
+      if (state !== "pass" && state !== "fail") continue;
+      if (this.finished.has(id)) continue;
+      this.finished.add(id);
+      for (const err of result.errors ?? []) {
+        this.emitError(err);
+      }
+      const duration = typeof result.duration === "number" ? Math.round(result.duration) : 0;
+      const tag = state === "pass" ? "TESTSPECTRA_TEST_PASS" : "TESTSPECTRA_TEST_FAIL";
+      this.emit(tag, `${task.name} (${duration}ms)`);
+    }
+  }
+  /**
+   * Intercepts every console log Vitest forwards from the browser. Step events (emitted in-page by
+   * prelude.ts, the one thing the Node-side reporter cannot observe natively) are forwarded as-is;
+   * genuine stderr is sanitized into a TestSpectra error so real failures reach the log.
+   */
+  onUserConsoleLog(log) {
+    if (!log?.content) return;
+    if (log.content.includes("[TESTSPECTRA_")) {
+      for (const line of log.content.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("[TESTSPECTRA_")) {
+          console.log(trimmed);
+        }
+      }
+      return;
+    }
+    if (log.type === "stderr") {
+      const sanitized = sanitizeError(log.content);
+      if (sanitized && !isVitestNoise(sanitized)) {
+        for (const line of sanitized.split("\n")) {
+          if (line.trim()) this.emit("TESTSPECTRA_TEST_ERROR", line.trim());
+        }
+      }
+    }
+  }
+  /**
+   * Recovery pass for failures that never produced a test task: a spec file that fails to
+   * import/transpile (e.g. the Vite dev server returning 500 for a missing scaffolding reference)
+   * never enters the `test` state, so `onTaskUpdate` never fires for it. Also surfaces any
+   * unhandled runner errors.
+   */
+  onFinished(files = [], errors = []) {
+    for (const file of files) {
+      const fileFailed = file.result?.state === "fail";
+      if (fileFailed && !this.reportedFileFailures.has(file.filepath) && !this.hasStartedTest(file)) {
+        this.reportedFileFailures.add(file.filepath);
+        const relativePath = path.relative(this.testRoot, file.filepath).replace(/\\/g, "/");
+        const fileErrors = file.result?.errors ?? [];
+        this.emit("TESTSPECTRA_TEST_START", JSON.stringify({ title: relativePath }));
+        if (fileErrors.length > 0) {
+          for (const err of fileErrors) this.emitError(err);
+        } else {
+          this.emit("TESTSPECTRA_TEST_ERROR", `Failed to load test file: ${relativePath}`);
+        }
+        this.emit("TESTSPECTRA_TEST_FAIL", `${relativePath} (0ms)`);
+      }
+    }
+    for (const err of errors) {
+      const sanitized = sanitizeError(err);
+      if (sanitized && !isVitestNoise(sanitized)) {
+        for (const line of sanitized.split("\n")) {
+          if (line.trim()) this.emit("TESTSPECTRA_TEST_ERROR", line.trim());
+        }
+      }
+    }
+  }
+  hasStartedTest(file) {
+    const check = (task) => {
+      if (task.type === "test" && this.started.has(task.id)) return true;
+      const children = task.tasks;
+      return Array.isArray(children) ? children.some(check) : false;
+    };
+    return check(file);
+  }
+  emit(tag, payload) {
+    console.log(`[${tag}] ${payload}`);
+  }
+  emitError(err) {
+    const sanitized = sanitizeError(err);
+    for (const line of sanitized.split("\n")) {
+      if (line.trim()) this.emit("TESTSPECTRA_TEST_ERROR", line.trim());
+    }
+  }
+};
+export {
+  SpectraVitestReporter
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testspectra/react",
-  "version": "1.1.8-rc.3",
+  "version": "1.1.8-rc.30",
   "description": "Bundled Vitest browser-mode runner for React component testing with the TestSpectra Spectra.* DSL",
   "keywords": [
     "testspectra",
@@ -27,37 +27,38 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
-    "./vitest.config.ts": "./vitest.config.ts"
+    "./package.json": "./package.json"
   },
   "files": [
     "dist",
     "bin"
   ],
-  "scripts": {
-    "build": "node scripts/build.js",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run --config ./vitest.config.ts",
-    "prepublishOnly": "npm run build"
-  },
   "dependencies": {
-    "@testspectra/matchers": "workspace:*",
     "@testing-library/react": "^16.0.0",
     "@testing-library/user-event": "^14.5.2",
     "@vitejs/plugin-react": "^4.3.1",
     "@vitest/browser": "^2.1.8",
+    "cross-spawn": "^7.0.6",
+    "esbuild": "^0.28.2",
     "playwright": "^1.48.0",
-    "vitest": "catalog:"
+    "vitest": "^2.1.8",
+    "@testspectra/matchers": "1.1.8-rc.30"
   },
   "peerDependencies": {
     "react": ">=18.0.0",
     "react-dom": ">=18.0.0"
   },
   "devDependencies": {
-    "@types/node": "catalog:",
+    "@types/cross-spawn": "^6.0.6",
+    "@types/node": "^20.14.0",
     "@types/react": "^18.3.3",
     "@types/react-dom": "^18.3.0",
-    "esbuild": "catalog:",
-    "typescript": "catalog:"
+    "typescript": "^5.6.3"
   },
-  "license": "SEE LICENSE IN LICENSE.md"
-}
+  "license": "SEE LICENSE IN LICENSE.md",
+  "scripts": {
+    "build": "node scripts/build.js",
+    "typecheck": "tsc --noEmit",
+    "test": "node bin/testspectra-react.js test"
+  }
+}