Files
quality_analyse/web/verification/analysis_submission.test.mjs
T

215 lines
15 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.doesNotMatch(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.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;
});