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, within } from '@testing-library/react'
import { HostTable, collectProviderIds } from '../HostTable'
import type { HostItem } from '../HostTable.types'
function renderHostTable(items: HostItem[], contextsByRef?: Record<string, string[]>) {
return render(
<HostTable
items={items}
onOpen={vi.fn()}
onOpenConnectors={vi.fn()}
onDelete={vi.fn().mockResolvedValue(undefined)}
deletingKey={null}
onRefresh={vi.fn()}
onCreateHost={vi.fn()}
refreshing={false}
contextsByRef={contextsByRef}
/>
)
}
function hostWithContext(
name: string,
contextRef: string,
model?: Record<string, unknown>
): HostItem {
return {
metadata: { name, namespace: 'mcp-host' },
spec: {
contextRef,
...(model ? { model: model as { provider?: string; name?: string } } : {}),
},
}
}
// Pure-function invariants for collectProviderIds — exported so the ordering
// and deduplication contract is verifiable independently of the DOM.
describe('collectProviderIds (HostTable provider extraction)', () => {
it('returns just the primary provider when no fallbacks are configured', () => {
expect(collectProviderIds({ model: { provider: 'openai' } })).toEqual(['openai'])
})
it('returns primary first then fallbacks in declared order', () => {
expect(
collectProviderIds({
model: { provider: 'openai' },
llmPolicy: { fallbacks: [{ provider: 'claude' }, { provider: 'zai' }] },
})
).toEqual(['openai', 'claude', 'zai'])
})
it('deduplicates when the primary provider is also listed as a fallback', () => {
expect(
collectProviderIds({
model: { provider: 'openai' },
llmPolicy: { fallbacks: [{ provider: 'openai' }, { provider: 'zai' }] },
})
).toEqual(['openai', 'zai'])
})
it('deduplicates when the same fallback provider appears twice', () => {
expect(
collectProviderIds({
model: { provider: 'openai' },
llmPolicy: { fallbacks: [{ provider: 'claude' }, { provider: 'claude' }] },
})
).toEqual(['openai', 'claude'])
})
it('drops empty fallback entries', () => {
expect(
collectProviderIds({
model: { provider: 'openai' },
llmPolicy: { fallbacks: [{ provider: '' }, { provider: ' ' }, { provider: 'zai' }] },
})
).toEqual(['openai', 'zai'])
})
it('returns an empty list when neither model nor fallbacks are present', () => {
expect(collectProviderIds({})).toEqual([])
expect(collectProviderIds({ model: {} })).toEqual([])
expect(collectProviderIds({ llmPolicy: { fallbacks: [] } })).toEqual([])
})
it('preserves fallback order even when the primary duplicates an earlier fallback', () => {
expect(
collectProviderIds({
model: { provider: 'zai' },
llmPolicy: { fallbacks: [{ provider: 'claude' }, { provider: 'zai' }] },
})
).toEqual(['zai', 'claude'])
})
})
// Rendered coverage: the cell exposes the collected provider ids through
// aria-label, and renders one chip per unique provider in order. These
// assertions bind the cell's DOM contract to the helper's output.
describe('HostTable providers column rendering', () => {
function chipTitles(cell: HTMLElement): string[] {
return Array.from(cell.querySelectorAll<HTMLElement>('.cu-host-providers__chip')).map(
chip => chip.getAttribute('title') || ''
)
}
function providersCell(row: HTMLElement): HTMLElement {
return within(row).getByLabelText(/^Providers:/)
}
function hostWithModel(
name: string,
model: Record<string, unknown>,
fallbacks?: Array<{ provider?: string }>
): HostItem {
return {
metadata: { name, namespace: 'mcp-host' },
spec: {
contextRef: 'context1',
model: model as { provider?: string; name?: string },
llmPolicy: fallbacks ? ({ fallbacks } as Record<string, unknown>) : undefined,
},
}
}
it('renders one icon per unique provider in primary-then-fallback order', () => {
renderHostTable([
hostWithModel('chatllm', { provider: 'openai' }, [
{ provider: 'claude' },
{ provider: 'zai' },
]),
])
const row = screen.getByLabelText('Open agent chatllm')
const cell = providersCell(row)
// aria-label lists every collected label in order.
expect(cell).toHaveAttribute('aria-label', 'Providers: OpenAI, Anthropic, Z.AI')
// Each chip exposes its label as the native title (hover tooltip).
expect(chipTitles(cell)).toEqual(['OpenAI', 'Anthropic', 'Z.AI'])
})
it('renders a single icon when a fallback duplicates the primary', () => {
renderHostTable([
hostWithModel('chatllm', { provider: 'openai' }, [
{ provider: 'openai' },
{ provider: 'zai' },
]),
])
const row = screen.getByLabelText('Open agent chatllm')
const cell = providersCell(row)
expect(cell).toHaveAttribute('aria-label', 'Providers: OpenAI, Z.AI')
expect(chipTitles(cell)).toEqual(['OpenAI', 'Z.AI'])
})
it('renders no chips when the host has no provider', () => {
renderHostTable([
{
metadata: { name: 'providerless' },
spec: { contextRef: 'context1' },
},
])
const row = screen.getByLabelText('Open agent providerless')
expect(within(row).queryByLabelText(/^Providers:/)).not.toBeInTheDocument()
expect(within(row).getByText('-')).toBeInTheDocument()
})
})
// UT-9 — the row shows the editable display name (spec.host) as the primary
// label. The immutable identifier (metadata.name / slug) remains searchable
// without restoring a visible identifier column.
describe('HostTable display name column (UT-9)', () => {
function makeDisplayHost(name: string, displayName: string): HostItem {
return {
metadata: { name, namespace: 'mcp-host' },
spec: {
host: displayName,
contextRef: 'context1',
model: { provider: 'zai', name: 'glm-5.1' },
},
}
}
it('renders the display name as the primary row label without an identifier column', () => {
renderHostTable([makeDisplayHost('prod-x', 'Prod X')])
const row = screen.getByLabelText('Open agent prod-x')
expect(within(row).getByText('Prod X')).toBeInTheDocument()
expect(within(row).queryByText('prod-x')).not.toBeInTheDocument()
})
it('falls back to the slug as the primary label when spec.host is blank', () => {
renderHostTable([makeDisplayHost('prod-x', ' ')])
const row = screen.getByLabelText('Open agent prod-x')
expect(within(row).getAllByText('prod-x')).toHaveLength(1)
})
it('filters rows by the display name', () => {
renderHostTable([
makeDisplayHost('prod-x', 'Prod X'),
makeDisplayHost('sales-agent', 'Sales Agent'),
])
fireEvent.change(screen.getByRole('searchbox', { name: 'Search agents' }), {
target: { value: 'Prod' },
})
expect(screen.getByText('Prod X')).toBeInTheDocument()
expect(screen.queryByText('Sales Agent')).not.toBeInTheDocument()
})
it('filters rows by the slug identifier', () => {
renderHostTable([
makeDisplayHost('prod-x', 'Prod X'),
makeDisplayHost('sales-agent', 'Sales Agent'),
])
fireEvent.change(screen.getByRole('searchbox', { name: 'Search agents' }), {
target: { value: 'sales-agent' },
})
expect(screen.getByText('Sales Agent')).toBeInTheDocument()
expect(screen.queryByText('Prod X')).not.toBeInTheDocument()
})
})
// Hover card on the Connectors column — when the page supplies a
// `contextsByRef` map, hovering (or keyboard-focusing) the count pill reveals
// the agent's MCP-server list. The cell shows the count; the tooltip shows a
// neutral "Connectors" heading + count + server names. The private context
// slug must never render (Category E1 invariant).
describe('HostTable connectors hover card', () => {
function contextPill(row: HTMLElement, count: string): HTMLElement {
return within(row).getByRole('button', { name: count })
}
it('reveals the MCP server list on hover without exposing the context slug', () => {
renderHostTable([hostWithContext('chatllm', 'context1')], {
context1: ['github', 'linear', 'slack'],
})
const row = screen.getByLabelText('Open agent chatllm')
const pill = contextPill(row, '3')
// Closed by default — nothing tooltipped.
expect(within(row).queryByRole('tooltip')).not.toBeInTheDocument()
expect(pill).not.toHaveAttribute('aria-describedby')
fireEvent.mouseEnter(pill)
const card = within(row).getByRole('tooltip')
expect(card).toHaveTextContent('Connectors')
expect(card).toHaveTextContent('3')
expect(within(card).getByText('github')).toBeInTheDocument()
expect(within(card).getByText('linear')).toBeInTheDocument()
expect(within(card).getByText('slack')).toBeInTheDocument()
// E1: the raw private-context slug never surfaces.
expect(card).not.toHaveTextContent('context1')
fireEvent.mouseLeave(pill)
expect(within(row).queryByRole('tooltip')).not.toBeInTheDocument()
})
it('opens the agent’s own connectors tab when the count is clicked', () => {
const onOpenConnectors = vi.fn()
render(
<HostTable
items={[hostWithContext('chatllm', 'context1')]}
onOpen={vi.fn()}
onOpenConnectors={onOpenConnectors}
onDelete={vi.fn().mockResolvedValue(undefined)}
deletingKey={null}
onRefresh={vi.fn()}
onCreateHost={vi.fn()}
refreshing={false}
contextsByRef={{ context1: ['github'] }}
/>
)
fireEvent.click(
within(screen.getByLabelText('Open agent chatllm')).getByRole('button', { name: '1' })
)
expect(onOpenConnectors).toHaveBeenCalledWith({ namespace: 'mcp-host', name: 'chatllm' })
})
it('reveals the card on keyboard focus (accessible path)', () => {
renderHostTable([hostWithContext('chatllm', 'context1')], {
context1: ['github'],
})
const row = screen.getByLabelText('Open agent chatllm')
const pill = contextPill(row, '1')
fireEvent.focus(pill)
const card = within(row).getByRole('tooltip')
expect(within(card).getByText('github')).toBeInTheDocument()
expect(pill).toHaveAttribute('aria-describedby', card.id)
fireEvent.blur(pill)
expect(within(row).queryByRole('tooltip')).not.toBeInTheDocument()
})
it('shows an empty connector tooltip when the context has no MCP servers', () => {
renderHostTable([hostWithContext('chatllm', 'context1')], {
context1: [],
})
const row = screen.getByLabelText('Open agent chatllm')
const count = within(row).getByRole('button', { name: '0' })
fireEvent.mouseEnter(count)
expect(screen.getByRole('tooltip')).toHaveTextContent('No connectors')
})
it('keeps the zero count aligned when the context map is missing', () => {
renderHostTable([hostWithContext('chatllm', 'context1')])
const row = screen.getByLabelText('Open agent chatllm')
const count = within(row).getByRole('button', { name: '0' })
fireEvent.focus(count)
expect(screen.getByRole('tooltip')).toHaveTextContent('No connectors')
})
})
// ─────────────────────────────────────────────────────────────────────────────
// Row actions kebab
// ─────────────────────────────────────────────────────────────────────────────
describe('HostTable — row actions kebab', () => {
it('exposes View agent details and Delete via a single kebab menu per row', () => {
const onOpen = vi.fn()
const onDelete = vi.fn().mockResolvedValue(undefined)
render(
<HostTable
items={[hostWithContext('chatllm', 'context1')]}
onOpen={onOpen}
onOpenConnectors={vi.fn()}
onDelete={onDelete}
deletingKey={null}
onRefresh={vi.fn()}
onCreateHost={vi.fn()}
refreshing={false}
contextsByRef={{ context1: [] }}
/>
)
fireEvent.click(screen.getByRole('button', { name: 'Actions for agent chatllm' }))
const viewItem = screen.getByRole('menuitem', { name: 'View agent details' })
const deleteItem = screen.getByRole('menuitem', { name: 'Delete' })
expect(deleteItem).toHaveClass('eft-row-actions__item--danger')
fireEvent.click(viewItem)
expect(onOpen).toHaveBeenCalledWith({ namespace: 'mcp-host', name: 'chatllm' })
expect(onDelete).not.toHaveBeenCalled()
})
it('does not open the agent detail when clicking the kebab itself', () => {
const onOpen = vi.fn()
render(
<HostTable
items={[hostWithContext('chatllm', 'context1')]}
onOpen={onOpen}
onOpenConnectors={vi.fn()}
onDelete={vi.fn().mockResolvedValue(undefined)}
deletingKey={null}
onRefresh={vi.fn()}
onCreateHost={vi.fn()}
refreshing={false}
contextsByRef={{ context1: [] }}
/>
)
fireEvent.click(screen.getByRole('button', { name: 'Actions for agent chatllm' }))
expect(onOpen).not.toHaveBeenCalled()
})
it('disables only the Delete item while deleting and renames it to Deleting agent…', () => {
const onDelete = vi.fn().mockResolvedValue(undefined)
render(
<HostTable
items={[hostWithContext('chatllm', 'context1')]}
onOpen={vi.fn()}
onOpenConnectors={vi.fn()}
onDelete={onDelete}
deletingKey="mcp-host/chatllm"
onRefresh={vi.fn()}
onCreateHost={vi.fn()}
refreshing={false}
contextsByRef={{ context1: [] }}
/>
)
fireEvent.click(screen.getByRole('button', { name: 'Actions for agent chatllm' }))
const viewItem = screen.getByRole('menuitem', { name: 'View agent details' })
const deletingItem = screen.getByRole('menuitem', { name: 'Deleting agent…' })
expect(viewItem).not.toBeDisabled()
expect(deletingItem).toBeDisabled()
})
})