ds-harness-remote-fast/packages/plugin/tests/compact-bot-round.test.ts

127 行
5.5 KiB
TypeScript

import { describe, expect, it } from 'vitest'
import { runScenarios } from '../../../scripts/test-scenarios.mjs'
import { compactBotRound, COMPACT_BOT_ROUND_LIMITS as LIMITS } from '../src/compact-bot-round.js'
// Shapes mirror ds-bot/src/host/groups.js round.replies entries.
const reply = (text: string, overrides: Record<string, unknown> = {}) => ({
botId: 'session-1', name: 'Chief', color: 'deepseek', text, time: 1, ...overrides,
})
const round = (replies: unknown[], extra: Record<string, unknown> = {}) =>
JSON.stringify({ replies, passed: replies.length, ...extra })
function parsed(value: string | undefined) {
expect(value).toBeDefined()
expect(value!.length).toBeLessThanOrEqual(LIMITS.payload)
return JSON.parse(value!) as { replies: Record<string, unknown>[]; passed?: number; failed?: number; truncated?: boolean }
}
describe('compact group round projection', () => {
it('keeps every recognised reply parseable inside the payload budget', async () => {
await runScenarios([
{
name: 'one long reply keeps its speaker and a bounded body',
run: () => {
const result = parsed(compactBotRound(round([reply('x'.repeat(3000))])))
expect(result.replies).toHaveLength(1)
expect(result.replies[0]).toMatchObject({ botId: 'session-1', name: 'Chief', time: 1 })
expect((result.replies[0]!.text as string).length).toBe(LIMITS.text)
expect(result.truncated).toBe(true)
expect(result.passed).toBe(1)
},
},
{
name: 'three typical replies stay whole and ordered without a truncation flag',
run: () => {
const value = compactBotRound(round([
reply('a'.repeat(500), { name: 'Chief' }),
reply('b'.repeat(500), { name: 'Monitor' }),
{ kind: 'user', text: 'c'.repeat(400), time: 2 },
]))
const result = parsed(value)
expect(result.replies.map(item => item.name ?? item.kind)).toEqual(['Chief', 'Monitor', 'user'])
expect(result.replies.map(item => (item.text as string)[0])).toEqual(['a', 'b', 'c'])
expect(result.truncated).toBeUndefined()
},
},
{
name: 'trailing replies are dropped at the entry ceiling',
run: () => {
const source = Array.from({ length: 100 }, (_, index) => reply(`reply-${index}`, { time: index }))
const result = parsed(compactBotRound(round(source)))
expect(result.replies).toHaveLength(LIMITS.entries)
expect(result.replies[0]!.text).toBe('reply-0')
expect(result.replies.at(-1)!.text).toBe(`reply-${LIMITS.entries - 1}`)
expect(result.truncated).toBe(true)
},
},
{
name: 'a single oversized detail is bounded, not discarded',
run: () => {
const value = compactBotRound(round([reply('y'.repeat(LIMITS.source - 100))]))
const result = parsed(value)
expect(result.replies).toHaveLength(1)
expect((result.replies[0]!.text as string).length).toBe(LIMITS.text)
},
},
{
name: 'prose around the payload is tolerated',
run: () => {
const result = parsed(compactBotRound(`工具输出:\n${round([reply('x')])}`))
expect(result.replies).toHaveLength(1)
},
},
{
name: 'unknown fields, colours and prototype keys are not forwarded',
run: () => {
const entryJson = `${JSON.stringify(reply('x')).slice(0, -1)},"colour":"pink","__proto__":{"polluted":true}}`
const result = parsed(compactBotRound(`{"replies":[${entryJson}],"passed":1,"meta":{"secret":"x"}}`))
const entry = result.replies[0]!
expect(Object.keys(entry).sort()).toEqual(['botId', 'name', 'text', 'time'])
expect(Object.getPrototypeOf(entry)).toBe(Object.prototype)
expect(({} as Record<string, unknown>).polluted).toBeUndefined()
expect(result).not.toHaveProperty('meta')
},
},
{
name: 'status entries without text keep their kind',
run: () => {
const result = parsed(compactBotRound(round([{ kind: 'working', botId: 'b', name: 'Monitor', time: 1 }])))
expect(result.replies[0]).toMatchObject({ kind: 'working', name: 'Monitor' })
},
},
{
name: 'identity projection is idempotent',
run: () => {
const once = compactBotRound(round([reply('x'.repeat(3000)), reply('short', { name: 'Monitor' })]))!
expect(compactBotRound(once)).toBe(once)
},
},
{
name: 'an upstream truncated flag survives a second projection',
run: () => {
const once = compactBotRound(round([reply('x')], { truncated: true }))!
expect(parsed(once).truncated).toBe(true)
expect(compactBotRound(once)).toBe(once)
},
},
{
name: 'non-round payloads stay on the ordinary renderer',
run: () => {
for (const detail of [
round([]),
'{"replies":[[{"text":"nested"}]]}',
'{"replies":[1,"x",{"nope":true}]}',
'{"ok":true,"lines":["a","b"]}',
'{"replies":[{"text":"cut"}',
'x'.repeat(LIMITS.scan + 1) + '{"replies":[{"text":"too late"}]}',
'z'.repeat(1024 * 1024 + 1) + '{"replies":[{"text":"too large"}]}',
'没有可解析的回复',
]) {
expect(compactBotRound(detail)).toBeUndefined()
}
},
},
].map(row => ({ name: row.name, run: async () => row.run() })))
})
})