mirror of
https://github.com/deepseek-ai/deepseek-harness
synced 2026-08-15 21:04:50 +00:00
1024 lines
40 KiB
TypeScript
1024 lines
40 KiB
TypeScript
// @vitest-environment jsdom
|
||
// Remaining chat branch tails: MessageItem context/unknown arms,
|
||
// user IconActions, StatsLine no-cache join,
|
||
// AssistantMarkdown single-line reasoning. (Tool-row dispatch tails live
|
||
// with the keyed-slot machinery specs since the tool ring dissolved into
|
||
// renderSlot.)
|
||
|
||
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
||
import { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
|
||
import { bindSnapshotSelector } from '@deepseek-ai/dsh-client-web-react'
|
||
import { makeTranslate } from '@deepseek-ai/dsh-client-test-runtime'
|
||
import { zh as commonZh } from '@deepseek-ai/dsh-client-locale/src/locales/zh.ts'
|
||
import {
|
||
formatMessageClock, msUntilNextLocalMidnight, startOfLocalDay,
|
||
} from '../src/client/chat/message-chrome.ts'
|
||
import { MessageItem, type MessageItemProps } from '../src/client/chat/MessageItem.tsx'
|
||
import { AssistantMarkdown } from '../src/client/chat/AssistantMarkdown.tsx'
|
||
import { StatsLine, type StatsLineProps } from '../src/client/chat/StatsLine.tsx'
|
||
import { zh } from '../src/client/locales.ts'
|
||
|
||
/** jsdom has no ResizeObserver; StatsLine watches its row for ellipsis truncation through one. */
|
||
class ResizeObserverStub {
|
||
observe(): void {}
|
||
unobserve(): void {}
|
||
disconnect(): void {}
|
||
}
|
||
|
||
beforeEach(() => { vi.stubGlobal('ResizeObserver', ResizeObserverStub) })
|
||
afterEach(() => {
|
||
cleanup()
|
||
vi.useRealTimers()
|
||
vi.unstubAllGlobals()
|
||
})
|
||
|
||
// Mirrors the real lookup chain (conversation namespace, then common).
|
||
const t: MessageItemProps['t'] = makeTranslate(zh, commonZh)
|
||
|
||
describe('MessageItem arms', () => {
|
||
it('user bubbles expose clock / copy / branch and no edit; copy writes the text', () => {
|
||
const writeText = vi.fn().mockResolvedValue(undefined)
|
||
Object.defineProperty(navigator, 'clipboard', {
|
||
configurable: true,
|
||
value: { writeText },
|
||
})
|
||
// Same-day clock: construct "today at 14:24" so the label stays `HH:mm`.
|
||
const now = new Date()
|
||
const time = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 14, 24).getTime()
|
||
const onFork = vi.fn()
|
||
render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'user', seq: 1, time,
|
||
content: [{ type: 'text', text: 'hello bubble' }] as never,
|
||
source: null,
|
||
}}
|
||
onFork={onFork}
|
||
/>,
|
||
)
|
||
expect(screen.getByText('14:24')).toBeTruthy()
|
||
expect(screen.getByRole('button', { name: '复制' })).toBeTruthy()
|
||
expect(screen.getByRole('button', { name: '在新对话中分支' })).toBeTruthy()
|
||
expect(screen.queryByRole('button', { name: '编辑' })).toBeNull()
|
||
fireEvent.click(screen.getByRole('button', { name: '复制' }))
|
||
expect(writeText).toHaveBeenCalledWith('hello bubble')
|
||
fireEvent.click(screen.getByRole('button', { name: '在新对话中分支' }))
|
||
expect(onFork).toHaveBeenCalledWith(1)
|
||
})
|
||
|
||
it('user copy falls back to execCommand when clipboard.writeText is unavailable', () => {
|
||
Object.defineProperty(navigator, 'clipboard', {
|
||
configurable: true,
|
||
value: undefined,
|
||
})
|
||
const exec = vi.fn().mockReturnValue(true)
|
||
Object.defineProperty(document, 'execCommand', {
|
||
configurable: true,
|
||
value: exec,
|
||
})
|
||
render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'user', seq: 1, time: 1_000,
|
||
content: [{ type: 'text', text: 'fallback body' }] as never,
|
||
source: null,
|
||
}}
|
||
/>,
|
||
)
|
||
fireEvent.click(screen.getByRole('button', { name: '复制' }))
|
||
expect(exec).toHaveBeenCalledWith('copy')
|
||
})
|
||
|
||
it('keeps an unavailable branch focusable and explains why without sending a fork', () => {
|
||
const onFork = vi.fn()
|
||
render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'user', seq: 1, time: 1_000,
|
||
content: [{ type: 'text', text: 'open turn' }] as never,
|
||
source: null,
|
||
}}
|
||
onFork={onFork}
|
||
forkUnavailable
|
||
/>,
|
||
)
|
||
const branch = screen.getByRole('button', { name: '在新对话中分支' }) as HTMLButtonElement
|
||
expect(branch.disabled).toBe(false)
|
||
expect(branch.getAttribute('aria-disabled')).toBe('true')
|
||
const reasonId = branch.getAttribute('aria-describedby')
|
||
expect(reasonId).not.toBeNull()
|
||
expect(document.getElementById(reasonId!)?.textContent).toBe('仅可从已完成轮次的最后一条消息分支')
|
||
fireEvent.click(branch)
|
||
expect(onFork).not.toHaveBeenCalled()
|
||
fireEvent.focus(branch)
|
||
expect(screen.getByRole('tooltip').textContent).toBe('仅可从已完成轮次的最后一条消息分支')
|
||
})
|
||
|
||
it('user copy never claims success when the host rejects the write', async () => {
|
||
Object.defineProperty(navigator, 'clipboard', {
|
||
configurable: true,
|
||
value: { writeText: vi.fn().mockRejectedValue(new Error('denied')) },
|
||
})
|
||
render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'user', seq: 1, time: 1_000,
|
||
content: [{ type: 'text', text: 'quiet' }] as never,
|
||
source: null,
|
||
}}
|
||
/>,
|
||
)
|
||
fireEvent.click(screen.getByRole('button', { name: '复制' }))
|
||
await act(async () => {
|
||
await Promise.resolve()
|
||
await Promise.resolve()
|
||
})
|
||
expect(screen.getByRole('button', { name: '复制' })).toBeTruthy()
|
||
expect(screen.queryByRole('button', { name: '复制成功' })).toBeNull()
|
||
})
|
||
|
||
it('copy swaps to the check success chrome, gates re-clicks, and reverts after a second', async () => {
|
||
vi.useFakeTimers()
|
||
const writeText = vi.fn().mockResolvedValue(undefined)
|
||
Object.defineProperty(navigator, 'clipboard', {
|
||
configurable: true,
|
||
value: { writeText },
|
||
})
|
||
render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'user', seq: 1, time: 1_000,
|
||
content: [{ type: 'text', text: 'copied body' }] as never,
|
||
source: null,
|
||
}}
|
||
/>,
|
||
)
|
||
const copy = screen.getByRole('button', { name: '复制' })
|
||
fireEvent.click(copy)
|
||
fireEvent.click(copy)
|
||
expect(writeText).toHaveBeenCalledTimes(1)
|
||
// Two microtask ticks: writeClipboard's own await, then the .then that
|
||
// lands the success chrome.
|
||
await act(async () => {
|
||
await Promise.resolve()
|
||
await Promise.resolve()
|
||
})
|
||
const done = screen.getByRole('button', { name: '复制成功' })
|
||
fireEvent.click(done)
|
||
expect(writeText).toHaveBeenCalledTimes(1)
|
||
act(() => { vi.advanceTimersByTime(1000) })
|
||
expect(screen.getByRole('button', { name: '复制' })).toBeTruthy()
|
||
})
|
||
|
||
it('clears copy feedback work when the message unmounts', async () => {
|
||
vi.useFakeTimers()
|
||
let finishWrite!: () => void
|
||
const writeText = vi.fn(() => new Promise<void>((resolve) => { finishWrite = resolve }))
|
||
Object.defineProperty(navigator, 'clipboard', {
|
||
configurable: true,
|
||
value: { writeText },
|
||
})
|
||
const view = render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'user', seq: 1, time: 1_000,
|
||
content: [{ type: 'text', text: 'copied body' }] as never,
|
||
source: null,
|
||
}}
|
||
/>,
|
||
)
|
||
fireEvent.click(screen.getByRole('button', { name: '复制' }))
|
||
view.unmount()
|
||
await act(async () => {
|
||
finishWrite()
|
||
await Promise.resolve()
|
||
await Promise.resolve()
|
||
})
|
||
expect(vi.getTimerCount()).toBe(0)
|
||
|
||
const mounted = render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'user', seq: 2, time: 1_000,
|
||
content: [{ type: 'text', text: 'copied body' }] as never,
|
||
source: null,
|
||
}}
|
||
/>,
|
||
)
|
||
Object.defineProperty(navigator, 'clipboard', {
|
||
configurable: true,
|
||
value: { writeText: vi.fn().mockResolvedValue(undefined) },
|
||
})
|
||
fireEvent.click(screen.getByRole('button', { name: '复制' }))
|
||
await act(async () => {
|
||
await Promise.resolve()
|
||
await Promise.resolve()
|
||
})
|
||
expect(screen.getByRole('button', { name: '复制成功' })).toBeTruthy()
|
||
mounted.unmount()
|
||
expect(vi.getTimerCount()).toBe(0)
|
||
})
|
||
|
||
it('consumed steering is captioned as an interjection and keeps copy and branch actions', () => {
|
||
const writeText = vi.fn().mockResolvedValue(undefined)
|
||
Object.defineProperty(navigator, 'clipboard', {
|
||
configurable: true,
|
||
value: { writeText },
|
||
})
|
||
const fork = vi.fn()
|
||
const view = render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'steering', messageId: 'steer-message', seq: 2, time: 1_000, turn: 1, source: null,
|
||
content: [{ type: 'text', text: 'steer!' }, { type: 'image', data: 'x' }] as never,
|
||
} as never}
|
||
onFork={fork}
|
||
/>,
|
||
)
|
||
expect(view.getByText('插话')).toBeTruthy()
|
||
expect(view.getByText('steer!')).toBeTruthy()
|
||
expect(view.getByText(/附加内容块/)).toBeTruthy()
|
||
fireEvent.click(view.getByRole('button', { name: '复制' }))
|
||
expect(writeText).toHaveBeenCalledWith('steer!')
|
||
fireEvent.click(view.getByRole('button', { name: '在新对话中分支' }))
|
||
expect(fork).toHaveBeenCalledWith(2)
|
||
})
|
||
|
||
it('context uses the Tool calls disclosure chrome and keeps its body collapsed by default', () => {
|
||
const ctxView = render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'context',
|
||
seq: 3,
|
||
content: [{ type: 'text', text: 'line one\n\nline two' }],
|
||
source: { kind: 'plugin', plugin: 'fixture', empty: {}, list: [] },
|
||
provenance: { role: 'inject', label: 'fixture' },
|
||
form: null,
|
||
} as never}
|
||
/>,
|
||
)
|
||
const disclosure = ctxView.getByRole('button', { name: /^上下文注入\s*fixture$/ })
|
||
expect(disclosure.getAttribute('aria-expanded')).toBe('false')
|
||
expect(ctxView.container.querySelector('[data-context-injection-body]')).toBeNull()
|
||
expect(ctxView.container.querySelector('svg')).not.toBeNull()
|
||
|
||
fireEvent.click(disclosure)
|
||
expect(disclosure.getAttribute('aria-expanded')).toBe('true')
|
||
// An unknown form renders the opaque body: the model-facing text keeps its
|
||
// real line breaks instead of being escaped into one JSON line, and the
|
||
// remaining provenance follows it as fields.
|
||
expect(ctxView.container.querySelector('[data-context-text]')?.textContent)
|
||
.toBe('line one\n\nline two')
|
||
const fields = [...ctxView.container.querySelectorAll('[data-context-fields] dt')].map(node => node.textContent)
|
||
expect(fields).toEqual(['plugin', 'empty', 'list'])
|
||
|
||
fireEvent.keyDown(disclosure, { key: ' ' })
|
||
expect(disclosure.getAttribute('aria-expanded')).toBe('false')
|
||
})
|
||
|
||
it('the instructions form names the files it reconciled above their text', () => {
|
||
const view = render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'context',
|
||
seq: 3,
|
||
content: [{ type: 'text', text: '<system-reminder>\nInstructions from: AGENTS.md\n</system-reminder>' }],
|
||
source: {
|
||
kind: 'workspace-instructions',
|
||
form: 'instructions',
|
||
baseline: true,
|
||
changes: [
|
||
{ action: 'set', scope: '.\u0000AGENTS.md', path: 'AGENTS.md', digest: 'abc' },
|
||
{ action: 'remove', scope: 'sub\u0000AGENTS.md', path: 'sub/AGENTS.md' },
|
||
{ action: 'replace', scope: '.\u0000AGENTS.md', path: 'AGENTS.md' },
|
||
],
|
||
},
|
||
provenance: { role: 'inject', label: 'AGENTS.md, sub/AGENTS.md' },
|
||
form: 'instructions',
|
||
} as never}
|
||
/>,
|
||
)
|
||
fireEvent.click(view.getByRole('button', { name: /^上下文注入\s*AGENTS\.md, sub\/AGENTS\.md$/ }))
|
||
const files = [...view.container.querySelectorAll('[data-context-files] li')].map(node => node.textContent)
|
||
expect(files).toEqual(['AGENTS.md已载入', 'sub/AGENTS.md已移除'])
|
||
// The `<system-reminder>` framing is part of what the model read, so the
|
||
// body keeps it verbatim rather than presenting a cleaned-up excerpt.
|
||
expect(view.container.querySelector('[data-context-text]')?.textContent)
|
||
.toContain('<system-reminder>')
|
||
})
|
||
|
||
it('a delta distinguishes a newly reconciled file from a rewritten one', () => {
|
||
const view = render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'context',
|
||
seq: 3,
|
||
content: [{ type: 'text', text: 'delta' }],
|
||
source: {
|
||
kind: 'workspace-instructions',
|
||
form: 'instructions',
|
||
changes: [
|
||
{ action: 'set', scope: 'a', path: 'new/AGENTS.md' },
|
||
{ action: 'replace', scope: 'b', path: 'old/AGENTS.md' },
|
||
],
|
||
},
|
||
provenance: { role: 'inject', label: 'new/AGENTS.md, old/AGENTS.md' },
|
||
form: 'instructions',
|
||
} as never}
|
||
/>,
|
||
)
|
||
fireEvent.click(view.getByRole('button', { name: /^上下文注入\s*new\/AGENTS\.md, old\/AGENTS\.md$/ }))
|
||
const files = [...view.container.querySelectorAll('[data-context-files] li')].map(node => node.textContent)
|
||
expect(files).toEqual(['new/AGENTS.md已新增', 'old/AGENTS.md已更新'])
|
||
})
|
||
|
||
it('keeps an interleaved unknown block in the order the model received it', () => {
|
||
const view = render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'context',
|
||
seq: 3,
|
||
content: [
|
||
{ type: 'text', text: 'before' },
|
||
{ type: 'future-block', payload: 1 },
|
||
{ type: 'text', text: 'after' },
|
||
],
|
||
source: null,
|
||
provenance: { role: 'inject', label: null },
|
||
form: null,
|
||
} as never}
|
||
/>,
|
||
)
|
||
fireEvent.click(view.getByRole('button', { name: '上下文注入' }))
|
||
const texts = [...view.container.querySelectorAll('[data-context-text]')].map(node => node.textContent)
|
||
expect(texts).toEqual(['before', 'after'])
|
||
expect(view.getByText(/未知内容块/)).toBeTruthy()
|
||
})
|
||
|
||
it('the catalog form lists its durable entries instead of the model-facing prose', () => {
|
||
const view = render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'context',
|
||
seq: 3,
|
||
content: [{ type: 'text', text: '<system-reminder>\n<available_skills>\n- `a`: A\n</available_skills>' }],
|
||
source: {
|
||
kind: 'skill-catalog',
|
||
form: 'catalog',
|
||
entries: [{ name: 'a-skill', description: 'Does A' }, { name: 'b-skill', description: 'Does B' }],
|
||
},
|
||
provenance: { role: 'inject', label: 'skill-catalog' },
|
||
form: 'catalog',
|
||
} as never}
|
||
/>,
|
||
)
|
||
fireEvent.click(view.getByRole('button', { name: /^上下文注入\s*skill-catalog$/ }))
|
||
const entries = [...view.container.querySelectorAll('[data-context-entries] li')].map(node => node.textContent)
|
||
expect(entries).toEqual(['a-skillDoes A', 'b-skillDoes B'])
|
||
expect(view.container.querySelector('[data-context-text]')).toBeNull()
|
||
expect(view.container.querySelector('[data-context-catalog-update]')).toBeNull()
|
||
})
|
||
|
||
it('a replacement catalog says so above its entries', () => {
|
||
const view = render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'context',
|
||
seq: 3,
|
||
content: [{ type: 'text', text: 'catalog prose' }],
|
||
source: {
|
||
kind: 'skill-catalog',
|
||
form: 'catalog',
|
||
update: true,
|
||
entries: [{ name: 'a-skill', description: 'Does A' }],
|
||
},
|
||
provenance: { role: 'inject', label: 'skill-catalog' },
|
||
form: 'catalog',
|
||
} as never}
|
||
/>,
|
||
)
|
||
fireEvent.click(view.getByRole('button', { name: /^上下文注入\s*skill-catalog$/ }))
|
||
expect(view.container.querySelector('[data-context-catalog-update]')?.textContent).toBe('替换目录')
|
||
})
|
||
|
||
it('a partially unreadable catalog falls back whole rather than showing a short list', () => {
|
||
// All-or-nothing: a body that replaces the model-facing text must not show
|
||
// a confident, incomplete account of what the model read.
|
||
const view = render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'context',
|
||
seq: 3,
|
||
content: [{ type: 'text', text: 'catalog prose' }],
|
||
source: {
|
||
kind: 'skill-catalog',
|
||
form: 'catalog',
|
||
entries: [{ name: 'a-skill', description: 'Does A' }, { name: 'b-skill' }],
|
||
},
|
||
provenance: { role: 'inject', label: 'skill-catalog' },
|
||
form: 'catalog',
|
||
} as never}
|
||
/>,
|
||
)
|
||
fireEvent.click(view.getByRole('button', { name: /^上下文注入\s*skill-catalog$/ }))
|
||
expect(view.container.querySelector('[data-context-entries]')).toBeNull()
|
||
expect(view.container.querySelector('[data-context-text]')?.textContent).toBe('catalog prose')
|
||
// The marker reports what rendered, not what was declared.
|
||
expect(view.container.querySelector('[data-context-injection-body]')?.getAttribute('data-context-form'))
|
||
.toBeNull()
|
||
})
|
||
|
||
it('an unreadable instruction list falls back to the opaque body with its fields', () => {
|
||
const view = render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'context',
|
||
seq: 3,
|
||
content: [{ type: 'text', text: 'instruction prose' }],
|
||
source: { kind: 'workspace-instructions', form: 'instructions', changes: [{ action: 'set' }] },
|
||
provenance: { role: 'inject', label: 'workspace-instructions' },
|
||
form: 'instructions',
|
||
} as never}
|
||
/>,
|
||
)
|
||
fireEvent.click(view.getByRole('button', { name: /^上下文注入\s*workspace-instructions$/ }))
|
||
expect(view.container.querySelector('[data-context-files]')).toBeNull()
|
||
expect(view.container.querySelector('[data-context-text]')?.textContent).toBe('instruction prose')
|
||
expect(view.container.querySelector('[data-context-fields]')).not.toBeNull()
|
||
})
|
||
|
||
it('joins adjacent text blocks the way a provider adapter flattens them', () => {
|
||
// No invented separator: showing a line break the model never saw would
|
||
// misreport the request.
|
||
const view = render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'context',
|
||
seq: 3,
|
||
content: [{ type: 'text', text: 'first' }, { type: 'text', text: 'second' }],
|
||
source: null,
|
||
provenance: { role: 'inject', label: null },
|
||
form: null,
|
||
} as never}
|
||
/>,
|
||
)
|
||
fireEvent.click(view.getByRole('button', { name: '上下文注入' }))
|
||
expect(view.container.querySelector('[data-context-text]')?.textContent).toBe('firstsecond')
|
||
})
|
||
|
||
it('bounds an oversized provenance field, not only the model-facing text', () => {
|
||
const view = render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'context',
|
||
seq: 3,
|
||
content: [{ type: 'text', text: 'short' }],
|
||
source: { kind: 'plugin', note: 'y'.repeat(21_000) },
|
||
provenance: { role: 'inject', label: 'plugin' },
|
||
form: null,
|
||
} as never}
|
||
/>,
|
||
)
|
||
fireEvent.click(view.getByRole('button', { name: /^上下文注入\s*plugin$/ }))
|
||
expect(view.container.querySelector('[data-context-fields] dd')?.textContent)
|
||
.toMatch(/… 已截断，共 \d+ 字符$/)
|
||
})
|
||
|
||
it('an empty replacement catalog stays a catalog: it retires every earlier name', () => {
|
||
// `renderCatalogUpdate` legitimately publishes zero entries when the last
|
||
// skill disappears; falling back would hide that the catalog was cleared.
|
||
const view = render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'context',
|
||
seq: 3,
|
||
content: [{ type: 'text', text: 'catalog prose' }],
|
||
source: { kind: 'skill-catalog', form: 'catalog', update: true, entries: [] },
|
||
provenance: { role: 'inject', label: 'skill-catalog' },
|
||
form: 'catalog',
|
||
} as never}
|
||
/>,
|
||
)
|
||
fireEvent.click(view.getByRole('button', { name: /^上下文注入\s*skill-catalog$/ }))
|
||
expect(view.container.querySelector('[data-context-catalog-update]')?.textContent).toBe('替换目录')
|
||
expect(view.container.querySelectorAll('[data-context-entries] li')).toHaveLength(0)
|
||
expect(view.container.querySelector('[data-context-injection-body]')?.getAttribute('data-context-form'))
|
||
.toBe('catalog')
|
||
})
|
||
|
||
it('a catalog whose entries are unreadable falls back to the opaque body', () => {
|
||
const view = render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'context',
|
||
seq: 3,
|
||
content: [{ type: 'text', text: 'catalog prose' }],
|
||
source: { kind: 'skill-catalog', form: 'catalog', entries: 'not-a-list' },
|
||
provenance: { role: 'inject', label: 'skill-catalog' },
|
||
form: 'catalog',
|
||
} as never}
|
||
/>,
|
||
)
|
||
fireEvent.click(view.getByRole('button', { name: /^上下文注入\s*skill-catalog$/ }))
|
||
expect(view.container.querySelector('[data-context-entries]')).toBeNull()
|
||
expect(view.container.querySelector('[data-context-text]')?.textContent).toBe('catalog prose')
|
||
})
|
||
|
||
it('bounds a large catalog and says how many rows it withheld', () => {
|
||
const entries = Array.from({ length: 205 }, (_, index) => ({ name: `s-${index}`, description: 'd' }))
|
||
const view = render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'context', seq: 3, content: [{ type: 'text', text: 'catalog prose' }],
|
||
source: { kind: 'skill-catalog', form: 'catalog', entries },
|
||
provenance: { role: 'inject', label: 'skill-catalog' },
|
||
form: 'catalog',
|
||
} as never}
|
||
/>,
|
||
)
|
||
fireEvent.click(view.getByRole('button', { name: /^上下文注入\s*skill-catalog$/ }))
|
||
expect(view.container.querySelectorAll('[data-context-entries] li')).toHaveLength(200)
|
||
expect(view.container.querySelector('[data-context-entries-truncated]')?.textContent).toBe('…还有 5 条')
|
||
})
|
||
|
||
it('a catalog keeps a content block this version does not know', () => {
|
||
const view = render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'context',
|
||
seq: 3,
|
||
content: [{ type: 'text', text: 'prose' }, { type: 'future-block', payload: 1 }],
|
||
source: { kind: 'skill-catalog', form: 'catalog', entries: [{ name: 'a', description: 'b' }] },
|
||
provenance: { role: 'inject', label: 'skill-catalog' },
|
||
form: 'catalog',
|
||
} as never}
|
||
/>,
|
||
)
|
||
fireEvent.click(view.getByRole('button', { name: /^上下文注入\s*skill-catalog$/ }))
|
||
expect(view.getByText(/未知内容块/)).toBeTruthy()
|
||
})
|
||
|
||
it('an instruction change with an unrecognized action falls back whole', () => {
|
||
// The action decides the word the row shows, so an unknown one cannot be
|
||
// presented as loaded or updated.
|
||
const view = render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'context',
|
||
seq: 3,
|
||
content: [{ type: 'text', text: 'instruction prose' }],
|
||
source: { kind: 'workspace-instructions', form: 'instructions', changes: [{ action: 'merge', path: 'A.md' }] },
|
||
provenance: { role: 'inject', label: 'workspace-instructions' },
|
||
form: 'instructions',
|
||
} as never}
|
||
/>,
|
||
)
|
||
fireEvent.click(view.getByRole('button', { name: /^上下文注入\s*workspace-instructions$/ }))
|
||
expect(view.container.querySelector('[data-context-files]')).toBeNull()
|
||
expect(view.container.querySelector('[data-context-text]')?.textContent).toBe('instruction prose')
|
||
})
|
||
|
||
it('the opaque fallback keeps a form declaration this version cannot present', () => {
|
||
// Otherwise a newer or foreign log's declared shape vanishes from the UI.
|
||
const view = render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'context', seq: 3, content: [{ type: 'text', text: 'x' }],
|
||
source: { kind: 'plugin', plugin: 'later', form: 'a-later-form' },
|
||
provenance: { role: 'inject', label: 'later' },
|
||
form: null,
|
||
} as never}
|
||
/>,
|
||
)
|
||
fireEvent.click(view.getByRole('button', { name: /^上下文注入\s*later$/ }))
|
||
const fields = [...view.container.querySelectorAll('[data-context-fields] dt')].map(node => node.textContent)
|
||
expect(fields).toEqual(['plugin', 'form'])
|
||
})
|
||
|
||
it('the snapshot form attributes each part to the subsystem that produced it', () => {
|
||
const view = render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'context',
|
||
seq: 3,
|
||
content: [{ type: 'text', text: 'Current runtime context.\n\nsandbox\n\nworkspace' }],
|
||
source: {
|
||
kind: 'plugin',
|
||
plugin: '@deepseek-ai/dsh-system-prompt',
|
||
form: 'snapshot',
|
||
sections: [{ name: 'sandbox:policy', text: 'workspace-write' }, { name: 'workspace', text: '/repo' }],
|
||
},
|
||
provenance: { role: 'inject', label: '@deepseek-ai/dsh-system-prompt' },
|
||
form: 'snapshot',
|
||
} as never}
|
||
/>,
|
||
)
|
||
fireEvent.click(view.getByRole('button', { name: /^上下文注入\s*@deepseek-ai\/dsh-system-prompt$/ }))
|
||
const rows = [...view.container.querySelectorAll('[data-context-sections] div')].map(node => node.textContent)
|
||
expect(rows).toEqual(['sandbox:policyworkspace-write', 'workspace/repo'])
|
||
})
|
||
|
||
it('a notice puts its account on the collapsed row', () => {
|
||
// The whole point of the form: readable without expanding.
|
||
const view = render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'context',
|
||
seq: 3,
|
||
content: [{ type: 'text', text: 'background task bash-1 finished.' }],
|
||
source: { kind: 'plugin', plugin: 'tool-tasks', form: 'notice', summary: 'bash pnpm test [status: completed]' },
|
||
provenance: { role: 'inject', label: 'tool-tasks' },
|
||
form: 'notice',
|
||
} as never}
|
||
/>,
|
||
)
|
||
expect(view.container.querySelector('[data-context-summary]')?.textContent)
|
||
.toBe('bash pnpm test [status: completed]')
|
||
expect(view.container.querySelector('[data-context-injection-body]')).toBeNull()
|
||
})
|
||
|
||
it('a notice without its account falls back to the opaque body', () => {
|
||
const view = render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'context', seq: 3, content: [{ type: 'text', text: 'notice prose' }],
|
||
source: { kind: 'plugin', plugin: 'tool-tasks', form: 'notice' },
|
||
provenance: { role: 'inject', label: 'tool-tasks' },
|
||
form: 'notice',
|
||
} as never}
|
||
/>,
|
||
)
|
||
expect(view.container.querySelector('[data-context-summary]')).toBeNull()
|
||
fireEvent.click(view.getByRole('button', { name: /^上下文注入\s*tool-tasks$/ }))
|
||
expect(view.container.querySelector('[data-context-fields]')).not.toBeNull()
|
||
})
|
||
|
||
it('each form falls back to the opaque body when its required facts are unreadable', () => {
|
||
// The fallback chain is the load-bearing wall: every dedicated form must
|
||
// reach it, and the row marker must not claim a form that did not render.
|
||
const cases = [
|
||
{ form: 'snapshot', source: { kind: 'plugin', form: 'snapshot', sections: 'not-a-list' }, label: 'plugin' },
|
||
{ form: 'relay', source: { kind: 'subagent-report', form: 'relay' }, label: 'subagent-report' },
|
||
{ form: 'recall', source: { kind: 'session-reference', form: 'recall', references: [{ label: 'x' }] }, label: 'session-reference' },
|
||
] as const
|
||
for (const { form, source, label } of cases) {
|
||
cleanup()
|
||
const view = render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'context', seq: 3, content: [{ type: 'text', text: `${form} prose` }],
|
||
source, provenance: { role: 'inject', label }, form,
|
||
} as never}
|
||
/>,
|
||
)
|
||
fireEvent.click(view.getByRole('button', { name: new RegExp(`^上下文注入\\s*${label}$`) }))
|
||
expect(view.container.querySelector('[data-context-text]')?.textContent).toBe(`${form} prose`)
|
||
expect(view.container.querySelector('[data-context-injection-body]')?.getAttribute('data-context-form'))
|
||
.toBeNull()
|
||
}
|
||
})
|
||
|
||
it('a snapshot states the supersession its framing line carries', () => {
|
||
const view = render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'context', seq: 3, content: [{ type: 'text', text: 'Current runtime context.' }],
|
||
source: { kind: 'plugin', form: 'snapshot', sections: [{ name: 'sandbox', text: 'w' }] },
|
||
provenance: { role: 'inject', label: 'plugin' },
|
||
form: 'snapshot',
|
||
} as never}
|
||
/>,
|
||
)
|
||
fireEvent.click(view.getByRole('button', { name: /^上下文注入\s*plugin$/ }))
|
||
expect(view.container.querySelector('[data-context-snapshot-supersedes]')?.textContent)
|
||
.toBe('取代先前的快照')
|
||
})
|
||
|
||
it('a relay names the agent that sent it above what it said', () => {
|
||
const view = render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'context',
|
||
seq: 3,
|
||
content: [{ type: 'text', text: 'child report body' }],
|
||
source: { kind: 'subagent-report', form: 'relay', senderSessionId: 'child-7' },
|
||
provenance: { role: 'inject', label: 'subagent-report' },
|
||
form: 'relay',
|
||
} as never}
|
||
/>,
|
||
)
|
||
fireEvent.click(view.getByRole('button', { name: /^上下文注入\s*subagent-report$/ }))
|
||
expect(view.container.querySelector('[data-context-relay-sender]')?.textContent).toBe('来自会话 child-7')
|
||
expect(view.container.querySelector('[data-context-text]')?.textContent).toBe('child report body')
|
||
})
|
||
|
||
it('a recall reports how much of each source session survived the read', () => {
|
||
// Recalled context is bounded on the way in, so hiding the omitted count
|
||
// would overstate what the model received.
|
||
const view = render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'context',
|
||
seq: 3,
|
||
content: [{ type: 'text', text: 'recalled material' }],
|
||
source: {
|
||
kind: 'session-reference',
|
||
form: 'recall',
|
||
version: 1,
|
||
references: [
|
||
{ label: '重构 loader', retainedMessages: 18, omittedMessages: 42, truncated: true },
|
||
{ label: '修 CI', retainedMessages: 3, omittedMessages: 0, truncated: false },
|
||
],
|
||
},
|
||
provenance: { role: 'recall', label: '重构 loader, 修 CI' },
|
||
form: 'recall',
|
||
} as never}
|
||
/>,
|
||
)
|
||
fireEvent.click(view.getByRole('button', { name: /^跨会话召回\s*重构 loader, 修 CI$/ }))
|
||
const rows = [...view.container.querySelectorAll('[data-context-recalls] li')].map(node => node.textContent)
|
||
expect(rows).toEqual(['重构 loader保留 18 条 · 省略 42 条已截断', '修 CI保留 3 条 · 省略 0 条'])
|
||
expect(view.container.querySelector('[data-context-text]')?.textContent).toBe('recalled material')
|
||
})
|
||
|
||
it('unknown nodes retain the generic JSON row', () => {
|
||
const unknownView = render(
|
||
<MessageItem t={t} node={{ kind: 'unknown', seq: 4, type: 'surface/next', data: { x: 1 } } as never} />,
|
||
)
|
||
expect(unknownView.getByText(/未知 surface 事件：surface\/next/)).toBeTruthy()
|
||
})
|
||
|
||
it('a compaction marker discloses its summary and never shows the framed checkpoint', () => {
|
||
const view = render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'compaction', seq: 5, time: 1_000,
|
||
summary: '## 摘要标题\n\n保留的事实。',
|
||
}}
|
||
/>,
|
||
)
|
||
const row = view.getByRole('button', { name: /上下文已压缩/ })
|
||
expect(row.getAttribute('aria-expanded')).toBe('false')
|
||
expect(view.queryByText(/保留的事实/)).toBeNull()
|
||
fireEvent.click(row)
|
||
expect(row.getAttribute('aria-expanded')).toBe('true')
|
||
expect(view.getByRole('heading', { name: '摘要标题' })).toBeTruthy()
|
||
fireEvent.click(row)
|
||
expect(row.getAttribute('aria-expanded')).toBe('false')
|
||
})
|
||
|
||
it('a marker whose provenance fell outside the window is not expandable', () => {
|
||
const view = render(<MessageItem t={t} node={{ kind: 'compaction', seq: 6, time: 1_000, summary: null }} />)
|
||
const row = view.getByRole('button', { name: /上下文已压缩/ })
|
||
expect(row).toHaveProperty('disabled', true)
|
||
expect(row.getAttribute('aria-expanded')).toBeNull()
|
||
expect(view.getByText('压缩摘要不可用')).toBeTruthy()
|
||
fireEvent.click(row) // a disabled control stays collapsed
|
||
expect(row.getAttribute('aria-expanded')).toBeNull()
|
||
})
|
||
|
||
it('collapses retry details behind the durable model retry status', () => {
|
||
vi.useFakeTimers()
|
||
vi.setSystemTime(10_000)
|
||
const view = render(
|
||
<MessageItem
|
||
t={t}
|
||
retryActive
|
||
node={{
|
||
kind: 'model-retry',
|
||
seq: 5,
|
||
time: 10_000,
|
||
retryState: 'scheduled',
|
||
turn: 1,
|
||
step: 0,
|
||
provider: 'mock',
|
||
mode: 'normal',
|
||
policyKey: 'mock-normal',
|
||
retry: 1,
|
||
maxRetries: 2,
|
||
delayMs: 2_500.4,
|
||
failure: { code: 'TRANSPORT', message: '连接被重置' },
|
||
}}
|
||
/>,
|
||
)
|
||
const details = view.container.querySelector('details')
|
||
const summary = view.container.querySelector('summary')
|
||
expect(details?.open).toBe(false)
|
||
expect(details?.dataset.active).toBe('true')
|
||
expect(view.getByRole('status').textContent).toBe('正在重试模型请求（1/2） · 3s')
|
||
expect(view.getByText('重试延迟：').parentElement?.textContent).toBe('重试延迟：2500ms')
|
||
expect(view.getByText('失败原因：').parentElement?.textContent).toBe('失败原因：连接被重置')
|
||
|
||
act(() => { vi.advanceTimersByTime(1_100) })
|
||
expect(view.getByRole('status').textContent).toBe('正在重试模型请求（1/2） · 2s')
|
||
act(() => { vi.advanceTimersByTime(1_000) })
|
||
expect(view.getByRole('status').textContent).toBe('正在重试模型请求（1/2） · 1s')
|
||
|
||
view.rerender(
|
||
<MessageItem
|
||
t={t}
|
||
retryActive
|
||
node={{
|
||
kind: 'model-retry',
|
||
seq: 6,
|
||
time: 12_100,
|
||
retryState: 'scheduled',
|
||
turn: 2,
|
||
step: 0,
|
||
provider: 'mock',
|
||
mode: 'normal',
|
||
policyKey: 'mock-normal',
|
||
retry: 2,
|
||
maxRetries: 2,
|
||
delayMs: 3_500.4,
|
||
failure: { code: 'TRANSPORT', message: '再次断开' },
|
||
}}
|
||
/>,
|
||
)
|
||
expect(view.getByRole('status').textContent).toBe('正在重试模型请求（2/2） · 4s')
|
||
|
||
if (summary === null) throw new Error('retry summary missing')
|
||
fireEvent.click(summary)
|
||
expect(details?.open).toBe(true)
|
||
|
||
view.rerender(
|
||
<MessageItem t={t} node={{
|
||
kind: 'model-retry',
|
||
seq: 6,
|
||
time: 12_100,
|
||
retryState: 'started',
|
||
turn: 2,
|
||
step: 0,
|
||
provider: 'mock',
|
||
mode: 'normal',
|
||
policyKey: 'mock-normal',
|
||
retry: 2,
|
||
maxRetries: 2,
|
||
delayMs: 3_500.4,
|
||
failure: { code: 'TRANSPORT', message: '再次断开' },
|
||
}}
|
||
/>,
|
||
)
|
||
expect(details?.dataset.active).toBeUndefined()
|
||
expect(view.getByRole('status').textContent).toBe('已重试模型请求（2/2） · 4s')
|
||
|
||
view.rerender(
|
||
<MessageItem t={t} node={{
|
||
kind: 'model-retry',
|
||
seq: 7,
|
||
time: 12_100,
|
||
retryState: 'started',
|
||
turn: 3,
|
||
step: 0,
|
||
provider: 'mock',
|
||
mode: 'always',
|
||
policyKey: 'mock-always',
|
||
retry: 3,
|
||
delayMs: 3_500.4,
|
||
failure: { code: 'TRANSPORT', message: '继续重试' },
|
||
}}
|
||
/>,
|
||
)
|
||
expect(view.getByRole('status').textContent).toBe('已重试模型请求（3/∞） · 4s')
|
||
|
||
view.rerender(
|
||
<MessageItem t={t} node={{
|
||
kind: 'model-retry',
|
||
seq: 8,
|
||
time: 12_100,
|
||
retryState: 'cancelled',
|
||
turn: 4,
|
||
step: 0,
|
||
provider: 'mock',
|
||
mode: 'normal',
|
||
policyKey: 'mock-normal',
|
||
retry: 1,
|
||
maxRetries: 2,
|
||
delayMs: 3_500.4,
|
||
failure: { code: 'TRANSPORT', message: '用户取消' },
|
||
}}
|
||
/>,
|
||
)
|
||
expect(view.getByRole('status').textContent).toBe('模型请求重试已取消（1/2） · 4s')
|
||
})
|
||
|
||
it('synchronizes the countdown when an inactive retry becomes active at the one-second floor', () => {
|
||
vi.useFakeTimers()
|
||
vi.setSystemTime(10_000)
|
||
const node = {
|
||
kind: 'model-retry',
|
||
seq: 5,
|
||
time: 10_000,
|
||
retryState: 'scheduled',
|
||
turn: 1,
|
||
step: 0,
|
||
provider: 'mock',
|
||
mode: 'normal',
|
||
policyKey: 'mock-normal',
|
||
retry: 1,
|
||
maxRetries: 2,
|
||
delayMs: 5_000,
|
||
failure: { code: 'TRANSPORT', message: '连接被重置' },
|
||
} as const
|
||
const view = render(<MessageItem t={t} node={node} />)
|
||
expect(view.getByRole('status').textContent).toBe('等待重试模型请求（1/2） · 5s')
|
||
|
||
act(() => { vi.advanceTimersByTime(4_200) })
|
||
view.rerender(<MessageItem t={t} node={node} retryActive />)
|
||
expect(view.getByRole('status').textContent).toBe('正在重试模型请求（1/2） · 1s')
|
||
})
|
||
})
|
||
|
||
describe('formatMessageClock', () => {
|
||
const now = new Date(2026, 6, 29, 10, 0).getTime()
|
||
|
||
it('keeps HH:mm on the same calendar day', () => {
|
||
expect(formatMessageClock(new Date(2026, 6, 29, 14, 24).getTime(), t, now)).toBe('14:24')
|
||
})
|
||
|
||
it('prefixes month and day across days in the same year', () => {
|
||
expect(formatMessageClock(new Date(2026, 0, 1, 14, 24).getTime(), t, now)).toBe('1月1日 14:24')
|
||
})
|
||
|
||
it('prefixes year, month, and day across years', () => {
|
||
expect(formatMessageClock(new Date(2025, 11, 31, 9, 5).getTime(), t, now)).toBe('2025年12月31日 09:05')
|
||
})
|
||
|
||
it('arms the next local midnight from an in-day instant', () => {
|
||
const noon = new Date(2026, 6, 29, 12, 0).getTime()
|
||
expect(startOfLocalDay(noon)).toBe(new Date(2026, 6, 29).getTime())
|
||
expect(msUntilNextLocalMidnight(noon)).toBe(12 * 3_600_000)
|
||
})
|
||
})
|
||
|
||
describe('useCalendarDay boundary refresh', () => {
|
||
beforeEach(() => {
|
||
vi.useFakeTimers()
|
||
})
|
||
afterEach(() => {
|
||
vi.useRealTimers()
|
||
})
|
||
|
||
it('widens a same-day user clock after local midnight', () => {
|
||
const dayStart = new Date(2026, 6, 29, 23, 50).getTime()
|
||
vi.setSystemTime(dayStart)
|
||
const time = new Date(2026, 6, 29, 14, 24).getTime()
|
||
render(
|
||
<MessageItem t={t} node={{
|
||
kind: 'user', seq: 1, time,
|
||
content: [{ type: 'text', text: 'night bubble' }] as never,
|
||
source: null,
|
||
}}
|
||
/>,
|
||
)
|
||
expect(screen.getByText('14:24')).toBeTruthy()
|
||
act(() => {
|
||
vi.advanceTimersByTime(msUntilNextLocalMidnight(dayStart) + 1)
|
||
})
|
||
expect(screen.getByText('7月29日 14:24')).toBeTruthy()
|
||
})
|
||
})
|
||
|
||
describe('small branch tails', () => {
|
||
it('AssistantMarkdown single-line reasoning summary skips the newline cut', () => {
|
||
const view = render(
|
||
<AssistantMarkdown t={t} blocks={[{ kind: 'reasoning', text: 'one-liner' }]} streaming={false} />,
|
||
)
|
||
expect(view.getByText('one-liner')).toBeTruthy()
|
||
})
|
||
|
||
it('finalized content messages expose copy / branch / clock; Think-only and streaming omit them', () => {
|
||
const writeText = vi.fn().mockResolvedValue(undefined)
|
||
Object.defineProperty(navigator, 'clipboard', {
|
||
configurable: true,
|
||
value: { writeText },
|
||
})
|
||
const now = new Date()
|
||
const time = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 14, 24).getTime()
|
||
const onFork = vi.fn()
|
||
const settled = render(
|
||
<AssistantMarkdown
|
||
t={t}
|
||
blocks={[{ kind: 'text', text: 'answer body' }, { kind: 'reasoning', text: 'hidden' }]}
|
||
streaming={false}
|
||
time={time}
|
||
seq={3}
|
||
onFork={onFork}
|
||
/>,
|
||
)
|
||
expect(settled.getByText('14:24')).toBeTruthy()
|
||
expect(settled.getByRole('button', { name: '复制' })).toBeTruthy()
|
||
expect(settled.getByRole('button', { name: '在新对话中分支' })).toBeTruthy()
|
||
fireEvent.click(settled.getByRole('button', { name: '复制' }))
|
||
expect(writeText).toHaveBeenCalledWith('answer body')
|
||
fireEvent.click(settled.getByRole('button', { name: '在新对话中分支' }))
|
||
expect(onFork).toHaveBeenCalledWith(3)
|
||
settled.unmount()
|
||
|
||
const thinkOnly = render(
|
||
<AssistantMarkdown
|
||
t={t}
|
||
blocks={[{ kind: 'reasoning', text: 'only thinking' }]}
|
||
streaming={false}
|
||
time={time}
|
||
/>,
|
||
)
|
||
expect(thinkOnly.queryByRole('button', { name: '复制' })).toBeNull()
|
||
expect(thinkOnly.queryByText('14:24')).toBeNull()
|
||
thinkOnly.unmount()
|
||
|
||
const streaming = render(
|
||
<AssistantMarkdown t={t} blocks={[{ kind: 'text', text: 'partial' }]} streaming time={time} />,
|
||
)
|
||
expect(streaming.queryByRole('button', { name: '复制' })).toBeNull()
|
||
expect(streaming.queryByText('14:24')).toBeNull()
|
||
})
|
||
|
||
it('StatsLine omits the cache-hit segment when no input accounting exists at all', () => {
|
||
// Cache hit is null only when all three prompt buckets are zero (pure
|
||
// output accounting) — any billed input makes it a real 0%.
|
||
const snap = {
|
||
nodes: [{ kind: 'assistant', seq: 1, turn: 1, step: 1, blocks: [], usage: { outputTokens: 10 } }],
|
||
}
|
||
const source = { getSnapshot: () => snap, subscribe: () => () => {} }
|
||
const view = render(
|
||
<StatsLine
|
||
t={t}
|
||
useSession={bindSnapshotSelector(source) as unknown as StatsLineProps['useSession']}
|
||
useProjection={(key: string) => key === 'tokenUsage'
|
||
? { uncachedInputTokens: 0, outputTokens: 10, cacheReadTokens: 0, cacheWriteTokens: 0 }
|
||
: undefined}
|
||
/>,
|
||
)
|
||
expect(view.container.textContent).toBe('1 轮 · 1 步| 输入 0 tok · 输出 10 tok')
|
||
})
|
||
})
|