统一:DSH 智能分析、Top100 与图表静默恢复

接入 DSH 专用运行时和对话界面,保留模型原始回答,支持会话分页、连续追问与显式报告。
补齐组合筛选、各维度 Top100、分组查询到排名图的转换,图表故障静默省略并基于保存数据自动恢复。
优化报告风格、图表顺序和表格换行,更新接入说明及构建输入。

验证:独立目录前后端构建通过;118 项 Java、102 项前端、102 项图表、14 项 DSH 应用和 13 项组合筛选检查通过。
仅提交相关源码、锁定依赖与测试;不包含凭据、会话、业务数据或本地产物。
This commit is contained in:
2026-11-12 11:57:41 +08:00
parent cc8832c8e5
commit f1a2fbd494
166 changed files with 26281 additions and 2248 deletions
+278 -171
View File
@@ -1,214 +1,321 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import ts from 'typescript';
import React from 'react';
import { renderToStaticMarkup } from 'react-dom/server';
import * as helpers from '../src/analysisSubmission.ts';
import { restoredAnalysisDraft } from '../src/analysisScope.ts';
import { beginAnalysisSubmission, submissionOutcomeUnknown } from '../src/analysisSubmission.ts';
import { createAnalysisSessionClient } from '../src/agent/sessionClient.ts';
const deferred = () => { let resolve, reject; const promise = new Promise((r,j) => { resolve = r; reject = j; }); return { promise, resolve, reject }; };
const tick = () => new Promise(resolve => setImmediate(resolve));
const source = fs.readFileSync(new URL('../src/ManagementPages.tsx', import.meta.url), 'utf8');
const page = source.slice(source.indexOf('function AnalysisPage('));
const closures = page.slice(page.indexOf(' const cancelAcceptedTurn = async'), page.indexOf('\n useEffect(() => { void sendQueuedFollowup(); }'));
const turnComponent = source.slice(source.indexOf('function AnalysisTurn('), source.indexOf('function AnalysisTurnMetadata('));
const renderDraft = turn => {
const component = new Function('React', 'useAnalysisVisualRecovery', ts.transpileModule(`${turnComponent}\nreturn AnalysisTurn;`, {
fileName: 'submission-render.tsx', compilerOptions: {target:ts.ScriptTarget.ES2022,jsx:ts.JsxEmit.React},
}).outputText)(React, turn => ({turn,available:false,recovering:false,error:''}));
return renderToStaticMarkup(React.createElement(component, { turn }));
const deferred = () => {
let resolve, reject;
const promise = new Promise((yes, no) => { resolve = yes; reject = no; });
return { promise, resolve, reject };
};
const saved = (id, status, extras = {}) => ({ id, question: 'saved question', status, ...extras });
const page = (id, turns = [], extra = {}) => ({ id, turns, ...extra });
// Run the component's current submission/cancellation closures with API doubles.
// This catches wiring errors that helper-only assertions would miss, without DOM or network.
function fixture(api, hooks = {}, initialSession = 'session-1') {
const body = `
const {beginAnalysisSubmission,requestSubmissionCancellation,submissionOutcomeUnknown}=helpers;
let query='',sessionId=${JSON.stringify(initialSession)},sessionContext=null,releaseId=undefined,sourceResultRef=undefined;
let sessionReadOnly=false,stopping=false,busy=false,historyLoading=false,lastTurn=null,turns=[],activeTurnId='',retryQuestion='',error='',progress='',queuedFollowup='';
const mounted={current:true},navigationGeneration={current:0},subscriptionGeneration={current:0},streamController={current:null},submissionAttempt={current:null},followOutput={current:true},explicitlyFollowing={current:false},followRequest={current:null},cancellationRequest={current:null};
const user={id:'fixture-user'},ANALYSIS_FINAL_STATUSES=new Set(['COMPLETED','PARTIAL','FAILED','CANCELLED','NEEDS_CLARIFICATION']);
const beginAnalysisSelection=()=>1,rememberAnalysisSession=()=>{},rememberPendingAnalysisSession=()=>{},writeAnalysisLocation=()=>{};
const onUnauthorized=()=>false,apiMessage=e=>e.message,message={error(){},info(){}};
const setStopping=v=>{stopping=v;},setBusy=v=>{busy=v;if(!v){stopping=false;cancellationRequest.current=null;}},setError=v=>{error=v;},setRetryQuestion=v=>{retryQuestion=v;},setQuery=v=>{query=v;},setSessionId=v=>{sessionId=v;};
const setLastTurn=v=>{lastTurn=typeof v==='function'?v(lastTurn):v;},setTurns=v=>{turns=typeof v==='function'?v(turns):v;};
const setActiveTurnId=v=>{activeTurnId=v;},setStreamProgress=v=>{progress=v;},setQueuedFollowup=v=>{queuedFollowup=v;};
const loadSessions=async()=>{if(hooks.loadSessions)await hooks.loadSessions();};
const followTurn=async id=>{activeTurnId=id;busy=true;if(hooks.followTurn)await hooks.followTurn(id);};
${closures}
return {submit,cancelTurn,retryTurn,queueFollowup,sendQueuedFollowup,
setReadOnly(value){sessionReadOnly=value;},
seedTurn(turn){lastTurn=turn;},
setInput(value){query=value;},
finishCurrent(){busy=false;lastTurn={...lastTurn,status:'COMPLETED'};},
switchSession(id){navigationGeneration.current++;submissionAttempt.current=null;sessionId=id;busy=false;lastTurn=null;activeTurnId='';error='';},
get:()=>({busy,stopping,lastTurn,turns,activeTurnId,retryQuestion,error,progress,queuedFollowup,query,attempt:submissionAttempt.current})};
`;
return new Function('api', 'helpers', 'hooks', 'restoredAnalysisDraft', ts.transpileModule(body, {compilerOptions:{target:ts.ScriptTarget.ES2022}}).outputText)(api, helpers, hooks, restoredAnalysisDraft);
function fixture(t, overrides = {}, initialPages = { 'session-1': page('session-1') }) {
const pages = { ...initialPages };
const requests = { starts: [], cancels: [], retries: [], follows: [] };
const transport = {
analysisSessions: async () => ({ items: Object.keys(pages).map(id => ({ id })) }),
analysisSessionFollow: (id, { signal, onEvent }) => {
const end = deferred();
requests.follows.push({ id, emit: onEvent, close: end.resolve });
signal.addEventListener('abort', end.resolve, { once: true });
onEvent({ event: 'snapshot', data: pages[id] || page(id) });
return end.promise;
},
createAnalysisSession: async () => ({ session: { id: 'session-1' } }),
startAnalysisTurn: async (id, body) => {
requests.starts.push({ id, ...body });
const turn = saved('turn-1', 'QUEUED', { sessionId: id, question: body.question });
pages[id] = page(id, [...(pages[id]?.turns || []), turn], { activeTurnId: turn.id });
return { turn };
},
retryAnalysisTurn: async id => { requests.retries.push(id); throw new Error('Unexpected retry'); },
cancelAnalysisTurn: async id => {
requests.cancels.push(id);
for (const [sessionId, previous] of Object.entries(pages)) {
const turns = previous.turns.map(turn => turn.id === id ? { ...turn, status: 'CANCELLED' } : turn);
pages[sessionId] = { ...previous, turns, activeTurnId: previous.activeTurnId === id ? '' : previous.activeTurnId };
}
return { status: 'CANCELLED', turnId: id };
},
...overrides,
};
const client = createAnalysisSessionClient({ userId: 'submission-fixture', transport });
t.after(client.dispose);
return { client, pages, requests, state: client.getSnapshot };
}
test('read-only history cannot submit, retry, or queue analysis and keeps its saved turn and draft', async () => {
const calls=[];const ui=fixture({startAnalysisTurn:async()=>calls.push('start'),retryAnalysisTurn:async()=>calls.push('retry')});
const turn={id:'legacy-turn',status:'FAILED',question:'old question',result:{answer:'saved answer'}};
ui.seedTurn(turn);ui.setInput('new question');ui.setReadOnly(true);
await ui.submit();await ui.retryTurn(turn);ui.queueFollowup();
assert.deepEqual(calls,[]);assert.equal(ui.get().lastTurn,turn);assert.equal(ui.get().query,'new question');
assert.equal(ui.get().busy,false);assert.equal(ui.get().queuedFollowup,'');
test('read-only history cannot submit or retry and keeps its saved turn', async t => {
const legacy = saved('legacy-turn', 'FAILED', { result: { answer: 'saved answer' } });
const { client, requests, state } = fixture(t, {}, { 'session-1': page('session-1', [legacy], { readOnly: true }) });
await client.openSession('session-1');
assert.equal(await client.submit('new question'), false);
assert.equal(await client.retry('legacy-turn'), false);
assert.deepEqual(requests.starts, []);
assert.deepEqual(requests.retries, []);
assert.equal(state().turns[0].result.answer, 'saved answer');
assert.equal(state().busy, false);
assert.equal(state().queuedQuestion, '');
});
test('unknown result retries reuse the key only for identical frozen submission', () => {
const input={sessionId:'s',question:'q',generation:1,context:{month:9,year:2026}};
const prior=helpers.beginAnalysisSubmission(null,input,()=> 'first-key');prior.uncertain=true;prior.inFlight=false;
assert.equal(helpers.beginAnalysisSubmission(prior,{...input,context:{year:2026,month:9}},()=> 'new-key'),prior);
for(const change of [{question:'other'},{sessionId:'other'},{generation:2},{context:{month:8,year:2026}}])
assert.equal(helpers.beginAnalysisSubmission(prior,{...input,...change},()=> 'new-key').idempotencyKey,'new-key');
const input = { sessionId: 's', question: 'q', generation: 1, context: { month: 9, year: 2026 } };
const prior = beginAnalysisSubmission(null, input, () => 'first-key');
prior.uncertain = true;
prior.inFlight = false;
assert.equal(beginAnalysisSubmission(prior, { ...input, context: { year: 2026, month: 9 } }, () => 'new-key'), prior);
for (const change of [{ question: 'other' }, { sessionId: 'other' }, { generation: 2 }, { context: { month: 8, year: 2026 } }]) {
assert.equal(beginAnalysisSubmission(prior, { ...input, ...change }, () => 'new-key').idempotencyKey, 'new-key');
}
});
test('explicit client rejection differs from an unknown network/server outcome', () => {
for(const status of [400,401,403,404,409,413,422,429])assert.equal(helpers.submissionOutcomeUnknown({status}),false);
for(const status of [0,200,408,500,502,503])assert.equal(helpers.submissionOutcomeUnknown({status}),true);
assert.equal(helpers.submissionOutcomeUnknown(new Error('connection lost')),true);
for (const status of [400, 401, 403, 404, 409, 413, 422, 429]) assert.equal(submissionOutcomeUnknown({ status }), false);
for (const status of [0, 200, 408, 500, 502, 503]) assert.equal(submissionOutcomeUnknown({ status }), true);
assert.equal(submissionOutcomeUnknown(new Error('connection lost')), true);
});
test('stop during turn creation is fulfilled once its response identifies the turn', async () => {
const start=deferred(),cancelled=[];
const ui=fixture({startAnalysisTurn:()=>start.promise,cancelAnalysisTurn:async id=>cancelled.push(id),analysisTurn:async()=>({status:'CANCELLED'})});
const pending=ui.submit('q');await ui.cancelTurn();assert.deepEqual(cancelled,[]);
start.resolve({turn:{id:'turn-1',status:'QUEUED'}});await pending;
assert.deepEqual(cancelled,['turn-1']);assert.equal(ui.get().lastTurn.status,'CANCELLED');assert.equal(ui.get().busy,false);
test('stop during turn creation is fulfilled once the receipt identifies the turn', async t => {
const receipt = deferred();
const { client, pages, requests, state } = fixture(t, { startAnalysisTurn: () => receipt.promise });
await client.openSession('session-1');
const pending = client.submit('q');
await tick();
assert.equal(await client.cancel(), true);
assert.deepEqual(requests.cancels, []);
const turn = saved('turn-1', 'QUEUED');
pages['session-1'] = page('session-1', [turn], { activeTurnId: 'turn-1' });
receipt.resolve({ turn });
assert.equal(await pending, true);
assert.deepEqual(requests.cancels, ['turn-1']);
assert.equal(state().turns.at(-1).status, 'CANCELLED');
assert.equal(state().busy, false);
});
test('stop before the new session is created prevents a model turn from starting', async () => {
const created=deferred();let starts=0;
const ui=fixture({createAnalysisSession:()=>created.promise,startAnalysisTurn:async()=>{starts++;}}, {}, '');
const pending=ui.submit('q');await ui.cancelTurn();created.resolve({session:{id:'new-session'}});await pending;
assert.equal(starts,0);assert.equal(ui.get().lastTurn.status,'CANCELLED');assert.equal(ui.get().busy,false);
test('stop before the new session is created prevents a model turn from starting', async t => {
const created = deferred();
const { client, requests, state } = fixture(t, { createAnalysisSession: () => created.promise }, {});
const pending = client.submit('q');
assert.equal(await client.cancel(), true);
created.resolve({ session: { id: 'new-session' } });
assert.equal(await pending, false);
assert.deepEqual(requests.starts, []);
assert.deepEqual(state().turns, []);
assert.equal(state().pendingQuestion, '');
assert.equal(state().busy, false);
});
test('a follow-up entered while analysis runs is sent after the current turn settles', async () => {
const following=deferred(),questions=[];
const ui=fixture({startAnalysisTurn:async(_session,body)=>{questions.push(body.question);return {turn:{id:`turn-${questions.length}`}};}},
{followTurn:()=>following.promise});
const first=ui.submit('initial question');await tick();
ui.setInput('follow-up question');ui.queueFollowup();
assert.equal(ui.get().queuedFollowup,'follow-up question');
assert.equal(ui.get().query,'');
assert.deepEqual(questions,['initial question']);
following.resolve();await first;ui.finishCurrent();
await ui.sendQueuedFollowup();
assert.deepEqual(questions,['initial question','follow-up question']);
assert.equal(ui.get().queuedFollowup,'');
test('a follow-up waits for the accepted task to settle and then sends once', async t => {
const { client, requests, pages, state } = fixture(t);
await client.openSession('session-1');
assert.equal(await client.submit('initial question'), true);
await tick();
assert.equal(await client.submit('follow-up question'), true);
assert.equal(await client.submit('second queued question'), false);
assert.equal(state().queuedQuestion, 'follow-up question');
assert.deepEqual(requests.starts.map(request => request.question), ['initial question']);
pages['session-1'] = page('session-1', [saved('turn-1', 'COMPLETED', { question: 'initial question' })]);
const current = requests.follows.at(-1);
current.emit({ id: '1', event: 'completed', data: { turnId: 'turn-1', result: { answer: 'done' } } });
current.close();
await tick();
requests.follows.at(-1).close();
await tick();
assert.deepEqual(requests.starts.map(request => request.question), ['initial question', 'follow-up question']);
assert.equal(state().queuedQuestion, '');
});
test('session-list refresh cannot delay turn following or its stop target', async () => {
const list=deferred(),following=deferred(),followed=[];
const ui=fixture({startAnalysisTurn:async()=>({turn:{id:'turn-1'}})}, {loadSessions:()=>list.promise,followTurn:id=>{followed.push(id);return following.promise;}});
const pending=ui.submit('q');await tick();assert.deepEqual(followed,['turn-1']);assert.equal(ui.get().activeTurnId,'turn-1');
following.resolve();list.resolve();await pending;
test('session-list refresh cannot delay following or the stop target', async t => {
const list = deferred();
const { client, requests, state } = fixture(t, { analysisSessions: () => list.promise });
await client.openSession('session-1');
assert.equal(await client.submit('q'), true);
await tick();
assert.equal(state().sessionsLoading, true);
assert.equal(requests.follows.length, 2);
assert.equal(state().activeTurnId, 'turn-1');
assert.equal(await client.cancel(), true);
assert.deepEqual(requests.cancels, ['turn-1']);
list.resolve({ items: [] });
});
test('a lost accepted response retries the same key without archiving an unsaved phantom turn', async () => {
const calls=[];
const ui=fixture({startAnalysisTurn:async(session,body)=>{calls.push({session,...body});if(calls.length===1)throw Object.assign(new Error('lost response'),{status:0});return {turn:{id:'original-turn'}};}});
await ui.submit('q');assert.equal(ui.get().attempt.uncertain,true);
await ui.submit(ui.get().retryQuestion);assert.equal(calls.length,2);assert.equal(calls[0].idempotencyKey,calls[1].idempotencyKey);
assert.equal(ui.get().lastTurn.id,'original-turn');assert.deepEqual(ui.get().turns,[]);
test('a lost accepted response retries the same key without archiving a phantom turn', async t => {
const bodies = [];
const { client, pages, state } = fixture(t, {
startAnalysisTurn: async (id, body) => {
bodies.push(body);
if (bodies.length === 1) throw Object.assign(new Error('service unavailable'), { status: 503 });
const turn = saved('original-turn', 'RUNNING', { question: body.question });
pages[id] = page(id, [turn], { activeTurnId: turn.id });
return { turn };
},
});
await client.openSession('session-1');
assert.equal(await client.submit('q'), false);
assert.equal(state().retryQuestion, 'q');
assert.equal(state().error, 'service unavailable');
assert.equal(state().busy, false);
assert.equal(state().activeTurnId, '');
assert.deepEqual(state().turns, []);
assert.equal(await client.submit(state().retryQuestion), true);
assert.equal(bodies.length, 2);
assert.equal(bodies[0].idempotencyKey, bodies[1].idempotencyKey);
assert.deepEqual(state().turns.map(turn => turn.id), ['original-turn']);
});
test('an explicit rejection clears the attempt so a corrected retry gets a fresh key', async () => {
const keys=[];
const ui=fixture({startAnalysisTurn:async(_session,body)=>{keys.push(body.idempotencyKey);throw Object.assign(new Error('validation rejected'),{status:400});}});
await ui.submit('q');assert.equal(ui.get().attempt,null);await ui.submit('corrected q');assert.notEqual(keys[0],keys[1]);
test('an explicit 400 rejection gives the same editable question a fresh key without showing it as running', async t => {
const keys = [];
const { client, state } = fixture(t, {
startAnalysisTurn: async (_id, body) => {
keys.push(body.idempotencyKey);
throw Object.assign(new Error('invalid question'), { status: 400 });
},
});
await client.openSession('session-1');
assert.equal(await client.submit('rejected question'), false);
assert.equal(state().retryQuestion, 'rejected question');
assert.equal(state().error, 'invalid question');
assert.equal(state().busy, false);
assert.deepEqual(state().turns, []);
assert.equal(await client.submit(state().retryQuestion), false);
assert.notEqual(keys[0], keys[1]);
});
test('switching session while creation is pending cannot cancel or render into the new session', async () => {
const start=deferred(),cancelled=[];
const ui=fixture({startAnalysisTurn:()=>start.promise,cancelAnalysisTurn:async id=>cancelled.push(id)});
const pending=ui.submit('q');await ui.cancelTurn();ui.switchSession('session-2');start.resolve({turn:{id:'old-turn'}});await pending;
assert.deepEqual(cancelled,[]);assert.equal(ui.get().lastTurn,null);assert.equal(ui.get().activeTurnId,'');
test('a pending stop applies only to its original turn after navigation', async t => {
const receipt = deferred();
const { client, requests, state } = fixture(t, { startAnalysisTurn: () => receipt.promise });
await client.openSession('session-1');
const pending = client.submit('q');
await tick();
assert.equal(await client.cancel(), true);
await client.openSession('session-2');
receipt.resolve({ turn: saved('old-turn', 'RUNNING', { sessionId: 'session-1' }) });
assert.equal(await pending, true);
assert.deepEqual(requests.cancels, ['old-turn']);
assert.deepEqual(state().turns, []);
assert.equal(state().activeTurnId, '');
assert.equal(state().sessionId, 'session-2');
});
test('stop during retry waits for requeue instead of cancelling the old terminal state', async () => {
const retry=deferred(),cancelled=[];
const ui=fixture({retryAnalysisTurn:()=>retry.promise,cancelAnalysisTurn:async id=>cancelled.push(id),analysisTurn:async()=>({status:'CANCELLED'})});
ui.seedTurn({id:'newest-turn',question:'newest question',status:'COMPLETED'});
const pending=ui.retryTurn({id:'partial-turn',sessionId:'session-1',question:'q',status:'PARTIAL'});
await ui.cancelTurn();assert.deepEqual(cancelled,[]);
retry.resolve({turn:{id:'partial-turn',sessionId:'session-1',status:'QUEUED'}});await pending;
assert.deepEqual(cancelled,['partial-turn']);assert.equal(ui.get().busy,false);assert.equal(ui.get().lastTurn.question,'q');
test('stop during retry waits for requeue and targets the original saved turn', async t => {
const receipt = deferred();
const savedTurn = saved('partial-turn', 'PARTIAL');
const { client, pages, requests, state } = fixture(t, { retryAnalysisTurn: () => receipt.promise }, {
'session-1': page('session-1', [savedTurn, saved('newest-turn', 'COMPLETED')]),
});
await client.openSession('session-1');
const pending = client.retry('partial-turn');
assert.equal(await client.cancel(), true);
assert.deepEqual(requests.cancels, []);
const turn = { ...savedTurn, status: 'QUEUED' };
pages['session-1'] = page('session-1', [turn, saved('newest-turn', 'COMPLETED')], { activeTurnId: 'partial-turn' });
receipt.resolve({ turn });
assert.equal(await pending, true);
assert.deepEqual(requests.cancels, ['partial-turn']);
assert.equal(state().busy, false);
assert.equal(state().turns.find(row => row.id === 'partial-turn').status, 'CANCELLED');
});
test('a late cancellation failure cannot put an error in a newly selected session', async () => {
const cancel=deferred(),following=deferred();
const ui=fixture({startAnalysisTurn:async()=>({turn:{id:'turn-1'}}),cancelAnalysisTurn:()=>cancel.promise}, {followTurn:()=>following.promise});
const pending=ui.submit('q');await tick();const stopping=ui.cancelTurn();ui.switchSession('other');cancel.reject(new Error('cancellation response lost'));await stopping;following.resolve();await pending;
assert.equal(ui.get().error,'');assert.equal(ui.get().lastTurn,null);
test('a late cancellation failure cannot put an error in a newly selected session', async t => {
const cancel = deferred();
const { client, state } = fixture(t, { cancelAnalysisTurn: () => cancel.promise });
await client.openSession('session-1');
await client.submit('q');
const stopping = client.cancel();
await client.openSession('other');
cancel.reject(new Error('cancellation response lost'));
assert.equal(await stopping, false);
assert.equal(state().error, '');
assert.deepEqual(state().turns, []);
});
test('repeated stop clicks make one cancellation request until the task settles', async () => {
const cancel=deferred(),following=deferred();let cancellationCount=0,detailReads=0;
const ui=fixture({startAnalysisTurn:async()=>({turn:{id:'turn-1'}}),cancelAnalysisTurn:()=>{cancellationCount++;return cancel.promise;},
analysisTurn:async()=>{detailReads++;return {id:'turn-1',status:'CANCELLED'};}}, {followTurn:()=>following.promise});
const pending=ui.submit('q');await tick();const first=ui.cancelTurn(),second=ui.cancelTurn();
await second;assert.equal(cancellationCount,1);assert.equal(ui.get().stopping,true);
cancel.resolve();await first;assert.equal(ui.get().attempt,null);assert.equal(ui.get().busy,false);assert.equal(detailReads,1);
following.resolve();await pending;
test('repeated stop clicks share one request until the task settles', async t => {
const cancellation = deferred();
let count = 0;
const { client, pages, state } = fixture(t, { cancelAnalysisTurn: () => { count++; return cancellation.promise; } });
await client.openSession('session-1');
await client.submit('q');
const first = client.cancel();
assert.equal(await client.cancel(), false);
assert.equal(count, 1);
assert.equal(state().stopping, true);
pages['session-1'] = page('session-1', [saved('turn-1', 'CANCELLED')]);
cancellation.resolve({ status: 'CANCELLED', turnId: 'turn-1' });
assert.equal(await first, true);
assert.equal(state().busy, false);
});
test('stopping retains a queued question and any newer draft without sending either', async () => {
const following=deferred(),questions=[];
const ui=fixture({startAnalysisTurn:async(_session,body)=>{questions.push(body.question);return {turn:{id:'turn-1'}};},
cancelAnalysisTurn:async()=>{},analysisTurn:async()=>({id:'turn-1',status:'CANCELLED'})}, {followTurn:()=>following.promise});
const pending=ui.submit('initial');await tick();
ui.setInput('queued follow-up');ui.queueFollowup();ui.setInput('new unsent draft');
await ui.cancelTurn();await ui.sendQueuedFollowup();
assert.equal(ui.get().query,'queued follow-up\n\nnew unsent draft');assert.equal(ui.get().queuedFollowup,'');
assert.deepEqual(questions,['initial']);following.resolve();await pending;
test('stopping keeps the queued question available for editing and does not send it', async t => {
const { client, requests, state } = fixture(t);
await client.openSession('session-1');
await client.submit('initial');
await client.submit('queued follow-up');
await client.cancel();
await tick();
requests.follows.at(-1).close();
await tick();
assert.equal(state().queuedQuestion, 'queued follow-up');
assert.deepEqual(requests.starts.map(request => request.question), ['initial']);
assert.equal(client.takeQueued(), 'queued follow-up');
assert.equal(state().queuedQuestion, '');
});
test('a failed stop request allows another explicit stop attempt', async () => {
const following=deferred();let cancellationCount=0;
const ui=fixture({startAnalysisTurn:async()=>({turn:{id:'turn-1'}}),cancelAnalysisTurn:async()=>{cancellationCount++;if(cancellationCount===1)throw new Error('offline');},
analysisTurn:async()=>({id:'turn-1',status:'CANCELLED'})}, {followTurn:()=>following.promise});
const pending=ui.submit('initial');await tick();await ui.cancelTurn();
assert.equal(ui.get().stopping,false);assert.equal(ui.get().busy,true);
await ui.cancelTurn();assert.equal(cancellationCount,2);assert.equal(ui.get().busy,false);
following.resolve();await pending;
test('a failed stop request allows another explicit stop attempt', async t => {
let count = 0;
const { client, pages, state } = fixture(t, {
cancelAnalysisTurn: async id => {
if (++count === 1) throw new Error('offline');
pages['session-1'] = page('session-1', [saved(id, 'CANCELLED')]);
return { status: 'CANCELLED', turnId: id };
},
});
await client.openSession('session-1');
await client.submit('initial');
assert.equal(await client.cancel(), false);
assert.equal(state().stopping, false);
assert.equal(state().busy, true);
assert.equal(await client.cancel(), true);
assert.equal(count, 2);
assert.equal(state().busy, false);
});
test('unknown 503 submission renders recovery notice without claiming a queued or running task', async () => {
const ui=fixture({startAnalysisTurn:async()=>{throw Object.assign(new Error('service unavailable'),{status:503});}});
await ui.submit('question with unknown outcome');
assert.equal(ui.get().attempt.uncertain,true);
const html=renderDraft(ui.get().lastTurn);
assert.doesNotMatch(html,/提交结果暂未确认/);
assert.doesNotMatch(html,/排队中|正在准备分析|仍在运行/);
assert.equal(ui.get().lastTurn.status,undefined);
test('a fresh submission immediately carries waiting status and a clock before acceptance', async t => {
const receipt = deferred();
const { client, pages, state } = fixture(t, { startAnalysisTurn: () => receipt.promise });
await client.openSession('session-1');
const pending = client.submit('即时状态');
assert.equal(state().turns.at(-1).status, 'SUBMITTING');
assert.ok(Number.isFinite(Date.parse(state().turns.at(-1)._uiSubmittedAt)));
const turn = saved('accepted', 'RUNNING', { question: '即时状态', createdAt: new Date().toISOString() });
pages['session-1'] = page('session-1', [turn], { activeTurnId: turn.id });
receipt.resolve({ turn });
assert.equal(await pending, true);
assert.equal(state().turns.at(-1).id, 'accepted');
assert.ok(Number.isFinite(Date.parse(state().turns.at(-1).createdAt)));
});
test('an explicit 400 rejection renders an unsuccessful draft without a running status', async () => {
const ui=fixture({startAnalysisTurn:async()=>{throw Object.assign(new Error('invalid question'),{status:400});}});
await ui.submit('rejected question');
assert.equal(ui.get().attempt,null);
const html=renderDraft(ui.get().lastTurn);
assert.doesNotMatch(html,/本次提交未成功/);
assert.doesNotMatch(html,/排队中|正在准备分析|仍在运行|恢复原任务/);
assert.equal(ui.get().lastTurn.status,undefined);
});
test('a fresh submission immediately carries waiting status and a clock before acceptance',async()=>{
const pending=deferred();const ui=fixture({startAnalysisTurn:()=>pending.promise});
const work=ui.submit('即时状态');assert.equal(ui.get().lastTurn.status,'SUBMITTING');
assert.ok(Number.isFinite(Date.parse(ui.get().lastTurn._uiSubmittedAt)));
pending.resolve({turn:{id:'accepted',status:'RUNNING'}});await work;
assert.ok(Number.isFinite(Date.parse(ui.get().lastTurn._uiSubmittedAt)));
});
test('retry starts a fresh waiting clock without displaying the old body or plan clock',async()=>{
const response=deferred();const ui=fixture({retryAnalysisTurn:()=>response.promise,analysisTurn:async()=>({id:'old',status:'QUEUED'})});
const work=ui.retryTurn({id:'old',status:'PARTIAL',answer:'old text',createdAt:'2020-01-01T00:00:00Z',startedAt:'2020-01-01T00:00:01Z',plan:{startedAt:'2020-01-01T00:00:01Z'}});
assert.equal(ui.get().lastTurn.status,'SUBMITTING');assert.equal(ui.get().lastTurn.answer,undefined);assert.equal(ui.get().lastTurn.plan,undefined);
response.resolve({turn:{id:'old',sessionId:'session-1',status:'QUEUED'}});await work;
test('retry starts a fresh waiting clock without the old answer or plan clock', async t => {
const receipt = deferred();
const old = saved('old', 'PARTIAL', {
answer: 'old text', createdAt: '2020-01-01T00:00:00Z', startedAt: '2020-01-01T00:00:01Z',
plan: { startedAt: '2020-01-01T00:00:01Z' },
});
const { client, pages, state } = fixture(t, { retryAnalysisTurn: () => receipt.promise }, {
'session-1': page('session-1', [old]),
});
await client.openSession('session-1');
const pending = client.retry('old');
const current = state().turns[0];
assert.equal(current.status, 'SUBMITTING');
assert.ok(Number.isFinite(Date.parse(current._uiSubmittedAt)));
assert.equal(current.answer, undefined);
assert.equal(current.plan, undefined);
assert.equal(current.startedAt, undefined);
const turn = saved('old', 'QUEUED');
pages['session-1'] = page('session-1', [turn], { activeTurnId: turn.id });
receipt.resolve({ turn });
assert.equal(await pending, true);
});