@danwo/playwright 0.0.0-stage → 0.1.0

package/src/fixture.ts

@@ -0,0 +1,306 @@
+/**
+ * The Playwright Test fixture: every worker starts the project's danwo environment once (app,
+ * emulators, proxy) and launches its browser behind that proxy; every test gets `danwo` to reach
+ * the emulators, read what the app sent, and arm faults; and a test's invariant runs after its
+ * body, whichever way the body went.
+ */
+import { appendFile } from "node:fs/promises"
+import { dirname, relative } from "node:path"
+import { stripVTControlCharacters } from "node:util"
+
+import type { ServiceDelivery } from "@danwo/matrix"
+import type { Exchange, Proxy } from "@danwo/proxy"
+import { proxyContextOptions, proxyLaunchOptions } from "@danwo/runner"
+import { FaultBench, type NamedFault } from "@danwo/runner/runner"
+import {
+  test as base,
+  type PlaywrightTestArgs,
+  type PlaywrightTestOptions,
+  type PlaywrightWorkerArgs,
+  type PlaywrightWorkerOptions,
+  type TestInfo,
+  type TestType,
+} from "@playwright/test"
+
+import { type EnvironmentFactory, startWorkerSetup, type WorkerSetup } from "./environment.ts"
+import {
+  OUTCOME_FILE,
+  TRIAL_FAULT,
+  type TestOutcome,
+  deliveryLine,
+  exchangeLine,
+} from "./protocol.ts"
+import {
+  attachRecord,
+  deliveriesSince,
+  type EvidenceMark,
+  exchangesSince,
+  markOf,
+  type Verdict,
+} from "./record.ts"
+
+/** What a test reaches danwo through. */
+export interface DanwoHandle {
+  /** The environment's fixtures by name: emulators (`stripe`, `slack`, …) and helpers. */
+  readonly fixtures: Readonly<Record<string, unknown>>
+  /** The proxy the browser and the app go through, when the environment has one. */
+  readonly proxy: Proxy | undefined
+  /** Lets pending background work finish, e.g. webhooks waiting on the emulator's clock. */
+  settle(): Promise<void>
+  /** Every call the app made through the proxy since this test began, bodies included. */
+  exchanges(): readonly Exchange[]
+  /** Every webhook delivery attempt since this test began. */
+  deliveries(): readonly ServiceDelivery[]
+  /**
+   * Arms one fault by its matrix label, e.g. `duplicate on webhook checkout.session.completed` or
+   * `status 500 on POST api.stripe.com/v1/checkout/sessions`; it fires on the next matching call.
+   */
+  inject(fault: string): NamedFault
+  /** Disarms every fault this test armed; returns how many had not fired. */
+  clearFaults(): number
+}
+
+/** The `danwo` fixture: the handle plus the environment's fixtures under their own names. */
+export type Danwo<F = Readonly<Record<string, unknown>>> = DanwoHandle & F
+
+export interface InvariantArgs<F> {
+  readonly danwo: Danwo<F>
+  readonly baseURL: string | undefined
+}
+
+/** What must hold after the test, however its body went: read from the app and the emulators. */
+export type Invariant<F = Readonly<Record<string, unknown>>> = (
+  args: InvariantArgs<F>,
+) => Promise<void> | void
+
+export interface DanwoTestFixtures<F> {
+  danwo: Danwo<F>
+  /** The test's invariant; set with `test.invariant(fn)` or `test.use({ invariant })`. */
+  invariant: Invariant<F> | undefined
+}
+
+export interface DanwoWorkerFixtures {
+  /** A danwo config file whose `environment()` the worker starts; default the nearest one. */
+  danwoConfig: string | undefined
+  /** An environment to start instead of the config's. */
+  danwoEnvironment: EnvironmentFactory | undefined
+  danwoWorker: WorkerSetup
+}
+
+export type DanwoTest<F = Readonly<Record<string, unknown>>> = TestType<
+  PlaywrightTestArgs & PlaywrightTestOptions & DanwoTestFixtures<F>,
+  PlaywrightWorkerArgs & PlaywrightWorkerOptions & DanwoWorkerFixtures
+> & {
+  /** Declares the invariant of every test in this file or describe block. */
+  invariant(fn: Invariant<F>): void
+}
+
+/** Where `danwoConfig` resolves from: the Playwright config's folder, else the working folder. */
+function projectRoot(configFile: string | undefined): string {
+  return configFile === undefined ? process.cwd() : dirname(configFile)
+}
+
+/** `text` without terminal colours, as Playwright's expect messages carry them. */
+function plain(text: string): string {
+  return stripVTControlCharacters(text)
+}
+
+function messageOf(error: unknown): string {
+  return plain(error instanceof Error ? error.message : String(error))
+}
+
+function handleOf(setup: WorkerSetup, mark: EvidenceMark, bench: FaultBench): Danwo {
+  const { env } = setup
+
+  return {
+    ...env.fixtures,
+    fixtures: env.fixtures ?? {},
+    proxy: env.proxy,
+    settle: async () => {
+      await env.settle?.()
+      await env.proxy?.settled()
+    },
+    exchanges: () => exchangesSince(env, mark),
+    deliveries: () => deliveriesSince(env, mark),
+    inject: (fault) => bench.arm(fault),
+    clearFaults: () => bench.clear(),
+  }
+}
+
+async function runInvariant(
+  invariant: Invariant | undefined,
+  args: InvariantArgs<Readonly<Record<string, unknown>>>,
+): Promise<string | null> {
+  if (invariant === undefined) return null
+
+  try {
+    await invariant(args)
+
+    return null
+  } catch (error) {
+    return messageOf(error)
+  }
+}
+
+/** The spec file line the body's failure went through, read from the error's stack. */
+function failureLine(testInfo: TestInfo): number | null {
+  const stack = testInfo.error?.stack ?? ""
+  const at = stack.split("\n").find((frame) => frame.includes(testInfo.file))
+  const line = at === undefined ? undefined : /:(\d+):\d+\)?$/.exec(at)?.[1]
+
+  return line === undefined ? null : Number(line)
+}
+
+/** Appends the test's outcome for `danwo-playwright matrix`, when it is the one running. */
+async function reportOutcome(
+  testInfo: TestInfo,
+  setup: WorkerSetup,
+  mark: EvidenceMark,
+  result: { verdict: Verdict; declared: boolean; record: string | null },
+): Promise<void> {
+  const file = process.env[OUTCOME_FILE]
+
+  if (file === undefined) return
+
+  const outcome: TestOutcome = {
+    title: testInfo.titlePath.join(" › "),
+    file: relative(projectRoot(testInfo.config.configFile), testInfo.file).split("\\").join("/"),
+    body: testInfo.status ?? "failed",
+    bodyError: result.verdict.bodyError,
+    invariant: result.declared ? { error: result.verdict.invariantError } : null,
+    line: failureLine(testInfo),
+    exchanges: exchangesSince(setup.env, mark).map(exchangeLine),
+    deliveries: deliveriesSince(setup.env, mark).map(deliveryLine),
+    record: result.record,
+  }
+
+  await appendFile(file, `${JSON.stringify(outcome)}\n`)
+}
+
+const fixtures = base.extend<
+  DanwoTestFixtures<Readonly<Record<string, unknown>>>,
+  DanwoWorkerFixtures
+>({
+  danwoConfig: [undefined, { option: true, scope: "worker" }],
+  danwoEnvironment: [undefined, { option: true, scope: "worker" }],
+  invariant: [undefined, { option: true }],
+  danwoWorker: [
+    async ({ danwoConfig, danwoEnvironment }, use, workerInfo) => {
+      const setup = await startWorkerSetup({
+        config: danwoConfig,
+        environment: danwoEnvironment,
+        cwd: projectRoot(workerInfo.config.configFile),
+        workerIndex: workerInfo.parallelIndex,
+      })
+
+      try {
+        await use(setup)
+      } finally {
+        await setup.env.close()
+      }
+    },
+    { scope: "worker" },
+  ],
+  /*
+   * The suite's own Playwright launches the browser, so its browser builds, its tracing and its
+   * screenshots all match the `@playwright/test` the project installed; danwo only adds its proxy
+   * and, for Chromium, the flag that trusts the proxy's CA.
+   */
+  browser: [
+    async ({ danwoWorker, playwright, browserName, launchOptions }, use) => {
+      const proxy = danwoWorker.env.proxy
+      const behind = proxyLaunchOptions(
+        proxy && { url: proxy.url, caSpki: proxy.caSpki },
+        browserName,
+      )
+      const browser = await playwright[browserName].launch({
+        ...launchOptions,
+        headless: launchOptions.headless ?? true,
+        ...(behind.proxy && { proxy: behind.proxy }),
+        args: [...(launchOptions.args ?? []), ...(behind.args ?? [])],
+      })
+
+      try {
+        await use(browser)
+      } finally {
+        await browser.close()
+      }
+    },
+    { scope: "worker" },
+  ],
+  /*
+   * Firefox and WebKit take no flag that trusts one CA, so their contexts behind danwo's proxy
+   * ignore certificate errors: the proxy is then their only TLS peer, and it checks each real
+   * site's certificate itself.
+   */
+  ignoreHTTPSErrors: async ({ ignoreHTTPSErrors, browserName, danwoWorker }, use) => {
+    const proxy = danwoWorker.env.proxy
+    const trust = proxyContextOptions(
+      proxy && { url: proxy.url, caSpki: proxy.caSpki },
+      browserName,
+    )
+
+    await use(trust.ignoreHTTPSErrors ?? ignoreHTTPSErrors)
+  },
+  baseURL: async ({ baseURL, danwoWorker }, use) => {
+    await use(danwoWorker.env.baseUrl ?? baseURL)
+  },
+  danwo: [
+    async ({ danwoWorker, invariant, baseURL }, use, testInfo) => {
+      const mark = markOf(danwoWorker.env)
+      const bench = new FaultBench(danwoWorker.env.proxy, danwoWorker.env.webhooks)
+      const fault = process.env[TRIAL_FAULT] ?? null
+
+      if (fault !== null) bench.arm(fault)
+
+      const danwo = handleOf(danwoWorker, mark, bench)
+
+      await use(danwo)
+      await danwo.settle()
+
+      const verdict: Verdict = {
+        bodyError: testInfo.error?.message === undefined ? null : plain(testInfo.error.message),
+        invariantError: await runInvariant(invariant, { danwo, baseURL }),
+        fault,
+      }
+      const failed = verdict.bodyError !== null || verdict.invariantError !== null
+      const record = failed ? await attachRecord(danwoWorker, mark, verdict, testInfo) : null
+
+      await reportOutcome(testInfo, danwoWorker, mark, {
+        verdict,
+        declared: invariant !== undefined,
+        record,
+      })
+      bench.clear()
+
+      if (verdict.invariantError !== null) throw new Error(`invariant: ${verdict.invariantError}`)
+    },
+    { auto: true },
+  ],
+})
+
+/**
+ * Declares the invariant of every test in the current file or describe block. Playwright reads a
+ * function given to `use` as a fixture, so the invariant is handed over by one.
+ */
+function declareInvariant(fn: Invariant): void {
+  fixtures.use({
+    invariant: async ({ danwoWorker: _worker }, use) => {
+      await use(fn)
+    },
+  })
+}
+
+/** `test` from `@playwright/test`, with danwo's environment, `danwo` fixture and invariants. */
+export const test: DanwoTest = Object.assign(fixtures, { invariant: declareInvariant })
+
+/**
+ * `test` with the environment's fixtures typed, e.g. `testWith<StripeFixtures>()` gives
+ * `danwo.stripe`. The fixtures are whatever the environment returns; the type only names them.
+ */
+export function testWith<F>(): DanwoTest<F> {
+  // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- the fixtures exist at run time; F only names the environment's fixtures for the caller
+  return test as unknown as DanwoTest<F>
+}
+
+export { expect } from "@playwright/test"

package/src/index.ts

@@ -0,0 +1,19 @@
+/*
+ * danwo for Playwright Test suites: the project's environment (app, emulators, proxy) per worker,
+ * a `danwo` fixture with the emulators and live faults, invariants, and flight records attached to
+ * failed tests. `danwo-playwright matrix` runs a spec once clean and once per planned fault.
+ */
+export type { EnvironmentFactory, WorkerSetup } from "./environment.ts"
+export {
+  type Danwo,
+  type DanwoHandle,
+  type DanwoTest,
+  type DanwoTestFixtures,
+  type DanwoWorkerFixtures,
+  expect,
+  type Invariant,
+  type InvariantArgs,
+  test,
+  testWith,
+} from "./fixture.ts"
+export { judgeTrial, type PlaywrightMatrixOptions, runPlaywrightMatrix } from "./matrix.ts"

package/src/matrix.ts

@@ -0,0 +1,181 @@
+/**
+ * `danwo-playwright matrix`: one Playwright test, run once clean and then once per fault planned
+ * from the calls and webhooks the clean run caused. Every trial is its own `playwright test`
+ * process, so each starts a fresh environment; the fixture arms the trial's fault and reports what
+ * happened. A faulted trial is judged by the test's invariant (its body may well break under the
+ * fault); a test without an invariant must pass its body under every fault.
+ */
+import { mkdtemp, readFile, rm } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join, relative } from "node:path"
+
+import {
+  checkFaultFired,
+  type FaultMatrixResult,
+  formatMatrix,
+  type PlannedFault,
+  planFaults,
+  type RunOutcome,
+} from "@danwo/matrix"
+import { DEFAULT_WEBHOOK_FAULTS, defaultOutboundFaults, loadConfig } from "@danwo/runner/runner"
+
+import { readOutcomes, type TestOutcome } from "./protocol.ts"
+import { runPlaywright } from "./spawn.ts"
+
+export interface PlaywrightMatrixOptions {
+  /** The spec file; with `grep`, it must select exactly one test. */
+  readonly spec: string
+  readonly grep?: string | undefined
+  /** A regular expression over planned fault labels: only the faults it matches run. */
+  readonly faults?: string | undefined
+  /** The Playwright config file, when it is not the default one. */
+  readonly config?: string | undefined
+  /** The danwo config whose `matrix` settings to use; default the nearest one. */
+  readonly danwoConfig?: string | undefined
+  readonly cwd?: string | undefined
+  readonly write?: ((line: string) => void) | undefined
+}
+
+/** An error in one report line: its first line, plus what was expected and received. */
+function firstLine(text: string): string {
+  const lines = text.split("\n").map((line) => line.trim())
+  const values = lines.filter((line) => /^(Expected|Received)\b/.test(line))
+
+  return [lines[0] ?? text, ...values].join(" · ")
+}
+
+function bodyNote(outcome: TestOutcome): string[] {
+  if (outcome.body === "passed" || outcome.bodyError === null) return []
+
+  const where = outcome.line === null ? "" : ` at ${outcome.file}:${outcome.line}`
+
+  return [`body stopped${where}: ${firstLine(outcome.bodyError)}`]
+}
+
+function invariantFailure(outcome: TestOutcome): string | null {
+  const error = outcome.invariant?.error ?? null
+
+  return error === null ? null : `invariant: ${firstLine(error)}`
+}
+
+function bodyFailure(outcome: TestOutcome): string | null {
+  if (outcome.body === "passed") return null
+
+  return firstLine(outcome.bodyError ?? outcome.body)
+}
+
+/** Turns one trial's outcome into a matrix run: the clean run needs body and invariant to hold. */
+export function judgeTrial(fault: PlannedFault | null, outcome: TestOutcome): RunOutcome {
+  const judgedByInvariant = fault !== null && outcome.invariant !== null
+  const error = judgedByInvariant
+    ? invariantFailure(outcome)
+    : (bodyFailure(outcome) ?? invariantFailure(outcome))
+
+  return checkFaultFired({
+    fault,
+    status: error === null ? "passed" : "failed",
+    error,
+    exchanges: outcome.exchanges,
+    deliveries: outcome.deliveries,
+    notes: judgedByInvariant ? bodyNote(outcome) : [],
+    record: outcome.record ?? undefined,
+  })
+}
+
+/** A trial's output folder name: its place in the run and its fault, e.g. `03-reset-on-post-…`. */
+function trialFolder(fault: PlannedFault | null, index: number): string {
+  const slug = (fault?.label ?? "clean run")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "")
+    .slice(0, 60)
+
+  return `${String(index).padStart(2, "0")}-${slug}`
+}
+
+function environmentError(fault: PlannedFault | null, error: string): RunOutcome {
+  return { fault, status: "environment-error", error, exchanges: [], deliveries: [], notes: [] }
+}
+
+/** Runs one trial in its own `playwright test` process and judges it. */
+async function trial(
+  options: PlaywrightMatrixOptions,
+  fault: PlannedFault | null,
+  index: number,
+): Promise<RunOutcome> {
+  const cwd = options.cwd ?? process.cwd()
+  const dir = await mkdtemp(join(tmpdir(), "danwo-playwright-"))
+  const outcomeFile = join(dir, "outcome.jsonl")
+  const outputDir = join("test-results", "danwo-matrix", trialFolder(fault, index))
+
+  try {
+    const output = await runPlaywright({ ...options, outcomeFile, outputDir, fault: fault?.label })
+    const outcomes = readOutcomes(await readFile(outcomeFile, "utf8").catch(() => ""))
+    const [outcome] = outcomes
+
+    if (outcomes.length !== 1 || outcome === undefined) {
+      return environmentError(
+        fault,
+        `the spec ran ${outcomes.length} danwo tests; select exactly one with --grep\n${output}`,
+      )
+    }
+
+    return judgeTrial(fault, {
+      ...outcome,
+      record: outcome.record === null ? null : relative(cwd, outcome.record).split("\\").join("/"),
+    })
+  } finally {
+    await rm(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 })
+  }
+}
+
+/** The faults to try, from the danwo config's `matrix` settings or danwo's defaults. */
+async function catalogue(options: PlaywrightMatrixOptions) {
+  const { config } = await loadConfig(options.cwd ?? process.cwd(), options.danwoConfig)
+
+  return {
+    outbound: config.matrix?.outboundFaults ?? defaultOutboundFaults,
+    webhook: config.matrix?.webhookFaults ?? DEFAULT_WEBHOOK_FAULTS,
+  }
+}
+
+function selected(plan: readonly PlannedFault[], filter: string | undefined): PlannedFault[] {
+  if (filter === undefined) return [...plan]
+
+  const pattern = new RegExp(filter)
+
+  return plan.filter((planned) => pattern.test(planned.label))
+}
+
+function failedAny(result: FaultMatrixResult): boolean {
+  return [result.clean, ...result.runs].some((run) => run.status !== "passed")
+}
+
+/** Runs the matrix and prints its report; resolves with the exit code. */
+export async function runPlaywrightMatrix(options: PlaywrightMatrixOptions): Promise<number> {
+  const write = options.write ?? ((line: string) => process.stdout.write(`${line}\n`))
+  const clean = await trial(options, null, 0)
+
+  if (clean.status !== "passed") {
+    write(formatMatrix({ clean, runs: [] }))
+    write("the clean run did not pass, so no faults were planned")
+
+    return 1
+  }
+
+  const faults = await catalogue(options)
+  const planned = planFaults(clean, faults.outbound, faults.webhook)
+  const plan = selected(planned, options.faults)
+
+  write(`clean run passed; ${plan.length} of ${planned.length} planned faults to run`)
+
+  const runs: RunOutcome[] = []
+
+  for (const [index, fault] of plan.entries()) runs.push(await trial(options, fault, index + 1))
+
+  const result = { clean, runs }
+
+  write(formatMatrix(result))
+
+  return failedAny(result) ? 1 : 0
+}

package/src/protocol.ts

@@ -0,0 +1,80 @@
+/**
+ * How `danwo-playwright matrix` and the fixture talk across the Playwright process they share
+ * nothing else with: the matrix sets two environment variables, the fixture appends one JSON line
+ * per test to the outcome file.
+ */
+import type { ServiceDelivery } from "@danwo/matrix"
+import type { Exchange } from "@danwo/proxy"
+import { z } from "@danwo/runner/runner"
+
+/** Where the fixture appends each test's outcome; set by the matrix for every trial. */
+export const OUTCOME_FILE = "DANWO_PLAYWRIGHT_OUTCOME"
+
+/** The fault a trial arms, by its matrix label; absent for the clean trial. */
+export const TRIAL_FAULT = "DANWO_PLAYWRIGHT_FAULT"
+
+const ExchangeLine = z.object({
+  disposition: z.enum(["routed", "passthrough", "blocked"]),
+  method: z.string(),
+  host: z.string(),
+  path: z.string(),
+  startedAt: z.string(),
+  id: z.string(),
+  fault: z.string().nullable(),
+  status: z.number().nullable(),
+  durationMs: z.number().nullable(),
+  aborted: z.boolean(),
+})
+
+const DeliveryLine = z.object({
+  messageId: z.number(),
+  topic: z.string(),
+  endpointId: z.string(),
+  attempt: z.number(),
+  at: z.string(),
+  status: z.number().nullable(),
+  error: z.string().nullable(),
+  durationMs: z.number(),
+  delivered: z.boolean(),
+  fault: z.string().nullable(),
+  service: z.string().exactOptional(),
+})
+
+/** One test's outcome as the fixture saw it. */
+const OutcomeLine = z.object({
+  title: z.string(),
+  file: z.string(),
+  /** Where the body ended up: Playwright's status for the test before the invariant ran. */
+  body: z.enum(["passed", "failed", "timedOut", "skipped", "interrupted"]),
+  bodyError: z.string().nullable(),
+  /** Null when the test declares no invariant. */
+  invariant: z.object({ error: z.string().nullable() }).nullable(),
+  /** The test file line the failure went through, when Playwright knows it. */
+  line: z.number().nullable(),
+  exchanges: z.array(ExchangeLine),
+  deliveries: z.array(DeliveryLine),
+  /** The flight record attached to the test's report, when one was. */
+  record: z.string().nullable(),
+})
+
+export type TestOutcome = z.infer<typeof OutcomeLine>
+
+/** An exchange as the outcome file carries it: everything but its bodies. */
+export function exchangeLine(exchange: Exchange): z.infer<typeof ExchangeLine> {
+  const { request: _request, response: _response, ...call } = exchange
+
+  return call
+}
+
+/** A delivery as the outcome file carries it. */
+export function deliveryLine(delivery: ServiceDelivery): z.infer<typeof DeliveryLine> {
+  return delivery
+}
+
+/** Every outcome line in `text`, in the order the tests finished. */
+export function readOutcomes(text: string): TestOutcome[] {
+  return text
+    .split("\n")
+    .filter((line) => line.trim() !== "")
+    .map((line) => OutcomeLine.parse(JSON.parse(line)))
+}

package/src/record.ts

@@ -0,0 +1,74 @@
+/**
+ * What a failed Playwright test leaves behind for danwo: the calls the app made through the proxy,
+ * the webhooks delivered, and the emulators' state, redacted the way danwo's own flight records
+ * are, attached to the test's report beside Playwright's trace.
+ */
+import { writeFile } from "node:fs/promises"
+
+import { deliveriesOf } from "@danwo/matrix"
+import {
+  createRedactor,
+  environmentState,
+  redactExchange,
+  type WorkerEnvironment,
+} from "@danwo/runner/runner"
+import type { TestInfo } from "@playwright/test"
+
+import type { WorkerSetup } from "./environment.ts"
+
+/** Where a test's evidence starts: counts of what the environment had seen before it. */
+export interface EvidenceMark {
+  readonly exchanges: number
+  readonly deliveries: number
+}
+
+export function markOf(env: WorkerEnvironment): EvidenceMark {
+  return {
+    exchanges: env.proxy?.exchanges().length ?? 0,
+    deliveries: deliveriesOf(env.webhooks).length,
+  }
+}
+
+/** The exchanges since `mark`, unredacted (bodies included) for the test's own use. */
+export function exchangesSince(env: WorkerEnvironment, mark: EvidenceMark) {
+  return env.proxy?.exchanges().slice(mark.exchanges) ?? []
+}
+
+/** The webhook delivery attempts since `mark`. */
+export function deliveriesSince(env: WorkerEnvironment, mark: EvidenceMark) {
+  return deliveriesOf(env.webhooks).slice(mark.deliveries)
+}
+
+export interface Verdict {
+  readonly bodyError: string | null
+  readonly invariantError: string | null
+  readonly fault: string | null
+}
+
+/** Writes the test's flight record next to its output and attaches it; returns its path. */
+export async function attachRecord(
+  setup: WorkerSetup,
+  mark: EvidenceMark,
+  verdict: Verdict,
+  testInfo: TestInfo,
+): Promise<string> {
+  const redactor = createRedactor(setup.vault.redact)
+  const record = {
+    test: testInfo.titlePath.join(" › "),
+    status: testInfo.status ?? "failed",
+    fault: verdict.fault,
+    bodyError: verdict.bodyError === null ? null : redactor.text(verdict.bodyError),
+    invariantError: verdict.invariantError === null ? null : redactor.text(verdict.invariantError),
+    exchanges: exchangesSince(setup.env, mark).map((exchange) =>
+      redactExchange(exchange, redactor),
+    ),
+    deliveries: deliveriesSince(setup.env, mark),
+    state: environmentState(setup.env, redactor),
+  }
+  const path = testInfo.outputPath("danwo-flight-record.json")
+
+  await writeFile(path, `${JSON.stringify(record, null, 2)}\n`)
+  await testInfo.attach("danwo flight record", { path, contentType: "application/json" })
+
+  return path
+}