# Test Results

Displays a test run by the agent, with its suites and failures.

Source: https://webjs.dev/ui/docs/ai-elements/test-results

```ts
import { html, nothing } from '@webjsdev/core';
import { cn } from '#lib/utils/cn.ts';
import { bubbleClass, bubbleContentClass } from '#components/ui/bubble.ts';
import { buttonClass } from '#components/ui/button.ts';
import {
  codeBlockClass, codeBlockContentClass, codeBlockCodeClass,
} from '#components/ui/code-block.ts';
import { messageClass, messageContentClass } from '#components/ui/message.ts';
import {
  traceClass, traceLineClass, traceIconClass, traceTitleClass,
  traceCollapsibleClass, traceCollapsibleTriggerClass, traceCollapsibleContentClass,
} from '#components/ui/trace.ts';
import {
  CheckIcon, ChevronRightIcon, CircleDashedIcon, FileCodeIcon, FlaskConicalIcon, XIcon,
} from '#lib/ui/lucide.ts';

type Test = {
  name: string;
  status: 'passed' | 'failed' | 'skipped';
  error?: string;
};

const question = 'Run the checkout tests.';
const answer =
  'One test failed. The payment client does not retry a declined card, so the second charge attempt never happens.';

const suites: { name: string; tests: Test[] }[] = [
  {
    name: 'cart.test.ts',
    tests: [
      { name: 'adds an item', status: 'passed' },
      { name: 'removes an item', status: 'passed' },
      { name: 'applies a discount code', status: 'passed' },
    ],
  },
  {
    name: 'payment.test.ts',
    tests: [
      { name: 'charges the saved card', status: 'passed' },
      {
        name: 'retries a declined card',
        status: 'failed',
        error: `Expected 2 charge attempts, received 1

  at Object.<anonymous> (src/payment.test.ts:58:22)`,
      },
    ],
  },
];

function countTests(tests: Test[]) {
  return {
    total: tests.length,
    failed: tests.filter((test) => test.status === 'failed').length,
    skipped: tests.filter((test) => test.status === 'skipped').length,
  };
}

function formatCounts({ total, failed, skipped }: ReturnType<typeof countTests>) {
  return [
    `${total} tests`,
    failed > 0 && `${failed} failed`,
    skipped > 0 && `${skipped} skipped`,
  ].filter(Boolean).join(', ');
}

const chevron = () => html`<span data-slot="trace-icon" aria-hidden="true" class=${cn(traceIconClass(), 'transition-transform [[open]>summary>&]:rotate-90')}>${ChevronRightIcon()}</span>`;

// A failed test opens to its error; the others are plain lines.
function TestRow(test: Test) {
  if (test.status === 'failed') {
    return html`
      <details data-slot="trace-collapsible" open class=${traceCollapsibleClass()}>
        <summary data-slot="trace-collapsible-trigger" class=${traceCollapsibleTriggerClass()}>
          <span data-slot="trace-line" data-status="error" class=${traceLineClass()}>
            <span data-slot="trace-icon" aria-hidden="true" class=${traceIconClass()}>${XIcon()}</span>
            <span data-slot="trace-title" class=${traceTitleClass()}>${test.name}</span>
          </span>
          ${chevron()}
        </summary>
        <div data-slot="trace-collapsible-content" class=${traceCollapsibleContentClass()}>
          <div data-slot="code-block" data-variant="default" data-size="sm" class=${codeBlockClass()}>
            <pre data-slot="code-block-content" data-wrap tabindex="0" dir="ltr" style="counter-reset: line 0" class=${cn(codeBlockContentClass(), 'max-h-64')}><code data-slot="code-block-code" class=${codeBlockCodeClass()}>${test.error}</code></pre>
          </div>
        </div>
      </details>
    `;
  }
  return html`
    <span data-slot="trace-line" class=${traceLineClass()}>
      <span data-slot="trace-icon" aria-hidden="true" class=${traceIconClass()}>${test.status === 'skipped' ? CircleDashedIcon() : CheckIcon()}</span>
      <span data-slot="trace-title" class=${traceTitleClass()}>${test.status === 'skipped' ? 'Skipped ' + test.name : test.name}</span>
    </span>
  `;
}

// The test run as one line, open because a test failed, with a line per
// suite, open where that suite has a failure.
function TestResultsRow() {
  const summary = countTests(suites.flatMap((suite) => suite.tests));
  return html`
    <details data-slot="trace-collapsible" ?open=${summary.failed > 0} class=${traceCollapsibleClass()}>
      <summary data-slot="trace-collapsible-trigger" class=${traceCollapsibleTriggerClass()}>
        <span data-slot="trace-line" data-status=${summary.failed > 0 ? 'error' : nothing} class=${traceLineClass()}>
          <span data-slot="trace-icon" aria-hidden="true" class=${traceIconClass()}>${FlaskConicalIcon()}</span>
          <span data-slot="trace-title" class=${traceTitleClass()}>Ran ${formatCounts(summary)}</span>
        </span>
        ${chevron()}
      </summary>
      <div data-slot="trace-collapsible-content" class=${traceCollapsibleContentClass()}>
        <div data-slot="trace" class=${traceClass()}>
          ${suites.map((suite) => {
            const counts = countTests(suite.tests);
            return html`
              <details data-slot="trace-collapsible" ?open=${counts.failed > 0} class=${traceCollapsibleClass()}>
                <summary data-slot="trace-collapsible-trigger" class=${traceCollapsibleTriggerClass()}>
                  <span data-slot="trace-line" data-status=${counts.failed > 0 ? 'error' : nothing} class=${traceLineClass()}>
                    <span data-slot="trace-icon" aria-hidden="true" class=${traceIconClass()}>${FileCodeIcon()}</span>
                    <span data-slot="trace-title" class=${traceTitleClass()}>${suite.name}, ${formatCounts(counts)}</span>
                  </span>
                  ${chevron()}
                </summary>
                <div data-slot="trace-collapsible-content" class=${traceCollapsibleContentClass()}>
                  <div data-slot="trace" class=${traceClass()}>
                    ${suite.tests.map((test) => TestRow(test))}
                  </div>
                </div>
              </details>
            `;
          })}
        </div>
      </div>
    </details>
  `;
}

// The conversation once the run and the reply have finished.
export default function TestResultsDemo() {
  return html`
    <div class="flex min-h-72 w-full max-w-sm flex-col gap-4 py-6 text-sm">
      <div data-slot="message" data-align="end" class=${messageClass()}>
        <div data-slot="message-content" class=${messageContentClass()}>
          <div data-slot="bubble" data-variant="muted" data-align="end" class=${bubbleClass({ variant: 'muted' })}>
            <div data-slot="bubble-content" class=${bubbleContentClass()}>${question}</div>
          </div>
        </div>
      </div>
      <div data-slot="message" data-align="start" class=${messageClass()}>
        <div data-slot="message-content" class=${cn(messageContentClass(), 'gap-4')}>
          <div data-slot="trace" class=${traceClass()}>
            ${TestResultsRow()}
          </div>
          <p>${answer}</p>
        </div>
      </div>
      <button type="button" data-slot="button" data-variant="outline" data-size="sm" class=${cn(buttonClass({ variant: 'outline', size: 'sm' }), 'mt-auto self-start')}>
        Replay
      </button>
    </div>
  `;
}
```

Test Results is a test run by the agent. The summary line counts what passed and failed. Open it to see each suite, its tests, and the error for each failure.

Test Results is built with a trace, with a trace collapsible for the run and for each suite.

## Installation

Test Results is built with the [Trace](https://webjs.dev/ui/docs/components/trace) and [Code Block](https://webjs.dev/ui/docs/components/code-block) components.

```bash
npx @webjsdev/ui add trace code-block
```

### Install the following dependencies:

```bash
npx @webjsdev/ui add code-block
```

### Copy and paste the following code into your project.

````ts title="components/ui/trace.ts"
/**
 * Trace: a vertical timeline of steps (a tool call, a reasoning step, a
 * deploy stage), each with an icon on a connecting line, a title and an
 * optional collapsible detail. Tier-1 class helper; compose with plain
 * elements and `<details>` for the collapsible part.
 *
 * shadcn parity:
 *   Trace                       → traceClass()
 *   TraceLine / TraceIcon       → traceLineClass() / traceIconClass()
 *   TraceTitle / TraceDescription
 *                               → traceTitleClass() / traceDescriptionClass()
 *   TraceCollapsible / TraceCollapsibleTrigger / TraceCollapsibleContent
 *                               → <details> / <summary> / a div, with the
 *                                 trace collapsible helpers
 *
 * shadcn has no new-york version of this component, so its look in the
 * default style is shadcn's vega style, the classic shadcn look.
 *
 * A11y (required for accessible output): a trace is an ordered list of steps,
 * so render it as `<ol>` with each step an `<li>`. A step's status must be in
 * text, not only in the icon colour ("Failed", "Done"), and a decorative icon
 * takes `aria-hidden="true"`. A collapsible step is a native `<details>` with a
 * `<summary>`, which carries the expanded state by itself.
 *
 * Design tokens used: --border, --muted-foreground, --foreground.
 *
 * @example
 * ```html
 * <ol class=${traceClass()} data-slot="trace">
 *   <li class=${traceLineClass()} data-slot="trace-line">
 *     <span class=${traceTitleClass()} data-slot="trace-title">Fetched the issue</span>
 *   </li>
 * </ol>
 * ```
 */

/** Set `data-slot="trace"` on the element. */
export function traceClass(): string {
  return 'gap-2 *:has-[>[data-slot=trace-line]]:rounded-md *:has-[>[data-slot=trace-line]]:focus-visible:ring-3 *:has-[>[data-slot=trace-line]]:focus-visible:ring-ring/50 flex w-full min-w-0 flex-col *:has-[>[data-slot=trace-line]]:flex *:has-[>[data-slot=trace-line]]:w-fit *:has-[>[data-slot=trace-line]]:max-w-full *:has-[>[data-slot=trace-line]]:min-w-0 *:has-[>[data-slot=trace-line]]:text-start *:has-[>[data-slot=trace-line]]:outline-none';
}

/** Set `data-slot="trace-line"` on the element. */
export function traceLineClass(): string {
  return 'gap-2 text-sm flex w-fit max-w-full min-w-0 items-center text-muted-foreground transition-colors in-[a,button]:cursor-pointer in-[a:hover,button:hover]:text-foreground data-[status=error]:text-destructive data-[status=error]:in-[a:hover,button:hover]:text-destructive data-[status=pending]:opacity-60 data-[status=running]:*:data-[slot=trace-title]:shimmer';
}

/** Set `data-slot="trace-icon"` on the element. */
export function traceIconClass(): string {
  return "size-4 [&_svg:not([class*='size-'])]:size-4 [[data-slot=trace-title]~&]:-ms-1 flex shrink-0 items-center justify-center [&_svg]:pointer-events-none";
}

/** Set `data-slot="trace-title"` on the element. */
export function traceTitleClass(): string {
  return 'min-w-0 truncate motion-reduce:shimmer-none';
}

/** Set `data-slot="trace-description"` on the element. */
export function traceDescriptionClass(): string {
  return 'shrink-0 text-muted-foreground/70 tabular-nums';
}

/** Set `data-slot="trace-collapsible"` on the element. */
export function traceCollapsibleClass(): string {
  return 'flex w-full min-w-0 flex-col';
}

/** Set `data-slot="trace-collapsible-trigger"` on the element. */
export function traceCollapsibleTriggerClass(): string {
  return 'gap-1 rounded-md focus-visible:ring-3 focus-visible:ring-ring/50 group/trace-collapsible-trigger flex w-fit max-w-full min-w-0 cursor-pointer items-center text-start text-muted-foreground transition-colors outline-none hover:text-foreground has-[[data-status=error]]:text-destructive';
}

/** Set `data-slot="trace-collapsible-content"` on the element. */
export function traceCollapsibleContentClass(): string {
  return 'mt-2 mb-1 ms-[calc(--spacing(2)-1px)] border-s pe-1 ps-4 leading-relaxed min-w-0 wrap-break-word text-muted-foreground';
}
````

### Update the import paths to match your project setup.

## Usage

```ts
import { codeBlockClass, codeBlockCodeClass, codeBlockContentClass } from '#components/ui/code-block.ts';
import {
  traceClass,
  traceCollapsibleClass,
  traceCollapsibleContentClass,
  traceCollapsibleTriggerClass,
  traceIconClass,
  traceLineClass,
  traceTitleClass,
} from '#components/ui/trace.ts';
```

```ts
<div data-slot="trace" class=${traceClass()}>
  <details data-slot="trace-collapsible" class=${traceCollapsibleClass()}>
    <summary data-slot="trace-collapsible-trigger" class=${traceCollapsibleTriggerClass()}>
      <span data-slot="trace-line" data-status="error" class=${traceLineClass()}>
        <span data-slot="trace-icon" aria-hidden="true" class=${traceIconClass()}>${FlaskConicalIcon()}</span>
        <span data-slot="trace-title" class=${traceTitleClass()}>Ran 2 tests, 1 failed</span>
      </span>
      <span data-slot="trace-icon" aria-hidden="true" class=${cn(traceIconClass(), 'transition-transform [[open]>summary>&]:rotate-90')}>
        ${ChevronRightIcon()}
      </span>
    </summary>
    <div data-slot="trace-collapsible-content" class=${traceCollapsibleContentClass()}>
      <div data-slot="trace" class=${traceClass()}>
        <span data-slot="trace-line" class=${traceLineClass()}>
          <span data-slot="trace-icon" aria-hidden="true" class=${traceIconClass()}>${CheckIcon()}</span>
          <span data-slot="trace-title" class=${traceTitleClass()}>creates a user</span>
        </span>
        <details data-slot="trace-collapsible" class=${traceCollapsibleClass()}>
          <summary data-slot="trace-collapsible-trigger" class=${traceCollapsibleTriggerClass()}>
            <span data-slot="trace-line" data-status="error" class=${traceLineClass()}>
              <span data-slot="trace-icon" aria-hidden="true" class=${traceIconClass()}>${XIcon()}</span>
              <span data-slot="trace-title" class=${traceTitleClass()}>updates a user profile</span>
            </span>
            <span data-slot="trace-icon" aria-hidden="true" class=${cn(traceIconClass(), 'transition-transform [[open]>summary>&]:rotate-90')}>
              ${ChevronRightIcon()}
            </span>
          </summary>
          <div data-slot="trace-collapsible-content" class=${traceCollapsibleContentClass()}>
            <div data-slot="code-block" data-variant="default" data-size="sm" class=${codeBlockClass()}>
              <pre data-slot="code-block-content" data-wrap tabindex="0" class=${cn(codeBlockContentClass(), 'max-h-64')}><code data-slot="code-block-code" class=${codeBlockCodeClass()}>Expected status 200, received 500</code></pre>
            </div>
          </div>
        </details>
      </div>
    </div>
  </details>
</div>
```

The collapsibles nest, so each chevron turns with its own `<details>` through `[[open]>summary>&]:rotate-90` rather than a named group, which an outer collapsible would also match.

## Suites

Group tests by file. Each suite is a collapsible line with a trace of its tests. Open the suites that have a failure.

```ts
import { html, nothing } from '@webjsdev/core';
import { cn } from '#lib/utils/cn.ts';
import {
  codeBlockClass, codeBlockContentClass, codeBlockCodeClass,
} from '#components/ui/code-block.ts';
import {
  traceClass, traceLineClass, traceIconClass, traceTitleClass,
  traceCollapsibleClass, traceCollapsibleTriggerClass, traceCollapsibleContentClass,
} from '#components/ui/trace.ts';
import {
  CheckIcon, ChevronRightIcon, CircleDashedIcon, FileCodeIcon, FlaskConicalIcon, XIcon,
} from '#lib/ui/lucide.ts';

type Test = {
  name: string;
  status: 'passed' | 'failed' | 'skipped';
  error?: string;
};

const suites: { name: string; tests: Test[] }[] = [
  {
    name: 'auth.test.ts',
    tests: [
      { name: 'logs in with valid credentials', status: 'passed' },
      { name: 'rejects an invalid password', status: 'passed' },
      { name: 'refreshes an expired token', status: 'passed' },
    ],
  },
  {
    name: 'user-api.test.ts',
    tests: [
      { name: 'creates a user', status: 'passed' },
      {
        name: 'updates a user profile',
        status: 'failed',
        error: `Expected status 200, received 500

  at Object.<anonymous> (src/user-api.test.ts:45:12)`,
      },
      { name: 'deletes a user', status: 'skipped' },
    ],
  },
  {
    name: 'db.test.ts',
    tests: [
      { name: 'connects to the database', status: 'passed' },
      {
        name: 'times out a slow query',
        status: 'failed',
        error: `Exceeded timeout of 5000 ms for a test.

  at Object.<anonymous> (src/db.test.ts:22:3)`,
      },
    ],
  },
];

function countTests(tests: Test[]) {
  return {
    total: tests.length,
    failed: tests.filter((test) => test.status === 'failed').length,
    skipped: tests.filter((test) => test.status === 'skipped').length,
  };
}

function formatCounts({ total, failed, skipped }: ReturnType<typeof countTests>) {
  return [
    `${total} tests`,
    failed > 0 && `${failed} failed`,
    skipped > 0 && `${skipped} skipped`,
  ].filter(Boolean).join(', ');
}

const chevron = () => html`<span data-slot="trace-icon" aria-hidden="true" class=${cn(traceIconClass(), 'transition-transform [[open]>summary>&]:rotate-90')}>${ChevronRightIcon()}</span>`;

function TestRow(test: Test) {
  if (test.status === 'failed') {
    return html`
      <details data-slot="trace-collapsible" class=${traceCollapsibleClass()}>
        <summary data-slot="trace-collapsible-trigger" class=${traceCollapsibleTriggerClass()}>
          <span data-slot="trace-line" data-status="error" class=${traceLineClass()}>
            <span data-slot="trace-icon" aria-hidden="true" class=${traceIconClass()}>${XIcon()}</span>
            <span data-slot="trace-title" class=${traceTitleClass()}>${test.name}</span>
          </span>
          ${chevron()}
        </summary>
        <div data-slot="trace-collapsible-content" class=${traceCollapsibleContentClass()}>
          <div data-slot="code-block" data-variant="default" data-size="sm" class=${codeBlockClass()}>
            <pre data-slot="code-block-content" data-wrap tabindex="0" dir="ltr" style="counter-reset: line 0" class=${cn(codeBlockContentClass(), 'max-h-64')}><code data-slot="code-block-code" class=${codeBlockCodeClass()}>${test.error}</code></pre>
          </div>
        </div>
      </details>
    `;
  }
  return html`
    <span data-slot="trace-line" class=${traceLineClass()}>
      <span data-slot="trace-icon" aria-hidden="true" class=${traceIconClass()}>${test.status === 'skipped' ? CircleDashedIcon() : CheckIcon()}</span>
      <span data-slot="trace-title" class=${traceTitleClass()}>${test.status === 'skipped' ? 'Skipped ' + test.name : test.name}</span>
    </span>
  `;
}

export default function TestResultsSuites() {
  const summary = countTests(suites.flatMap((suite) => suite.tests));
  return html`
    <div data-slot="trace" class=${cn(traceClass(), 'max-w-sm')}>
      <details data-slot="trace-collapsible" open class=${traceCollapsibleClass()}>
        <summary data-slot="trace-collapsible-trigger" class=${traceCollapsibleTriggerClass()}>
          <span data-slot="trace-line" data-status=${summary.failed > 0 ? 'error' : nothing} class=${traceLineClass()}>
            <span data-slot="trace-icon" aria-hidden="true" class=${traceIconClass()}>${FlaskConicalIcon()}</span>
            <span data-slot="trace-title" class=${traceTitleClass()}>Ran ${formatCounts(summary)}</span>
          </span>
          ${chevron()}
        </summary>
        <div data-slot="trace-collapsible-content" class=${traceCollapsibleContentClass()}>
          <div data-slot="trace" class=${traceClass()}>
            ${suites.map((suite) => {
              const counts = countTests(suite.tests);
              return html`
                <details data-slot="trace-collapsible" ?open=${counts.failed > 0} class=${traceCollapsibleClass()}>
                  <summary data-slot="trace-collapsible-trigger" class=${traceCollapsibleTriggerClass()}>
                    <span data-slot="trace-line" data-status=${counts.failed > 0 ? 'error' : nothing} class=${traceLineClass()}>
                      <span data-slot="trace-icon" aria-hidden="true" class=${traceIconClass()}>${FileCodeIcon()}</span>
                      <span data-slot="trace-title" class=${traceTitleClass()}>${suite.name}, ${formatCounts(counts)}</span>
                    </span>
                    ${chevron()}
                  </summary>
                  <div data-slot="trace-collapsible-content" class=${traceCollapsibleContentClass()}>
                    <div data-slot="trace" class=${traceClass()}>
                      ${suite.tests.map((test) => TestRow(test))}
                    </div>
                  </div>
                </details>
              `;
            })}
          </div>
        </div>
      </details>
    </div>
  `;
}
```

```ts
<details data-slot="trace-collapsible" ?open=${failed > 0} class=${traceCollapsibleClass()}>
  <summary data-slot="trace-collapsible-trigger" class=${traceCollapsibleTriggerClass()}>
    <span data-slot="trace-line" data-status=${failed > 0 ? 'error' : nothing} class=${traceLineClass()}>
      <span data-slot="trace-icon" aria-hidden="true" class=${traceIconClass()}>${FileCodeIcon()}</span>
      <span data-slot="trace-title" class=${traceTitleClass()}>user-api.test.ts, 14 tests, 2 failed</span>
    </span>
  </summary>
  <div data-slot="trace-collapsible-content" class=${traceCollapsibleContentClass()}>
    <div data-slot="trace" class=${traceClass()}>…</div>
  </div>
</details>
```

## AI SDK

Run the tests as a tool and render its output. The tool states map the same way as in [Tool](https://webjs.dev/ui/docs/ai-elements/tool#states), and [AI SDK](https://webjs.dev/ui/docs/helpers/ai-sdk) shows streaming the parts from a `'use server'` action.

```ts
function testRun(part: RunTestsPart) {
  const tests = part.output.suites.flatMap((suite) => suite.tests);
  const failed = tests.filter((test) => test.status === 'failed').length;

  return html`<details data-slot="trace-collapsible" ?open=${failed > 0} class=${traceCollapsibleClass()}>
    <summary data-slot="trace-collapsible-trigger" class=${traceCollapsibleTriggerClass()}>
      <span data-slot="trace-line" data-status=${failed > 0 ? 'error' : nothing} class=${traceLineClass()}>
        <span data-slot="trace-icon" aria-hidden="true" class=${traceIconClass()}>${FlaskConicalIcon()}</span>
        <span data-slot="trace-title" class=${traceTitleClass()}>
          Ran ${tests.length} tests${failed > 0 ? ', ' + failed + ' failed' : ''}
        </span>
      </span>
    </summary>
    <div data-slot="trace-collapsible-content" class=${traceCollapsibleContentClass()}>…</div>
  </details>`;
}
```

## Migrating from AI SDK Elements

If you used Test Results from [AI SDK Elements](https://elements.ai-sdk.dev), its wrapper lives in `components/ai-elements/test-results.tsx`. In a WebJs app it becomes this pattern, built from WebJs UI components. Each export of the wrapper maps onto a part:

| AI SDK Elements | WebJs UI |
| --- | --- |
| `TestResults` | A trace with a trace collapsible. |
| `TestResultsHeader, TestResultsSummary` | The collapsible's `<summary>`, holding a trace line, and a trace title with the counts, like "Ran 42 tests, 2 failed". Set `data-status="error"` when a test failed. |
| `TestResultsContent` | The trace collapsible content, holding a trace for the suites. |
| `TestSuite, TestSuiteName, TestSuiteContent` | A trace collapsible, open when it has a failure, with its `<summary>` holding a trace line and its content a trace for the tests. |
| `Test` | A trace line with a trace title for its name, with `data-status="error"` when it failed. |
| `TestError, TestErrorMessage, TestErrorStack` | A Code Block with `data-size="sm"`, the message and the stack in its content. |
| `TestResultsDuration, TestResultsProgress, TestSuiteStats, TestName, TestDuration, TestStatus` | No kit part. Keep them as markup of your own, a trace description for a duration. |

## API Reference

See [Trace](https://webjs.dev/ui/docs/components/trace#api-reference).
