as-test 1.5.1 → 1.6.0

package/bin/commands/run-core.js

@@ -1,6 +1,5 @@
 import chalk from "chalk";
 import { spawn } from "child_process";
-import { glob } from "glob";
 import { minimatch } from "minimatch";
 import { Channel, MessageType } from "../wipc.js";
 import {
@@ -21,6 +20,12 @@ import { PassThrough } from "stream";
 import { buildWebRunnerSource } from "./web-runner-source.js";
 import { PersistentWebSessionHost } from "./web-session.js";
 import { build } from "./build-core.js";
+import {
+  cacheStorage,
+  reportHasFailure,
+  sha256OfFile,
+} from "../build-cache.js";
+import { resolveSpecFiles, emitSelectorWarnings } from "../selectors.js";
 import { createReporter as createDefaultReporter } from "../reporters/default.js";
 import { createTapReporter } from "../reporters/tap.js";
 import { persistCrashRecord } from "../crash-store.js";
@@ -733,14 +738,9 @@ export async function run(
       }
     }
   }
-  const inputPatterns = resolveInputPatterns(config.input, selectors);
-  const includePatterns = inputPatterns.filter((p) => !p.startsWith("!"));
-  const ignorePatterns = inputPatterns
-    .filter((p) => p.startsWith("!"))
-    .map((p) => p.slice(1));
-  const inputFiles = (
-    await glob(includePatterns, { ignore: ignorePatterns })
-  ).sort((a, b) => a.localeCompare(b));
+  const { files: inputFiles, warnings: selectorWarnings } =
+    await resolveSpecFiles(config.input, selectors);
+  emitSelectorWarnings(selectorWarnings);
   const snapshotEnabled = flags.snapshot !== false;
   const createSnapshots = Boolean(flags.createSnapshots);
   const overwriteSnapshots = Boolean(flags.overwriteSnapshots);
@@ -813,6 +813,7 @@ export async function run(
       ? await PersistentWebSessionHost.start(false)
       : null;
   const webSession = options.webSession ?? ownedWebSession;
+  const cacheCtx = cacheStorage.getStore();
   try {
     for (let i = 0; i < inputFiles.length; i++) {
       const file = inputFiles[i];
@@ -820,6 +821,72 @@ export async function run(
         config.outDir,
         resolveArtifactPath(file, config.input),
       );
+      // Tier 2: replay a stored passing report instead of running. build() ran
+      // first this session and validated the build is fresh (else it cleared
+      // the stored report), so here we only re-check the run-specific inputs.
+      if (cacheCtx?.replay) {
+        const snapPath = resolveSnapshotPath(
+          file,
+          config.snapshotDir,
+          config.input,
+        );
+        const snapshotSha = existsSync(snapPath)
+          ? sha256OfFile(snapPath)
+          : null;
+        if (
+          cacheCtx.cache.canReplay(options.modeName, file, {
+            runtimeCmd: runtimeCommand,
+            snapshotSha,
+          })
+        ) {
+          const cached = cacheCtx.cache.getReport(options.modeName, file);
+          if (cached && !reportHasFailure(cached)) {
+            const cachedSuites = Array.isArray(cached.suites)
+              ? cached.suites
+              : [];
+            const selected = options.suiteSelectors?.length
+              ? filterSelectedSuites(
+                  cachedSuites,
+                  options.suiteSelectors,
+                  file,
+                  options.modeName ?? "default",
+                )
+              : cachedSuites;
+            replayCachedReport(reporter, file, selected);
+            const cachedSnap = cached.snapshotSummary ?? {
+              matched: 0,
+              created: 0,
+              updated: 0,
+              failed: 0,
+            };
+            snapshotSummary.matched += cachedSnap.matched ?? 0;
+            snapshotSummary.created += cachedSnap.created ?? 0;
+            snapshotSummary.updated += cachedSnap.updated ?? 0;
+            snapshotSummary.failed += cachedSnap.failed ?? 0;
+            reports.push({
+              file,
+              modeName: options.modeName ?? "default",
+              suites: selected,
+              coverage: cached.coverage ?? {
+                total: 0,
+                covered: 0,
+                uncovered: 0,
+                percent: 100,
+                points: [],
+              },
+              runCommand: cached.runCommand ?? "",
+              buildCommand:
+                options.buildCommandsByFile?.[file] ??
+                options.buildCommand ??
+                cached.buildCommand ??
+                "",
+              snapshotSummary: cachedSnap,
+              cached: true,
+            });
+            continue;
+          }
+        }
+      }
       if (!existsSync(outFile)) {
         const buildStartedAt = Date.now();
         await build(
@@ -934,7 +1001,7 @@ export async function run(
       snapshotSummary.created += snapshotStore.created;
       snapshotSummary.updated += snapshotStore.updated;
       snapshotSummary.failed += snapshotStore.failed;
-      reports.push({
+      const fileReport = {
         file,
         modeName: options.modeName ?? "default",
         suites: selectedSuites,
@@ -948,7 +1015,29 @@ export async function run(
           updated: snapshotStore.updated,
           failed: snapshotStore.failed,
         },
-      });
+        // When the cache is active, mark freshly-run reports `false` (replays
+        // are marked `true`) so the summary can show a cache hit/miss split.
+        // Left undefined when the cache is off so no Cache line is shown.
+        ...(cacheCtx?.cache ? { cached: false } : {}),
+      };
+      reports.push(fileReport);
+      // Persist this report so an unchanged future run can replay it (Tier 2).
+      // recordBuild ran during build() this session, so the entry exists.
+      if (cacheCtx?.cache) {
+        const snapPath = resolveSnapshotPath(
+          file,
+          config.snapshotDir,
+          config.input,
+        );
+        const snapshotSha = existsSync(snapPath)
+          ? sha256OfFile(snapPath)
+          : null;
+        cacheCtx.cache.recordReport(options.modeName, file, {
+          report: fileReport,
+          snapshotSha,
+          runtimeCmd: runtimeCommand,
+        });
+      }
     }
   } finally {
     await ownedWebSession?.close();
@@ -1364,61 +1453,6 @@ function runtimeNameFromCommand(command) {
   const token = command.trim().split(/\s+/)[0];
   return token && token.length ? token : "runtime";
 }
-function resolveInputPatterns(configured, selectors) {
-  const configuredInputs = Array.isArray(configured)
-    ? configured
-    : [configured];
-  if (!selectors.length) return configuredInputs;
-  const patterns = new Set();
-  for (const selector of expandSelectors(selectors)) {
-    if (!selector) continue;
-    if (isBareSuiteSelector(selector)) {
-      const base = stripSuiteSuffix(selector);
-      for (const configuredInput of configuredInputs) {
-        patterns.add(
-          path.join(path.dirname(configuredInput), `${base}.spec.ts`),
-        );
-      }
-      continue;
-    }
-    patterns.add(selector);
-  }
-  return [...patterns];
-}
-function expandSelectors(selectors) {
-  const expanded = [];
-  for (const selector of selectors) {
-    if (!selector) continue;
-    if (!shouldSplitSelector(selector)) {
-      expanded.push(selector);
-      continue;
-    }
-    for (const token of selector.split(",")) {
-      const trimmed = token.trim();
-      if (!trimmed.length) continue;
-      expanded.push(trimmed);
-    }
-  }
-  return expanded;
-}
-function shouldSplitSelector(selector) {
-  return (
-    selector.includes(",") &&
-    !selector.includes("/") &&
-    !selector.includes("\\") &&
-    !/[*?[\]{}]/.test(selector)
-  );
-}
-function isBareSuiteSelector(selector) {
-  return (
-    !selector.includes("/") &&
-    !selector.includes("\\") &&
-    !/[*?[\]{}]/.test(selector)
-  );
-}
-function stripSuiteSuffix(selector) {
-  return selector.replace(/\.spec\.ts$/, "").replace(/\.ts$/, "");
-}
 function normalizeReport(raw) {
   if (Array.isArray(raw)) {
     return {
@@ -2220,6 +2254,22 @@ async function runProcess(
       });
       return synthesized;
     }
+    // A spec file with no test suites never calls `run()`, so it emits no
+    // lifecycle frames and exits cleanly. That is an empty test file, not a
+    // crash — mark it skipped instead of surfacing "missing report payload".
+    if (
+      code === 0 &&
+      reportStream.dataFrames === 0 &&
+      !runtimeEvents.sawFileStart &&
+      !runtimeEvents.sawFileEnd &&
+      runtimeEvents.suiteStarts === 0 &&
+      !hasMeaningfulRuntimeOutput(stderrBuffer)
+    ) {
+      reporter.onWarning?.({
+        message: `${formatSpecDisplayPath(specFile)} contains no tests; marked as skipped`,
+      });
+      return createEmptyFileSkipReport(specFile, modeName);
+    }
     const errorText = "missing report payload from test runtime";
     const diagnostics = buildRuntimeReportDiagnostics(
       code,
@@ -2710,6 +2760,24 @@ function buildRuntimeReportDiagnostics(
     `runtime events: fileStart=${runtimeEvents.sawFileStart ? "yes" : "no"}, fileEnd=${runtimeEvents.sawFileEnd ? "yes" : "no"}, fileVerdict=${runtimeEvents.fileVerdict}, suiteStarts=${runtimeEvents.suiteStarts}, suiteEnds=${runtimeEvents.suiteEnds}, assertionFails=${runtimeEvents.assertionFails}, warnings=${runtimeEvents.warnings}, logs=${runtimeEvents.logs}`,
   ].join("\n");
 }
+function createEmptyFileSkipReport(specFile, modeName) {
+  // No suites: a file with zero suites contributes no skipped-suite count, just
+  // a skipped file (an empty `suites` array yields a "none" file verdict, which
+  // collectRunStats tallies as a skipped file). The accompanying onWarning tells
+  // the user the file had no tests.
+  return {
+    file: specFile,
+    modeName: modeName ?? "default",
+    suites: [],
+    coverage: {
+      total: 0,
+      covered: 0,
+      uncovered: 0,
+      percent: 100,
+      points: [],
+    },
+  };
+}
 function createRuntimeFailureReport(
   specFile,
   modeName,
@@ -2805,6 +2873,58 @@ function shouldSuppressWasiWarningLine(line) {
   }
   return false;
 }
+// Drive the reporter from a stored (passing) file report so a replayed spec
+// still scrolls past the live display and is counted, exactly as a fresh run
+// would render it. Only passing/skipped reports are replayed, so there are no
+// assertion failures to re-emit.
+function replayCachedReport(reporter, file, suites) {
+  reporter.onFileStart?.({
+    file,
+    depth: 0,
+    suiteKind: "file",
+    description: file,
+  });
+  let verdict = "none";
+  for (const suite of suites) {
+    verdict = mergeReplayVerdict(
+      verdict,
+      emitReplaySuite(reporter, file, suite),
+    );
+  }
+  reporter.onFileEnd?.({
+    file,
+    depth: 0,
+    suiteKind: "file",
+    description: file,
+    verdict,
+    cached: true,
+  });
+}
+function emitReplaySuite(reporter, file, suite) {
+  const depth = Number(suite?.depth ?? 0);
+  const kind = String(suite?.kind ?? "");
+  const description = String(suite?.description ?? "");
+  reporter.onSuiteStart?.({ file, depth, suiteKind: kind, description });
+  let verdict = String(suite?.verdict ?? "none");
+  const subs = Array.isArray(suite?.suites) ? suite.suites : [];
+  for (const sub of subs) {
+    verdict = mergeReplayVerdict(verdict, emitReplaySuite(reporter, file, sub));
+  }
+  reporter.onSuiteEnd?.({
+    file,
+    depth,
+    suiteKind: kind,
+    description,
+    verdict: String(suite?.verdict ?? verdict),
+  });
+  return verdict;
+}
+function mergeReplayVerdict(a, b) {
+  if (a === "fail" || b === "fail") return "fail";
+  if (a === "ok" || b === "ok") return "ok";
+  if (a === "skip" || b === "skip") return "skip";
+  return "none";
+}
 function collectRunStats(reports) {
   const stats = {
     passedFiles: 0,

package/bin/commands/test.js

@@ -29,6 +29,8 @@ export async function executeTestCommand(
     browser: deps.resolveBrowserOverride(rawArgs, "test"),
     reporterPath: deps.resolveReporterOverride(rawArgs, "test"),
     watch: flags.includes("--watch") || flags.includes("-w"),
+    cache: flags.includes("--cache"),
+    noCache: flags.includes("--no-cache"),
   };
   const fuzzEnabled = flags.includes("--fuzz");
   const fuzzOverrides = deps.resolveFuzzOverrides(rawArgs, "test");