282 lines
15 KiB
TypeScript
282 lines
15 KiB
TypeScript
// @vitest-environment node
|
|
import { describe, expect, it, vi } from 'vitest';
|
|
import {
|
|
parseTeacherDiscussionContent,
|
|
parseTeacherDiscussionReply,
|
|
type TeacherDiscussionContent,
|
|
} from '../../shared/teacher-discussion';
|
|
|
|
const ideas: TeacherDiscussionContent = {
|
|
kind: 'ideas', title: '我想做的小狗游戏',
|
|
items: [
|
|
{ id: 'dog', text: '养一只小狗', state: 'kept' },
|
|
{ id: 'breed', text: '柯基', parentId: 'dog', state: 'kept' },
|
|
{ id: 'adventure', text: '一起冒险', state: 'suggested' },
|
|
{ id: 'garden', text: '种菜', state: 'aside' },
|
|
],
|
|
firstItemId: 'dog',
|
|
};
|
|
const structure: TeacherDiscussionContent = {
|
|
kind: 'structure', title: '这些想法有什么关系',
|
|
nodes: [
|
|
{ id: 'dog', label: '我的小狗' },
|
|
{ id: 'breed', label: '柯基', parentId: 'dog', relation: '品种' },
|
|
{ id: 'personality', label: '胆小但好奇', parentId: 'dog', relation: '性格' },
|
|
],
|
|
};
|
|
const flow: TeacherDiscussionContent = {
|
|
kind: 'flow', title: '回家时怎么欢迎我',
|
|
nodes: [
|
|
{ id: 'door', label: '打开家门', kind: 'event' },
|
|
{ id: 'awake', label: '小狗醒着吗？', kind: 'condition' },
|
|
{ id: 'welcome', label: '跑过来欢迎', kind: 'outcome' },
|
|
{ id: 'sleep', label: '动动耳朵，继续睡', kind: 'outcome' },
|
|
],
|
|
edges: [
|
|
{ id: 'start', from: 'door', to: 'awake' },
|
|
{ id: 'yes', from: 'awake', to: 'welcome', label: '醒着' },
|
|
{ id: 'no', from: 'awake', to: 'sleep', label: '睡着' },
|
|
],
|
|
};
|
|
const comparison: TeacherDiscussionContent = {
|
|
kind: 'comparison', title: '没打中时怎样回应',
|
|
columns: [{ id: 'penalty', label: '直接扣分' }, { id: 'hint', label: '先给提示' }],
|
|
rows: [{
|
|
id: 'new', label: '第一次玩的人',
|
|
cells: [
|
|
{ columnId: 'penalty', text: '可能不知道错在哪' },
|
|
{ columnId: 'hint', text: '更容易知道如何调整' },
|
|
],
|
|
}],
|
|
};
|
|
|
|
describe('teacher discussion content contract', () => {
|
|
it.each([ideas, structure, flow, comparison])('preserves Agent-provided $kind content in an independent safe projection', content => {
|
|
const parsed = parseTeacherDiscussionContent(content);
|
|
expect(parsed).toEqual(content);
|
|
expect(parsed).not.toBe(content);
|
|
expect(parseTeacherDiscussionContent(structuredClone(content))).toEqual(parsed);
|
|
});
|
|
|
|
it('preserves arbitrary structural relationships without inventing fixed character/place/item categories', () => {
|
|
expect(parseTeacherDiscussionContent({
|
|
kind: 'structure', title: '音乐盒', nodes: [
|
|
{ id: 'melody', label: '自己录的旋律' },
|
|
{ id: 'tempo', label: '慢慢加快', relation: '播放速度', parentId: 'melody' },
|
|
],
|
|
})).toEqual({
|
|
kind: 'structure', title: '音乐盒', nodes: [
|
|
{ id: 'melody', label: '自己录的旋律' },
|
|
{ id: 'tempo', label: '慢慢加快', relation: '播放速度', parentId: 'melody' },
|
|
],
|
|
});
|
|
});
|
|
|
|
it('accepts explicit game/retry loops while validating every edge target', () => {
|
|
const looping = {
|
|
...flow,
|
|
edges: [...flow.edges, { id: 'retry', from: 'sleep', to: 'door', label: '明天再来' }],
|
|
};
|
|
expect(parseTeacherDiscussionContent(looping)).toEqual(looping);
|
|
expect(() => parseTeacherDiscussionContent({
|
|
...looping, edges: [...looping.edges, { id: 'missing', from: 'welcome', to: 'outside' }],
|
|
})).toThrow(Error);
|
|
});
|
|
|
|
it('aligns comparison cells by their explicit column ids rather than their array position', () => {
|
|
const reversed = { ...comparison, rows: [{ ...comparison.rows[0], cells: [...comparison.rows[0].cells].reverse() }] };
|
|
expect(parseTeacherDiscussionContent(reversed)).toEqual(comparison);
|
|
});
|
|
|
|
it.each([
|
|
['duplicate item', { ...ideas, items: [ideas.items[0], ideas.items[0]] }],
|
|
['unknown parent', { ...structure, nodes: [{ id: 'child', label: '柯基', parentId: 'missing' }] }],
|
|
['self parent', { ...structure, nodes: [{ id: 'dog', label: '小狗', parentId: 'dog' }] }],
|
|
['parent cycle', { ...structure, nodes: [{ id: 'a', label: '甲', parentId: 'b' }, { id: 'b', label: '乙', parentId: 'a' }] }],
|
|
['idea cycle', { ...ideas, items: [{ id: 'a', text: '甲', state: 'kept', parentId: 'b' }, { id: 'b', text: '乙', state: 'kept', parentId: 'a' }] }],
|
|
['missing first item', { ...ideas, firstItemId: 'missing' }],
|
|
['aside first item', { ...ideas, firstItemId: 'garden' }],
|
|
['duplicate flow nodes', { ...flow, nodes: [...flow.nodes, flow.nodes[0]] }],
|
|
['duplicate edge', { ...flow, edges: [flow.edges[0], flow.edges[0]] }],
|
|
['unknown edge source', { ...flow, edges: [{ id: 'bad', from: 'missing', to: 'door' }] }],
|
|
['unknown node kind', { ...flow, nodes: [{ id: 'a', label: '运行脚本', kind: 'execute' }], edges: [] }],
|
|
['missing comparison cell', { ...comparison, rows: [{ ...comparison.rows[0], cells: comparison.rows[0].cells.slice(0, 1) }] }],
|
|
['duplicate comparison cell', { ...comparison, rows: [{ ...comparison.rows[0], cells: [comparison.rows[0].cells[0], comparison.rows[0].cells[0]] }] }],
|
|
['unknown comparison column', { ...comparison, rows: [{ ...comparison.rows[0], cells: [{ columnId: 'other', text: '其他' }, comparison.rows[0].cells[1]] }] }],
|
|
['duplicate comparison columns', { ...comparison, columns: [comparison.columns[0], comparison.columns[0]] }],
|
|
['duplicate comparison rows', { ...comparison, rows: [comparison.rows[0], comparison.rows[0]] }],
|
|
])('rejects broken graph/table identity: %s', (_name, content) => {
|
|
expect(() => parseTeacherDiscussionContent(content)).toThrow(Error);
|
|
});
|
|
|
|
it.each([
|
|
['empty title', { ...structure, title: ' ' }],
|
|
['long title', { ...structure, title: '字'.repeat(121) }],
|
|
['long label', { ...structure, nodes: [{ id: 'a', label: '字'.repeat(601) }] }],
|
|
['unsafe id', { ...structure, nodes: [{ id: 'node a', label: '甲' }] }],
|
|
['long id', { ...structure, nodes: [{ id: 'x'.repeat(65), label: '甲' }] }],
|
|
['empty nodes', { ...structure, nodes: [] }],
|
|
['too many nodes', { ...structure, nodes: Array.from({ length: 25 }, (_, i) => ({ id: 'n' + i, label: '节点' })) }],
|
|
['too many edges', { ...flow, edges: Array.from({ length: 41 }, (_, i) => ({ id: 'e' + i, from: 'door', to: 'awake' })) }],
|
|
['too many rows', { ...comparison, rows: Array.from({ length: 13 }, (_, i) => ({ ...comparison.rows[0], id: 'r' + i })) }],
|
|
['one comparison column', { ...comparison, columns: [comparison.columns[0]] }],
|
|
['unknown content kind', { kind: 'html', title: '网页', html: '<script>run()</script>' }],
|
|
['missing field', { kind: 'ideas', title: '想法' }],
|
|
])('rejects unbounded or unsupported content: %s', (_name, content) => {
|
|
expect(() => parseTeacherDiscussionContent(content)).toThrow(Error);
|
|
});
|
|
|
|
it('does not accept sparse arrays or invoke object accessors', () => {
|
|
expect(() => parseTeacherDiscussionContent({ ...structure, nodes: new Array(2) })).toThrow(Error);
|
|
const getter = vi.fn(() => '偷偷读取');
|
|
const content = { ...structure };
|
|
Object.defineProperty(content, 'title', { get: getter });
|
|
expect(() => parseTeacherDiscussionContent(content)).toThrow(Error);
|
|
expect(getter).not.toHaveBeenCalled();
|
|
const arrayGetter = vi.fn(() => structure.nodes[0]);
|
|
const nodes = [structure.nodes[0]];
|
|
Object.defineProperty(nodes, 0, { get: arrayGetter });
|
|
expect(() => parseTeacherDiscussionContent({ ...structure, nodes })).toThrow(Error);
|
|
expect(arrayGetter).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('drops extra display/execution fields and rejects dangerous object keys without polluting prototypes', () => {
|
|
const parsed = parseTeacherDiscussionContent({
|
|
...structure, html: '<svg onload="execute()"/>', action: 'run',
|
|
nodes: structure.nodes.map(node => ({ ...node, style: { color: 'red' }, onClick: 'execute()' })),
|
|
});
|
|
expect(parsed).toEqual(structure);
|
|
const polluted = JSON.parse('{"kind":"structure","title":"图","nodes":[{"id":"a","label":"节点","__proto__":{"polluted":true}}]}');
|
|
expect(() => parseTeacherDiscussionContent(polluted)).toThrow(Error);
|
|
expect(Object.hasOwn(Object.prototype, 'polluted')).toBe(false);
|
|
expect(() => parseTeacherDiscussionContent(Object.assign(Object.create({ injected: true }), structure))).toThrow(Error);
|
|
expect(parseTeacherDiscussionContent(Object.assign(Object.create(null), structure))).toEqual(structure);
|
|
});
|
|
});
|
|
|
|
describe('teacher discussion model envelope', () => {
|
|
const envelope = { reply: '我把睡着的分支补好了。', quickReplies: ['还能怎样回应？'], tool: flow };
|
|
|
|
it.each([
|
|
(json: string) => json,
|
|
(json: string) => '```json\n' + json + '\n```',
|
|
(json: string) => '```JSON\r\n' + json + '\r\n```',
|
|
(json: string) => '```\n' + json + '\n```',
|
|
(json: string) => '```makelore-teacher-discussion\n' + json + '\n```',
|
|
(json: string) => '下面是整理。\n```json\n' + json + '\n```',
|
|
(json: string) => '下面是整理。\n' + json,
|
|
])('accepts structured JSON transport without exposing its envelope', wrap => {
|
|
expect(parseTeacherDiscussionReply(wrap(JSON.stringify(envelope)))).toEqual(envelope);
|
|
});
|
|
|
|
it('keeps legacy prose and ordinary programming examples without selecting a tool from keywords', () => {
|
|
const prose = '我们可以用流程图看看。\n```js\nif (awake) welcome();\n```';
|
|
expect(parseTeacherDiscussionReply(prose)).toEqual({ reply: prose, quickReplies: [] });
|
|
expect(parseTeacherDiscussionReply('柯基、冒险和菜园都是好点子。'))
|
|
.toEqual({ reply: '柯基、冒险和菜园都是好点子。', quickReplies: [] });
|
|
});
|
|
|
|
it.each([
|
|
'[项目说明](https://example.com/readme)\n\n先看已有设计。',
|
|
'[1, 2, 3]',
|
|
'[{"reply":"普通数组示例"}]',
|
|
'```json\nnot valid json\n```',
|
|
'{"scripts":{"dev":"vite"},"name":"flybot"}',
|
|
'项目配置可以这样写：\n\n```json\n{"name":"flybot","scripts":{"dev":"vite"}}\n```',
|
|
'```json\n[{"id":1,"label":"入口"}]\n```',
|
|
'{"example":{"reply":"这是数据字段，不是回答协议"}}',
|
|
'```js\nconst example = {"reply":"代码示例"};\n```',
|
|
])('preserves Markdown links and JSON examples as readable content: %s', raw => {
|
|
expect(parseTeacherDiscussionReply(raw)).toEqual({ reply: raw, quickReplies: [] });
|
|
});
|
|
|
|
it('distinguishes an absent tool from an explicit null and supports a tool-only envelope', () => {
|
|
expect(parseTeacherDiscussionReply('{"reply":"这轮只解释一下。"}'))
|
|
.toEqual({ reply: '这轮只解释一下。', quickReplies: [] });
|
|
expect(parseTeacherDiscussionReply('{"reply":"先聊聊。","tool":null}'))
|
|
.toEqual({ reply: '先聊聊。', quickReplies: [], tool: null });
|
|
expect(parseTeacherDiscussionReply(JSON.stringify({ reply: '', tool: ideas })))
|
|
.toEqual({ reply: '', quickReplies: [], tool: ideas });
|
|
});
|
|
|
|
it('preserves the valid reply but omits an invalid tool so the service can keep the current component', () => {
|
|
const parsed = parseTeacherDiscussionReply(JSON.stringify({
|
|
reply: '你的补充我收到了。', quickReplies: ['接着聊'],
|
|
tool: { ...flow, edges: [{ id: 'broken', from: 'door', to: 'missing' }] },
|
|
}));
|
|
expect(parsed.reply).toBe('你的补充我收到了。');
|
|
expect(parsed.quickReplies).toEqual(['接着聊']);
|
|
expect(parsed.tool).toBeUndefined();
|
|
expect(parsed.toolError).toBeTruthy();
|
|
expect(JSON.stringify(parsed)).not.toContain('broken');
|
|
});
|
|
|
|
it.each([
|
|
'{"reply":"说明已经完整。","tool":{"kind":"flow",',
|
|
'```json\n{"reply":"说明已经完整。","tool":',
|
|
'整理结果：\n{"reply":"说明已经完整。","tool":',
|
|
'{"quickReplies":[],"tool":{"nodes":[]},"reply":"说明已经完整。",',
|
|
])('recovers a complete top-level reply from truncated JSON: %s', raw => {
|
|
const parsed = parseTeacherDiscussionReply(raw);
|
|
expect(parsed.reply).toBe('说明已经完整。');
|
|
expect(parsed.tool).toBeUndefined();
|
|
expect(parsed.toolError).toBeTruthy();
|
|
});
|
|
|
|
it.each([
|
|
'{"reply":"还没有说完',
|
|
'{"tool":{"reply":"不能拿嵌套结构充当正文"},',
|
|
'```json\n{"tool":{"secret":"raw-data"}}',
|
|
'```makelore-teacher-discussion\nnot valid json\n```',
|
|
'{"reply":13,"tool":{"kind":"html"}}',
|
|
'```json\n{"reply":"结束"}\n```\n```json\n{"reply":"第二个"}\n```',
|
|
])('never exposes malformed JSON as the student reply: %s', raw => {
|
|
const parsed = parseTeacherDiscussionReply(raw);
|
|
expect(parsed.reply).not.toContain('{');
|
|
expect(parsed.reply).not.toContain('```');
|
|
expect(parsed.reply).not.toContain('raw-data');
|
|
expect(parsed.reply).not.toContain('不能拿嵌套结构');
|
|
expect(parsed.reply).not.toContain('不是合法 envelope');
|
|
expect(parsed.reply).toBeTruthy();
|
|
expect(parsed.tool).toBeUndefined();
|
|
expect(parsed.toolError).toBeTruthy();
|
|
});
|
|
|
|
it('recovers JSON-escaped reply strings without copying following malformed data', () => {
|
|
const reply = '你说：“先别叫醒它。”\n这个想法可以留下。';
|
|
const parsed = parseTeacherDiscussionReply('{"reply":' + JSON.stringify(reply) + ',"tool":{');
|
|
expect(parsed.reply).toBe(reply);
|
|
expect(parsed.toolError).toBeTruthy();
|
|
});
|
|
|
|
it('bounds transport by UTF-8 bytes and keeps only a recovered readable reply', () => {
|
|
const raw = JSON.stringify({ reply: '简短回复保留。', tool: flow, ignored: '中'.repeat(22000) });
|
|
expect(raw.length).toBeLessThan(64000);
|
|
expect(new TextEncoder().encode(raw).length).toBeGreaterThan(64000);
|
|
const parsed = parseTeacherDiscussionReply(raw);
|
|
expect(parsed.reply).toBe('简短回复保留。');
|
|
expect(parsed.tool).toBeUndefined();
|
|
expect(parsed.toolError).toBeTruthy();
|
|
});
|
|
|
|
it('bounds quick replies independently while retaining a valid component', () => {
|
|
expect(parseTeacherDiscussionReply(JSON.stringify({ reply: '想一想。', tool: structure, quickReplies: [' 再解释 ', '再解释'] })))
|
|
.toEqual({ reply: '想一想。', tool: structure, quickReplies: ['再解释'] });
|
|
for (const invalid of [['一', '二', '三', '四'], ['x'.repeat(121)], [13], ['']]) {
|
|
expect(parseTeacherDiscussionReply(JSON.stringify({ reply: '想一想。', tool: structure, quickReplies: invalid })))
|
|
.toEqual({ reply: '想一想。', tool: structure, quickReplies: [] });
|
|
}
|
|
});
|
|
|
|
it('bounds plain and structured reply text and does not propagate hostile envelope keys', () => {
|
|
expect(parseTeacherDiscussionReply('字'.repeat(12001)).reply).toHaveLength(12000);
|
|
const longReply = parseTeacherDiscussionReply(JSON.stringify({ reply: '字'.repeat(12001) }));
|
|
expect(longReply.reply.length).toBeLessThan(100);
|
|
expect(longReply.toolError).toBeTruthy();
|
|
const hostile = parseTeacherDiscussionReply('{"reply":"说明保留。","__proto__":{"polluted":true}}');
|
|
expect(hostile.reply).toBe('说明保留。');
|
|
expect(hostile.toolError).toBeTruthy();
|
|
expect(Object.hasOwn(Object.prototype, 'polluted')).toBe(false);
|
|
});
|
|
});
|