@polderlabs/bizar 5.1.0 → 5.3.0

package/bizar-dash/tests/components/marketplace-plugin-card.test.tsx

@@ -0,0 +1,144 @@
+// tests/components/marketplace-plugin-card.test.tsx — MarketplacePluginCard and InstallConfirmDialog unit tests.
+
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, it, expect, vi } from 'vitest';
+import { ModalProvider } from '../../src/web/components/Modal';
+import { MarketplacePluginCard } from '../../src/web/components/MarketplacePluginCard';
+import { InstallConfirmDialog } from '../../src/web/components/InstallConfirmDialog';
+import { PluginPermissions } from '../../src/web/components/PluginPermissions';
+
+const defaultPlugin = {
+  id: 'test-marketplace-plugin',
+  name: 'Test Marketplace Plugin',
+  version: '2.1.0',
+  author: 'TestAuthor',
+  description: 'A test plugin for the marketplace',
+  category: 'Utilities',
+  tags: ['testing', 'utility'],
+  permissions: ['net', 'fs'],
+};
+
+describe('MarketplacePluginCard', () => {
+  it('renders name, version, description', () => {
+    render(
+      <MarketplacePluginCard
+        plugin={defaultPlugin}
+        onInstall={vi.fn()}
+        onView={vi.fn()}
+      />,
+    );
+    expect(screen.getByText('Test Marketplace Plugin')).toBeInTheDocument();
+    expect(screen.getByText('v2.1.0 · Utilities')).toBeInTheDocument();
+    expect(screen.getByText('A test plugin for the marketplace')).toBeInTheDocument();
+  });
+
+  it('shows tags as chips', () => {
+    render(
+      <MarketplacePluginCard
+        plugin={defaultPlugin}
+        onInstall={vi.fn()}
+        onView={vi.fn()}
+      />,
+    );
+    expect(screen.getByText('testing')).toBeInTheDocument();
+    expect(screen.getByText('utility')).toBeInTheDocument();
+  });
+
+  it('shows permissions', () => {
+    render(
+      <MarketplacePluginCard
+        plugin={defaultPlugin}
+        onInstall={vi.fn()}
+        onView={vi.fn()}
+      />,
+    );
+    // PluginPermissions renders "Network access" for 'net' and "Filesystem" for 'fs'
+    expect(screen.getByText('Network access')).toBeInTheDocument();
+    expect(screen.getByText('Filesystem')).toBeInTheDocument();
+  });
+
+  it('calls onInstall when Install clicked', async () => {
+    const onInstall = vi.fn();
+    const user = userEvent.setup();
+    render(
+      <MarketplacePluginCard
+        plugin={defaultPlugin}
+        onInstall={onInstall}
+        onView={vi.fn()}
+      />,
+    );
+    await user.click(screen.getByRole('button', { name: 'Install' }));
+    expect(onInstall).toHaveBeenCalledTimes(1);
+  });
+
+  it('calls onView when Details clicked', async () => {
+    const onView = vi.fn();
+    const user = userEvent.setup();
+    render(
+      <MarketplacePluginCard
+        plugin={defaultPlugin}
+        onInstall={vi.fn()}
+        onView={onView}
+      />,
+    );
+    await user.click(screen.getByRole('button', { name: 'Details' }));
+    expect(onView).toHaveBeenCalledTimes(1);
+  });
+});
+
+function InstallConfirmDialogTestHarness({ plugin, installing = false }: {
+  plugin: typeof defaultPlugin;
+  installing?: boolean;
+}) {
+  return (
+    <ModalProvider>
+      <InstallConfirmDialog
+        plugin={plugin}
+        onConfirm={vi.fn()}
+        onCancel={vi.fn()}
+        installing={installing}
+      />
+    </ModalProvider>
+  );
+}
+
+describe('InstallConfirmDialog', () => {
+  it('renders plugin name and description', async () => {
+    render(<InstallConfirmDialogTestHarness plugin={defaultPlugin} />);
+    // The dialog content is rendered in a modal, check for the title
+    expect(await screen.findByText('Install Test Marketplace Plugin?')).toBeInTheDocument();
+    expect(screen.getByText('A test plugin for the marketplace')).toBeInTheDocument();
+  });
+
+  it('shows permissions prominently', async () => {
+    render(<InstallConfirmDialogTestHarness plugin={defaultPlugin} />);
+    expect(await screen.findByText('Network access')).toBeInTheDocument();
+    expect(screen.getByText('Filesystem')).toBeInTheDocument();
+  });
+
+  it('disables buttons during install', async () => {
+    render(<InstallConfirmDialogTestHarness plugin={defaultPlugin} installing={true} />);
+    expect(await screen.findByRole('button', { name: 'Installing...' })).toBeDisabled();
+    expect(screen.getByRole('button', { name: 'Cancel' })).toBeDisabled();
+  });
+});
+
+describe('PluginPermissions', () => {
+  it('renders each permission as a chip', () => {
+    render(<PluginPermissions permissions={['net', 'fs']} />);
+    expect(screen.getByText('Network access')).toBeInTheDocument();
+    expect(screen.getByText('Filesystem')).toBeInTheDocument();
+  });
+
+  it('shows unknown permission with default label', () => {
+    render(<PluginPermissions permissions={['unknown_perm']} />);
+    expect(screen.getByText('unknown_perm')).toBeInTheDocument();
+  });
+
+  it('handles empty permissions array', () => {
+    const { container } = render(<PluginPermissions permissions={[]} />);
+    expect(container.querySelector('.plugin-permissions')).toBeInTheDocument();
+    expect(container.querySelectorAll('.permission-chip')).toHaveLength(0);
+  });
+});

package/bizar-dash/tests/components/plugin-permissions.test.tsx

@@ -0,0 +1,95 @@
+// tests/components/plugin-permissions.test.tsx — PluginPermissions and PluginCard unit tests.
+
+import { render, screen } from '@testing-library/react';
+import { describe, it, expect, vi } from 'vitest';
+import { PluginPermissions } from '../../src/web/components/PluginPermissions';
+import { PluginCard } from '../../src/web/components/PluginCard';
+
+describe('PluginPermissions', () => {
+  it('renders each permission as a chip', () => {
+    render(<PluginPermissions permissions={['net', 'fs']} />);
+    expect(screen.getByText('Network access')).toBeInTheDocument();
+    expect(screen.getByText('Filesystem')).toBeInTheDocument();
+  });
+
+  it('shows unknown permission with default label', () => {
+    render(<PluginPermissions permissions={['unknown_perm']} />);
+    expect(screen.getByText('unknown_perm')).toBeInTheDocument();
+  });
+
+  it('handles empty permissions array', () => {
+    const { container } = render(<PluginPermissions permissions={[]} />);
+    expect(container.querySelector('.plugin-permissions')).toBeInTheDocument();
+    expect(container.querySelectorAll('.permission-chip')).toHaveLength(0);
+  });
+});
+
+describe('PluginCard', () => {
+  const defaultPlugin = {
+    id: 'test-plugin',
+    name: 'Test Plugin',
+    version: '1.0.0',
+    description: 'A test plugin',
+    permissions: ['net', 'fs'],
+    invocations: 42,
+    lastInvokedAt: '2026-07-05T10:00:00Z',
+    enabled: true,
+  };
+
+  it('renders name, version, description', () => {
+    render(
+      <PluginCard
+        plugin={defaultPlugin}
+        onToggle={vi.fn()}
+        onUninstall={vi.fn()}
+        onConfigure={vi.fn()}
+      />,
+    );
+    expect(screen.getByText('Test Plugin')).toBeInTheDocument();
+    expect(screen.getByText('v1.0.0 · test-plugin')).toBeInTheDocument();
+    expect(screen.getByText('A test plugin')).toBeInTheDocument();
+  });
+
+  it('calls onToggle when toggle clicked', async () => {
+    const onToggle = vi.fn();
+    render(
+      <PluginCard
+        plugin={defaultPlugin}
+        onToggle={onToggle}
+        onUninstall={vi.fn()}
+        onConfigure={vi.fn()}
+      />,
+    );
+    const toggle = screen.getByRole('switch');
+    toggle.click();
+    expect(onToggle).toHaveBeenCalledWith('test-plugin');
+  });
+
+  it('calls onUninstall when uninstall clicked', () => {
+    const onUninstall = vi.fn();
+    render(
+      <PluginCard
+        plugin={defaultPlugin}
+        onToggle={vi.fn()}
+        onUninstall={onUninstall}
+        onConfigure={vi.fn()}
+      />,
+    );
+    screen.getByText('Uninstall').click();
+    expect(onUninstall).toHaveBeenCalledWith('test-plugin');
+  });
+
+  it('calls onConfigure when configure clicked', () => {
+    const onConfigure = vi.fn();
+    render(
+      <PluginCard
+        plugin={defaultPlugin}
+        onToggle={vi.fn()}
+        onUninstall={vi.fn()}
+        onConfigure={onConfigure}
+      />,
+    );
+    screen.getByText('Configure').click();
+    expect(onConfigure).toHaveBeenCalledWith('test-plugin');
+  });
+});

package/bizar-dash/tests/eval-csv.test.mjs

@@ -0,0 +1,67 @@
+// tests/eval-csv.test.mjs — v5.3.0
+// Tests for CSV export functionality in eval.mjs
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { toCSV } from '../src/server/eval.mjs';
+
+describe('CSV export', () => {
+  it('produces valid CSV with headers', () => {
+    const csv = toCSV([
+      { fixtureId: 'test-1', name: 'Test', ok: true, latencyMs: 100, checks: [] },
+    ]);
+    assert.ok(csv.split('\n')[0].includes('fixture_id'));
+    assert.ok(csv.split('\n')[0].includes('name'));
+    assert.ok(csv.split('\n')[0].includes('ok'));
+    assert.ok(csv.split('\n')[0].includes('pass_count'));
+    assert.ok(csv.split('\n')[0].includes('fail_count'));
+    assert.ok(csv.split('\n')[0].includes('latency_ms'));
+    assert.ok(csv.split('\n')[0].includes('tokens'));
+    assert.ok(csv.split('\n')[0].includes('timestamp'));
+  });
+
+  it('escapes commas in values', () => {
+    const csv = toCSV([{ fixtureId: 'a,b', ok: true, checks: [] }]);
+    assert.ok(csv.includes('"a,b"'));
+  });
+
+  it('escapes quotes in values', () => {
+    const csv = toCSV([{ fixtureId: 'a"b', ok: true, checks: [] }]);
+    assert.ok(csv.includes('"a""b"'));
+  });
+
+  it('handles newlines in values', () => {
+    const csv = toCSV([{ fixtureId: 'a\nb', ok: true, checks: [] }]);
+    assert.ok(csv.includes('"a\nb"'));
+  });
+
+  it('outputs ok as 1 or 0', () => {
+    const csvPass = toCSV([{ fixtureId: 'p', ok: true, checks: [] }]);
+    const csvFail = toCSV([{ fixtureId: 'f', ok: false, checks: [] }]);
+    assert.ok(csvPass.match(/,1,/));
+    assert.ok(csvFail.match(/,0,/));
+  });
+
+  it('counts pass/fail checks correctly', () => {
+    const csv = toCSV([
+      {
+        fixtureId: 'c1',
+        ok: false,
+        checks: [
+          { pass: true },
+          { pass: false, message: 'failed check' },
+          { pass: true },
+        ],
+      },
+    ]);
+    // pass_count=2, fail_count=1
+    const row = csv.split('\n')[1];
+    assert.ok(row.match(/c1.*,2,1/));
+  });
+
+  it('returns empty string for missing optional fields', () => {
+    const csv = toCSV([{ fixtureId: 'minimal' }]);
+    // Should not throw and should have all 9 columns
+    assert.strictEqual(csv.split('\n')[0].split(',').length, 9);
+  });
+});

package/bizar-dash/tests/eval-scheduled.test.mjs

@@ -0,0 +1,84 @@
+// tests/eval-scheduled.test.mjs — v5.3.0
+// Tests for eval schedule CRUD
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { rmSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+describe('Eval schedule CRUD', () => {
+  const originalConfigDir = process.env.BIZAR_EVAL_CONFIG_DIR;
+
+  beforeEach(() => {
+    // Use a unique config dir per test to avoid cross-test pollution
+    const testId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    process.env.BIZAR_EVAL_CONFIG_DIR = `/tmp/bizar-eval-config-${testId}`;
+    mkdirSync(process.env.BIZAR_EVAL_CONFIG_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    process.env.BIZAR_EVAL_CONFIG_DIR = originalConfigDir;
+  });
+
+  it('registerEvalSchedule returns a schedule with id', async () => {
+    // Dynamic import ensures env var is set before module initializes
+    const mod = await import(`../src/server/eval-store.mjs?v=${Date.now()}`);
+    const { registerEvalSchedule } = mod;
+    const schedule = registerEvalSchedule({
+      name: 'Daily check',
+      suitePath: './fixtures',
+      cron: '0 8 * * *',
+      agent: 'thor',
+    });
+    assert.ok(schedule.id);
+    assert.strictEqual(schedule.name, 'Daily check');
+    assert.strictEqual(schedule.suitePath, './fixtures');
+    assert.strictEqual(schedule.cron, '0 8 * * *');
+    assert.strictEqual(schedule.agent, 'thor');
+  });
+
+  it('listEvalSchedules returns all registered schedules', async () => {
+    const mod = await import(`../src/server/eval-store.mjs?v=${Date.now()}-${Math.random()}`);
+    const { registerEvalSchedule, listEvalSchedules } = mod;
+    registerEvalSchedule({ name: 's1', suitePath: './a', cron: '0 9 * * *' });
+    registerEvalSchedule({ name: 's2', suitePath: './b', cron: '0 10 * * *' });
+    const schedules = listEvalSchedules();
+    assert.strictEqual(schedules.length, 2);
+    assert.ok(schedules.find((s) => s.name === 's1'));
+    assert.ok(schedules.find((s) => s.name === 's2'));
+  });
+
+  it('deleteEvalSchedule removes a schedule by id', async () => {
+    const mod = await import(`../src/server/eval-store.mjs?v=${Date.now()}`);
+    const { registerEvalSchedule, listEvalSchedules, deleteEvalSchedule } = mod;
+    const sched = registerEvalSchedule({ name: 'to-delete', suitePath: './x', cron: '0 9 * * *' });
+    const result = deleteEvalSchedule(sched.id);
+    assert.strictEqual(result.ok, true);
+    const remaining = listEvalSchedules();
+    assert.strictEqual(remaining.find((s) => s.id === sched.id), undefined);
+  });
+
+  it('deleteEvalSchedule returns ok:false for unknown id', async () => {
+    const mod = await import(`../src/server/eval-store.mjs?v=${Date.now()}`);
+    const { deleteEvalSchedule } = mod;
+    const result = deleteEvalSchedule('does-not-exist');
+    assert.strictEqual(result.ok, false);
+  });
+
+  it('schedule ids are unique across multiple registrations', async () => {
+    const mod = await import(`../src/server/eval-store.mjs?v=${Date.now()}`);
+    const { registerEvalSchedule, listEvalSchedules } = mod;
+    const ids = new Set();
+    for (let i = 0; i < 10; i++) {
+      ids.add(registerEvalSchedule({ name: `s${i}`, suitePath: '.', cron: '* * * * *' }).id);
+    }
+    assert.strictEqual(ids.size, 10);
+  });
+});
+
+describe('schedules runner eval-run action', () => {
+  it('schedulesRunner module loads and exposes tick', async () => {
+    const { schedulesRunner } = await import('../src/server/schedules-runner.mjs');
+    assert.strictEqual(typeof schedulesRunner.tick, 'function');
+  });
+});

package/bizar-dash/tests/eval-web-ui.test.tsx

@@ -0,0 +1,220 @@
+// tests/eval-web-ui.test.tsx — v5.2.0
+//
+// Tests for the eval framework web UI components:
+//   - EvalRunCard: pass/total rendering, status pill (pass/warn/fail)
+//   - EvalDiff: categorize fixtures as improved/regressed/unchanged
+//
+// We render with @testing-library/react in jsdom and assert on the
+// status pill text + class list.
+
+import { render, screen } from '@testing-library/react';
+import { describe, it, expect } from 'vitest';
+import { EvalRunCard, type EvalRunSummary } from '../src/web/components/EvalRunCard';
+import { EvalDiff, computeEvalDiff, type EvalRunWithResults } from '../src/web/components/EvalDiff';
+
+const BASE_RUN: EvalRunSummary = {
+  id: 'run_2026-07-05_a1b2',
+  startedAt: '2026-07-05T10:00:00.000Z',
+  finishedAt: '2026-07-05T10:01:00.000Z',
+  suitePath: '/tmp/fixtures',
+  total: 10,
+  passed: 10,
+  failed: 0,
+};
+
+describe('EvalRunCard', () => {
+  it('renders the run id and suite path', () => {
+    render(<EvalRunCard run={BASE_RUN} />);
+    expect(screen.getByText(BASE_RUN.id)).toBeInTheDocument();
+    // The card meta includes the suite path. The format helper prepends
+    // a formatted timestamp, so we look for the suite path fragment.
+    expect(screen.getByText(/fixtures/)).toBeInTheDocument();
+  });
+
+  it('renders the pass count and total in the status pill', () => {
+    render(<EvalRunCard run={BASE_RUN} />);
+    expect(screen.getByText('10/10 (100.0%)')).toBeInTheDocument();
+  });
+
+  it('uses the "pass" status when failed === 0', () => {
+    const { container } = render(<EvalRunCard run={BASE_RUN} />);
+    const pill = container.querySelector('.eval-status');
+    expect(pill).toBeInTheDocument();
+    expect(pill).toHaveClass('is-pass');
+    expect(pill).not.toHaveClass('is-warn');
+    expect(pill).not.toHaveClass('is-fail');
+  });
+
+  it('uses the "warn" status when pass rate is between 0.8 and 1.0', () => {
+    const run: EvalRunSummary = { ...BASE_RUN, total: 10, passed: 9, failed: 1 };
+    const { container } = render(<EvalRunCard run={run} />);
+    const pill = container.querySelector('.eval-status');
+    expect(pill).toHaveClass('is-warn');
+    expect(screen.getByText('9/10 (90.0%)')).toBeInTheDocument();
+  });
+
+  it('uses the "fail" status when pass rate is at or below 0.8', () => {
+    const run: EvalRunSummary = { ...BASE_RUN, total: 10, passed: 7, failed: 3 };
+    const { container } = render(<EvalRunCard run={run} />);
+    const pill = container.querySelector('.eval-status');
+    expect(pill).toHaveClass('is-fail');
+    expect(screen.getByText('7/10 (70.0%)')).toBeInTheDocument();
+  });
+
+  it('uses the "fail" status when there is any failure at all (10/10a vs 8/10b)', () => {
+    // pass rate exactly 0.8 → still "fail" (the brief says strictly > 0.8)
+    const run: EvalRunSummary = { ...BASE_RUN, total: 10, passed: 8, failed: 2 };
+    const { container } = render(<EvalRunCard run={run} />);
+    expect(container.querySelector('.eval-status')).toHaveClass('is-fail');
+  });
+
+  it('renders 0/0 (0.0%) without crashing when total is zero', () => {
+    const run: EvalRunSummary = { ...BASE_RUN, total: 0, passed: 0, failed: 0 };
+    render(<EvalRunCard run={run} />);
+    expect(screen.getByText('0/0 (0.0%)')).toBeInTheDocument();
+  });
+
+  it('marks the card as selected when selected=true', () => {
+    const { container } = render(<EvalRunCard run={BASE_RUN} selected />);
+    const card = container.querySelector('.eval-run-card');
+    expect(card).toHaveClass('eval-run-card-selected');
+  });
+
+  it('calls onClick when the card is clicked', () => {
+    let clicked = false;
+    const { container } = render(<EvalRunCard run={BASE_RUN} onClick={() => { clicked = true; }} />);
+    const card = container.querySelector('.eval-run-card') as HTMLElement;
+    card.click();
+    expect(clicked).toBe(true);
+  });
+});
+
+describe('EvalDiff — computeEvalDiff', () => {
+  const runA: EvalRunWithResults = {
+    id: 'run_a',
+    startedAt: '2026-07-01T00:00:00Z',
+    suitePath: '/tmp/fixtures',
+    total: 3,
+    passed: 2,
+    failed: 1,
+    results: [
+      { fixtureId: 'f1', ok: false, latencyMs: 100 },
+      { fixtureId: 'f2', ok: true, latencyMs: 120 },
+      { fixtureId: 'f3', ok: true, latencyMs: 140 },
+    ],
+  };
+
+  const runB: EvalRunWithResults = {
+    id: 'run_b',
+    startedAt: '2026-07-05T00:00:00Z',
+    suitePath: '/tmp/fixtures',
+    total: 3,
+    passed: 3,
+    failed: 0,
+    results: [
+      { fixtureId: 'f1', ok: true, latencyMs: 110 },
+      { fixtureId: 'f2', ok: true, latencyMs: 115 },
+      { fixtureId: 'f3', ok: true, latencyMs: 150 },
+    ],
+  };
+
+  const runC: EvalRunWithResults = {
+    ...runB,
+    id: 'run_c',
+    results: [
+      { fixtureId: 'f1', ok: false, latencyMs: 110 },
+      { fixtureId: 'f2', ok: true, latencyMs: 115 },
+      { fixtureId: 'f3', ok: true, latencyMs: 150 },
+    ],
+  };
+
+  it('identifies improvements (was failing, now passing)', () => {
+    const diff = computeEvalDiff(runA, runB);
+    const improved = diff.filter((d) => d.change === 'improved');
+    expect(improved).toHaveLength(1);
+    expect(improved[0].fixtureId).toBe('f1');
+    expect(improved[0].before).toBe(false);
+    expect(improved[0].after).toBe(true);
+  });
+
+  it('identifies regressions (was passing, now failing)', () => {
+    const diff = computeEvalDiff(runB, runC);
+    const regressed = diff.filter((d) => d.change === 'regressed');
+    expect(regressed).toHaveLength(1);
+    expect(regressed[0].fixtureId).toBe('f1');
+    expect(regressed[0].before).toBe(true);
+    expect(regressed[0].after).toBe(false);
+  });
+
+  it('lists unchanged fixtures separately', () => {
+    const diff = computeEvalDiff(runA, runB);
+    const unchanged = diff.filter((d) => d.change === 'same');
+    expect(unchanged.map((d) => d.fixtureId).sort()).toEqual(['f2', 'f3']);
+  });
+
+  it('returns empty arrays for identical runs', () => {
+    const diff = computeEvalDiff(runA, runA);
+    const changed = diff.filter((d) => d.change !== 'same');
+    expect(changed).toHaveLength(0);
+  });
+});
+
+describe('EvalDiff — rendering', () => {
+  const runA: EvalRunWithResults = {
+    id: 'run_a',
+    startedAt: '2026-07-01T00:00:00Z',
+    suitePath: '/tmp/fixtures',
+    total: 3,
+    passed: 2,
+    failed: 1,
+    results: [
+      { fixtureId: 'f1', ok: false, latencyMs: 100 },
+      { fixtureId: 'f2', ok: true, latencyMs: 120 },
+      { fixtureId: 'f3', ok: true, latencyMs: 140 },
+    ],
+  };
+
+  const runB: EvalRunWithResults = {
+    id: 'run_b',
+    startedAt: '2026-07-05T00:00:00Z',
+    suitePath: '/tmp/fixtures',
+    total: 3,
+    passed: 3,
+    failed: 0,
+    results: [
+      { fixtureId: 'f1', ok: true, latencyMs: 110 },
+      { fixtureId: 'f2', ok: true, latencyMs: 115 },
+      { fixtureId: 'f4', ok: true, latencyMs: 200 },
+    ],
+  };
+
+  it('renders the diff container with a heading', () => {
+    render(<EvalDiff runA={runA} runB={runB} />);
+    expect(screen.getByTestId('eval-diff')).toBeInTheDocument();
+    expect(screen.getByRole('heading', { level: 3 })).toHaveTextContent('Regression Analysis');
+  });
+
+  it('renders the improved/regressed/unchanged counters', () => {
+    render(<EvalDiff runA={runA} runB={runB} />);
+    // f1: false → true = improved
+    // f2: true → true = unchanged
+    // f3: true → true (only in A) → removed
+    // f4: true (only in B) → added
+    expect(screen.getByText(/1 improved/)).toBeInTheDocument();
+    expect(screen.getByText(/0 regressed/)).toBeInTheDocument();
+    expect(screen.getByText(/1 unchanged/)).toBeInTheDocument();
+  });
+
+  it('renders improved and regressed rows with their fixture ids', () => {
+    render(<EvalDiff runA={runA} runB={runB} />);
+    const improvedRow = screen.getByText('f1').closest('.eval-diff-row');
+    expect(improvedRow).not.toBeNull();
+    expect(improvedRow).toHaveClass('is-improved');
+  });
+
+  it('shows the empty state when no fixtures changed', () => {
+    // Pass the same run for both A and B — no changes.
+    render(<EvalDiff runA={runA} runB={runA} />);
+    expect(screen.getByText(/No fixture-level changes/)).toBeInTheDocument();
+  });
+});