@elench/testkit 0.1.82 → 0.1.84

package/lib/cli/tui/run-session-state.mjs

@@ -0,0 +1,481 @@
+import { fileDisplayName } from "../../discovery/index.mjs";
+import { suiteSelectionType } from "../../runner/suite-selection.mjs";
+import { buildRunSummaryData } from "../../runner/formatting.mjs";
+
+export function buildFailureKey(serviceName, filePath) {
+  return `${serviceName}::${filePath}`;
+}
+
+export function parseFailureKey(failureKey) {
+  const separator = String(failureKey || "").indexOf("::");
+  if (separator <= 0) return { serviceName: null, filePath: null };
+  return {
+    serviceName: failureKey.slice(0, separator),
+    filePath: failureKey.slice(separator + 2),
+  };
+}
+
+export function createRunSessionState() {
+  const services = new Map();
+  let totalCount = 0;
+  let completedCount = 0;
+  let phase = null;
+  let finished = false;
+  let summaryData = null;
+  let regressionCatalog = null;
+  let mode = "running";
+  let notice = null;
+  let selectedFailureKey = null;
+  let agentSession = null;
+  const listeners = new Set();
+
+  function notify() {
+    for (const callback of listeners) callback();
+  }
+
+  function getOrCreateService(serviceName) {
+    if (!services.has(serviceName)) {
+      services.set(serviceName, { name: serviceName, types: new Map(), skipped: false, skipReason: null });
+    }
+    return services.get(serviceName);
+  }
+
+  function getOrCreateType(service, displayType) {
+    if (!service.types.has(displayType)) {
+      service.types.set(displayType, { type: displayType, suites: new Map() });
+    }
+    return service.types.get(displayType);
+  }
+
+  function getOrCreateSuite(typeNode, suiteKey, suiteMeta) {
+    if (!typeNode.suites.has(suiteKey)) {
+      typeNode.suites.set(suiteKey, {
+        name: suiteMeta.name,
+        groupLabel: suiteMeta.groupLabel,
+        framework: suiteMeta.framework,
+        files: new Map(),
+      });
+    }
+    return typeNode.suites.get(suiteKey);
+  }
+
+  function findFile(serviceName, suiteKey, filePath) {
+    const service = services.get(serviceName);
+    if (!service) return null;
+    for (const typeNode of service.types.values()) {
+      const suite = typeNode.suites.get(suiteKey);
+      if (!suite) continue;
+      const file = suite.files.get(filePath);
+      if (file) return file;
+    }
+    return null;
+  }
+
+  function findFileByServiceAndPath(serviceName, filePath) {
+    const service = services.get(serviceName);
+    if (!service) return null;
+    for (const typeNode of service.types.values()) {
+      for (const suite of typeNode.suites.values()) {
+        const file = suite.files.get(filePath);
+        if (file) return file;
+      }
+    }
+    return null;
+  }
+
+  function collectFailedFiles() {
+    const failures = [];
+    for (const service of services.values()) {
+      for (const typeNode of service.types.values()) {
+        for (const [suiteKey, suite] of typeNode.suites) {
+          for (const file of suite.files.values()) {
+            if (file.status !== "failed") continue;
+            failures.push({
+              key: buildFailureKey(service.name, file.path),
+              serviceName: service.name,
+              suiteKey,
+              suiteName: suite.name,
+              displayType: typeNode.type,
+              framework: suite.framework,
+              filePath: file.path,
+              displayName: file.displayName,
+              error: file.error,
+              failureDetails: file.failureDetails,
+            });
+          }
+        }
+      }
+    }
+    return failures.sort(
+      (left, right) =>
+        left.serviceName.localeCompare(right.serviceName) || left.filePath.localeCompare(right.filePath)
+    );
+  }
+
+  function ensureSelectedFailure() {
+    const failures = collectFailedFiles();
+    if (failures.length === 0) {
+      selectedFailureKey = null;
+      return;
+    }
+    if (selectedFailureKey && failures.some((failure) => failure.key === selectedFailureKey)) return;
+    selectedFailureKey = failures[0].key;
+  }
+
+  function appendTranscriptEntry(kind, text) {
+    if (!agentSession || !text) return;
+    const normalizedText = String(text);
+    const entries = agentSession.entries || [];
+    const lastEntry = entries.at(-1);
+    if (kind === "assistant" && lastEntry?.kind === "assistant") {
+      lastEntry.text += normalizedText;
+      agentSession.updatedAt = Date.now();
+      return;
+    }
+    entries.push({ kind, text: normalizedText });
+    agentSession.entries = entries;
+    agentSession.updatedAt = Date.now();
+  }
+
+  function finishAgentSession(status, extra = {}) {
+    if (!agentSession) return;
+    agentSession = {
+      ...agentSession,
+      ...extra,
+      status,
+      endedAt: Date.now(),
+    };
+  }
+
+  return {
+    initFromPlans(servicePlans) {
+      for (const plan of servicePlans) {
+        const serviceName = plan.config.name;
+        const service = getOrCreateService(serviceName);
+
+        if (plan.skipped) {
+          service.skipped = true;
+          continue;
+        }
+
+        for (const suite of plan.suites) {
+          const displayType = suite.displayType || suiteSelectionType(suite.type, suite.framework);
+          const typeNode = getOrCreateType(service, displayType);
+          const suiteKey = `${displayType}:${suite.name}`;
+          const suiteNode = getOrCreateSuite(typeNode, suiteKey, {
+            name: suite.name,
+            groupLabel: fileDisplayName(suite.name),
+            framework: suite.framework,
+          });
+
+          for (const filePath of suite.files) {
+            if (suiteNode.files.has(filePath)) continue;
+            suiteNode.files.set(filePath, {
+              path: filePath,
+              displayName: fileDisplayName(filePath),
+              status: "pending",
+              durationMs: null,
+              error: null,
+              failureDetails: null,
+              skipReason: null,
+            });
+          }
+        }
+      }
+      ensureSelectedFailure();
+      notify();
+    },
+
+    setRegressionCatalog(document) {
+      regressionCatalog = document;
+      notify();
+    },
+
+    markFileRunning(serviceName, suiteKey, filePath) {
+      const file = findFile(serviceName, suiteKey, filePath) || findFileByServiceAndPath(serviceName, filePath);
+      if (!file) return;
+      file.status = "running";
+      notify();
+    },
+
+    markFileFinished(task, outcome) {
+      const suiteKey = `${task.displayType || suiteSelectionType(task.type, task.framework)}:${task.suiteName}`;
+      const file = findFile(task.serviceName, suiteKey, task.file) || findFileByServiceAndPath(task.serviceName, task.file);
+      if (!file) return;
+      if (outcome.status === "skipped") {
+        file.status = "skipped";
+        file.skipReason = outcome.reason || null;
+      } else if (outcome.status === "not_run") {
+        file.status = "not_run";
+        file.skipReason = outcome.reason || null;
+      } else if (outcome.failed) {
+        file.status = "failed";
+        file.error = outcome.error || null;
+        file.failureDetails = outcome.failureDetails || null;
+      } else {
+        file.status = "passed";
+      }
+      file.durationMs = outcome.durationMs || null;
+      completedCount += 1;
+      ensureSelectedFailure();
+      notify();
+    },
+
+    markServiceSkipped(serviceName, reason) {
+      const service = getOrCreateService(serviceName);
+      service.skipped = true;
+      service.skipReason = reason || null;
+      notify();
+    },
+
+    markPlannedSkip(entry) {
+      const file = findFileByServiceAndPath(entry.serviceName, entry.file);
+      if (!file) return;
+      file.status = "skipped";
+      file.skipReason = entry.reason || null;
+      completedCount += 1;
+      notify();
+    },
+
+    markRuntimeError(task, message) {
+      const file = findFileByServiceAndPath(task.serviceName, task.file);
+      if (!file) return;
+      file.status = "failed";
+      file.error = message || "runtime error";
+      completedCount += 1;
+      ensureSelectedFailure();
+      notify();
+    },
+
+    setTotalFileCount(count) {
+      totalCount = count;
+      notify();
+    },
+
+    setPhase(label) {
+      phase = label;
+      notify();
+    },
+
+    finish(results, durationMs, regressionReport) {
+      finished = true;
+      mode = "complete";
+      const summary = buildRunSummaryData(results, durationMs, regressionReport);
+      const rows = [
+        ["Result", summary.result],
+        ["Passed", String(summary.passed)],
+        ["Failed", String(summary.failed)],
+        ["Skipped", String(summary.skipped)],
+        ["Not run", String(summary.notRun)],
+        ["Files", String(summary.files)],
+        ["Duration", summary.duration],
+      ];
+      if (summary.serviceErrors > 0) rows.push(["Runtime errors", String(summary.serviceErrors)]);
+      if (summary.newRegressions > 0) rows.push(["New regressions", String(summary.newRegressions)]);
+      if (summary.knownRegressions > 0) rows.push(["Known regressions", String(summary.knownRegressions)]);
+      if (summary.fixedKnownRegressions > 0) rows.push(["Fixed known", String(summary.fixedKnownRegressions)]);
+      if (summary.catalogStale > 0) rows.push(["Catalog stale", String(summary.catalogStale)]);
+      summaryData = { rows, result: summary.result };
+      ensureSelectedFailure();
+      notify();
+    },
+
+    setNotice(message) {
+      notice = message ? String(message) : null;
+      notify();
+    },
+
+    clearNotice() {
+      if (!notice) return;
+      notice = null;
+      notify();
+    },
+
+    selectNextFailure() {
+      const failures = collectFailedFiles();
+      if (failures.length === 0) return;
+      const currentIndex = failures.findIndex((failure) => failure.key === selectedFailureKey);
+      const nextIndex = currentIndex < 0 ? 0 : (currentIndex + 1) % failures.length;
+      selectedFailureKey = failures[nextIndex].key;
+      notify();
+    },
+
+    selectPreviousFailure() {
+      const failures = collectFailedFiles();
+      if (failures.length === 0) return;
+      const currentIndex = failures.findIndex((failure) => failure.key === selectedFailureKey);
+      const nextIndex = currentIndex < 0 ? failures.length - 1 : (currentIndex - 1 + failures.length) % failures.length;
+      selectedFailureKey = failures[nextIndex].key;
+      notify();
+    },
+
+    selectFailure(failureKey) {
+      selectedFailureKey = failureKey || null;
+      ensureSelectedFailure();
+      notify();
+    },
+
+    beginInvestigation({ provider, userMessage } = {}) {
+      mode = "investigating";
+      notice = null;
+      agentSession = {
+        provider: provider || "auto",
+        userMessage: userMessage || "",
+        status: "starting",
+        startedAt: Date.now(),
+        updatedAt: Date.now(),
+        entries: [],
+      };
+      notify();
+    },
+
+    appendAgentEvent(event) {
+      if (!agentSession || !event) return;
+      if (event.type === "start") {
+        agentSession.status = "running";
+      } else if (event.type === "delta") {
+        appendTranscriptEntry("assistant", event.text || "");
+      } else if (event.type === "final") {
+        if (event.text && !(agentSession.entries || []).some((entry) => entry.kind === "assistant")) {
+          appendTranscriptEntry("assistant", event.text);
+        }
+        agentSession.finalText = event.text || agentSession.finalText || "";
+      } else if (event.type === "tool") {
+        appendTranscriptEntry("tool", event.detail ? `${event.name}: ${event.detail}` : event.name);
+      } else if (event.type === "status") {
+        appendTranscriptEntry("status", event.message || "");
+      } else if (event.type === "error") {
+        appendTranscriptEntry("error", event.message || "Agent error");
+      } else if (event.type === "exit") {
+        agentSession.exitCode = event.code;
+      }
+      notify();
+    },
+
+    completeAgentSession(result = {}) {
+      finishAgentSession("complete", {
+        finalText: result.finalText || agentSession?.finalText || "",
+        exitCode: result.exitCode ?? agentSession?.exitCode ?? 0,
+      });
+      notify();
+    },
+
+    failAgentSession(error) {
+      finishAgentSession("error", {
+        error: error instanceof Error ? error.message : String(error || "Agent error"),
+      });
+      notify();
+    },
+
+    cancelAgentSession(message = "Cancelled investigation.") {
+      finishAgentSession("cancelled");
+      mode = "complete";
+      notice = message;
+      notify();
+    },
+
+    returnToSummary() {
+      mode = "complete";
+      notify();
+    },
+
+    subscribe(callback) {
+      listeners.add(callback);
+      return () => listeners.delete(callback);
+    },
+
+    getSnapshot() {
+      const serviceSnapshots = [];
+      for (const service of services.values()) {
+        if (service.skipped) {
+          serviceSnapshots.push({
+            name: service.name,
+            skipped: true,
+            skipReason: service.skipReason,
+            types: [],
+          });
+          continue;
+        }
+
+        const typeSnapshots = [];
+        for (const typeNode of service.types.values()) {
+          const suiteSnapshots = [];
+          let typeAllCollapsed = true;
+
+          for (const [suiteKey, suite] of typeNode.suites) {
+            const files = [...suite.files.values()];
+            const allPassed = files.length > 0 && files.every((file) => file.status === "passed");
+            const allSkipped = files.length > 0 && files.every((file) => file.status === "skipped");
+            const anyFailed = files.some((file) => file.status === "failed");
+            const anyRunning = files.some((file) => file.status === "running");
+            const anyPending = files.some((file) => file.status === "pending");
+
+            let collapsed = false;
+            let collapseStatus = null;
+            let visibleFiles = files;
+
+            if (allPassed) {
+              collapsed = true;
+              collapseStatus = "all_passed";
+              visibleFiles = [];
+            } else if (allSkipped) {
+              collapsed = true;
+              collapseStatus = "all_skipped";
+              visibleFiles = [];
+            } else if (anyFailed && !anyRunning && !anyPending) {
+              visibleFiles = files.filter((file) => file.status === "failed" || file.status === "not_run");
+            }
+
+            if (!collapsed) {
+              typeAllCollapsed = false;
+            }
+
+            suiteSnapshots.push({
+              key: suiteKey,
+              name: suite.name,
+              groupLabel: suite.groupLabel,
+              framework: suite.framework,
+              collapsed,
+              collapseStatus,
+              fileCount: files.length,
+              passedCount: files.filter((file) => file.status === "passed").length,
+              totalDurationMs: files.reduce((sum, file) => sum + (file.durationMs || 0), 0),
+              visibleFiles,
+            });
+          }
+
+          typeSnapshots.push({
+            type: typeNode.type,
+            collapsed: typeAllCollapsed,
+            suites: suiteSnapshots,
+          });
+        }
+
+        serviceSnapshots.push({
+          name: service.name,
+          skipped: false,
+          skipReason: null,
+          types: typeSnapshots,
+        });
+      }
+
+      const failures = collectFailedFiles();
+      const selectedFailure = failures.find((failure) => failure.key === selectedFailureKey) || null;
+      return {
+        services: serviceSnapshots,
+        completedCount,
+        totalCount,
+        phase,
+        finished,
+        summaryData,
+        regressionCatalog,
+        mode,
+        notice,
+        failures,
+        selectedFailureKey,
+        selectedFailure,
+        agentSession,
+      };
+    },
+  };
+}

package/lib/cli/tui/run-tree-state.mjs

@@ -0,0 +1 @@
+export { createRunSessionState as createRunTreeState } from "./run-session-state.mjs";

package/lib/config-api/auth-fixtures.mjs

@@ -250,16 +250,21 @@ function resolveActorSession({ actorDefinition, actorIndex, contract, env }) {
   };
 
   if (contract.signup.enabled) {
-    runProfileRequest({
-      requestConfig: {
-        body: () => buildSignupBody(actorDefinition),
-        expect: contract.signup.expect,
-        method: "POST",
-        path: contract.signup.path,
-      },
-      context: { ...context, phase: "signup" },
-      label: `auth.fixture signup for actor "${actorDefinition.actorName}"`,
-    });
+    try {
+      runProfileRequest({
+        requestConfig: {
+          body: () => buildSignupBody(actorDefinition),
+          expect: contract.signup.expect,
+          method: "POST",
+          path: contract.signup.path,
+        },
+        context: { ...context, phase: "signup" },
+        label: `auth.fixture signup for actor "${actorDefinition.actorName}"`,
+      });
+    } catch {
+      // Provisioning is best-effort. Some apps report duplicate-account races as 500s
+      // instead of a clean 409, and a successful login is the authoritative signal.
+    }
   }
 
   const response = runProfileRequest({

package/lib/discovery/index.mjs

@@ -494,7 +494,7 @@ function normalizePath(filePath) {
   return String(filePath).split(path.sep).join("/").replace(/^\.\/+/, "");
 }
 
-function fileDisplayName(filePath) {
+export function fileDisplayName(filePath) {
   const base = path.posix
     .basename(filePath)
     .replace(/(\.int|\.e2e|\.scenario|\.dal|\.load|\.pw)\.testkit\.ts$/, "");

package/lib/index.d.ts

@@ -2,6 +2,7 @@ import type {
   ActorRequestClient,
   HttpClient,
   HttpClientConfig,
+  RawRequestClient,
   RuntimeDb,
   RuntimeDalContext,
   RuntimeEnv,
@@ -33,11 +34,14 @@ export interface AuthAdapter<TSetup = unknown> {
 
 export interface SuiteActor<TSession = Record<string, unknown>> {
   email: string | null;
+  headers: RuntimeHeaders;
   index: number;
   key: string;
   name: string | null;
   organizationKey: string | null;
   organizationName: string | null;
+  rawHeaders: RuntimeHeaders;
+  rawReq: RawRequestClient;
   req: ActorRequestClient;
   session: TSession | null;
 }
@@ -55,7 +59,7 @@ export interface HttpSuiteContext<TSession = Record<string, unknown>> {
   actors: SuiteActors<TSession>;
   env: RuntimeEnv;
   req: HttpClient<TSession>;
-  rawReq: HttpClient["raw"];
+  rawReq: RawRequestClient;
 }
 
 export interface ScenarioStepResult {

package/lib/runner/orchestrator.mjs

@@ -85,6 +85,7 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
     execution,
     reporter
   );
+  reporter?.setServicePlans?.(servicePlans);
   const trackers = buildServiceTrackers(servicePlans, startedAt);
   let writeLiveSnapshot = () => {};
   const setupRegistry = createSetupOperationRegistry({ logRegistry, onChange: () => writeLiveSnapshot() });