import test from 'node:test'; import assert from 'node:assert/strict'; import fs from 'node:fs'; import { createAnalysisSessionClient } from '../src/agent/sessionClient.ts'; const tick = () => new Promise(resolve => setImmediate(resolve)); const deferred = () => { let resolve, reject; const promise = new Promise((yes, no) => { resolve = yes; reject = no; }); return { promise, resolve, reject }; }; function fixture(t, overrides = {}) { const calls = { lists: 0, followed: [], details: [], options: 0, submissions: 0 }; const transport = { analysisSessions: async () => { calls.lists++; return { items: [] }; }, analysisTurn: async id => { calls.details.push(id); return { id, sessionId: 'linked-session', status: 'COMPLETED' }; }, analysisSessionFollow: async (id, { onEvent }) => { calls.followed.push(id); onEvent({ event: 'snapshot', data: { id, title: '授权会话', turns: [{ id: 'requested-turn', status: 'COMPLETED', result: { answer: '已保存答复' } }], } }); }, options: async () => { calls.options++; return {}; }, createAnalysisSession: async () => { calls.submissions++; throw new Error('Unexpected submission'); }, startAnalysisTurn: async () => { calls.submissions++; throw new Error('Unexpected submission'); }, ...overrides, }; const client = createAnalysisSessionClient({ userId: 'loading-fixture', transport }); t.after(client.dispose); return { client, calls }; } test('an explicit session opens its saved answer while the session list is still pending', async t => { const list = deferred(); const { client, calls } = fixture(t, { analysisSessions: () => list.promise }); assert.equal(await client.openInitial({ sessionId: 'requested-session' }), true); assert.deepEqual(calls.followed, ['requested-session']); assert.equal(client.getSnapshot().turns[0].answer, '已保存答复'); assert.equal(client.getSnapshot().historyLoading, false); assert.equal(client.getSnapshot().sessionsLoading, true); list.reject(new Error('list unavailable')); await tick(); assert.equal(client.getSnapshot().sessionsError, 'list unavailable'); assert.equal(client.getSnapshot().historyError, ''); assert.equal(client.getSnapshot().turns[0].answer, '已保存答复'); }); test('a turn-only link resolves and focuses its session while the list is pending', async t => { const list = deferred(); const { client, calls } = fixture(t, { analysisSessions: () => list.promise }); assert.equal(await client.openInitial({ turnId: 'requested-turn' }), true); assert.deepEqual(calls.details, ['requested-turn']); assert.deepEqual(calls.followed, ['linked-session']); assert.equal(client.getSnapshot().focusTurnId, 'requested-turn'); assert.equal(client.getSnapshot().sessionsLoading, true); list.resolve({ items: [] }); }); test('default restoration waits for the recent session list', async t => { const list = deferred(); const { client, calls } = fixture(t, { analysisSessions: () => list.promise }); const opening = client.openInitial(); await tick(); assert.deepEqual(calls.followed, []); assert.equal(client.getSnapshot().historyLoading, true); list.resolve({ items: [{ id: 'recent' }] }); assert.equal(await opening, true); assert.deepEqual(calls.followed, ['recent']); assert.equal(client.getSnapshot().historyLoading, false); }); test('concurrent sidebar refreshes share a single list request', async t => { const list = deferred(); let reads = 0; const { client } = fixture(t, { analysisSessions: () => { reads++; return list.promise; } }); const first = client.refreshSessions(); const second = client.refreshSessions(); assert.equal(first, second); await tick(); assert.equal(reads, 1); assert.equal(client.getSnapshot().sessionsLoading, true); list.resolve({ items: [{ id: 'recent' }] }); assert.deepEqual(await first, [{ id: 'recent' }]); assert.deepEqual(client.getSnapshot().sessions, [{ id: 'recent' }]); assert.equal(client.getSnapshot().sessionsLoading, false); assert.equal(client.getSnapshot().sessionsError, ''); }); test('a failed list request exposes its own error and permits retry', async t => { let reads = 0; const { client } = fixture(t, { analysisSessions: async () => { if (++reads === 1) throw new Error('list unavailable'); return { items: [{ id: 'restored' }] }; } }); await client.refreshSessions(); assert.equal(client.getSnapshot().sessionsLoading, false); assert.equal(client.getSnapshot().sessionsError, 'list unavailable'); assert.equal(client.getSnapshot().historyError, ''); await client.refreshSessions(); assert.equal(client.getSnapshot().sessionsError, ''); assert.deepEqual(client.getSnapshot().sessions, [{ id: 'restored' }]); }); test('ordinary and linked history restoration do not request analysis options', async t => { for (const initial of [{}, { sessionId: 'selected' }, { turnId: 'requested-turn' }, { selectRecent: false }]) { const { client, calls } = fixture(t); assert.equal(await client.openInitial(initial), true); assert.equal(calls.lists, 1); assert.equal(calls.options, 0); } const workspace = fs.readFileSync(new URL('../src/agent/AgentWorkspace.tsx', import.meta.url), 'utf8'); assert.doesNotMatch(workspace, /\b(?:optionsRead|analysisOptions)\b|\bapi\.options\s*\(/); }); test('retrying an explicitly selected history opens its snapshot while the list is slow', async t => { const list = deferred(); const reads = []; const { client } = fixture(t, { analysisSessions: () => list.promise, analysisSessionFollow: async (id, { onEvent }) => { reads.push(id); if (reads.length === 1) throw new Error('history unavailable'); onEvent({ event: 'snapshot', data: { id, turns: [] } }); }, }); assert.equal(await client.openInitial({ sessionId: 'selected' }), false); const failed = client.getSnapshot(); assert.equal(failed.historyError, 'history unavailable'); assert.equal(await client.openSession(failed.sessionId, failed.focusTurnId), true); assert.deepEqual(reads, ['selected', 'selected']); assert.equal(client.getSnapshot().sessionsLoading, true); list.resolve({ items: [] }); }); test('a late default-list retry cannot navigate over a newer user selection', async t => { const retry = deferred(); let reads = 0; const { client, calls } = fixture(t, { analysisSessions: async () => { if (++reads === 1) throw new Error('list unavailable'); return retry.promise; } }); assert.equal(await client.openInitial(), false); const retrying = client.openInitial(); assert.equal(await client.openSession('selected'), true); retry.resolve({ items: [{ id: 'old-default' }] }); assert.equal(await retrying, false); assert.deepEqual(calls.followed, ['selected']); assert.equal(client.getSnapshot().sessionId, 'selected'); }); test('retrying an unresolved turn link resolves the same turn before choosing any default', async t => { const reads = []; const { client, calls } = fixture(t, { analysisSessions: async () => ({ items: [{ id: 'unrelated-default' }] }), analysisTurn: async id => { reads.push(id); if (reads.length === 1) throw new Error('turn unavailable'); return { id, sessionId: 'linked-session', status: 'COMPLETED' }; }, }); const initial = { turnId: 'requested-turn' }; assert.equal(await client.openInitial(initial), false); assert.equal(await client.openInitial(initial), true); assert.deepEqual(reads, ['requested-turn', 'requested-turn']); assert.deepEqual(calls.followed, ['linked-session']); assert.equal(client.getSnapshot().focusTurnId, 'requested-turn'); }); test('retrying default restoration keeps submission locked until its target resolves', async t => { const retry = deferred(); let reads = 0; const { client, calls } = fixture(t, { analysisSessions: async () => { if (++reads === 1) throw new Error('list unavailable'); return retry.promise; } }); assert.equal(await client.openInitial(), false); const retrying = client.openInitial(); assert.equal(client.getSnapshot().historyLoading, true); assert.equal(await client.submit('新问题'), false); assert.equal(calls.submissions, 0); retry.resolve({ items: [{ id: 'default' }] }); assert.equal(await retrying, true); assert.equal(client.getSnapshot().historyLoading, false); });