1 files changed, 154 insertions, 0 deletions
diff --git a/web/test/dashboard.test.mjs b/web/test/dashboard.test.mjs
new file mode 100644
index 0000000..0f96c08
--- /dev/null
+++ b/web/test/dashboard.test.mjs
@@ -0,0 +1,154 @@
+// dashboard.test.mjs — Unit tests for the Phase 9b budget/escalation
+// dashboard's pure logic: reshaping the raw escalation-funnel and
+// spend-timeseries aggregate rows, provider color/label lookup, and
+// escalation-ladder formatting for the role/config panel. Mirrors
+// stories-board.test.mjs's convention of testing pure computation only —
+// DOM-building render functions are verified against a real running server
+// (see Phase 9b's manual verification notes), not unit-tested here.
+//
+// Run with: node --test web/test/dashboard.test.mjs
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  computeEscalationFunnel,
+  computeSpendSeries,
+  formatBucketLabel,
+  colorForProvider,
+  providerLabel,
+  formatEscalationLadder,
+} from '../app.js';
+
+describe('computeEscalationFunnel', () => {
+  it('groups by rung, summing counts/cost and collecting per-agent breakdown', () => {
+    const buckets = [
+      { rung: 0, agent: 'local', count: 5, cost_usd: 0 },
+      { rung: 0, agent: 'anthropic', count: 1, cost_usd: 0.02 },
+      { rung: 1, agent: 'anthropic', count: 2, cost_usd: 0.10 },
+    ];
+    const { rungs, grandTotal } = computeEscalationFunnel(buckets);
+    assert.equal(grandTotal, 8);
+    assert.equal(rungs.length, 2);
+    assert.equal(rungs[0].rung, 0);
+    assert.equal(rungs[0].total, 6);
+    assert.equal(rungs[0].byAgent.length, 2);
+    assert.equal(rungs[1].rung, 1);
+    assert.equal(rungs[1].total, 2);
+    assert.equal(rungs[1].cost, 0.10);
+  });
+
+  it('sorts rungs ascending regardless of input order', () => {
+    const buckets = [
+      { rung: 2, agent: 'openai', count: 1, cost_usd: 0.5 },
+      { rung: 0, agent: 'local', count: 3, cost_usd: 0 },
+      { rung: 1, agent: 'google', count: 2, cost_usd: 0.1 },
+    ];
+    const { rungs } = computeEscalationFunnel(buckets);
+    assert.deepEqual(rungs.map(r => r.rung), [0, 1, 2]);
+  });
+
+  it('returns an empty rungs array and zero grand total for no data', () => {
+    const { rungs, grandTotal } = computeEscalationFunnel([]);
+    assert.deepEqual(rungs, []);
+    assert.equal(grandTotal, 0);
+  });
+
+  it('handles a missing/null buckets argument gracefully', () => {
+    const { rungs, grandTotal } = computeEscalationFunnel(undefined);
+    assert.deepEqual(rungs, []);
+    assert.equal(grandTotal, 0);
+  });
+});
+
+describe('computeSpendSeries', () => {
+  it('aligns per-provider series over a shared sorted bucket axis, filling gaps with 0', () => {
+    const points = [
+      { bucket: '2026-07-01', agent: 'local', cost_usd: 1.0 },
+      { bucket: '2026-07-02', agent: 'local', cost_usd: 2.0 },
+      { bucket: '2026-07-02', agent: 'anthropic', cost_usd: 0.5 },
+    ];
+    const { buckets, agents, series, maxCost } = computeSpendSeries(points);
+    assert.deepEqual(buckets, ['2026-07-01', '2026-07-02']);
+    assert.deepEqual(agents, ['anthropic', 'local']);
+    assert.deepEqual(series.local, [1.0, 2.0]);
+    assert.deepEqual(series.anthropic, [0, 0.5]);
+    assert.equal(maxCost, 2.0);
+  });
+
+  it('returns empty structures for no data', () => {
+    const { buckets, agents, series, maxCost } = computeSpendSeries([]);
+    assert.deepEqual(buckets, []);
+    assert.deepEqual(agents, []);
+    assert.deepEqual(series, {});
+    assert.equal(maxCost, 0);
+  });
+});
+
+describe('formatBucketLabel', () => {
+  it('formats an hourly RFC3339 bucket with the hour', () => {
+    const label = formatBucketLabel('2026-07-02T14:00:00Z');
+    assert.match(label, /\d/); // exact format is locale-dependent; just confirm it's non-empty and date-like
+  });
+
+  it('formats a daily YYYY-MM-DD bucket', () => {
+    const label = formatBucketLabel('2026-07-02');
+    assert.match(label, /\d/);
+  });
+
+  it('returns empty string for falsy input', () => {
+    assert.equal(formatBucketLabel(''), '');
+    assert.equal(formatBucketLabel(null), '');
+  });
+});
+
+describe('colorForProvider / providerLabel', () => {
+  it('returns a distinct hex color for each known provider', () => {
+    const providers = ['local', 'anthropic', 'google', 'groq', 'openrouter', 'openai'];
+    const colors = new Set(providers.map(colorForProvider));
+    assert.equal(colors.size, providers.length, 'expected all known providers to have distinct colors');
+    for (const c of colors) assert.match(c, /^#[0-9a-f]{6}$/i);
+  });
+
+  it('falls back to a muted color for an unknown provider', () => {
+    assert.match(colorForProvider('some-future-provider'), /^#[0-9a-f]{6}$/i);
+  });
+
+  it('capitalizes provider labels', () => {
+    assert.equal(providerLabel('anthropic'), 'Anthropic');
+    assert.equal(providerLabel('local'), 'Local');
+  });
+
+  it('labels a missing/empty provider as Unknown', () => {
+    assert.equal(providerLabel(''), 'Unknown');
+    assert.equal(providerLabel(undefined), 'Unknown');
+  });
+});
+
+describe('formatEscalationLadder', () => {
+  it('formats each tier with index, mode, retry budget, and candidate strings', () => {
+    const ladder = [
+      { candidates: [{ provider: 'local', model: 'llama3.1:8b' }], selection_mode: 'single', max_retries: 2 },
+      { candidates: [{ provider: 'anthropic', model: 'claude-haiku' }, { provider: 'google', model: 'gemini-flash' }], max_retries: 0 },
+    ];
+    const rows = formatEscalationLadder(ladder);
+    assert.equal(rows.length, 2);
+    assert.equal(rows[0].tier, 0);
+    assert.equal(rows[0].mode, 'single');
+    assert.equal(rows[0].maxRetries, 2);
+    assert.deepEqual(rows[0].candidates, ['local/llama3.1:8b']);
+
+    assert.equal(rows[1].tier, 1);
+    assert.equal(rows[1].mode, 'round_robin'); // default when unset
+    assert.deepEqual(rows[1].candidates, ['anthropic/claude-haiku', 'google/gemini-flash']);
+  });
+
+  it('formats a provider-only candidate (no model) without a trailing slash', () => {
+    const rows = formatEscalationLadder([{ candidates: [{ provider: 'local' }], max_retries: 0 }]);
+    assert.deepEqual(rows[0].candidates, ['local']);
+  });
+
+  it('returns an empty array for an empty/missing ladder', () => {
+    assert.deepEqual(formatEscalationLadder([]), []);
+    assert.deepEqual(formatEscalationLadder(undefined), []);
+  });
+});