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; });