mirror of
https://github.com/deepseek-ai/deepseek-harness
synced 2026-08-15 21:04:50 +00:00
1394 lines
61 KiB
TypeScript
1394 lines
61 KiB
TypeScript
// @vitest-environment jsdom
|
||
// ChatView behavior: flow derivation, streaming isolation (Profiler counts),
|
||
// Tool seat ownership and selection handoff — driven through a scripted
|
||
// ObservableSnapshot fake, no wire or Tool presentation plugin.
|
||
|
||
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
||
import { Profiler } from 'react'
|
||
import { act, cleanup, fireEvent, render, within } from '@testing-library/react'
|
||
import type {
|
||
AssistantMessageNode, CommandNode, CompactionSummaryNode, ConversationNode, ConversationSnapshot,
|
||
ModelRetryNode, RunningToolCall, SessionId, SessionListState, ToolResultNode, TurnErrorNode,
|
||
UserMessageNode, WorkspaceListState,
|
||
} from '@deepseek-ai/dsh-client-runtime/client'
|
||
import { bindSnapshotSelector } from '@deepseek-ai/dsh-client-web-react'
|
||
import { createSnapshotStore, PendingWait } from '@deepseek-ai/dsh-client-runtime/client'
|
||
import { RpcId } from '@deepseek-ai/dsh-client-connection/client'
|
||
import type { ChatViewSlotProps, SelectionTarget, ToolTreeOwnerProps } from '@deepseek-ai/dsh-client-ui-conversation/client'
|
||
import { makeTranslate } from '@deepseek-ai/dsh-client-test-runtime'
|
||
import { zh as commonZh } from '@deepseek-ai/dsh-client-locale/src/locales/zh.ts'
|
||
import { createChatStore } from '../src/client/stores.ts'
|
||
import { ChatView } from '../src/client/chat/ChatView.tsx'
|
||
import { zh } from '../src/client/locales.ts'
|
||
import { assistantActionsSeqs, assistantBranchSeqs, deriveChatFlow, flowKeys, runningTurnStartTime } from '../src/client/chat/chat-flow.ts'
|
||
import { formatRunDuration } from '../src/client/chat/message-chrome.ts'
|
||
|
||
afterEach(() => {
|
||
cleanup()
|
||
vi.unstubAllGlobals()
|
||
})
|
||
// Keyless create() persists under the bare declared key; clear between cases
|
||
// so one harness's selection cannot rehydrate into the next.
|
||
beforeEach(() => {
|
||
localStorage.clear()
|
||
})
|
||
|
||
const SID = 's1' as SessionId
|
||
|
||
function snapshotBase(): ConversationSnapshot {
|
||
return {
|
||
sessionId: SID, nodes: [], turnTimings: new Map(), turnEnds: new Map(), partial: null, runningCalls: [],
|
||
pending: [], queue: [], running: false, composerPhase: 'active', removed: false, openState: 'open', openError: null,
|
||
hasMore: false, loadingOlder: false, promptError: null, blank: false, subagent: null, lastAgentError: null,
|
||
}
|
||
}
|
||
|
||
/** Scripted snapshot source: set() swaps the top-level object like the real Session. */
|
||
function makeSource(init?: Partial<ConversationSnapshot>) {
|
||
let snap: ConversationSnapshot = { ...snapshotBase(), ...init }
|
||
const subs = new Set<() => void>()
|
||
return {
|
||
set: (next: Partial<ConversationSnapshot>) => {
|
||
snap = { ...snap, ...next }
|
||
for (const fn of [...subs]) fn()
|
||
},
|
||
source: {
|
||
getSnapshot: () => snap,
|
||
subscribe: (fn: () => void) => {
|
||
subs.add(fn)
|
||
return () => subs.delete(fn)
|
||
},
|
||
},
|
||
}
|
||
}
|
||
|
||
const user = (seq: number, text: string): UserMessageNode => ({
|
||
kind: 'user',
|
||
seq,
|
||
time: seq * 1000,
|
||
content: [{ type: 'text', text }] as never,
|
||
source: null,
|
||
})
|
||
const assistant = (seq: number, text: string, turn = 1): AssistantMessageNode => ({
|
||
kind: 'assistant', seq, time: seq * 1_000, turn, step: 1, blocks: [{ kind: 'text', text }],
|
||
})
|
||
const retry = (seq: number): ModelRetryNode => ({
|
||
kind: 'model-retry', seq, time: seq * 1_000, turn: 1, step: 0,
|
||
retryState: 'scheduled',
|
||
provider: 'mock', mode: 'normal', policyKey: 'mock-normal',
|
||
retry: 1, maxRetries: 2, delayMs: 450,
|
||
failure: { code: 'TRANSPORT', message: '连接被重置' },
|
||
})
|
||
const turnError = (seq: number, code?: string): TurnErrorNode => ({
|
||
kind: 'turn-error', seq, time: seq * 1_000, turn: 1, step: 0,
|
||
message: seq === 2 ? 'API key is invalid' : 'plugin exploded',
|
||
...(code === undefined ? {} : { code }),
|
||
})
|
||
const toolResult = (seq: number, callId: string, name = 'bash'): ToolResultNode => ({
|
||
kind: 'tool-result', seq, time: seq * 1_000, callId,
|
||
call: { name, argsRaw: `{"command":"cmd-${callId}","description":"run ${callId}"}` },
|
||
callTime: seq * 1_000 - 500,
|
||
content: [], isError: false, callView: null, resultView: null, subCalls: [],
|
||
})
|
||
const runningCall = (callId: string, name = 'bash'): RunningToolCall => ({
|
||
callId, name, argsRaw: `{"command":"cmd-${callId}"}`, turn: 2, step: 1, time: 1_000, callView: null, subCalls: [],
|
||
})
|
||
const command = (over: Partial<CommandNode> = {}): CommandNode => ({
|
||
kind: 'command', seq: 5, time: 5_000, commandId: 'cmd-1' as CommandNode['commandId'],
|
||
name: 'plan', args: '', outcome: { kind: 'success', text: '已进入 plan mode' },
|
||
...over,
|
||
})
|
||
const compaction = (over: Partial<CompactionSummaryNode> = {}): CompactionSummaryNode => ({
|
||
kind: 'compaction', seq: 8, time: 8_000,
|
||
summary: '## 压缩摘要\n\n保留的事实。',
|
||
summaryEventSeq: 7,
|
||
shadowedItemCount: 16,
|
||
shadowedTokenCount: 11_309,
|
||
...over,
|
||
})
|
||
|
||
/** Empty sessions-list hook for the global standard-kit seat. */
|
||
function emptySessions() {
|
||
const store = createSnapshotStore<SessionListState>(
|
||
{ ids: [], byId: {}, current: undefined, phase: 'ready', subagentsByParent: {}, currentAddress: undefined })
|
||
return bindSnapshotSelector(store)
|
||
}
|
||
|
||
function emptyWorkspaces() {
|
||
const store = createSnapshotStore<WorkspaceListState>({
|
||
items: [], archivedSessionIds: [], state: 'idle', phase: 'ready', error: null,
|
||
baselinesReady: true, recentWorkspaceId: undefined,
|
||
})
|
||
return bindSnapshotSelector(store)
|
||
}
|
||
|
||
function makeHarness(init?: Partial<ConversationSnapshot>) {
|
||
const { set, source } = makeSource(init)
|
||
const openDetails = vi.fn<(t: SelectionTarget) => void>()
|
||
const openFile = vi.fn<(path: string) => void>()
|
||
const loadOlder = vi.fn()
|
||
const inspectCall = vi.fn<(callId: string) => void>()
|
||
// In-memory scroll memory matching the apply.ts per-session map contract.
|
||
let savedScroll: ReturnType<ChatViewSlotProps['chatScroll']['read']> = null
|
||
const chatScroll: ChatViewSlotProps['chatScroll'] = {
|
||
save: (position) => { savedScroll = position },
|
||
read: () => savedScroll,
|
||
}
|
||
const forkAt = vi.fn()
|
||
// Selection rides the REAL chat store (same construction path as
|
||
// production; the view reads it through the PropsStore useStore share).
|
||
const chat = createChatStore().create()
|
||
const t = makeTranslate(zh, commonZh)
|
||
const toolOwners: ToolTreeOwnerProps[] = []
|
||
const renderSlot = ((key: string, owner: object, opts?: { fallback?: React.ReactNode }) => {
|
||
if (key !== 'conversation.chat.tool') return opts?.fallback ?? null
|
||
const tool = owner as ToolTreeOwnerProps
|
||
toolOwners.push(tool)
|
||
// Tool providers own their subtree. The host double carries only the
|
||
// semantic anchor required by ChatView's prepend-position contract.
|
||
return (
|
||
<div
|
||
data-testid={`tool-seat-${tool.callId}`}
|
||
data-chat-anchor-key={`call:${tool.callId}`}
|
||
data-chat-call-id={tool.callId}
|
||
>
|
||
{tool.toolName || '(unnamed)'}:{tool.callId}
|
||
</div>
|
||
)
|
||
}) as unknown as ChatViewSlotProps['renderSlot']
|
||
const renderSlotChain = ((_key: string, _owner: object, opts?: { fallback?: React.ReactNode }) =>
|
||
opts?.fallback ?? null) as unknown as ChatViewSlotProps['renderSlotChain']
|
||
// SessionProvider seat arrives with the session-scope child declaration;
|
||
// ChatView never invokes it (render-prop pass-through stub).
|
||
const SessionProviderStub: ChatViewSlotProps['SessionProvider'] = ({ children }) => <>{children(SID)}</>
|
||
const props: ChatViewSlotProps = {
|
||
sessionId: SID,
|
||
useSession: bindSnapshotSelector(source),
|
||
useSessions: emptySessions(),
|
||
useWorkspaces: emptyWorkspaces(),
|
||
useProjection: (() => undefined),
|
||
useInput: (() => { throw new Error('unused') }),
|
||
inputActions: { setDraft: () => {}, submit: () => {} },
|
||
useStore: bindSnapshotSelector(chat),
|
||
actions: chat.actions,
|
||
renderSlot,
|
||
renderSlotChain,
|
||
SessionProvider: SessionProviderStub,
|
||
openDetails,
|
||
openFile,
|
||
loadOlder,
|
||
inspectCall,
|
||
chatScroll,
|
||
forkAt,
|
||
// Absent-service default; mention tests override with a real resolver.
|
||
fileMentions: () => undefined,
|
||
// Mirrors the real lookup chain (conversation namespace, then common).
|
||
t,
|
||
}
|
||
const setSelection = (next: SelectionTarget | null): void => { chat.actions.select(next) }
|
||
return {
|
||
set, ChatView, props, openDetails, openFile, loadOlder, inspectCall,
|
||
chatScroll, forkAt, setSelection, toolOwners,
|
||
}
|
||
}
|
||
|
||
/** Simulate reader input (any device): a delivered position that deviates
|
||
* from the observed-top ledger of programmatic writes. */
|
||
function readerScroll(element: HTMLElement, top: number): void {
|
||
element.scrollTop = top
|
||
fireEvent.scroll(element)
|
||
}
|
||
|
||
function installScrollMetrics(element: HTMLElement, initialHeight: number, clientHeight: number) {
|
||
let scrollHeight = initialHeight
|
||
let scrollTop = 0
|
||
Object.defineProperty(element, 'scrollHeight', { configurable: true, get: () => scrollHeight })
|
||
Object.defineProperty(element, 'clientHeight', { configurable: true, get: () => clientHeight })
|
||
Object.defineProperty(element, 'scrollTop', {
|
||
configurable: true,
|
||
get: () => scrollTop,
|
||
set: (value: number) => { scrollTop = Math.max(0, Math.min(value, scrollHeight - clientHeight)) },
|
||
})
|
||
return {
|
||
setHeight: (value: number) => { scrollHeight = value },
|
||
setLayout: (height: number, top: number) => {
|
||
scrollHeight = height
|
||
scrollTop = Math.max(0, Math.min(top, scrollHeight - clientHeight))
|
||
},
|
||
}
|
||
}
|
||
|
||
describe('chat-flow derivation', () => {
|
||
it('groups consecutive tool results and keeps stable keys', () => {
|
||
const nodes: ConversationNode[] = [
|
||
user(1, 'hi'), assistant(2, 'let me look'), toolResult(3, 'a'), toolResult(4, 'b'),
|
||
assistant(5, 'found'), toolResult(6, 'c'),
|
||
]
|
||
const items = deriveChatFlow(nodes)
|
||
expect(items.map(i => i.kind)).toEqual(['node', 'node', 'tool-group', 'node', 'tool-group'])
|
||
const group = items[2]!
|
||
expect(group.kind === 'tool-group' && group.results.map(r => r.callId)).toEqual(['a', 'b'])
|
||
expect(flowKeys(items)).toBe('n1|n2|g3|n5|g6')
|
||
expect(flowKeys(deriveChatFlow([...nodes, toolResult(7, 'd')]))).toBe('n1|n2|g3|n5|g6')
|
||
})
|
||
|
||
it('reuses one stable row for consecutive retry turns', () => {
|
||
const first = retry(2)
|
||
const second = { ...retry(3), turn: 2, retry: 2 }
|
||
const initial = deriveChatFlow([user(1, 'try'), first])
|
||
const updated = deriveChatFlow([user(1, 'try'), first, second])
|
||
expect(flowKeys(initial)).toBe('n1|n2')
|
||
expect(flowKeys(updated)).toBe('n1|n2')
|
||
expect(updated).toHaveLength(2)
|
||
expect(updated[1]?.kind === 'node' && updated[1].node).toBe(second)
|
||
})
|
||
|
||
it('folds a successful /compact lifecycle into its explicitly linked checkpoint', () => {
|
||
const running = command({
|
||
seq: 1,
|
||
commandId: 'cmd-compact' as CommandNode['commandId'],
|
||
name: 'compact',
|
||
outcome: null,
|
||
})
|
||
expect(flowKeys(deriveChatFlow([user(0, 'before'), running]))).toBe('n0|ccmd-compact')
|
||
|
||
const settled = {
|
||
...running,
|
||
outcome: { kind: 'success' as const, text: 'Compacted 16 history items.', sourceEventSeq: 3 },
|
||
}
|
||
const checkpoint = compaction({ seq: 4, summaryEventSeq: 3 })
|
||
const items = deriveChatFlow([user(0, 'before'), settled, user(2, 'injected while compacting'), checkpoint])
|
||
expect(flowKeys(items)).toBe('n0|n2|ccmd-compact')
|
||
expect(items.at(-1)).toEqual({
|
||
kind: 'command-compaction',
|
||
key: 'ccmd-compact',
|
||
command: settled,
|
||
compaction: checkpoint,
|
||
})
|
||
})
|
||
|
||
it('does not split adjacent tool results around a folded /compact command', () => {
|
||
const folded = command({
|
||
seq: 2,
|
||
commandId: 'cmd-compact' as CommandNode['commandId'],
|
||
name: 'compact',
|
||
outcome: { kind: 'success', sourceEventSeq: 4 },
|
||
})
|
||
const items = deriveChatFlow([
|
||
toolResult(1, 'a'),
|
||
folded,
|
||
toolResult(3, 'b'),
|
||
compaction({ seq: 5, summaryEventSeq: 4 }),
|
||
])
|
||
expect(flowKeys(items)).toBe('g1|ccmd-compact')
|
||
expect(
|
||
items[0]?.kind === 'tool-group' && items[0].results.map(result => result.callId),
|
||
).toEqual(['a', 'b'])
|
||
})
|
||
|
||
it('keeps automatic, unlinked, and ambiguously linked compactions as separate rows', () => {
|
||
const automatic = compaction({ seq: 2, summaryEventSeq: 1 })
|
||
expect(flowKeys(deriveChatFlow([automatic]))).toBe('n2')
|
||
|
||
const first = command({
|
||
seq: 3,
|
||
commandId: 'cmd-a' as CommandNode['commandId'],
|
||
name: 'compact',
|
||
outcome: { kind: 'success', sourceEventSeq: 9 },
|
||
})
|
||
const second = command({
|
||
seq: 4,
|
||
commandId: 'cmd-b' as CommandNode['commandId'],
|
||
name: 'compact',
|
||
outcome: { kind: 'success', sourceEventSeq: 9 },
|
||
})
|
||
const ambiguous = compaction({ seq: 10, summaryEventSeq: 9 })
|
||
expect(flowKeys(deriveChatFlow([first, second, ambiguous]))).toBe('ccmd-a|ccmd-b|n10')
|
||
|
||
const sole = command({
|
||
seq: 11,
|
||
commandId: 'cmd-sole' as CommandNode['commandId'],
|
||
name: 'compact',
|
||
outcome: { kind: 'success', sourceEventSeq: 12 },
|
||
})
|
||
const duplicateA = compaction({ seq: 13, summaryEventSeq: 12 })
|
||
const duplicateB = compaction({ seq: 14, summaryEventSeq: 12 })
|
||
expect(flowKeys(deriveChatFlow([sole, duplicateA, duplicateB]))).toBe('ccmd-sole|n13|n14')
|
||
})
|
||
|
||
it('skips render-nothing assistant nodes so tool runs stay one group', () => {
|
||
// A tool-call-only step message (and blank text/reasoning) renders nothing:
|
||
// it must not split the run into two groups with an empty line between.
|
||
const headsOnly: AssistantMessageNode = {
|
||
kind: 'assistant', seq: 4, time: 4_000, turn: 1, step: 2,
|
||
blocks: [{ kind: 'tool-call', callId: 'b', name: 'read', argsRaw: '{}' }, { kind: 'text', text: ' \n' }, { kind: 'reasoning', text: '' }],
|
||
}
|
||
const items = deriveChatFlow([toolResult(3, 'a'), headsOnly, toolResult(5, 'b')])
|
||
expect(flowKeys(items)).toBe('g3')
|
||
const group = items[0]!
|
||
expect(group.kind === 'tool-group' && group.results.map(r => r.callId)).toEqual(['a', 'b'])
|
||
// Interrupted and visible-content nodes still render (已停止 marker / prose).
|
||
expect(flowKeys(deriveChatFlow([toolResult(3, 'a'), { ...headsOnly, interrupted: true }, toolResult(5, 'b')]))).toBe('g3|n4|g5')
|
||
expect(flowKeys(deriveChatFlow([toolResult(3, 'a'), assistant(4, 'found'), toolResult(5, 'b')]))).toBe('g3|n4|g5')
|
||
})
|
||
|
||
it('assistantActionsSeqs keeps only the last content assistant per completed turn', () => {
|
||
const thinkOnly: AssistantMessageNode = {
|
||
kind: 'assistant', seq: 3, time: 3_000, turn: 1, step: 2,
|
||
blocks: [{ kind: 'reasoning', text: 'planning' }],
|
||
}
|
||
const nodes: ConversationNode[] = [
|
||
user(1, 'hi'),
|
||
assistant(2, 'looking', 1),
|
||
thinkOnly,
|
||
toolResult(4, 'a'),
|
||
assistant(5, 'done', 1),
|
||
user(6, 'again'),
|
||
assistant(7, 'second turn', 2),
|
||
]
|
||
expect([...assistantActionsSeqs(nodes, new Map([[1, 5], [2, 7]]))].sort((a, b) => a - b)).toEqual([5, 7])
|
||
// Turn 2 is still producing steps: its latest narration owns nothing, and
|
||
// the settled turn 1 keeps its seat.
|
||
expect([...assistantActionsSeqs(nodes, new Map([[1, 5]]))]).toEqual([5])
|
||
})
|
||
|
||
it('threads the injected file-mention vocabulary into the closing prose only', () => {
|
||
const wrote = (seq: number, callId: string, path: string): ToolResultNode => ({
|
||
...toolResult(seq, callId, 'write'),
|
||
callView: {
|
||
card: 'diff', title: 'Write', diffs: [{ path, oldText: null, newText: 'x' }], locations: [{ path }],
|
||
},
|
||
})
|
||
const h = makeHarness({
|
||
nodes: [
|
||
user(1, 'build it'),
|
||
assistant(2, 'writing `report.html` now', 1),
|
||
wrote(3, 'w', 'site/report.html'),
|
||
assistant(4, 'Wrote `report.html`; `notes.md` untouched.', 1),
|
||
],
|
||
turnEnds: new Map([[1, 4]]),
|
||
})
|
||
// Stub provider mirroring the real service: only produced files resolve.
|
||
h.props.fileMentions = owner => ({
|
||
resolve: (value) => {
|
||
if (value !== 'report.html') return undefined
|
||
return {
|
||
open: () => { h.openFile(`for-seq-${String(owner.seq)}/site/report.html`) },
|
||
label: '打开 site/report.html',
|
||
title: 'site/report.html',
|
||
}
|
||
},
|
||
})
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
// Exactly one live mention: the closing message links, the mid-turn
|
||
// narration stays inert code, and the unknown file resolves to nothing.
|
||
const mentions = view.container.querySelectorAll('code button')
|
||
expect(mentions).toHaveLength(1)
|
||
const mention = view.getByRole('button', { name: '打开 site/report.html' })
|
||
expect(mention.getAttribute('title')).toBe('site/report.html')
|
||
fireEvent.click(mention)
|
||
// The vocabulary was built from the closing message's own owner currency.
|
||
expect(h.openFile).toHaveBeenCalledWith('for-seq-4/site/report.html')
|
||
})
|
||
|
||
it('runningTurnStartTime selects the latest turn/start without a turn/end', () => {
|
||
expect(runningTurnStartTime(new Map([
|
||
[1, { startTime: 1_000, endTime: 5_000 }],
|
||
[2, { startTime: 6_000 }],
|
||
]))).toBe(6_000)
|
||
expect(runningTurnStartTime(new Map([
|
||
[1, { startTime: 1_000, endTime: 5_000 }],
|
||
[2, { startTime: 6_000, endTime: 9_000 }],
|
||
]))).toBeNull()
|
||
})
|
||
|
||
it('formatRunDuration localizes units and floors partial seconds', () => {
|
||
const t = makeTranslate(zh, commonZh)
|
||
expect(formatRunDuration(0, t)).toBe('0秒')
|
||
expect(formatRunDuration(-500, t)).toBe('0秒')
|
||
expect(formatRunDuration(15_999, t)).toBe('15秒')
|
||
expect(formatRunDuration(125_000, t)).toBe('2分05秒')
|
||
})
|
||
|
||
it('assistantBranchSeqs keeps only content-assistant tails; user/steering tails own no branch', () => {
|
||
const interruptedThink: AssistantMessageNode = {
|
||
kind: 'assistant', seq: 4.1, time: 4_100, turn: 1, step: 2,
|
||
blocks: [{ kind: 'reasoning', text: 'bad path' }], interrupted: true,
|
||
}
|
||
const nodes: ConversationNode[] = [
|
||
user(1, 'first'),
|
||
assistant(2, 'answer before tools'),
|
||
toolResult(3, 'a'),
|
||
interruptedThink,
|
||
user(6, 'second'),
|
||
assistant(7, 'clean tail', 2),
|
||
user(10, 'user-only tail'),
|
||
user(13, 'steering tail'),
|
||
]
|
||
const seqs = assistantBranchSeqs(nodes, new Map([[1, 5], [2, 8], [3, 11], [4, 14]]))
|
||
expect([...seqs]).toEqual([7])
|
||
})
|
||
})
|
||
|
||
describe('ChatView', () => {
|
||
it('hands a windowless tool result to the Tool seat with an empty tool name', () => {
|
||
const h = makeHarness({
|
||
nodes: [{ ...toolResult(3, 'w1'), call: null }],
|
||
})
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
expect(view.getByTestId('tool-seat-w1')).toBeTruthy()
|
||
expect(h.toolOwners[0]).toMatchObject({ callId: 'w1', toolName: '' })
|
||
})
|
||
|
||
it('prepend keeps the reader\'s latest pending-request scroll position anchored', () => {
|
||
const h = makeHarness({ nodes: [user(9, 'first visible'), user(10, 'next visible')], hasMore: true })
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
const scroller = view.container.querySelector('[class*="scroll"]') as HTMLDivElement
|
||
const first = view.container.querySelector('[data-chat-flow-key="n9"]') as HTMLDivElement
|
||
const next = view.container.querySelector('[data-chat-flow-key="n10"]') as HTMLDivElement
|
||
let firstTop = 100
|
||
let nextTop = 300
|
||
vi.spyOn(scroller, 'getBoundingClientRect').mockImplementation(
|
||
() => ({ top: 0, bottom: 200 } as DOMRect),
|
||
)
|
||
vi.spyOn(first, 'getBoundingClientRect').mockImplementation(
|
||
() => ({ top: firstTop, bottom: firstTop + 40 } as DOMRect),
|
||
)
|
||
vi.spyOn(next, 'getBoundingClientRect').mockImplementation(
|
||
() => ({ top: nextTop, bottom: nextTop + 40 } as DOMRect),
|
||
)
|
||
Object.defineProperty(scroller, 'scrollHeight', { value: 800, writable: true })
|
||
Object.defineProperty(scroller, 'clientHeight', { value: 200, writable: true })
|
||
readerScroll(scroller, 50)
|
||
fireEvent.click(view.getByText('加载更早'))
|
||
// The reader moves after the request starts; this, not the click-time
|
||
// row, is the intent the arriving page must preserve.
|
||
firstTop = -200
|
||
nextTop = 60
|
||
readerScroll(scroller, 90)
|
||
Object.defineProperty(scroller, 'scrollHeight', { value: 1300, writable: true })
|
||
nextTop = 560
|
||
act(() => { h.set({ nodes: [assistant(2, 'older'), user(9, 'first visible'), user(10, 'next visible')] }) })
|
||
expect(scroller.scrollTop).toBe(590) // latest 90 + the anchored row's 500px prepend shift
|
||
})
|
||
|
||
it('renders the fixture main line: bubble, narration, grouped tool rows', () => {
|
||
const h = makeHarness({
|
||
nodes: [user(1, 'do the thing'), assistant(2, 'running tools'), toolResult(3, 'a'), toolResult(4, 'b')],
|
||
})
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
expect(view.getByText('do the thing')).toBeTruthy()
|
||
expect(view.getByText('running tools')).toBeTruthy()
|
||
expect(view.getByTestId('tool-seat-a').textContent).toBe('bash:a')
|
||
expect(view.getByTestId('tool-seat-b').textContent).toBe('bash:b')
|
||
expect([...view.container.querySelectorAll('[data-chat-flow-key]')].map(row => ({
|
||
key: row.getAttribute('data-chat-flow-key'),
|
||
kind: row.getAttribute('data-chat-flow-kind'),
|
||
}))).toEqual([
|
||
{ key: 'n1', kind: 'user' },
|
||
{ key: 'n2', kind: 'assistant' },
|
||
{ key: 'g3', kind: 'tool-group' },
|
||
])
|
||
expect([...view.container.querySelectorAll('[data-chat-call-id]')].map(row => row.getAttribute('data-chat-call-id')))
|
||
.toEqual(['a', 'b'])
|
||
expect([...view.container.querySelectorAll('[data-chat-anchor-key]')].map(row => row.getAttribute('data-chat-anchor-key')))
|
||
.toEqual(['node:1', 'node:2', 'call:a', 'call:b'])
|
||
})
|
||
|
||
it('renders Host-pending steering at the flow tail and hands off to the durable node', () => {
|
||
const writeText = vi.fn().mockResolvedValue(undefined)
|
||
Object.defineProperty(navigator, 'clipboard', {
|
||
configurable: true,
|
||
value: { writeText },
|
||
})
|
||
const pending = {
|
||
id: 'steer-occurrence' as never,
|
||
messageId: 'steer-message' as never,
|
||
placement: 'steering' as const,
|
||
content: [{ type: 'text' as const, text: 'interrupt now' }],
|
||
preview: 'interrupt now',
|
||
text: 'interrupt now',
|
||
}
|
||
const queued = {
|
||
id: 'queued-occurrence' as never,
|
||
messageId: 'queued-message' as never,
|
||
placement: 'queued' as const,
|
||
content: [{ type: 'text' as const, text: 'later' }],
|
||
preview: 'later',
|
||
text: 'later',
|
||
}
|
||
const h = makeHarness({ nodes: [assistant(1, 'working')], queue: [queued, pending], running: true })
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
|
||
expect(view.getByText('interrupt now').closest('[data-pending-steering]')).not.toBeNull()
|
||
expect(view.queryByText('later')).toBeNull()
|
||
const pendingBubble = view.getByText('interrupt now').closest('[data-pending-steering]')
|
||
expect(pendingBubble).not.toBeNull()
|
||
// Pending and durable steering carry the same interjection caption, so the
|
||
// hand-off does not change what the row says it is.
|
||
expect(within(pendingBubble as HTMLElement).getByText('插话')).toBeTruthy()
|
||
fireEvent.click(within(pendingBubble as HTMLElement).getByRole('button', { name: '复制' }))
|
||
expect(writeText).toHaveBeenCalledWith('interrupt now')
|
||
expect(within(pendingBubble as HTMLElement).queryByRole('button', { name: '在新对话中分支' })).toBeNull()
|
||
expect(view.getByRole('status').compareDocumentPosition(view.getByText('interrupt now'))
|
||
& Node.DOCUMENT_POSITION_FOLLOWING).not.toBe(0)
|
||
|
||
act(() => {
|
||
h.set({
|
||
queue: [queued],
|
||
nodes: [
|
||
assistant(1, 'working'),
|
||
{
|
||
kind: 'steering', messageId: pending.messageId,
|
||
seq: 2, time: 2_000,
|
||
content: [{ type: 'text', text: 'interrupt now' }], source: null,
|
||
},
|
||
],
|
||
})
|
||
})
|
||
expect(view.getAllByText('interrupt now')).toHaveLength(1)
|
||
expect(view.container.querySelector('[data-pending-steering]')).toBeNull()
|
||
expect(view.getAllByText('插话')).toHaveLength(1)
|
||
// Only the durable steering bubble: the turn is still running, so its
|
||
// assistant narration owns no footer yet, and a steering bubble never
|
||
// carries a branch action.
|
||
expect(view.getAllByRole('button', { name: '复制' })).toHaveLength(1)
|
||
const durableBubble = view.getByText('interrupt now').closest('[class*="userRow"]') as HTMLElement
|
||
expect(within(durableBubble).queryByRole('button', { name: '在新对话中分支' })).toBeNull()
|
||
|
||
act(() => {
|
||
h.set({ running: false, turnEnds: new Map([[1, 3]]) })
|
||
})
|
||
// The completed turn's transcript tail is the steering bubble, not the
|
||
// narration, so the assistant's branch action stays unavailable and the
|
||
// steering bubble still offers none.
|
||
const branchButtons = view.getAllByRole('button', { name: '在新对话中分支' })
|
||
expect(branchButtons).toHaveLength(1)
|
||
expect(branchButtons[0]!.getAttribute('aria-disabled')).toBe('true')
|
||
fireEvent.click(branchButtons[0]!)
|
||
expect(h.forkAt).not.toHaveBeenCalled()
|
||
})
|
||
|
||
it('keeps a later pending occurrence visible when it reuses a durable MessageId', () => {
|
||
const pending = {
|
||
id: 'steer-occurrence-later' as never,
|
||
messageId: 'shared-steer-message' as never,
|
||
placement: 'steering' as const,
|
||
content: [{ type: 'text' as const, text: 'same steering' }],
|
||
preview: 'same steering',
|
||
text: 'same steering',
|
||
}
|
||
const h = makeHarness({
|
||
queue: [pending],
|
||
nodes: [{
|
||
kind: 'user', seq: 2, time: 2_000,
|
||
content: pending.content, source: null,
|
||
}],
|
||
running: true,
|
||
})
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
|
||
expect(view.getAllByText('same steering')).toHaveLength(2)
|
||
expect(view.container.querySelectorAll('[data-pending-steering]')).toHaveLength(1)
|
||
})
|
||
|
||
it('animates only the latest unresolved model retry', () => {
|
||
const retryNode = retry(2)
|
||
const nextRetry = { ...retry(3), turn: 2, retry: 2 }
|
||
const context = {
|
||
kind: 'context', seq: 4, time: 4_000, content: [], source: null,
|
||
provenance: { role: 'inject', label: null },
|
||
form: null,
|
||
} as const satisfies ConversationNode
|
||
const h = makeHarness({ nodes: [user(1, 'try'), retryNode], running: true })
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
const disclosure = view.container.querySelector('details') as HTMLDetailsElement
|
||
expect(disclosure.dataset.active).toBe('true')
|
||
expect(within(disclosure).getByRole('status').textContent).toBe('正在重试模型请求（1/2） · 1s')
|
||
|
||
act(() => {
|
||
h.set({ nodes: [user(1, 'try'), retryNode, nextRetry] })
|
||
})
|
||
expect(within(disclosure).getAllByRole('status')).toHaveLength(1)
|
||
expect(view.container.querySelector('details')).toBe(disclosure)
|
||
expect(within(disclosure).getByRole('status').textContent).toBe('正在重试模型请求（2/2） · 1s')
|
||
|
||
act(() => {
|
||
h.set({
|
||
nodes: [
|
||
user(1, 'try'),
|
||
retryNode,
|
||
{ ...nextRetry, retryState: 'started' },
|
||
context,
|
||
assistant(5, 'done'),
|
||
],
|
||
running: false,
|
||
})
|
||
})
|
||
expect(disclosure.dataset.active).toBeUndefined()
|
||
expect(within(disclosure).getByRole('status').textContent).toBe('已重试模型请求（2/2） · 1s')
|
||
|
||
act(() => {
|
||
h.set({ nodes: [user(1, 'try'), { ...retry(6), retryState: 'cancelled' }], running: true })
|
||
})
|
||
const cancelledDisclosure = view.container.querySelector('details') as HTMLDetailsElement
|
||
expect(cancelledDisclosure.dataset.active).toBeUndefined()
|
||
expect(within(cancelledDisclosure).getByRole('status').textContent).toContain('重试已取消')
|
||
})
|
||
|
||
it('renders terminal turn failures inline with their durable message and optional code', () => {
|
||
const h = makeHarness({ nodes: [user(1, 'try'), turnError(2, 'AUTH'), turnError(3)] })
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
const statuses = view.getAllByRole('status')
|
||
expect(statuses.map(status => status.textContent)).toEqual([
|
||
'本轮运行失败API key is invalidAUTH',
|
||
'本轮运行失败plugin exploded',
|
||
])
|
||
})
|
||
|
||
it('hands the trajectory callback to the Tool seat', () => {
|
||
const h = makeHarness({
|
||
nodes: [toolResult(3, 'a')],
|
||
})
|
||
render(<h.ChatView {...h.props} />)
|
||
expect(h.toolOwners[0]?.inspectCall).toBe(h.inspectCall)
|
||
})
|
||
|
||
it('shows assistant IconActions only on the last content message of each turn', () => {
|
||
const h = makeHarness({
|
||
nodes: [
|
||
user(1, 'hi'),
|
||
assistant(2, 'mid-turn text'),
|
||
toolResult(3, 'a'),
|
||
assistant(4, 'final answer'),
|
||
user(5, 'next'),
|
||
assistant(6, 'second turn', 2),
|
||
],
|
||
turnEnds: new Map([[1, 4], [2, 6]]),
|
||
})
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
// Branch renders only under assistant answers; user bubbles keep copy alone.
|
||
expect(view.getAllByRole('button', { name: '复制' })).toHaveLength(4)
|
||
const branchButtons = view.getAllByRole('button', { name: '在新对话中分支' })
|
||
expect(branchButtons).toHaveLength(2)
|
||
expect(branchButtons.map(button => button.getAttribute('aria-disabled'))).toEqual([null, null])
|
||
})
|
||
|
||
it('withholds assistant IconActions while the turn is still running', () => {
|
||
const h = makeHarness({
|
||
running: true,
|
||
runningCalls: [runningCall('a')],
|
||
nodes: [
|
||
user(1, 'first'),
|
||
assistant(2, 'previous answer', 1),
|
||
user(4, 'second'),
|
||
assistant(5, 'mid-turn text', 2),
|
||
],
|
||
// Boundary seqs follow the log: a turn/end is strictly after its own nodes.
|
||
turnEnds: new Map([[1, 3]]),
|
||
})
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
// 2 user + the settled turn-1 tail, which keeps its seat while a later
|
||
// turn runs; turn 2's narration stays chrome-free while its tool runs, so
|
||
// the footer never appears and then moves.
|
||
expect(view.getAllByRole('button', { name: '复制' })).toHaveLength(3)
|
||
expect(view.getByText('mid-turn text')).toBeTruthy()
|
||
// turn/end lands: the same node becomes the settled answer and takes the seat.
|
||
act(() => { h.set({ running: false, runningCalls: [], turnEnds: new Map([[1, 3], [2, 6]]) }) })
|
||
expect(view.getAllByRole('button', { name: '复制' })).toHaveLength(4)
|
||
})
|
||
|
||
it('the actions-owning assistant footer shows the turn run time', () => {
|
||
const h = makeHarness({
|
||
nodes: [
|
||
user(1, 'hi'), // time 1_000
|
||
assistant(2, 'mid-turn text'),
|
||
assistant(16, 'final answer'),
|
||
toolResult(18, 'trailing'),
|
||
],
|
||
turnTimings: new Map([[1, { startTime: 1_000, endTime: 20_000 }]]),
|
||
turnEnds: new Map([[1, 20]]),
|
||
})
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
// The exact turn/end includes trailing tool activity after the final text.
|
||
expect(view.getAllByText(/用时 19秒/)).toHaveLength(1)
|
||
})
|
||
|
||
it('the settled footer appends first-step ttft and turn decode throughput', () => {
|
||
const first: AssistantMessageNode = {
|
||
kind: 'assistant', seq: 2, time: 2_000, turn: 1, step: 1, blocks: [{ kind: 'text', text: 'mid' }],
|
||
timing: { stepStartTime: 1_000, firstTokenTime: 2_200, completedTime: 5_200 },
|
||
usage: { outputTokens: 40 },
|
||
}
|
||
const second: AssistantMessageNode = {
|
||
kind: 'assistant', seq: 16, time: 16_000, turn: 1, step: 2, blocks: [{ kind: 'text', text: 'final' }],
|
||
timing: { stepStartTime: 10_000, firstTokenTime: 10_200, completedTime: 12_200 },
|
||
usage: { outputTokens: 60 },
|
||
}
|
||
const h = makeHarness({
|
||
nodes: [user(1, 'hi'), first, second],
|
||
turnTimings: new Map([[1, { startTime: 1_000, endTime: 20_000 }]]),
|
||
turnEnds: new Map([[1, 20]]),
|
||
})
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
// First-step ttft (1.2s) plus 100 tokens over 5s of decode.
|
||
expect(view.getAllByText(/用时 19秒/)).toHaveLength(1)
|
||
expect(view.getAllByText(/首 token 1\.2秒/)).toHaveLength(1)
|
||
expect(view.getAllByText(/20 tok\/s/)).toHaveLength(1)
|
||
})
|
||
|
||
it('withholds ttft and throughput while the turn is still running', () => {
|
||
const settled: AssistantMessageNode = {
|
||
kind: 'assistant', seq: 2, time: 2_000, turn: 1, step: 1, blocks: [{ kind: 'text', text: 'answer' }],
|
||
timing: { stepStartTime: 1_000, firstTokenTime: 1_500, completedTime: 2_000 },
|
||
usage: { outputTokens: 10 },
|
||
}
|
||
const h = makeHarness({
|
||
nodes: [user(1, 'hi'), settled],
|
||
turnTimings: new Map([[1, { startTime: 1_000 }]]),
|
||
turnEnds: new Map(),
|
||
running: true,
|
||
})
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
expect(view.queryByText(/首 token|tok\/s/)).toBeNull()
|
||
})
|
||
|
||
it('user and assistant message containers scope the hover-revealed time chrome', () => {
|
||
const h = makeHarness({
|
||
nodes: [user(1, 'hi'), assistant(2, 'answer')],
|
||
turnTimings: new Map([[1, { startTime: 1_000, endTime: 2_000 }]]),
|
||
turnEnds: new Map([[1, 2]]),
|
||
})
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
// One scope per message row; the CSS reveal keys off this attribute.
|
||
expect(view.container.querySelectorAll('[data-time-hover-root]')).toHaveLength(2)
|
||
})
|
||
|
||
it('the run-time label is withheld when the turn start is outside the window', () => {
|
||
const h = makeHarness({
|
||
nodes: [assistant(16, 'tail without trigger')],
|
||
turnEnds: new Map([[1, 16]]),
|
||
})
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
expect(view.queryByText(/用时/)).toBeNull()
|
||
})
|
||
|
||
it('enables fork only on the finalized assistant at the completed transcript tail', () => {
|
||
const h = makeHarness({
|
||
nodes: [user(1, 'question'), assistant(2, 'answer')],
|
||
turnEnds: new Map([[1, 3]]),
|
||
})
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
// The user bubble offers no branch; the settled answer's is live.
|
||
const buttons = view.getAllByRole('button', { name: '在新对话中分支' })
|
||
expect(buttons).toHaveLength(1)
|
||
expect(buttons[0]!.getAttribute('aria-disabled')).toBeNull()
|
||
fireEvent.click(buttons[0]!)
|
||
expect(h.forkAt.mock.calls).toEqual([[2]])
|
||
})
|
||
|
||
it('keeps branch visible but unavailable when tool and interrupted Think follow the response', () => {
|
||
const interruptedThink: AssistantMessageNode = {
|
||
kind: 'assistant', seq: 4.1, time: 4_100, turn: 1, step: 2,
|
||
blocks: [{ kind: 'reasoning', text: 'bad path' }], interrupted: true,
|
||
}
|
||
const h = makeHarness({
|
||
nodes: [user(1, 'question'), assistant(2, 'answer'), toolResult(3, 'a'), interruptedThink],
|
||
turnEnds: new Map([[1, 5]]),
|
||
})
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
expect(view.getAllByRole('button', { name: '复制' })).toHaveLength(2)
|
||
const buttons = view.getAllByRole('button', { name: '在新对话中分支' })
|
||
expect(buttons).toHaveLength(1)
|
||
expect(buttons[0]!.getAttribute('aria-disabled')).toBe('true')
|
||
fireEvent.click(buttons[0]!)
|
||
expect(h.forkAt).not.toHaveBeenCalled()
|
||
})
|
||
|
||
it('renders assistant Markdown across history, streaming, final, and interrupted states while user text stays literal', () => {
|
||
const markdown = '# Rendered\n\n- **one**\n- `two`'
|
||
const h = makeHarness({ nodes: [user(1, markdown), assistant(2, markdown)] })
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
expect(view.container.querySelectorAll('h1')).toHaveLength(1)
|
||
const literal = view.getByText((_content, element) => (
|
||
element?.tagName === 'DIV' && element.childElementCount === 0 && element.textContent === markdown
|
||
))
|
||
expect(literal.querySelector('h1')).toBeNull()
|
||
|
||
act(() => {
|
||
h.set({ partial: { turn: 2, step: 1, blocks: [{ kind: 'text', text: markdown }] } })
|
||
})
|
||
expect(view.container.querySelectorAll('h1')).toHaveLength(2)
|
||
expect(view.container.querySelector('[data-streaming="true"] h1')?.textContent).toBe('Rendered')
|
||
|
||
act(() => {
|
||
h.set({
|
||
nodes: [user(1, markdown), assistant(2, markdown), assistant(3, markdown)],
|
||
partial: null,
|
||
})
|
||
})
|
||
expect(view.container.querySelectorAll('h1')).toHaveLength(2)
|
||
expect(view.container.querySelector('[data-streaming="true"]')).toBeNull()
|
||
|
||
act(() => {
|
||
h.set({
|
||
nodes: [
|
||
user(1, markdown),
|
||
assistant(2, markdown),
|
||
{ ...assistant(3, markdown), interrupted: true },
|
||
],
|
||
})
|
||
})
|
||
expect(view.getByText('已停止')).toBeTruthy()
|
||
expect(view.container.querySelectorAll('h1')).toHaveLength(2)
|
||
})
|
||
|
||
it('streaming partial frames re-render only the tail (Profiler count)', () => {
|
||
const h = makeHarness({
|
||
nodes: [user(1, 'q'), assistant(2, 'old answer'), toolResult(3, 'a')],
|
||
})
|
||
let renders = 0
|
||
const counting = (
|
||
<Profiler id="chat" onRender={() => { renders += 1 }}>
|
||
<h.ChatView {...h.props} />
|
||
</Profiler>
|
||
)
|
||
const view = render(counting)
|
||
const before = renders
|
||
const beforeHtml = view.container.querySelector('[class*="toolGroup"]')!.innerHTML
|
||
act(() => {
|
||
h.set({ partial: { turn: 2, step: 1, blocks: [{ kind: 'text', text: 'streaming…' }] } })
|
||
})
|
||
act(() => {
|
||
h.set({ partial: { turn: 2, step: 1, blocks: [{ kind: 'text', text: 'streaming… more' }] } })
|
||
})
|
||
expect(view.getByText('streaming… more')).toBeTruthy()
|
||
// Each chunk commits exactly one profiler pass (the tail), never a full-tree storm.
|
||
expect(renders - before).toBe(2)
|
||
expect(view.container.querySelector('[class*="toolGroup"]')!.innerHTML).toBe(beforeHtml)
|
||
})
|
||
|
||
it('streaming leaves neighbor tool rows and history items at zero re-renders', () => {
|
||
const h = makeHarness({
|
||
nodes: [user(1, 'q'), assistant(2, 'old'), toolResult(3, 'a')],
|
||
})
|
||
// Count renderSlot invocations: the memo boundary holds when CallRow does
|
||
// not re-render, so the row's renderSlot call count freezes during chunks.
|
||
let rowRenders = 0
|
||
h.props.renderSlot = ((key: string, _owner: object) => {
|
||
if (key !== 'conversation.chat.tool') return null
|
||
rowRenders += 1
|
||
return <div data-testid="counting-row" />
|
||
})
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
expect(view.getByTestId('counting-row')).toBeTruthy()
|
||
const afterMount = rowRenders
|
||
act(() => {
|
||
h.set({ partial: { turn: 2, step: 1, blocks: [{ kind: 'text', text: 'chunk1' }] } })
|
||
})
|
||
act(() => {
|
||
h.set({ partial: { turn: 2, step: 1, blocks: [{ kind: 'text', text: 'chunk1 chunk2' }] } })
|
||
})
|
||
expect(rowRenders).toBe(afterMount)
|
||
})
|
||
|
||
it('updates the selected call id handed to the Tool seat', () => {
|
||
const h = makeHarness({ nodes: [toolResult(3, 'a')] })
|
||
render(<h.ChatView {...h.props} />)
|
||
expect(h.toolOwners.at(-1)?.selectedCallId).toBeUndefined()
|
||
act(() => { h.setSelection({ turnSeq: 3, callId: 'a', toolName: 'bash' }) })
|
||
expect(h.toolOwners.at(-1)?.selectedCallId).toBe('a')
|
||
})
|
||
|
||
it('hands running calls to a live Tool group', () => {
|
||
const h = makeHarness({ runningCalls: [runningCall('r1')], running: true })
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
expect(view.getByTestId('tool-seat-r1')).toBeTruthy()
|
||
expect(h.toolOwners[0]?.block).toMatchObject({ callId: 'r1', argsRaw: '{"command":"cmd-r1"}' })
|
||
expect(view.getByRole('status').textContent).toBe('Deep diving...')
|
||
})
|
||
|
||
it('the running clock uses turn/start, ignores steering, and stays out of the live region', () => {
|
||
const startTime = Date.now() - 125_000
|
||
const trigger: UserMessageNode = { ...user(1, 'go'), time: startTime + 1 }
|
||
const h = makeHarness({
|
||
nodes: [trigger], turnTimings: new Map([[1, { startTime }]]), running: true,
|
||
})
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
// Freshly mounted (as after a reload) yet already past the 15s gate.
|
||
const status = view.getByRole('status')
|
||
expect(status.textContent).toMatch(/^Deep diving\.\.\.2分0\d秒$/)
|
||
expect(status.querySelector('[aria-hidden="true"]')).not.toBeNull()
|
||
act(() => {
|
||
h.set({ queue: [{
|
||
id: 'steering-occurrence' as never,
|
||
messageId: 'steering-message' as never,
|
||
placement: 'steering',
|
||
content: [{ type: 'text', text: 'also' }],
|
||
preview: 'also',
|
||
text: 'also',
|
||
}] })
|
||
})
|
||
expect(status.textContent).toMatch(/^Deep diving\.\.\.2分0\d秒$/)
|
||
})
|
||
|
||
it('hands each ordered root call to the whole-Tool slot', () => {
|
||
const block = toolResult(3, 'a')
|
||
const h = makeHarness({ nodes: [block] })
|
||
const calls: { key: string; owner: object; entryKey?: string }[] = []
|
||
h.props.renderSlot = ((key: string, owner: object, opts?: { entryKey?: string; fallback?: React.ReactNode }) => {
|
||
calls.push({ key, owner, ...(opts?.entryKey !== undefined ? { entryKey: opts.entryKey } : {}) })
|
||
return opts?.fallback ?? null
|
||
})
|
||
render(<h.ChatView {...h.props} />)
|
||
expect(calls).toHaveLength(1)
|
||
expect(calls[0]).toMatchObject({
|
||
key: 'conversation.chat.tool',
|
||
owner: { callId: 'a', toolName: 'bash', selectedCallId: undefined },
|
||
})
|
||
const owner = calls[0]?.owner as ToolTreeOwnerProps
|
||
expect(owner.block).toBe(block)
|
||
expect(owner.openFile).toBe(h.openFile)
|
||
expect(owner.inspectCall).toBe(h.inspectCall)
|
||
expect(calls[0]?.entryKey).toBeUndefined()
|
||
})
|
||
|
||
it('prepend preserves a semantic row; a trailing user node force-scrolls', () => {
|
||
const h = makeHarness({ nodes: [user(5, 'later'), assistant(6, 'a')], hasMore: true })
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
const scroller = view.container.querySelector('[class*="scroll"]') as HTMLDivElement
|
||
// jsdom has no layout: fake the metrics the anchor math reads.
|
||
Object.defineProperty(scroller, 'scrollHeight', { value: 1000, writable: true })
|
||
Object.defineProperty(scroller, 'clientHeight', { value: 400, writable: true })
|
||
const anchored = view.container.querySelector('[data-chat-flow-key="n5"]') as HTMLDivElement
|
||
let anchoredTop = 100
|
||
vi.spyOn(anchored, 'getBoundingClientRect').mockImplementation(
|
||
() => ({ top: anchoredTop, bottom: anchoredTop + 40 } as DOMRect),
|
||
)
|
||
readerScroll(scroller, 80)
|
||
// Arm the paging anchor, then deliver an older page (head seq decreases).
|
||
fireEvent.click(view.getByText('加载更早'))
|
||
Object.defineProperty(scroller, 'scrollHeight', { value: 1600, writable: true })
|
||
anchoredTop = 700
|
||
act(() => { h.set({ nodes: [user(1, 'old'), assistant(2, 'b'), user(5, 'later'), assistant(6, 'a')] }) })
|
||
expect(scroller.scrollTop).toBe(680) // reader offset 80 + the anchored row's 600px shift
|
||
// A new trailing user bubble (own words) force-scrolls to the bottom.
|
||
act(() => { h.set({ nodes: [user(1, 'old'), assistant(2, 'b'), user(5, 'later'), assistant(6, 'a'), user(9, 'mine')] }) })
|
||
expect(scroller.scrollTop).toBe(1600)
|
||
})
|
||
|
||
it('uses stable call identity when a prepend changes the tool-group key amid unrelated growth', () => {
|
||
const h = makeHarness({ nodes: [toolResult(5, 'late')], hasMore: true })
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
const scroller = view.container.querySelector('[class*="scroll"]') as HTMLDivElement
|
||
let prepended = false
|
||
const rect = vi.spyOn(HTMLElement.prototype, 'getBoundingClientRect').mockImplementation(function (this: HTMLElement) {
|
||
if (this.dataset.chatAnchorKey === 'call:late') {
|
||
const top = prepended ? 400 : 100
|
||
return { top, bottom: top + 40 } as DOMRect
|
||
}
|
||
return { top: 0, bottom: 200 } as DOMRect
|
||
})
|
||
try {
|
||
Object.defineProperty(scroller, 'scrollHeight', { value: 700, writable: true })
|
||
Object.defineProperty(scroller, 'clientHeight', { value: 200, writable: true })
|
||
readerScroll(scroller, 80)
|
||
fireEvent.click(view.getByText('加载更早'))
|
||
// Total height grows by 500, but only 300 belongs before the call row.
|
||
Object.defineProperty(scroller, 'scrollHeight', { value: 1_200, writable: true })
|
||
prepended = true
|
||
act(() => { h.set({ nodes: [toolResult(4, 'early'), toolResult(5, 'late')] }) })
|
||
expect(scroller.scrollTop).toBe(380)
|
||
} finally {
|
||
rect.mockRestore()
|
||
}
|
||
})
|
||
|
||
it('uses the latest retry identity when prepending an earlier retry changes the flow key', () => {
|
||
const h = makeHarness({ nodes: [retry(5)], hasMore: true })
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
const scroller = view.container.querySelector('[class*="scroll"]') as HTMLDivElement
|
||
let prepended = false
|
||
const rect = vi.spyOn(HTMLElement.prototype, 'getBoundingClientRect').mockImplementation(function (this: HTMLElement) {
|
||
if (this.dataset.chatAnchorKey === 'node:5') {
|
||
const top = prepended ? 400 : 100
|
||
return { top, bottom: top + 40 } as DOMRect
|
||
}
|
||
return { top: 0, bottom: 200 } as DOMRect
|
||
})
|
||
try {
|
||
Object.defineProperty(scroller, 'scrollHeight', { value: 700, writable: true })
|
||
Object.defineProperty(scroller, 'clientHeight', { value: 200, writable: true })
|
||
readerScroll(scroller, 80)
|
||
fireEvent.click(view.getByText('加载更早'))
|
||
Object.defineProperty(scroller, 'scrollHeight', { value: 1_200, writable: true })
|
||
prepended = true
|
||
act(() => { h.set({ nodes: [retry(4), retry(5)] }) })
|
||
expect(scroller.scrollTop).toBe(380)
|
||
expect(view.container.querySelector('[data-chat-flow-key="n4"][data-chat-anchor-key="node:5"]')).not.toBeNull()
|
||
} finally {
|
||
rect.mockRestore()
|
||
}
|
||
})
|
||
|
||
it('back-to-bottom cancels an in-flight paging anchor', () => {
|
||
const h = makeHarness({ nodes: [user(9, 'late')], hasMore: true })
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
const scroller = view.container.querySelector('[class*="scroll"]') as HTMLDivElement
|
||
Object.defineProperty(scroller, 'scrollHeight', { value: 800, writable: true })
|
||
Object.defineProperty(scroller, 'clientHeight', { value: 200, writable: true })
|
||
readerScroll(scroller, 50)
|
||
fireEvent.click(view.getByText('加载更早'))
|
||
fireEvent.click(view.getByLabelText('回到底部'))
|
||
Object.defineProperty(scroller, 'scrollHeight', { value: 1_300, writable: true })
|
||
act(() => { h.set({ nodes: [assistant(2, 'older'), user(9, 'late')] }) })
|
||
expect(scroller.scrollTop).toBe(1_300)
|
||
expect(h.chatScroll.read()).toBeNull()
|
||
})
|
||
|
||
it('scrolling away disables follow and shows the back-to-bottom button; clicking returns', () => {
|
||
const h = makeHarness({ nodes: [user(1, 'q'), assistant(2, 'a')] })
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
const scroller = view.container.querySelector('[class*="scroll"]') as HTMLDivElement
|
||
Object.defineProperty(scroller, 'scrollHeight', { value: 1000, writable: true })
|
||
Object.defineProperty(scroller, 'clientHeight', { value: 300, writable: true })
|
||
readerScroll(scroller, 100) // far from bottom
|
||
const backButton = view.getByLabelText('回到底部')
|
||
expect(backButton).toBeTruthy()
|
||
// Streaming growth must NOT drag a scrolled-away reader down.
|
||
act(() => { h.set({ partial: { turn: 1, step: 1, blocks: [{ kind: 'text', text: 'grow' }] } }) })
|
||
expect(scroller.scrollTop).toBe(100)
|
||
fireEvent.click(backButton)
|
||
expect(scroller.scrollTop).toBe(1000)
|
||
// At the bottom again: follow re-arms and the button unmounts.
|
||
expect(view.queryByLabelText('回到底部')).toBeNull()
|
||
})
|
||
|
||
it('keeps following when a stream-finalization shrink clamp delivers its scroll', () => {
|
||
const h = makeHarness({ nodes: [user(1, 'q'), assistant(2, 'a')] })
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
const scroller = view.container.querySelector('[class*="scroll"]') as HTMLDivElement
|
||
const metrics = installScrollMetrics(scroller, 1_000, 300)
|
||
scroller.scrollTop = 700
|
||
fireEvent.scroll(scroller)
|
||
|
||
// Stream finalization shrinks the column: the browser clamps the pinned
|
||
// position onto the new floor and delivers a scroll event. The clamp
|
||
// lands exactly on the ledger's floor min, so it is not reader input.
|
||
metrics.setLayout(800, 700)
|
||
fireEvent.scroll(scroller)
|
||
expect(scroller.scrollTop).toBe(500)
|
||
expect(view.queryByLabelText('回到底部')).toBeNull()
|
||
expect(h.chatScroll.read()).toBeNull()
|
||
|
||
metrics.setHeight(1_200)
|
||
act(() => { h.set({ running: true }) })
|
||
expect(scroller.scrollTop).toBe(900)
|
||
})
|
||
|
||
it('uses the last delivered top when compositor scrolling precedes scroll delivery', () => {
|
||
const h = makeHarness({ nodes: [user(1, 'q'), assistant(2, 'a')] })
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
const scroller = view.container.querySelector('[class*="scroll"]') as HTMLDivElement
|
||
installScrollMetrics(scroller, 1_000, 300)
|
||
scroller.scrollTop = 700
|
||
fireEvent.scroll(scroller)
|
||
|
||
// Chromium advances compositor geometry before delivering the event:
|
||
// attribution must compare against the observed-top ledger, never a
|
||
// baseline sampled from already-moved raw geometry.
|
||
scroller.scrollTop = 500
|
||
fireEvent.scroll(scroller)
|
||
expect(view.getByLabelText('回到底部')).toBeTruthy()
|
||
})
|
||
|
||
it('one ResizeObserver owns pinned dynamic-height follow and ignores growth while away', () => {
|
||
let notify: (() => void) | undefined
|
||
const observe = vi.fn()
|
||
class ResizeObserverStub {
|
||
constructor(callback: ResizeObserverCallback) {
|
||
notify = () => { callback([], this as unknown as ResizeObserver) }
|
||
}
|
||
|
||
observe = observe
|
||
disconnect = vi.fn()
|
||
}
|
||
vi.stubGlobal('ResizeObserver', ResizeObserverStub)
|
||
const h = makeHarness({ nodes: [user(1, 'q'), assistant(2, 'a')] })
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
const scroller = view.container.querySelector('[class*="scroll"]') as HTMLDivElement
|
||
Object.defineProperty(scroller, 'scrollHeight', { value: 1_000, writable: true })
|
||
Object.defineProperty(scroller, 'clientHeight', { value: 300, writable: true })
|
||
scroller.scrollTop = 700
|
||
fireEvent.scroll(scroller)
|
||
Object.defineProperty(scroller, 'scrollHeight', { value: 1_200, writable: true })
|
||
act(() => { notify?.() })
|
||
expect(scroller.scrollTop).toBe(1_200)
|
||
readerScroll(scroller, 200)
|
||
Object.defineProperty(scroller, 'scrollHeight', { value: 1_400, writable: true })
|
||
act(() => { notify?.() })
|
||
expect(scroller.scrollTop).toBe(200)
|
||
expect(observe).toHaveBeenCalledTimes(1)
|
||
})
|
||
|
||
it('entering the at-bottom threshold does not snap the remaining scroll distance', () => {
|
||
const h = makeHarness({ nodes: [user(1, 'q'), assistant(2, 'a')] })
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
const scroller = view.container.querySelector('[class*="scroll"]') as HTMLDivElement
|
||
Object.defineProperty(scroller, 'scrollHeight', { value: 1000, writable: true })
|
||
Object.defineProperty(scroller, 'clientHeight', { value: 300, writable: true })
|
||
// Inside FOLLOW_THRESHOLD (24) but not flush with the floor — the chrome
|
||
// re-render from setAtBottom must not force scrollTop to scrollHeight.
|
||
readerScroll(scroller, 690) // distance-to-bottom = 10
|
||
expect(view.queryByLabelText('回到底部')).toBeNull()
|
||
expect(scroller.scrollTop).toBe(690)
|
||
})
|
||
|
||
it('under data-conversation-scroll, bottom-follow targets the host scrollport', () => {
|
||
const host = document.createElement('div')
|
||
host.setAttribute('data-conversation-scroll', '')
|
||
Object.defineProperty(host, 'scrollHeight', { value: 2000, writable: true, configurable: true })
|
||
Object.defineProperty(host, 'clientHeight', { value: 500, writable: true, configurable: true })
|
||
Object.defineProperty(host, 'scrollTop', { value: 0, writable: true, configurable: true })
|
||
document.body.appendChild(host)
|
||
try {
|
||
const h = makeHarness({ nodes: [user(1, 'q'), assistant(2, 'a')] })
|
||
const view = render(<h.ChatView {...h.props} />, { container: host })
|
||
// Open jump uses the host, not the local .scroll node.
|
||
expect(host.scrollTop).toBe(2000)
|
||
readerScroll(host, 100)
|
||
expect(view.getByLabelText('回到底部')).toBeTruthy()
|
||
fireEvent.click(view.getByLabelText('回到底部'))
|
||
expect(host.scrollTop).toBe(2000)
|
||
} finally {
|
||
host.remove()
|
||
}
|
||
})
|
||
|
||
it('a remount restores the saved semantic row after width reflow', () => {
|
||
const host = document.createElement('div')
|
||
host.setAttribute('data-conversation-scroll', '')
|
||
Object.defineProperty(host, 'scrollHeight', { value: 2000, writable: true, configurable: true })
|
||
Object.defineProperty(host, 'clientHeight', { value: 500, writable: true, configurable: true })
|
||
Object.defineProperty(host, 'scrollTop', { value: 0, writable: true, configurable: true })
|
||
document.body.appendChild(host)
|
||
let anchorTop = 80
|
||
vi.spyOn(host, 'getBoundingClientRect').mockImplementation(
|
||
() => ({ top: 0, bottom: 500 } as DOMRect),
|
||
)
|
||
const rect = vi.spyOn(HTMLElement.prototype, 'getBoundingClientRect').mockImplementation(function (this: HTMLElement) {
|
||
if (this.dataset.chatAnchorKey === 'node:1') {
|
||
return { top: anchorTop, bottom: anchorTop + 40 } as DOMRect
|
||
}
|
||
return { top: 0, bottom: 40 } as DOMRect
|
||
})
|
||
try {
|
||
const h = makeHarness({ nodes: [user(1, 'q'), assistant(2, 'a')] })
|
||
// Fresh open (nothing saved): the bottom jump stands.
|
||
const view = render(<h.ChatView {...h.props} />, { container: host })
|
||
expect(host.scrollTop).toBe(2000)
|
||
// Reader scrolls up; the position is recorded continuously.
|
||
readerScroll(host, 100)
|
||
// View-tab switch away and back: the view unmounts, then remounts.
|
||
view.rerender(<div />)
|
||
anchorTop = 560
|
||
host.scrollTop = 0
|
||
view.rerender(<h.ChatView {...h.props} />)
|
||
expect(host.scrollTop).toBe(580) // approximate 100 + the row's 480px reflow shift
|
||
// The restored position is above the floor: follow stays disarmed.
|
||
expect(view.getByLabelText('回到底部')).toBeTruthy()
|
||
} finally {
|
||
rect.mockRestore()
|
||
host.remove()
|
||
}
|
||
})
|
||
|
||
it('normalizes a semantic restore clamped to the bottom before an immediate remount', () => {
|
||
const host = document.createElement('div')
|
||
host.setAttribute('data-conversation-scroll', '')
|
||
Object.defineProperty(host, 'scrollHeight', { value: 2_000, writable: true, configurable: true })
|
||
Object.defineProperty(host, 'clientHeight', { value: 500, writable: true, configurable: true })
|
||
let scrollTop = 0
|
||
Object.defineProperty(host, 'scrollTop', {
|
||
configurable: true,
|
||
get: () => scrollTop,
|
||
set: (value: number) => { scrollTop = Math.min(value, 1_500) },
|
||
})
|
||
document.body.appendChild(host)
|
||
const rect = vi.spyOn(HTMLElement.prototype, 'getBoundingClientRect').mockImplementation(function (this: HTMLElement) {
|
||
if (this.dataset.chatAnchorKey === 'node:1') return { top: 300, bottom: 340 } as DOMRect
|
||
return { top: 0, bottom: 500 } as DOMRect
|
||
})
|
||
try {
|
||
const h = makeHarness({ nodes: [user(1, 'q'), assistant(2, 'a')] })
|
||
h.chatScroll.save({ anchorKey: 'node:1', anchorTop: 80, scrollTop: 1_400 })
|
||
const view = render(<h.ChatView {...h.props} />, { container: host })
|
||
expect(host.scrollTop).toBe(1_500)
|
||
expect(h.chatScroll.read()).toBeNull()
|
||
view.rerender(<div />)
|
||
host.scrollTop = 0
|
||
view.rerender(<h.ChatView {...h.props} />)
|
||
expect(host.scrollTop).toBe(1_500)
|
||
} finally {
|
||
rect.mockRestore()
|
||
host.remove()
|
||
}
|
||
})
|
||
|
||
it('a remount while pinned to the bottom keeps the bottom jump', () => {
|
||
const host = document.createElement('div')
|
||
host.setAttribute('data-conversation-scroll', '')
|
||
Object.defineProperty(host, 'scrollHeight', { value: 2000, writable: true, configurable: true })
|
||
Object.defineProperty(host, 'clientHeight', { value: 500, writable: true, configurable: true })
|
||
Object.defineProperty(host, 'scrollTop', { value: 0, writable: true, configurable: true })
|
||
document.body.appendChild(host)
|
||
try {
|
||
const h = makeHarness({ nodes: [user(1, 'q'), assistant(2, 'a')] })
|
||
const view = render(<h.ChatView {...h.props} />, { container: host })
|
||
// At the bottom: the scroll event records the pinned state (null).
|
||
fireEvent.scroll(host)
|
||
expect(h.chatScroll.read()).toBeNull()
|
||
view.rerender(<div />)
|
||
host.scrollTop = 0
|
||
view.rerender(<h.ChatView {...h.props} />)
|
||
expect(host.scrollTop).toBe(2000)
|
||
} finally {
|
||
host.remove()
|
||
}
|
||
})
|
||
|
||
it('paging button loads older and shows its busy label', () => {
|
||
const h = makeHarness({ nodes: [user(5, 'later')], hasMore: true })
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
fireEvent.click(view.getByText('加载更早'))
|
||
expect(h.loadOlder).toHaveBeenCalledTimes(1)
|
||
act(() => { h.set({ loadingOlder: true }) })
|
||
expect(view.getByText('加载中…')).toBeTruthy()
|
||
})
|
||
|
||
it('shows open error and loading states', () => {
|
||
const h = makeHarness({
|
||
openState: 'error',
|
||
openError: { code: 'internal', message: 'boom' } as never,
|
||
})
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
expect(view.getByText(/历史加载失败：boom/)).toBeTruthy()
|
||
const loading = makeHarness({ openState: 'loading' })
|
||
const lv = render(<loading.ChatView {...loading.props} />)
|
||
expect(lv.getByText('载入历史…')).toBeTruthy()
|
||
})
|
||
|
||
it('pending waits leave the flow entirely — questions and approvals both take over the composer', () => {
|
||
const h = makeHarness({
|
||
pending: [
|
||
new PendingWait('approval', RpcId('r1'), SID,
|
||
{ approvalId: 'ap1', toolName: 'bash' } as PendingWait<'approval'>['payload'], vi.fn()),
|
||
new PendingWait('question', RpcId('r2'), SID,
|
||
{ questions: [{ id: 'q1', question: '选择' }] }, vi.fn()),
|
||
],
|
||
})
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
expect(view.queryByText(/等待回答/)).toBeNull()
|
||
expect(view.queryByText(/等待审批/)).toBeNull()
|
||
})
|
||
|
||
it('renders command nodes as durable rows: settled text, error state, executing spinner, run-less soft-fall', () => {
|
||
// Settled success: the bare command name is the title, the outcome text
|
||
// the summary — neither the dispatched `/` nor its arguments reach the row
|
||
// (the settlement text already says what the command did).
|
||
const settled = makeHarness({ nodes: [user(1, 'hi'), command({ args: ' now' })] })
|
||
const view = render(<settled.ChatView {...settled.props} />)
|
||
expect(view.getByText('plan')).toBeTruthy()
|
||
expect(view.queryByText('/plan')).toBeNull()
|
||
expect(view.queryByText('/plan now')).toBeNull()
|
||
expect(view.getByText('已进入 plan mode')).toBeTruthy()
|
||
|
||
// Error outcome flips the row state; a text-less error gets the default copy.
|
||
const failed = makeHarness({
|
||
nodes: [command({ seq: 6, commandId: 'cmd-2' as CommandNode['commandId'], outcome: { kind: 'error' } })],
|
||
})
|
||
const fv = render(<failed.ChatView {...failed.props} />)
|
||
expect(fv.container.querySelector('[data-state="error"]')).not.toBeNull()
|
||
expect(fv.getByText('命令失败')).toBeTruthy()
|
||
expect(fv.getByText('失败')).toBeTruthy()
|
||
|
||
// Still executing: running state with the executing copy.
|
||
const executing = makeHarness({
|
||
nodes: [command({ seq: 7, commandId: 'cmd-3' as CommandNode['commandId'], outcome: null })],
|
||
})
|
||
const xv = render(<executing.ChatView {...executing.props} />)
|
||
expect(xv.container.querySelector('[data-state="running"]')).not.toBeNull()
|
||
expect(xv.getByText('执行中…')).toBeTruthy()
|
||
expect(xv.getByText('运行中')).toBeTruthy()
|
||
|
||
// Cross-window soft-fall (run page truncated): generic title, outcome preserved.
|
||
const orphan = makeHarness({
|
||
nodes: [command({ seq: 8, commandId: 'cmd-4' as CommandNode['commandId'], name: null, args: null, outcome: { kind: 'success' } })],
|
||
})
|
||
const ov = render(<orphan.ChatView {...orphan.props} />)
|
||
expect(ov.getByText('命令')).toBeTruthy()
|
||
expect(ov.getByText('已完成')).toBeTruthy()
|
||
})
|
||
|
||
it('renders /compact as one stateful disclosure from running through completion', () => {
|
||
const running = command({
|
||
commandId: 'cmd-compact' as CommandNode['commandId'],
|
||
name: 'compact',
|
||
outcome: null,
|
||
})
|
||
const h = makeHarness({ nodes: [running] })
|
||
const view = render(<h.ChatView {...h.props} />)
|
||
expect(view.getByText('正在压缩…')).toBeTruthy()
|
||
expect(view.container.querySelector('[data-state="running"]')).not.toBeNull()
|
||
|
||
act(() => {
|
||
h.set({
|
||
nodes: [{
|
||
...running,
|
||
outcome: {
|
||
kind: 'success',
|
||
text: 'Compacted 16 history items (~11309 tokens).',
|
||
sourceEventSeq: 7,
|
||
},
|
||
}, compaction()],
|
||
})
|
||
})
|
||
|
||
expect(view.queryByText('正在压缩…')).toBeNull()
|
||
expect(view.queryByText('上下文已压缩')).toBeNull()
|
||
expect(view.getByText('已压缩 16 条历史记录（约 11309 tokens）')).toBeTruthy()
|
||
const row = view.getByRole('button', { name: /compact/ })
|
||
expect(row.getAttribute('aria-expanded')).toBe('false')
|
||
expect(row.querySelector('[data-compaction-icon="context"]')).not.toBeNull()
|
||
expect(row.querySelector('[data-compaction-disclosure="collapsed"]')).not.toBeNull()
|
||
expect(view.queryByText('保留的事实。')).toBeNull()
|
||
fireEvent.click(row)
|
||
expect(row.getAttribute('aria-expanded')).toBe('true')
|
||
expect(row.querySelector('[data-compaction-disclosure="expanded"]')).not.toBeNull()
|
||
expect(view.getByRole('heading', { name: '压缩摘要' })).toBeTruthy()
|
||
})
|
||
|
||
it('keeps /compact no-history and error settlements on the generic command row', () => {
|
||
const noHistory = makeHarness({
|
||
nodes: [command({
|
||
name: 'compact',
|
||
outcome: { kind: 'success', text: 'No compactable history yet.' },
|
||
})],
|
||
})
|
||
const noHistoryView = render(<noHistory.ChatView {...noHistory.props} />)
|
||
expect(noHistoryView.getByText('No compactable history yet.')).toBeTruthy()
|
||
expect(noHistoryView.queryByRole('button')).toBeNull()
|
||
|
||
const failed = makeHarness({
|
||
nodes: [command({
|
||
commandId: 'cmd-compact-failed' as CommandNode['commandId'],
|
||
name: 'compact',
|
||
outcome: { kind: 'error', text: 'Compaction cancelled.' },
|
||
})],
|
||
})
|
||
const failedView = render(<failed.ChatView {...failed.props} />)
|
||
expect(failedView.getByText('Compaction cancelled.')).toBeTruthy()
|
||
expect(failedView.container.querySelector('[data-state="error"]')).not.toBeNull()
|
||
})
|
||
})
|