executable-stories-vitest 8.7.0 → 8.8.0

package/dist/index.js

@@ -1,4 +1,5 @@
 // src/story-api.ts
+import { expect, onTestFinished } from "vitest";
 import { createRequire } from "module";
 import { tryGetActiveOtelContext, resolveTraceUrl } from "executable-stories-core/utils/otel-detect";
 import { buildHtmlDocEntry } from "executable-stories-core/utils/doc-builders";
@@ -214,8 +215,41 @@ function init(task, options) {
     attachments: [],
     activeTimers: /* @__PURE__ */ new Map(),
     timerCounter: 0,
-    traceUrlTemplate
+    traceUrlTemplate,
+    pendingStep: null
   };
+  const ctx = activeContext;
+  try {
+    onTestFinished(() => {
+      flushPendingAssertions(ctx);
+      task.meta.story = ctx.meta;
+    });
+  } catch {
+  }
+}
+function flushPendingAssertions(ctx) {
+  const step = ctx.pendingStep;
+  const before = ctx.pendingFrom;
+  ctx.pendingStep = null;
+  ctx.pendingFrom = void 0;
+  if (!step || before === void 0) return;
+  const after = readAssertionCount();
+  if (after === void 0) return;
+  step.assertions = after - before;
+}
+function readAssertionCount() {
+  try {
+    const state2 = expect.getState?.();
+    return typeof state2?.assertionCalls === "number" ? state2.assertionCalls : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function recordAssertions(step, before) {
+  if (before === void 0) return;
+  const after = readAssertionCount();
+  if (after === void 0) return;
+  step.assertions = after - before;
 }
 function createStepMarker(keyword) {
   function stepMarker(text, docsOrBody) {
@@ -234,8 +268,13 @@ function createStepMarker(keyword) {
       docs: stepDocs,
       ...isCallback ? { wrapped: true } : {}
     };
+    flushPendingAssertions(ctx);
     ctx.meta.steps.push(step);
     ctx.currentStep = step;
+    if (!isCallback) {
+      ctx.pendingStep = step;
+      ctx.pendingFrom = readAssertionCount();
+    }
     syncMetaToTask();
     if (isChildrenArray) {
       const children = docsOrBody;
@@ -255,27 +294,32 @@ function createStepMarker(keyword) {
     if (!isCallback) return;
     const body = docsOrBody;
     const start = performance.now();
+    const assertionsBefore = readAssertionCount();
     try {
       const result = body();
       if (result instanceof Promise) {
         return result.then(
           (val) => {
             step.durationMs = performance.now() - start;
+            recordAssertions(step, assertionsBefore);
             syncMetaToTask();
             return val;
           },
           (err) => {
             step.durationMs = performance.now() - start;
+            recordAssertions(step, assertionsBefore);
             syncMetaToTask();
             throw err;
           }
         );
       }
       step.durationMs = performance.now() - start;
+      recordAssertions(step, assertionsBefore);
       syncMetaToTask();
       return result;
     } catch (err) {
       step.durationMs = performance.now() - start;
+      recordAssertions(step, assertionsBefore);
       syncMetaToTask();
       throw err;
     }
@@ -664,6 +708,11 @@ var StoryReporter = class {
   startTime = 0;
   packageVersion;
   gitSha;
+  /**
+   * Left unknown until onInit sees a config. Claiming full coverage without
+   * having looked would let a later merge retire scenarios on a guess.
+   */
+  runScope;
   coverageByFile = {};
   constructor(options = {}) {
     this.options = options;
@@ -672,6 +721,9 @@ var StoryReporter = class {
     this.ctx = ctx;
     this.startTime = Date.now();
     const root = ctx.config?.root ?? process.cwd();
+    if (ctx.config) {
+      this.runScope = ctx.config.testNamePattern != null ? "filtered" : "full";
+    }
     const includeMetadata = this.options.markdown?.includeMetadata ?? true;
     if (includeMetadata) {
       this.packageVersion = readPackageVersion(root);
@@ -688,6 +740,8 @@ var StoryReporter = class {
     if (reason === "interrupted") return;
     const root = this.ctx?.config?.root ?? process.cwd();
     const rawTestCases = this.collectTestCases(testModules, root);
+    const coveredSourceFiles = this.collectCoveredSourceFiles(testModules, root);
+    const incompleteSourceFiles = this.collectIncompleteSourceFiles(testModules, root);
     const features = collectFeatures(testModules, root);
     const rawRun = {
       testCases: rawTestCases,
@@ -697,7 +751,10 @@ var StoryReporter = class {
       projectRoot: root,
       packageVersion: this.packageVersion,
       gitSha: this.gitSha,
-      ci: detectCI()
+      ci: detectCI(),
+      ...this.runScope ? { runScope: this.runScope } : {},
+      ...coveredSourceFiles.length > 0 ? { coveredSourceFiles } : {},
+      ...incompleteSourceFiles.length > 0 ? { incompleteSourceFiles } : {}
     };
     const rawRunPath = this.options.rawRunPath;
     if (rawRunPath) {
@@ -774,6 +831,58 @@ var StoryReporter = class {
   /**
    * Collect test cases from Vitest test modules.
    */
+  /**
+   * Every module vitest ran, whether or not it produced a story.
+   *
+   * The collected test cases only name modules that produced something, so a
+   * file whose last story was deleted would otherwise look like a file that did
+   * not run and keep its old scenarios for good.
+   */
+  collectCoveredSourceFiles(testModules, root) {
+    const files = /* @__PURE__ */ new Set();
+    for (const mod of testModules) {
+      const moduleId = mod.moduleId ?? mod.relativeModuleId ?? "";
+      if (!moduleId) continue;
+      const absolute = path.isAbsolute(moduleId) ? moduleId : path.resolve(root, moduleId);
+      files.add(toRelativePosix(absolute, root));
+    }
+    return [...files].sort();
+  }
+  /**
+   * Files whose scenarios could not be collected in full.
+   *
+   * A module that errored, or a test that failed without ever declaring a
+   * story, is missing scenarios because the run broke. Treating that as
+   * deletion would throw away documentation at the exact moment the suite is
+   * unhealthy. Checked per test, not per file: one healthy story in a module
+   * does not vouch for its broken siblings.
+   */
+  collectIncompleteSourceFiles(testModules, root) {
+    const incomplete = /* @__PURE__ */ new Set();
+    for (const mod of testModules) {
+      const moduleId = mod.moduleId ?? mod.relativeModuleId ?? "";
+      if (!moduleId) continue;
+      const absolute = path.isAbsolute(moduleId) ? moduleId : path.resolve(root, moduleId);
+      const sourceFile = toRelativePosix(absolute, root);
+      const errors = mod.errors?.() ?? [];
+      const collection = mod.children;
+      if (errors.length > 0 || !collection) {
+        const state2 = mod.state?.();
+        if (errors.length > 0 || state2 === "failed") incomplete.add(sourceFile);
+        continue;
+      }
+      for (const test of collection.allTests()) {
+        const meta = this.getStoryMeta(test);
+        if (meta?.scenario && Array.isArray(meta.steps)) continue;
+        if (test.options?.mode === "todo") continue;
+        if (test.result?.()?.state === "failed") {
+          incomplete.add(sourceFile);
+          break;
+        }
+      }
+    }
+    return [...incomplete].sort();
+  }
   collectTestCases(testModules, root) {
     const testCases = [];
     for (const mod of testModules) {