@triflare/fx 2.1.0-beta.1 → 2.1.0-beta.2

package/src/test/pattern.js

@@ -0,0 +1,84 @@
+/**
+ * Test-file glob matching.
+ *
+ * Kept free of Node built-ins so the browser-safe linter can share the same
+ * matcher as `fx test`, the build, and the VS Code extension.
+ */
+
+/** Default test-file glob, relative to the project directory. */
+export const DEFAULT_TEST_PATTERN = "test/**/*.test.tfx";
+
+const REGEX_SPECIAL = /[.+^${}()|[\]\\]/g;
+
+/** Escape regular-expression syntax so a glob is matched literally. */
+function escapeRegex(text) {
+  return text.replace(REGEX_SPECIAL, "\\$&");
+}
+
+/**
+ * Translate a small glob (`**`, `*`, `?`) into an anchored regular expression.
+ * A double star followed by a slash also matches zero directories, so
+ * `test/**\/*.test.tfx` matches `test/score.test.tfx`.
+ *
+ * @param {string} pattern
+ * @returns {RegExp}
+ */
+export function globToRegExp(pattern) {
+  const normalized = String(pattern).replace(/\\/g, "/").replace(/^\.\//, "");
+  let source = "";
+  for (let index = 0; index < normalized.length; index += 1) {
+    const char = normalized[index];
+    if (char === "*") {
+      if (normalized[index + 1] === "*") {
+        index += 1;
+        if (normalized[index + 1] === "/") {
+          index += 1;
+          source += "(?:.*/)?";
+        } else {
+          source += ".*";
+        }
+      } else {
+        source += "[^/]*";
+      }
+    } else if (char === "?") {
+      source += "[^/]";
+    } else {
+      source += escapeRegex(char);
+    }
+  }
+  return new RegExp(`^${source}$`);
+}
+
+/**
+ * Whether a project-relative path (posix separators) is a test file.
+ * @param {string} relativePath
+ * @param {string} [pattern]
+ */
+export function matchesTestPattern(
+  relativePath,
+  pattern = DEFAULT_TEST_PATTERN,
+) {
+  const normalized = String(relativePath).replace(/\\/g, "/");
+  return globToRegExp(pattern).test(normalized);
+}
+
+/**
+ * Whether `file` matches `pattern` relative to `root`.
+ *
+ * `root` may be absent, in which case the path is matched as given. Both
+ * separators are accepted so callers can pass filesystem paths or URIs.
+ *
+ * @param {string} file
+ * @param {string|null|undefined} root
+ * @param {string} [pattern]
+ */
+export function isTestPath(file, root, pattern = DEFAULT_TEST_PATTERN) {
+  if (!pattern) return false;
+  const normalized = String(file).replace(/\\/g, "/");
+  const base = root ? String(root).replace(/\\/g, "/").replace(/\/+$/, "") : "";
+  const relative =
+    base && normalized.startsWith(`${base}/`)
+      ? normalized.slice(base.length + 1)
+      : normalized;
+  return matchesTestPattern(relative, pattern);
+}

package/src/test/reporters.js

@@ -0,0 +1,332 @@
+/**
+ * Test reporters.
+ *
+ * Every reporter consumes the runner's structured events and owns all
+ * formatting, so terminal, JSON, JUnit, and future editors see idential data.
+ */
+import path from "node:path";
+
+export const REPORTER_NAMES = ["default", "verbose", "dot", "json", "junit"];
+
+const green = (color, text) => (color ? `\x1b[32m${text}\x1b[0m` : text);
+const red = (color, text) => (color ? `\x1b[31m${text}\x1b[0m` : text);
+const yellow = (color, text) => (color ? `\x1b[33m${text}\x1b[0m` : text);
+const dim = (color, text) => (color ? `\x1b[2m${text}\x1b[0m` : text);
+const bold = (color, text) => (color ? `\x1b[1m${text}\x1b[0m` : text);
+
+/** Human-readable duration for terminal output. */
+function seconds(ms) {
+  if (ms < 1000) return `${ms}ms`;
+  return `${(ms / 1000).toFixed(2)}s`;
+}
+
+/** Right-align a value in a fixed-width field. */
+function pad(value, width) {
+  return String(value).padStart(width);
+}
+
+/** Summary block printed after a terminal run. */
+function summarize(result) {
+  const lines = [];
+  const { counts } = result;
+  const files = `${dim(true, "Test Files")}  ${
+    counts.failedFiles ? `${red(true, `${counts.failedFiles} failed`)} | ` : ""
+  }${green(true, `${counts.passedFiles} passed`)} (${counts.files})`;
+  const tests = `${dim(true, "     Tests")}  ${
+    counts.failed ? `${red(true, `${counts.failed} failed`)} | ` : ""
+  }${green(true, `${counts.passed} passed`)} (${counts.tests})`;
+  lines.push(files, tests);
+  if (counts.pending)
+    lines.push(`${dim(true, "   Pending")}  ${yellow(true, counts.pending)}`);
+  if (counts.errors)
+    lines.push(`${dim(true, "    Errors")}  ${red(true, counts.errors)}`);
+  const start = new Date(result.startTime);
+  lines.push(
+    `${dim(true, "   Start at")}  ${start.toLocaleTimeString([], {
+      hour12: false,
+    })}`,
+  );
+  lines.push(`${dim(true, "   Duration")}  ${seconds(result.durationMs)}`);
+  return lines.join("\n");
+}
+
+/** Failure detail blocks for a terminal run, with source locations. */
+function failureBlocks(result, dir) {
+  const blocks = [];
+  for (const file of result.files) {
+    for (const test of file.tests) {
+      if (test.status !== "failed" && test.status !== "error") continue;
+      if (!test.error) continue;
+      const error = test.error;
+      // A test file is reported relative to the project, so resolve it before
+      // asking for a path relative to the project root.
+      const where = error.file
+        ? `${error.file}${error.line ? `:${error.line}:${error.column ?? 0}` : ""}`
+        : path.relative(dir, path.resolve(dir, file.file));
+      const label = test.status === "error" ? "ERROR" : "FAIL";
+      blocks.push(
+        [
+          red(true, `${label} ${file.file} > ${test.name}`),
+          `${error.name}: ${error.message}`,
+          dim(true, `❯ ${where}`),
+        ].join("\n"),
+      );
+    }
+  }
+  return blocks;
+}
+
+/** JSON document for `fx test --reporter json` and `--json`. */
+export function jsonReport(result, { events = [], warnings = [] } = {}) {
+  return {
+    schemaVersion: 1,
+    command: "test",
+    ok: result.ok,
+    warnings,
+    data: { ...result, events },
+  };
+}
+
+/** Remove XML 1.0-forbidden C0 controls, keeping tab, newline and CR. */
+function stripInvalidXmlChars(text) {
+  return [...String(text)]
+    .filter((char) => {
+      const code = char.charCodeAt(0);
+      return code === 0x9 || code === 0xa || code === 0xd || code >= 0x20;
+    })
+    .join("");
+}
+
+/** Escape text for use in JUnit attribute values and bodies. */
+function escapeXml(text) {
+  // Terminal color sequences in an error message must not make the report
+  // unparseable, even when their control characters are escaped.
+  return stripInvalidXmlChars(text)
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
+
+/** JUnit XML for CI integrations. */
+export function junitReport(result) {
+  const diagnostics = result.files.length ? [] : (result.diagnostics ?? []);
+  const files = diagnostics.length
+    ? [
+        {
+          file: "<project>",
+          durationMs: result.durationMs,
+          tests: diagnostics.map((diagnostic, index) => ({
+            name: `diagnostic ${index + 1}`,
+            status: "error",
+            durationMs: 0,
+            error: diagnostic,
+          })),
+        },
+      ]
+    : result.files;
+  const errors = files.reduce(
+    (total, file) =>
+      total + file.tests.filter((test) => test.status === "error").length,
+    0,
+  );
+  const lines = ['<?xml version="1.0" encoding="UTF-8"?>'];
+  lines.push(
+    `<testsuites name="fx" tests="${result.counts.tests + diagnostics.length}" failures="${result.counts.failed}" errors="${errors}" time="${(result.durationMs / 1000).toFixed(3)}">`,
+  );
+  for (const file of files) {
+    lines.push(
+      `  <testsuite name="${escapeXml(file.file)}" tests="${file.tests.length}" failures="${file.tests.filter((t) => t.status === "failed").length}" errors="${file.tests.filter((t) => t.status === "error").length}" time="${(file.durationMs / 1000).toFixed(3)}">`,
+    );
+    for (const test of file.tests) {
+      const time = (test.durationMs / 1000).toFixed(3);
+      if (test.status === "failed") {
+        const message = test.error?.message ?? "failed";
+        lines.push(
+          `    <testcase name="${escapeXml(test.name)}" classname="${escapeXml(file.file)}" time="${time}"><failure message="${escapeXml(message)}" type="${escapeXml(test.error?.name ?? "AssertionError")}">${escapeXml(
+            `${test.error?.name ?? "Error"}: ${message}${test.error?.file ? `\n at ${test.error.file}:${test.error.line ?? 0}` : ""}`,
+          )}</failure></testcase>`,
+        );
+      } else if (test.status === "error") {
+        const message = test.error?.message ?? "execution error";
+        lines.push(
+          `    <testcase name="${escapeXml(test.name)}" classname="${escapeXml(file.file)}" time="${time}"><error message="${escapeXml(message)}" type="${escapeXml(test.error?.name ?? "Error")}">${escapeXml(message)}</error></testcase>`,
+        );
+      } else if (test.status === "pending") {
+        lines.push(
+          `    <testcase name="${escapeXml(test.name)}" classname="${escapeXml(file.file)}" time="${time}"><skipped/></testcase>`,
+        );
+      } else {
+        lines.push(
+          `    <testcase name="${escapeXml(test.name)}" classname="${escapeXml(file.file)}" time="${time}"/>`,
+        );
+      }
+    }
+    lines.push("  </testsuite>");
+  }
+  lines.push("</testsuites>");
+  return lines.join("\n");
+}
+
+/**
+ * @param {object} [options]
+ * @param {"default"|"verbose"|"dot"|"json"|"junit"} [options.name]
+ * @param {NodeJS.WriteStream} [options.stream]
+ * @param {boolean} [options.color]
+ * @param {boolean} [options.tty]
+ * @param {string} [options.dir] project root, for failure locations
+ */
+export function createTestReporter({
+  name = "default",
+  stream = process.stdout,
+  color = false,
+  tty = false,
+  dir = process.cwd(),
+} = {}) {
+  const events = [];
+  let liveLine = "";
+
+  const write = (text) => stream.write(text);
+  const clearLive = () => {
+    if (!liveLine) return;
+    write("\r\x1b[2K");
+    liveLine = "";
+  };
+  const live = (text) => {
+    clearLive();
+    liveLine = text;
+    write(`\r${text}`);
+  };
+
+  const onEvent = (event) => {
+    if (event.event === "run-start") events.length = 0;
+    events.push(event);
+    switch (event.event) {
+      case "run-start":
+        if (name === "default" || name === "verbose")
+          write(
+            `\n ${bold(color, "RUN")}  ${dim(color, `v${event.version}`)} ${event.dir}\n\n`,
+          );
+        break;
+      case "discovered":
+        if (name === "default") {
+          for (const file of event.files)
+            for (const test of file.tests)
+              write(
+                `  ${dim(color, "PENDING")}  ${file.file} > ${test.name}\n`,
+              );
+        } else if (name === "verbose") {
+          for (const file of event.files)
+            for (const test of file.tests)
+              write(
+                `   ${yellow(color, "↓")} ${file.file} > ${test.name} ${dim(color, test.status)}\n`,
+              );
+        }
+        break;
+      case "test-start":
+        if (name === "verbose")
+          write(
+            `   ${dim(color, "▸")} ${event.file} > ${event.name} ${dim(color, event.status)}\n`,
+          );
+        else if (name === "default") {
+          if (tty) live(dim(color, `  ▸ ${event.file} > ${event.name}`));
+          else
+            write(
+              `  ${dim(color, "RUNNING")}  ${event.file} > ${event.name}\n`,
+            );
+        }
+        break;
+      case "test-result":
+        clearLive();
+        if (name === "verbose") {
+          const mark =
+            event.status === "passed"
+              ? green(color, "✓")
+              : event.status === "failed" || event.status === "error"
+                ? red(color, "×")
+                : yellow(color, "↓");
+          write(
+            `   ${mark} ${event.name} ${dim(color, seconds(event.durationMs))}\n`,
+          );
+        } else if (name === "default") {
+          const mark =
+            event.status === "passed"
+              ? green(color, "✓")
+              : event.status === "failed" || event.status === "error"
+                ? red(color, "×")
+                : yellow(color, "↓");
+          write(
+            `  ${mark} ${event.file} > ${event.name} ${dim(color, seconds(event.durationMs))}\n`,
+          );
+        } else if (name === "dot")
+          write(
+            event.status === "passed"
+              ? green(color, "·")
+              : event.status === "failed" || event.status === "error"
+                ? red(color, "×")
+                : yellow(color, "↓"),
+          );
+        break;
+      case "file-result": {
+        if (name !== "default" && name !== "verbose") break;
+        const failed = event.tests.filter((test) => test.status === "failed");
+        const errors = event.tests.filter((test) => test.status === "error");
+        const detail = [
+          `${event.tests.length} ${event.tests.length === 1 ? "test" : "tests"}`,
+          ...(failed.length ? [`${failed.length} failed`] : []),
+          ...(errors.length ? [`${errors.length} errors`] : []),
+        ].join(" | ");
+        const mark =
+          event.status === "passed" ? green(color, "✓") : red(color, "×");
+        write(
+          `${mark} ${event.file} ${dim(color, `(${detail}) ${seconds(event.durationMs)}`)}\n`,
+        );
+        break;
+      }
+      case "diagnostic":
+        clearLive();
+        // JSON and JUnit own the whole stream: a plain diagnostic line would
+        // make the document unparseable. Both reporters carry diagnostics in
+        // their structured payload instead.
+        if (name === "json" || name === "junit") break;
+        write(
+          `${red(color, "×")} ${event.file ?? "<project>"}${
+            event.line ? `:${event.line}` : ""
+          } ${event.message}\n`,
+        );
+        break;
+      case "run-end":
+        clearLive();
+        if (name === "dot") write("\n");
+        if (name === "json") {
+          write(`${JSON.stringify(jsonReport(event.result, { events }))}\n`);
+          break;
+        }
+        if (name === "junit") {
+          write(`${junitReport(event.result)}\n`);
+          break;
+        }
+        if (name === "default" || name === "verbose") {
+          const blocks = failureBlocks(event.result, dir);
+          if (blocks.length) {
+            const totalErrors =
+              event.result.counts.failed + (event.result.counts.errors ?? 0);
+            write(`\n${red(color, `⎯⎯⎯ Failed Tests ${totalErrors} ⎯⎯⎯`)}\n\n`);
+            write(`${blocks.join("\n\n")}\n`);
+          }
+          for (const diagnostic of event.result.diagnostics)
+            if (!event.result.files.length)
+              write(`${red(color, "×")} ${diagnostic.message}\n`);
+          write(`\n${summarize(event.result)}\n\n`);
+        }
+        break;
+      default:
+        break;
+    }
+  };
+
+  return { name, onEvent, events };
+}
+
+export { pad, seconds };