Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure
TypeScript
import { describe, expect, it, vi } from 'vitest'
import { fireEvent, render, screen, waitFor } from '@testing-library/react'
import type { LlmAllowedModel } from '../../lib/api'
import { LlmModelTable } from '../LlmModelTable'
const baseModel: LlmAllowedModel = {
id: 'model-1',
provider: 'claude',
model: 'claude-sonnet-4-6',
vendor: 'Anthropic',
display_name: 'Claude Sonnet 4.6',
context_window_tokens: 200000,
enabled: true,
source: 'manual',
stale: false,
discovered_at: null,
last_seen_at: null,
created_at: '2026-01-01T00:00:00.000Z',
updated_at: '2026-01-01T00:00:00.000Z',
}
function renderTable(items: LlmAllowedModel[], unpricedKeys = new Set<string>()) {
return render(
<LlmModelTable
items={items}
unpricedKeys={unpricedKeys}
onCreate={vi.fn()}
onEdit={vi.fn()}
onDelete={vi.fn().mockResolvedValue(undefined)}
onRefresh={vi.fn()}
deletingId={null}
refreshing={false}
loading={false}
/>
)
}
function expandAnthropicModels() {
fireEvent.click(screen.getByRole('button', { name: 'Expand Anthropic models' }))
}
describe('LlmModelTable catalog-lifecycle columns', () => {
it('shows the Discovered badge for a discovery-sourced row', () => {
renderTable([{ ...baseModel, source: 'discovery' }])
expandAnthropicModels()
expect(screen.getByText('Discovered')).toBeInTheDocument()
expect(screen.queryByText('Manual')).not.toBeInTheDocument()
})
it('keeps stale status on its record without restoring the removed Catalog status column', () => {
renderTable([{ ...baseModel, id: 'm-stale', source: 'discovery', stale: true }, baseModel])
expandAnthropicModels()
expect(screen.getByText('Stale', { selector: '.cu-px-badge--warn' })).toBeVisible()
expect(screen.queryByRole('columnheader', { name: 'Catalog status' })).toBeNull()
})
it('defaults a legacy row without source/stale to Manual and not stale', () => {
// Simulate a pre-migration API row that omits the new catalog fields.
const legacy = {
id: 'legacy-1',
provider: 'openai',
model: 'gpt-4o',
vendor: null,
display_name: null,
context_window_tokens: null,
enabled: true,
created_at: '2026-01-01T00:00:00.000Z',
updated_at: '2026-01-01T00:00:00.000Z',
} as LlmAllowedModel
renderTable([legacy])
fireEvent.click(screen.getByRole('button', { name: 'Expand OpenAI models' }))
expect(screen.getByText('Manual', { selector: '.cu-px-badge' })).toBeInTheDocument()
expect(screen.queryByText('Discovered')).not.toBeInTheDocument()
expect(screen.queryByText('Stale', { selector: '.cu-px-badge--warn' })).toBeNull()
})
it('groups OpenAI API-key and subscription rows under one family', () => {
renderTable([
{
...baseModel,
id: 'oa-key',
provider: 'openai',
model: 'gpt-5.1',
vendor: 'OpenAI',
display_name: 'GPT-5.1',
},
{
...baseModel,
id: 'oa-sub',
provider: 'codex-subscription',
model: 'gpt-5.1',
vendor: 'OpenAI',
display_name: 'GPT-5.1',
},
{
...baseModel,
id: 'oa-sub-only',
provider: 'codex-subscription',
model: 'gpt-5.3-codex',
vendor: 'OpenAI',
display_name: 'GPT-5.3 Codex',
},
])
expect(
screen.queryByRole('button', { name: /OpenAI Codex Subscription/i })
).not.toBeInTheDocument()
fireEvent.click(screen.getByRole('button', { name: 'Expand OpenAI models' }))
expect(screen.getByText('gpt-5.1')).toBeInTheDocument()
expect(screen.getByText('API key · Subscription')).toBeInTheDocument()
expect(screen.getByText('gpt-5.3-codex').closest('tr')).toHaveTextContent('Subscription')
})
it('edits the subscription row of an expanded OpenAI family through the existing actions menu', () => {
const onEdit = vi.fn()
render(
<LlmModelTable
items={[
{
...baseModel,
id: 'oa-key',
provider: 'openai',
model: 'gpt-5.1',
vendor: 'OpenAI',
display_name: 'GPT-5.1',
},
{
...baseModel,
id: 'oa-sub',
provider: 'codex-subscription',
model: 'gpt-5.1',
vendor: 'OpenAI',
display_name: 'GPT-5.1',
},
]}
unpricedKeys={new Set()}
onCreate={vi.fn()}
onEdit={onEdit}
onDelete={vi.fn().mockResolvedValue(undefined)}
onRefresh={vi.fn()}
deletingId={null}
refreshing={false}
loading={false}
/>
)
fireEvent.click(screen.getByRole('button', { name: 'Expand OpenAI models' }))
fireEvent.click(screen.getByRole('button', { name: 'Actions for model openai/gpt-5.1' }))
fireEvent.click(screen.getByRole('menuitem', { name: 'Edit subscription' }))
expect(onEdit).toHaveBeenCalledWith('oa-sub')
})
it('groups xAI API-key and subscription rows under one family', () => {
renderTable([
{
...baseModel,
id: 'xai-key',
provider: 'xai',
model: 'grok-4.6',
vendor: 'xAI',
display_name: 'Grok 4.6',
},
{
...baseModel,
id: 'xai-sub',
provider: 'grok-subscription',
model: 'grok-4.6',
vendor: 'xAI',
display_name: 'Grok 4.6',
},
{
...baseModel,
id: 'xai-sub-only',
provider: 'grok-subscription',
model: 'grok-4.6-fast',
vendor: 'xAI',
display_name: 'Grok 4.6 Fast',
},
])
// One group, under the vendor's own label — not a second group for the broker.
expect(
screen.queryByRole('button', { name: /Expand xAI Grok Subscription models/i })
).not.toBeInTheDocument()
fireEvent.click(screen.getByRole('button', { name: 'Expand xAI (Grok) models' }))
expect(screen.getByText('grok-4.6')).toBeInTheDocument()
expect(screen.getByText('API key · Subscription')).toBeInTheDocument()
expect(screen.getByText('grok-4.6-fast').closest('tr')).toHaveTextContent('Subscription')
})
it('edits the subscription row of an expanded xAI family through the existing actions menu', () => {
const onEdit = vi.fn()
render(
<LlmModelTable
items={[
{
...baseModel,
id: 'xai-key',
provider: 'xai',
model: 'grok-4.6',
vendor: 'xAI',
display_name: 'Grok 4.6',
},
{
...baseModel,
id: 'xai-sub',
provider: 'grok-subscription',
model: 'grok-4.6',
vendor: 'xAI',
display_name: 'Grok 4.6',
},
]}
unpricedKeys={new Set()}
onCreate={vi.fn()}
onEdit={onEdit}
onDelete={vi.fn().mockResolvedValue(undefined)}
onRefresh={vi.fn()}
deletingId={null}
refreshing={false}
loading={false}
/>
)
fireEvent.click(screen.getByRole('button', { name: 'Expand xAI (Grok) models' }))
fireEvent.click(screen.getByRole('button', { name: 'Actions for model xai/grok-4.6' }))
// Collapsing merges two rows into one line; the menu must still reach the
// broker's own row, not the API-key row it is displayed beside.
fireEvent.click(screen.getByRole('menuitem', { name: 'Edit subscription' }))
expect(onEdit).toHaveBeenCalledWith('xai-sub')
expect(onEdit).not.toHaveBeenCalledWith('xai-key')
})
it('labels a model only the API key serves without implying a subscription', () => {
renderTable([
{
...baseModel,
id: 'xai-key',
provider: 'xai',
model: 'grok-4.6',
vendor: 'xAI',
display_name: 'Grok 4.6',
},
{
...baseModel,
id: 'xai-sub',
provider: 'grok-subscription',
model: 'grok-4.6',
vendor: 'xAI',
display_name: 'Grok 4.6',
},
{
...baseModel,
id: 'xai-key-only',
provider: 'xai',
model: 'grok-4.6-heavy',
vendor: 'xAI',
display_name: 'Grok 4.6 Heavy',
},
])
fireEvent.click(screen.getByRole('button', { name: 'Expand xAI (Grok) models' }))
// The mirror of the subscription-only row the suite already covers. The
// badge is per model, not per family: a family that holds a broker must not
// make every one of its models look reachable through the subscription.
const apiKeyOnly = screen.getByText('grok-4.6-heavy').closest('tr')
expect(apiKeyOnly).toHaveTextContent('API key')
expect(apiKeyOnly).not.toHaveTextContent('Subscription')
// Liveness witness: the collapse really ran on this family, so the negative
// above is about a rendered badge and not about an unrendered table.
expect(screen.getByText('grok-4.6').closest('tr')).toHaveTextContent('API key · Subscription')
})
it('leaves a single-provider family uncollapsed and unlabelled', () => {
renderTable([
{ ...baseModel, id: 'cl-1', model: 'claude-sonnet-4-6' },
{ ...baseModel, id: 'cl-2', model: 'claude-opus-4-1', display_name: 'Claude Opus 4.1' },
])
expandAnthropicModels()
expect(screen.getByText('claude-sonnet-4-6')).toBeInTheDocument()
expect(screen.getByText('claude-opus-4-1')).toBeInTheDocument()
expect(screen.queryByText('API key · Subscription')).not.toBeInTheDocument()
expect(screen.queryByText('Subscription')).not.toBeInTheDocument()
})
})
describe('LlmModelTable filters', () => {
const enabledModel: LlmAllowedModel = {
...baseModel,
id: 'm-enabled',
model: 'claude-enabled',
enabled: true,
source: 'manual',
}
const disabledModel: LlmAllowedModel = {
...baseModel,
id: 'm-disabled',
model: 'claude-disabled',
enabled: false,
source: 'discovery',
}
it('filters by enabled state', () => {
renderTable([enabledModel, disabledModel])
expandAnthropicModels()
expect(screen.getByText('claude-enabled')).toBeInTheDocument()
expect(screen.getByText('claude-disabled')).toBeInTheDocument()
fireEvent.change(screen.getByLabelText('Filter by enabled state'), {
target: { value: 'disabled' },
})
expect(screen.queryByText('claude-enabled')).not.toBeInTheDocument()
expect(screen.getByText('claude-disabled')).toBeInTheDocument()
})
it('filters by source when both kinds are present', () => {
renderTable([enabledModel, disabledModel])
expandAnthropicModels()
fireEvent.change(screen.getByLabelText('Filter by source'), {
target: { value: 'discovery' },
})
expect(screen.queryByText('claude-enabled')).not.toBeInTheDocument()
expect(screen.getByText('claude-disabled')).toBeInTheDocument()
})
it('hides the source filter when only one source is present', () => {
renderTable([enabledModel])
expect(screen.queryByLabelText('Filter by source')).toBeNull()
})
it('clears a selected provider when that provider disappears', async () => {
const openAiModel = {
...enabledModel,
id: 'openai-model',
provider: 'openai',
model: 'gpt-5',
vendor: 'OpenAI',
display_name: 'GPT-5',
}
const view = renderTable([enabledModel, openAiModel])
fireEvent.click(screen.getByRole('button', { name: 'Filter by provider' }))
fireEvent.click(screen.getByRole('option', { name: 'OpenAI' }))
expect(screen.getByText('gpt-5')).toBeInTheDocument()
view.rerender(
<LlmModelTable
items={[enabledModel]}
unpricedKeys={new Set()}
onCreate={vi.fn()}
onEdit={vi.fn()}
onDelete={vi.fn().mockResolvedValue(undefined)}
onRefresh={vi.fn()}
deletingId={null}
refreshing={false}
loading={false}
/>
)
await waitFor(() => {
expect(screen.queryByLabelText('Filter by provider')).toBeNull()
expect(screen.getByRole('button', { name: 'Expand Anthropic models' })).toBeInTheDocument()
})
expect(screen.queryByText('No models match this filter.')).toBeNull()
})
it('clears a selected provider that disappears while other providers remain', async () => {
const openAiModel = {
...enabledModel,
id: 'openai-model',
provider: 'openai',
model: 'gpt-5',
vendor: 'OpenAI',
display_name: 'GPT-5',
}
const googleModel = {
...enabledModel,
id: 'google-model',
provider: 'google',
model: 'gemini-2.5-pro',
vendor: 'Google',
display_name: 'Gemini 2.5 Pro',
}
const view = renderTable([enabledModel, openAiModel, googleModel])
fireEvent.click(screen.getByRole('button', { name: 'Filter by provider' }))
fireEvent.click(screen.getByRole('option', { name: 'OpenAI' }))
view.rerender(
<LlmModelTable
items={[enabledModel, googleModel]}
unpricedKeys={new Set()}
onCreate={vi.fn()}
onEdit={vi.fn()}
onDelete={vi.fn().mockResolvedValue(undefined)}
onRefresh={vi.fn()}
deletingId={null}
refreshing={false}
loading={false}
/>
)
await waitFor(() => {
expect(screen.getByRole('button', { name: 'Filter by provider' })).toHaveTextContent(
'All providers'
)
})
expect(screen.queryByText('No models match this filter.')).toBeNull()
expect(screen.getByRole('button', { name: 'Expand Anthropic models' })).toBeInTheDocument()
expect(screen.getByRole('button', { name: 'Expand google models' })).toBeInTheDocument()
})
it('shows the filtered empty state when no row matches', () => {
renderTable([enabledModel])
fireEvent.change(screen.getByLabelText('Filter by enabled state'), {
target: { value: 'disabled' },
})
expect(screen.getByText('No models match this filter.')).toBeInTheDocument()
})
})
describe('LlmModelTable states', () => {
it('keeps the toolbar and semantic headers mounted while loading and empty', () => {
const loadingView = render(
<LlmModelTable
items={[]}
unpricedKeys={new Set()}
onCreate={vi.fn()}
onEdit={vi.fn()}
onDelete={vi.fn().mockResolvedValue(undefined)}
onRefresh={vi.fn()}
deletingId={null}
refreshing={false}
loading
/>
)
expect(screen.getByRole('heading', { name: /LLM Models/ })).toBeInTheDocument()
expect(screen.getByRole('columnheader', { name: /Model/i })).toBeInTheDocument()
expect(screen.getByRole('status', { name: 'Loading models…' })).toBeInTheDocument()
expect(screen.getByRole('button', { name: 'Add model' })).toBeDisabled()
loadingView.rerender(
<LlmModelTable
items={[]}
unpricedKeys={new Set()}
onCreate={vi.fn()}
onEdit={vi.fn()}
onDelete={vi.fn().mockResolvedValue(undefined)}
onRefresh={vi.fn()}
deletingId={null}
refreshing={false}
loading={false}
/>
)
expect(screen.getByRole('columnheader', { name: /Model/i })).toBeInTheDocument()
expect(
screen.getByText('No models in the allowlist yet. Add one to let agents and runtime use it.')
).toBeInTheDocument()
})
it('preserves grouped rows while refresh is in progress', () => {
render(
<LlmModelTable
items={[baseModel]}
unpricedKeys={new Set()}
onCreate={vi.fn()}
onEdit={vi.fn()}
onDelete={vi.fn().mockResolvedValue(undefined)}
onRefresh={vi.fn()}
deletingId={null}
refreshing
loading={false}
/>
)
expect(screen.getByRole('button', { name: 'Refreshing…' })).toBeDisabled()
expect(screen.getByRole('button', { name: 'Expand Anthropic models' })).toBeInTheDocument()
})
})
describe('LlmModelTable provider groups', () => {
const openAiModel: LlmAllowedModel = {
...baseModel,
id: 'openai-model',
provider: 'openai',
model: 'gpt-5',
vendor: 'OpenAI',
display_name: 'GPT-5',
}
it('renders one collapsed summary per provider family and expands independently', () => {
renderTable([baseModel, openAiModel])
expect(screen.getByRole('columnheader', { name: 'Provider' })).toBeInTheDocument()
expect(screen.getByRole('columnheader', { name: 'Models' })).toBeInTheDocument()
expect(screen.getByRole('columnheader', { name: 'Availability' })).toBeInTheDocument()
expect(screen.queryByRole('columnheader', { name: 'Credential' })).toBeNull()
expect(screen.getByRole('button', { name: 'Expand Anthropic models' })).toHaveAttribute(
'aria-expanded',
'false'
)
expect(screen.getByRole('button', { name: 'Expand OpenAI models' })).toHaveAttribute(
'aria-expanded',
'false'
)
const summaryRow = screen.getByRole('button', { name: 'Expand Anthropic models' }).closest('tr')
expect(Array.from(summaryRow?.cells ?? []).map(cell => cell.colSpan)).toEqual([1, 1, 1, 1])
expect(screen.queryByText('claude-sonnet-4-6')).toBeNull()
expect(screen.queryByText('gpt-5')).toBeNull()
expandAnthropicModels()
expect(screen.getByRole('columnheader', { name: 'Credential' })).toBeInTheDocument()
const childTable = screen.getByText('claude-sonnet-4-6').closest('table')
expect(childTable).toHaveClass('cu-llm-model-table__children')
expect(childTable?.querySelectorAll(':scope > thead > tr > th')).toHaveLength(8)
expect(screen.getByText('claude-sonnet-4-6')).toBeInTheDocument()
expect(screen.queryByText('gpt-5')).toBeNull()
expect(screen.getByRole('button', { name: 'Collapse Anthropic models' })).toHaveAttribute(
'aria-expanded',
'true'
)
})
it('summarizes total, enabled, stale, and matching model counts', () => {
renderTable([
{ ...baseModel, source: 'discovery', stale: true },
{ ...baseModel, id: 'disabled-model', model: 'claude-haiku', enabled: false },
])
const summary = screen.getByRole('button', { name: 'Expand Anthropic models' }).closest('tr')
expect(summary).not.toBeNull()
expect(summary).toHaveTextContent('2 models')
expect(summary).toHaveTextContent('1 enabled')
expect(summary).toHaveTextContent('1 stale')
fireEvent.change(screen.getByLabelText('Search models'), { target: { value: 'haiku' } })
expect(
screen.getByRole('button', { name: 'Collapse Anthropic models' }).closest('tr')
).toHaveTextContent('1 matching')
expect(screen.getByText('claude-haiku')).toBeInTheDocument()
})
it('opens matching groups while searching and keeps them open after clearing search', () => {
renderTable([
baseModel,
openAiModel,
{
...openAiModel,
id: 'openai-model-2',
model: 'o3',
display_name: 'O3',
},
])
const searchInput = screen.getByLabelText('Search models')
searchInput.focus()
fireEvent.change(searchInput, {
target: { value: 'gpt-5' },
})
expect(searchInput).toHaveFocus()
expect(screen.getByText('gpt-5')).toBeInTheDocument()
expect(screen.queryByRole('button', { name: /Anthropic models/ })).toBeNull()
expect(
screen.getByRole('button', { name: 'Collapse OpenAI models' }).closest('tr')
).toHaveTextContent('1 matching')
fireEvent.change(screen.getByLabelText('Search models'), { target: { value: '' } })
expect(screen.getByRole('button', { name: 'Collapse OpenAI models' })).toBeInTheDocument()
expect(screen.getByText('o3')).toBeInTheDocument()
})
it('opens a provider selected from the provider filter', () => {
renderTable([baseModel, openAiModel])
fireEvent.click(screen.getByRole('button', { name: 'Filter by provider' }))
const openAiOption = screen.getByRole('option', { name: 'OpenAI' })
expect(openAiOption.querySelector('img')).toHaveAttribute('src', '/provider-icons/openai.svg')
fireEvent.click(openAiOption)
expect(screen.getByText('gpt-5')).toBeInTheDocument()
expect(screen.getByRole('button', { name: 'Filter by provider' })).toHaveTextContent('OpenAI')
expect(
screen.getByRole('button', { name: 'Filter by provider' }).querySelector('img')
).toHaveAttribute('src', '/provider-icons/openai.svg')
expect(screen.queryByText('claude-sonnet-4-6')).toBeNull()
expect(screen.getByRole('button', { name: 'Collapse OpenAI models' })).toHaveAttribute(
'aria-expanded',
'true'
)
})
it('orders provider groups deterministically by display label', () => {
renderTable([
{ ...openAiModel, id: 'google', provider: 'google', model: 'gemini' },
openAiModel,
baseModel,
])
const groupLabels = Array.from(document.querySelectorAll('.cu-llm-model-group__provider')).map(
node => node.textContent
)
expect(groupLabels).toEqual(['Anthropic', 'google', 'OpenAI'])
})
it('shows missing-price details and a prefilled CTA only on the affected row', () => {
renderTable([baseModel, openAiModel], new Set(['claude/claude-sonnet-4-6']))
expandAnthropicModels()
expect(
screen.getByRole('button', {
name: 'Anthropic/claude-sonnet-4-6 has no enabled price',
})
).toBeVisible()
expect(screen.getByRole('note')).toHaveTextContent('No enabled price')
expect(screen.getByRole('note')).toHaveTextContent(
'Cost budgets may under-count spend for this model.'
)
expect(screen.getByRole('link', { name: 'Add price' })).toHaveAttribute(
'href',
'/cost-and-usage/llm-prices/new?provider=claude&model=claude-sonnet-4-6'
)
expect(screen.queryByText(/allowed models? have no enabled price/i)).toBeNull()
})
})
describe('LlmModelTable sorting', () => {
const newModel = (overrides: Partial<LlmAllowedModel>): LlmAllowedModel => ({
...baseModel,
id: overrides.id ?? baseModel.id,
...overrides,
})
function expandedRowOrder(): string[] {
const rows = document.querySelectorAll('tr.cu-llm-model-row')
return Array.from(rows).map(row => {
const cell = row.querySelector('td.cu-px-model')
return cell?.textContent?.trim() ?? ''
})
}
it('keeps the static LLM Models title regardless of filters', () => {
renderTable([baseModel])
expect(screen.getByRole('heading', { name: /LLM Models/ })).toBeInTheDocument()
})
it('exposes model ascending as the initial sort and applies it inside groups', () => {
const alpha = newModel({ id: 'z', model: 'alpha', display_name: 'Alpha' })
const bravo = newModel({ id: 'm', model: 'bravo', display_name: 'Bravo' })
const charlie = newModel({ id: 'a', model: 'charlie', display_name: 'Charlie' })
renderTable([charlie, alpha, bravo])
expandAnthropicModels()
expect(screen.getByRole('columnheader', { name: 'Model' })).toHaveAttribute(
'aria-sort',
'ascending'
)
expect(expandedRowOrder()).toEqual(['alpha', 'bravo', 'charlie'])
})
it('toggles the active model sort between descending and ascending', () => {
const alpha = newModel({ id: 'a', model: 'alpha' })
const bravo = newModel({ id: 'b', model: 'bravo' })
renderTable([alpha, bravo])
expandAnthropicModels()
expect(expandedRowOrder()).toEqual(['alpha', 'bravo'])
fireEvent.click(screen.getByRole('button', { name: 'Sort by Model descending' }))
expect(expandedRowOrder()).toEqual(['bravo', 'alpha'])
fireEvent.click(screen.getByRole('button', { name: 'Sort by Model ascending' }))
expect(expandedRowOrder()).toEqual(['alpha', 'bravo'])
})
it('sorts context window descending by default and pushes null values to the end', () => {
const small = newModel({ id: 's', model: 'small', context_window_tokens: 8_000 })
const large = newModel({ id: 'l', model: 'large', context_window_tokens: 1_000_000 })
const unknown = newModel({ id: 'u', model: 'unknown', context_window_tokens: null })
renderTable([small, large, unknown])
expandAnthropicModels()
fireEvent.click(screen.getByRole('button', { name: 'Sort by Context window descending' }))
expect(expandedRowOrder()).toEqual(['large', 'small', 'unknown'])
})
it('resets to the natural default direction when switching sort columns', () => {
const alpha = newModel({ id: 'a', model: 'alpha', context_window_tokens: 100 })
const bravo = newModel({ id: 'b', model: 'bravo', context_window_tokens: 200 })
renderTable([alpha, bravo])
expandAnthropicModels()
// Model asc is the visible initial sort.
expect(expandedRowOrder()).toEqual(['alpha', 'bravo'])
// Switching to context window uses its natural default (descending) — not
// the previous direction — so the operator gets the most useful ordering.
fireEvent.click(screen.getByRole('button', { name: 'Sort by Context window descending' }))
expect(expandedRowOrder()).toEqual(['bravo', 'alpha'])
})
})