同步已上线的智能分析执行协议、来源查询、图表报告与管理页面配套代码。 补齐数据库迁移、运行依赖和回归测试,保留原有指标计算口径。 统一午夜黑及其他主题的控件细节、中文和业务数字字体。 排除本地业务数据、凭据、预览、发布与验收产物。 验证:生产构建通过,320项前端回归通过;本轮仅同步Git,不再次部署。
199 lines
14 KiB
JavaScript
199 lines
14 KiB
JavaScript
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';
|
|
|
|
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 }));
|
|
};
|
|
|
|
// 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);
|
|
}
|
|
|
|
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('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');
|
|
});
|
|
|
|
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);
|
|
});
|
|
|
|
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 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('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('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('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('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('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('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('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('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('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('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('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.match(html,/提交结果暂未确认,请重试上一问恢复原任务/);
|
|
assert.doesNotMatch(html,/排队中|正在准备分析|仍在运行/);
|
|
assert.equal(ui.get().lastTurn.status,undefined);
|
|
});
|
|
|
|
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.match(html,/本次提交未成功,请检查错误提示后重试/);
|
|
assert.doesNotMatch(html,/排队中|正在准备分析|仍在运行|恢复原任务/);
|
|
assert.equal(ui.get().lastTurn.status,undefined);
|
|
});
|