@elench/testkit 0.1.53 → 0.1.54

package/lib/cli/presentation/code-frames.mjs

@@ -0,0 +1,57 @@
+import fs from "fs";
+import path from "path";
+import { codeFrameColumns } from "@babel/code-frame";
+import { createColors } from "picocolors";
+
+const pc = createColors(Boolean(process.stdout?.isTTY || process.env.FORCE_COLOR));
+
+export function findFailureLocation(detail = {}, fallbackError = "") {
+  if (detail?.location?.path && Number.isFinite(detail?.location?.line)) {
+    return detail.location;
+  }
+
+  const stack = detail?.stack || fallbackError;
+  if (!stack) return null;
+  const match = String(stack).match(/(\/[^\s:()]+):(\d+):(\d+)/);
+  if (!match) return null;
+  return {
+    path: match[1],
+    line: Number(match[2]),
+    column: Number(match[3]),
+  };
+}
+
+export function renderCodeFrame(location, options = {}) {
+  if (!location?.path || !Number.isFinite(location.line)) return [];
+  if (!fs.existsSync(location.path)) return [];
+
+  try {
+    const source = fs.readFileSync(location.path, "utf8");
+    const frame = codeFrameColumns(
+      source,
+      {
+        start: {
+          line: location.line,
+          column: Math.max(1, Number(location.column) || 1),
+        },
+      },
+      {
+        highlightCode: Boolean(process.stdout?.isTTY || process.env.FORCE_COLOR),
+        linesAbove: options.linesAbove ?? 2,
+        linesBelow: options.linesBelow ?? 2,
+      }
+    );
+    const label = `${options.label || "code"}: ${formatLocation(location, options.cwd)}`;
+    return [pc.bold(label), ...frame.split(/\r?\n/)];
+  } catch {
+    return [];
+  }
+}
+
+export function formatLocation(location, cwd = process.cwd()) {
+  if (!location?.path || !Number.isFinite(location.line)) return null;
+  const relativePath = path.isAbsolute(location.path)
+    ? path.relative(cwd, location.path) || path.basename(location.path)
+    : location.path;
+  return `${relativePath}:${location.line}:${location.column || 1}`;
+}

package/lib/cli/presentation/code-frames.test.mjs

@@ -0,0 +1,71 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { afterEach, describe, expect, it } from "vitest";
+import { findFailureLocation, formatLocation, renderCodeFrame } from "./code-frames.mjs";
+
+const cleanups = [];
+
+afterEach(() => {
+  while (cleanups.length > 0) {
+    cleanups.pop()();
+  }
+});
+
+describe("code frame presentation", () => {
+  it("finds a location from structured failure metadata", () => {
+    expect(
+      findFailureLocation({
+        location: {
+          path: "/tmp/example.ts",
+          line: 10,
+          column: 2,
+        },
+      })
+    ).toEqual({
+      path: "/tmp/example.ts",
+      line: 10,
+      column: 2,
+    });
+  });
+
+  it("renders a code frame for a local file", () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-code-frame-"));
+    cleanups.push(() => fs.rmSync(tempDir, { recursive: true, force: true }));
+    const filePath = path.join(tempDir, "example.ts");
+    fs.writeFileSync(
+      filePath,
+      [
+        "export function run() {",
+        "  const value = 1;",
+        "  return value + missing;",
+        "}",
+      ].join("\n")
+    );
+
+    const lines = renderCodeFrame(
+      {
+        path: filePath,
+        line: 3,
+        column: 18,
+      },
+      { cwd: tempDir }
+    );
+
+    expect(lines.join("\n")).toContain("example.ts:3:18");
+    expect(lines.join("\n")).toContain("return value + missing;");
+  });
+
+  it("formats locations relative to the cwd", () => {
+    expect(
+      formatLocation(
+        {
+          path: "/tmp/example.ts",
+          line: 7,
+          column: 3,
+        },
+        "/tmp"
+      )
+    ).toBe("example.ts:7:3");
+  });
+});

package/lib/cli/presentation/colors.mjs

@@ -0,0 +1,29 @@
+import { createColors } from "picocolors";
+
+const pc = createColors(Boolean(process.stdout?.isTTY || process.env.FORCE_COLOR));
+
+export function colorStatus(status) {
+  if (status === "PASS") return pc.green(status);
+  if (status === "FAIL") return pc.red(status);
+  if (status === "SKIP") return pc.yellow(status);
+  if (status === "RUN") return pc.cyan(status);
+  return status;
+}
+
+export function dim(text) {
+  return pc.dim(text);
+}
+
+export function colorResultLine(line) {
+  if (/^Result: PASSED\b/.test(line)) return line.replace("PASSED", pc.green("PASSED"));
+  if (/^Result: FAILED\b/.test(line)) return line.replace("FAILED", pc.red("FAILED"));
+  return line;
+}
+
+export function colorSectionLine(line) {
+  if (line === "Failures:" || line === "Runtime Errors:" || line === "Known-failure issues:" || line === "Triage:") {
+    return pc.bold(line);
+  }
+  if (/^Summary: /.test(line)) return line.replace("Summary:", `${pc.bold("Summary:")}`);
+  return colorResultLine(line);
+}

package/lib/cli/presentation/run-reporter.mjs

@@ -4,6 +4,7 @@ import {
   buildDebugRunSummaryLines,
   formatDuration,
 } from "../../runner/formatting.mjs";
+import { colorSectionLine, colorStatus, dim } from "./colors.mjs";
 
 export function createRunReporter({ outputMode = "compact", stdout = process.stdout, stderr = process.stderr } = {}) {
   const mode = outputMode || "compact";
@@ -30,29 +31,32 @@ export function createRunReporter({ outputMode = "compact", stdout = process.std
       stdout.write(`Starting ${config.runtimeLabel}:${config.name}: ${command}\n`);
     },
     serviceSkipped(config, reason) {
-      stdout.write(`SKIP ${config.name} ${reason}\n`);
+      stdout.write(`${colorStatus("SKIP")} ${config.name} ${reason}\n`);
     },
     plannedSkip(entry) {
       stdout.write(
-        `SKIP ${entry.serviceName} ${entry.type} ${normalizePath(entry.file)} 0s ${shortenMessage(entry.reason || "skipped")}\n`
+        `${colorStatus("SKIP")} ${entry.serviceName} ${entry.type} ${normalizePath(entry.file)} ${dim("0s")} ${shortenMessage(entry.reason || "skipped")}\n`
       );
     },
     taskStarted(task, targetConfig) {
       if (mode !== "debug") return;
-      stdout.write(`RUN  ${targetConfig.name} ${task.type} ${task.file}\n`);
+      stdout.write(`${colorStatus("RUN").padEnd(12)} ${targetConfig.name} ${task.type} ${task.file}\n`);
     },
     taskFinished(task, outcome) {
       if (mode === "json") return;
       const status = outcome.status === "skipped" ? "SKIP" : outcome.failed ? "FAIL" : "PASS";
       const duration = formatDuration(outcome.durationMs || 0);
+      const primaryFailure = firstFailureDetail(outcome);
+      const preferredFailure =
+        primaryFailure && isThresholdWrapperMessage(outcome.error) ? primaryFailure : outcome.error || primaryFailure;
       const detail =
         status === "FAIL"
-          ? ` ${shortenMessage(outcome.error || firstFailureDetail(outcome) || "failed")}`
+          ? ` ${shortenMessage(preferredFailure || "failed")}`
           : outcome.status === "not_run"
             ? ` ${shortenMessage(outcome.reason || "not run")}`
             : "";
       stdout.write(
-        `${status} ${task.serviceName} ${displayTaskType(task)} ${normalizePath(task.file)} ${duration}${detail}\n`
+        `${colorStatus(status)} ${task.serviceName} ${displayTaskType(task)} ${normalizePath(task.file)} ${dim(duration)}${detail}\n`
       );
     },
     telemetry(message) {
@@ -64,7 +68,7 @@ export function createRunReporter({ outputMode = "compact", stdout = process.std
         mode === "debug"
           ? buildDebugRunSummaryLines(results, durationMs, knownFailureIssueValidation)
           : buildCompactRunSummaryLines(results, durationMs, knownFailureIssueValidation);
-      for (const line of lines) stdout.write(`${line}\n`);
+      for (const line of lines) stdout.write(`${colorSectionLine(line)}\n`);
     },
     error(message) {
       stderr.write(`${message}\n`);
@@ -83,7 +87,12 @@ function shortenMessage(message) {
 }
 
 function firstFailureDetail(outcome) {
-  return outcome.failureDetails?.[0]?.message || outcome.failureDetails?.[0]?.title || null;
+  const detail = outcome.failureDetails?.[0];
+  return detail?.message || detail?.title || null;
+}
+
+function isThresholdWrapperMessage(message) {
+  return /Default runtime thresholds failed:/.test(String(message || ""));
 }
 
 function normalizePath(filePath) {

package/lib/cli/viewer.mjs

@@ -1,7 +1,12 @@
 import fs from "fs";
 import path from "path";
 import { formatDuration } from "../runner/formatting.mjs";
-import { readLogTail } from "../runner/logs.mjs";
+import { findLogSliceByRequestId, readLogTail } from "../runner/logs.mjs";
+import {
+  findFailureLocation,
+  formatLocation,
+  renderCodeFrame,
+} from "./presentation/code-frames.mjs";
 
 export function loadLatestRunArtifact(productDir) {
   const artifactPath = path.join(productDir, ".testkit", "results", "latest.json");
@@ -63,6 +68,8 @@ export function collectArtifactEntries(productDir, runArtifact, selector = null,
 
 export function formatFileDetail(productDir, runArtifact, subject, options = {}) {
   const lines = [];
+  const failureDetails = subject.file.failureDetails || [];
+  const primaryDetail = rankFailureDetails(failureDetails)[0] || null;
   lines.push(`File: ${subject.file.path}`);
   lines.push(`Service: ${subject.service.name}`);
   lines.push(`Suite: ${subject.suite.type}:${subject.suite.name}`);
@@ -70,15 +77,37 @@ export function formatFileDetail(productDir, runArtifact, subject, options = {})
   lines.push(`Duration: ${formatDuration(subject.file.durationMs || 0)}`);
   if (subject.file.error) lines.push(`Error: ${subject.file.error}`);
 
-  if ((subject.file.failureDetails || []).length > 0) {
+  if (failureDetails.length > 0) {
     lines.push("");
     lines.push("Failure Details:");
-    for (const detail of subject.file.failureDetails.slice(0, options.failureLimit || 5)) {
+    for (const detail of rankFailureDetails(failureDetails).slice(0, options.failureLimit || 5)) {
       lines.push(`  ${detail.title}`);
       if (detail.message) lines.push(`    ${detail.message}`);
+      const requestLine = formatRequestLine(detail);
+      if (requestLine) lines.push(`    ${requestLine}`);
+      const responseLine = formatResponseLine(detail);
+      if (responseLine) lines.push(`    ${responseLine}`);
+      const location = findFailureLocation(detail, subject.file.error || "");
+      if (location) lines.push(`    at ${formatLocation(location, productDir)}`);
     }
   }
 
+  const codeFrame = renderCodeFrame(findFailureLocation(primaryDetail, subject.file.error || ""), {
+    cwd: productDir,
+  });
+  if (codeFrame.length > 0) {
+    lines.push("");
+    lines.push("Code Frame:");
+    for (const line of codeFrame) lines.push(`  ${line}`);
+  }
+
+  if (subject.file.triage) {
+    lines.push("");
+    lines.push("Triage:");
+    const triageLines = formatTriage(subject.file.triage);
+    for (const line of triageLines) lines.push(`  ${line}`);
+  }
+
   const artifacts = collectArtifactEntries(productDir, runArtifact, subject.file.path, subject.service.name);
   if (artifacts.length > 0) {
     lines.push("");
@@ -100,7 +129,12 @@ export function formatFileDetail(productDir, runArtifact, subject, options = {})
     for (const logRef of logRefs) {
       lines.push(`  ${logRef.runtimeLabel}`);
       lines.push(`    ${logRef.path}`);
-      const tail = readLogTail(path.join(productDir, logRef.path), options.logTail || 12);
+      const logPath = path.join(productDir, logRef.path);
+      const requestId = primaryDetail?.request?.requestId || null;
+      const tail =
+        requestId && findLogSliceByRequestId(logPath, requestId, 2).length > 0
+          ? findLogSliceByRequestId(logPath, requestId, 2)
+          : readLogTail(logPath, options.logTail || 12);
       for (const line of tail.slice(-Math.max(0, options.logTail || 12))) {
         lines.push(`    ${line}`);
       }
@@ -119,6 +153,9 @@ export function formatArtifactPreview(payload, maxLines = 6) {
   if (payload.kind === "agentic-query") {
     return formatAgenticArtifact(payload, maxLines);
   }
+  if (payload.kind === "testkit.http-traces") {
+    return formatHttpTraceArtifact(payload, maxLines);
+  }
   if (payload.contentType === "text/plain" && typeof payload.data?.text === "string") {
     return payload.data.text
       .split(/\r?\n/)
@@ -145,6 +182,74 @@ function formatAgenticArtifact(payload, maxLines) {
   return lines.slice(0, maxLines);
 }
 
+function formatHttpTraceArtifact(payload, maxLines) {
+  const traces = Array.isArray(payload.data?.traces) ? payload.data.traces : [];
+  const lines = [];
+  for (const trace of traces.slice(0, maxLines)) {
+    lines.push(
+      `${trace.method} ${trace.path} -> ${trace.response?.status ?? "?"}${trace.requestId ? ` [${trace.requestId}]` : ""}`
+    );
+  }
+  return lines;
+}
+
+function rankFailureDetails(details) {
+  return [...(Array.isArray(details) ? details : [])].sort((left, right) => {
+    return failureDetailRank(left) - failureDetailRank(right) || String(left?.key || "").localeCompare(String(right?.key || ""));
+  });
+}
+
+function failureDetailRank(detail) {
+  if (detail?.kind === "http-assertion") return 1;
+  if (detail?.request && detail?.response) return 2;
+  if (detail?.location || detail?.stack) return 3;
+  if (detail?.message) return 4;
+  return 5;
+}
+
+function formatRequestLine(detail) {
+  const method = detail?.request?.method;
+  const path = detail?.request?.path;
+  if (!method || !path) return null;
+  const requestId = detail?.request?.requestId;
+  return requestId ? `request: ${method} ${path} [${requestId}]` : `request: ${method} ${path}`;
+}
+
+function formatResponseLine(detail) {
+  if (!detail?.response) return null;
+  const parts = [`response: ${detail.response.status ?? "?"}`];
+  if (detail.response.contentType) parts.push(detail.response.contentType);
+  if (detail.response.bodyPreview) parts.push(detail.response.bodyPreview);
+  return parts.join(" ");
+}
+
+function formatTriage(triage) {
+  const lines = [`status: ${triage.status}`];
+  if (triage.classifications?.length) {
+    lines.push(`classification: ${triage.classifications.join(", ")}`);
+  }
+  if (triage.availability?.mode) {
+    lines.push(
+      `validation: ${triage.availability.mode}${triage.availability.reason ? ` (${triage.availability.reason})` : ""}`
+    );
+  }
+  for (const entry of triage.entries || []) {
+    lines.push(`issue: ${entry.issue.repo}#${entry.issue.number}`);
+    if (entry.issue.url) lines.push(`url: ${entry.issue.url}`);
+    if (entry.github?.state) {
+      lines.push(`github state: ${entry.github.state}${entry.github.cached ? " (cache)" : ""}`);
+    }
+    if (entry.validationStatus) lines.push(`validation status: ${entry.validationStatus}`);
+    if (entry.findings?.length) {
+      for (const finding of entry.findings.slice(0, 3)) {
+        lines.push(`finding: ${finding.message}`);
+      }
+    }
+    break;
+  }
+  return lines;
+}
+
 function collectFiles(runArtifact, serviceFilter = null) {
   const files = [];
   for (const service of runArtifact.services || []) {

package/lib/known-failures/index.mjs

@@ -194,7 +194,7 @@ export function matchesKnownFailureMatch(match, fileSummary) {
   if (match.path !== fileSummary.path) return false;
   if (match.failureKey) {
     const failureKeys = Array.isArray(fileSummary.failureDetails)
-      ? fileSummary.failureDetails.map((detail) => detail?.key)
+      ? fileSummary.failureDetails.flatMap((detail) => [detail?.key, detail?.title].filter(Boolean))
       : [];
     if (!failureKeys.includes(match.failureKey)) return false;
   }

package/lib/known-failures/index.test.mjs

@@ -59,6 +59,52 @@ describe("known failures core", () => {
     expect(matches[0].id).toBe("bad-message");
   });
 
+  it("matches failureKey against a detail title when the key becomes richer", () => {
+    const document = normalizeKnownFailuresDocument({
+      schemaVersion: 1,
+      entries: [
+        {
+          id: "missing-route",
+          title: "Missing route bug",
+          classification: "product_bug",
+          state: "open",
+          issue: {
+            repo: "acme/repo",
+            number: 13,
+            url: "https://github.com/acme/repo/issues/13",
+          },
+          description: "Wrong status code",
+          whyFailing: "The route returns 404",
+          lastReviewedAt: "2026-04-28",
+          matches: [
+            {
+              service: "api",
+              type: "int",
+              path: "__testkit__/health/http-failure.int.testkit.ts",
+              failureKey: "GET /missing returns 200",
+            },
+          ],
+        },
+      ],
+    });
+
+    const matches = findMatchingKnownFailureEntries(document, {
+      service: "api",
+      type: "int",
+      path: "__testkit__/health/http-failure.int.testkit.ts",
+      error: "Default runtime thresholds failed: checks(rate==1.0)",
+      failureDetails: [
+        {
+          key: "GET /missing > GET /missing returns 200",
+          title: "GET /missing returns 200",
+        },
+      ],
+    });
+
+    expect(matches).toHaveLength(1);
+    expect(matches[0].id).toBe("missing-route");
+  });
+
   it("validates status coverage and filesystem matches", () => {
     const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-known-failures-"));
     tempDirs.push(tempDir);

package/lib/runner/default-runtime-errors.mjs

@@ -1,3 +1,6 @@
+import path from "path";
+import { fileURLToPath } from "url";
+
 export function determineDefaultRuntimeFailure(result, summary, firstLine) {
   const fatalRuntimeError = extractDefaultRuntimeFatalError(result.stderr || "", firstLine);
   if (fatalRuntimeError) {
@@ -26,6 +29,22 @@ export function extractDefaultRuntimeFatalError(stderr, firstLine) {
   return matched?.[1]?.trim() || firstLine(stderr);
 }
 
+export function extractDefaultRuntimeFatalDetail(stderr, firstLine) {
+  if (!stderr || !/source=stacktrace/.test(stderr)) return null;
+  const message = extractDefaultRuntimeFatalError(stderr, firstLine);
+  if (!message) return null;
+
+  const location = extractFirstLocation(stderr);
+  return {
+    kind: "runtime-exception",
+    key: location ? `${location.path}:${location.line}:${location.column}` : message,
+    title: "Uncaught runtime exception",
+    message: `Uncaught testkit suite error: ${message}`,
+    location,
+    stack: sanitizeStack(stderr),
+  };
+}
+
 export function extractDefaultRuntimeThresholdFailures(summary) {
   const metrics = summary?.metrics;
   if (!metrics || typeof metrics !== "object") return [];
@@ -51,3 +70,50 @@ export function sanitizeDefaultRuntimeExitError(exitCode, output, firstLine) {
   }
   return `Default runtime failed with exit code ${exitCode}`;
 }
+
+function extractFirstLocation(stderr) {
+  const locations = [...String(stderr).matchAll(/(file:\/\/[^\s)]+|\/[^\s):]+):(\d+):(\d+)/g)].map((match) => ({
+    path: normalizeLocationPath(match[1]),
+    line: Number(match[2]),
+    column: Number(match[3]),
+  }));
+  if (locations.length === 0) return null;
+
+  return (
+    locations.find((location) => isPreferredLocation(location.path)) ||
+    locations.find((location) => !isRuntimeInternalLocation(location.path)) ||
+    locations[0]
+  );
+}
+
+function normalizeLocationPath(rawPath) {
+  if (!rawPath) return rawPath;
+  if (rawPath.startsWith("file://")) {
+    try {
+      return fileURLToPath(rawPath);
+    } catch {
+      return rawPath;
+    }
+  }
+  return rawPath;
+}
+
+function sanitizeStack(stderr) {
+  return String(stderr)
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .join("\n");
+}
+
+function isPreferredLocation(filePath) {
+  if (typeof filePath !== "string") return false;
+  const normalized = filePath.split(path.sep).join("/");
+  return normalized.includes("/.testkit/_bundles/") || normalized.includes("/__testkit__/");
+}
+
+function isRuntimeInternalLocation(filePath) {
+  if (typeof filePath !== "string") return false;
+  const normalized = filePath.split(path.sep).join("/");
+  return normalized.includes("/testkit/lib/runtime-src/k6/") || normalized.includes("/vendor/k6");
+}

package/lib/runner/default-runtime-runner.mjs

@@ -8,7 +8,10 @@ import {
   formatFileTimeoutBudgetError,
 } from "../shared/file-timeout.mjs";
 import { persistTaskArtifacts, persistTaskOutputArtifacts } from "./artifacts.mjs";
-import { determineDefaultRuntimeFailure } from "./default-runtime-errors.mjs";
+import {
+  determineDefaultRuntimeFailure,
+  extractDefaultRuntimeFatalDetail,
+} from "./default-runtime-errors.mjs";
 import { collectFailureDetailsFromRuntimeArtifacts } from "./failure-details.mjs";
 import { RUNTIME_ARTIFACT_MARKER } from "../runtime-src/k6/artifacts.js";
 import { readDatabaseUrl } from "./state-io.mjs";
@@ -147,6 +150,10 @@ export async function runDefaultRuntimeTask(
       : null,
   ]);
   const failureDetails = collectFailureDetailsFromRuntimeArtifacts(rawRuntimeArtifacts);
+  const fatalRuntimeDetail = extractDefaultRuntimeFatalDetail(result.stderr || "", getFirstLine);
+  if (fatalRuntimeDetail && !failureDetails.some((detail) => detail?.kind === "runtime-exception")) {
+    failureDetails.unshift(fatalRuntimeDetail);
+  }
   const runtimeError = timedOut
     ? formatFileTimeoutBudgetError(fileTimeoutSeconds)
     : determineDefaultRuntimeFailure(result, summary, getFirstLine);

package/lib/runner/failure-details.mjs

@@ -28,6 +28,24 @@ export function normalizeFailureDetail(detail) {
   const message = normalizeNonEmptyString(detail.message);
   if (message) normalized.message = message;
 
+  if (detail.expected !== undefined) normalized.expected = cloneJsonValue(detail.expected);
+  if (detail.actual !== undefined) normalized.actual = cloneJsonValue(detail.actual);
+
+  const traceId = normalizeNonEmptyString(detail.traceId);
+  if (traceId) normalized.traceId = traceId;
+
+  const request = normalizeRecord(detail.request);
+  if (request) normalized.request = request;
+
+  const response = normalizeRecord(detail.response);
+  if (response) normalized.response = response;
+
+  const location = normalizeRecord(detail.location);
+  if (location) normalized.location = location;
+
+  const stack = normalizeNonEmptyString(detail.stack);
+  if (stack) normalized.stack = stack;
+
   return normalized;
 }
 
@@ -89,3 +107,16 @@ function normalizePositiveInteger(value) {
   if (!Number.isInteger(value) || value <= 0) return null;
   return value;
 }
+
+function normalizeRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  return cloneJsonValue(value);
+}
+
+function cloneJsonValue(value) {
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    return String(value);
+  }
+}

package/lib/runner/failure-details.test.mjs

@@ -60,4 +60,55 @@ describe("runner failure details", () => {
       },
     ]);
   });
+
+  it("preserves rich assertion metadata", () => {
+    expect(
+      mergeFailureDetails([
+        {
+          kind: "http-assertion",
+          key: "GET /health > status is 200",
+          title: "status is 200",
+          expected: 200,
+          actual: 404,
+          request: {
+            method: "GET",
+            path: "/health",
+            requestId: "req-1",
+          },
+          response: {
+            status: 404,
+            bodyPreview: '{"error":"nope"}',
+          },
+          location: {
+            path: "/tmp/example.ts",
+            line: 12,
+            column: 4,
+          },
+        },
+      ])
+    ).toEqual([
+      {
+        kind: "http-assertion",
+        key: "GET /health > status is 200",
+        title: "status is 200",
+        count: 1,
+        expected: 200,
+        actual: 404,
+        request: {
+          method: "GET",
+          path: "/health",
+          requestId: "req-1",
+        },
+        response: {
+          status: 404,
+          bodyPreview: '{"error":"nope"}',
+        },
+        location: {
+          path: "/tmp/example.ts",
+          line: 12,
+          column: 4,
+        },
+      },
+    ]);
+  });
 });