import test from 'node:test'; import assert from 'node:assert/strict'; import fs from 'node:fs'; import ts from 'typescript'; import {analysisComposerState} from '../src/analysisScope.ts'; const source=fs.readFileSync(new URL('../src/ManagementPages.tsx',import.meta.url),'utf8'); const tick=()=>new Promise(resolve=>setImmediate(resolve)); const deferred=()=>{let resolve;const promise=new Promise(r=>resolve=r);return{promise,resolve};}; function restoreFixture({sessionId='',turnId='',link=false}={}){ const list=deferred(),opens=[];let effect,loading=true; const env={active:true,restoreStarted:{current:false},mounted:{current:true},navigationGeneration:{current:0},initialSessionId:sessionId,initialTurnId:turnId,initialLink:{present:link},user:{id:'u'}, useEffect:fn=>{effect=fn;},setHistoryLoading:v=>{loading=v;},setSessions(){},setSessionsLoaded(){},setSessionsLoading(){},collectionItems:v=>v.items||[], loadSessions:async()=>(await list.promise).items,api:{analysisSessions:()=>list.promise,analysisTurn:async()=>({sessionId:'linked-session'})},defaultAnalysisSession:(_u,items)=>items[0]?.id, openSession:async(...args)=>{opens.push(args);loading=false;return true;},onUnauthorized:()=>false,setError(){},apiMessage:e=>e.message}; const marker=' useEffect(() => {\n if (!active || restoreStarted.current)';const start=source.indexOf(marker);const end=source.indexOf('\n useEffect(() => {',start+marker.length); const code=ts.transpileModule(source.slice(start,end),{compilerOptions:{target:ts.ScriptTarget.ES2022}}).outputText; new Function(...Object.keys(env),code)(...Object.values(env));effect(); return{list,opens,get loading(){return loading;}}; } test('an explicit history link loads its body without waiting for the unrelated session list',async()=>{ const ui=restoreFixture({sessionId:'requested-session'});await tick();assert.deepEqual(ui.opens,[['requested-session',undefined]]); ui.list.resolve({items:[]});await tick(); }); test('a turn link can resolve its session while the session list is still pending',async()=>{ const ui=restoreFixture({turnId:'requested-turn'});await tick();assert.deepEqual(ui.opens,[['linked-session','requested-turn']]); ui.list.resolve({items:[]});await tick(); }); test('default history selection still waits for the list before choosing a session',async()=>{ const ui=restoreFixture();await tick();assert.equal(ui.opens.length,0);ui.list.resolve({items:[{id:'recent'}]});await tick();assert.deepEqual(ui.opens,[['recent',undefined]]); }); function listFixture(){ const read=deferred();let reads=0,state={busy:false,loaded:false,items:[],error:''}; const env={mounted:{current:true},active:true,sessionReadRequest:{current:null},setSessionsLoading:v=>{state.busy=v;},setSessions:v=>{state.items=v;},setSessionsLoaded:v=>{state.loaded=v;},setSessionsError:v=>{state.error=v;},onUnauthorized:()=>false,apiMessage:e=>e.message,collectionItems:v=>v.items||[],api:{analysisSessions:()=>{reads++;return read.promise;}}}; const start=source.indexOf(' const loadSessions = async');const end=source.indexOf('\n const retrySessions =',start); const code=ts.transpileModule(source.slice(start,end)+'\nreturn loadSessions;',{compilerOptions:{target:ts.ScriptTarget.ES2022}}).outputText; return{read,state,reads:()=>reads,load:new Function(...Object.keys(env),code)(...Object.values(env))}; } test('session-list reads are shared, and failure stays within the list resource',async()=>{ const ui=listFixture();const a=ui.load(),b=ui.load();assert.equal(ui.reads(),1);assert.equal(ui.state.busy,true); ui.read.resolve({items:[{id:'recent'}]});assert.deepEqual(await a,[{id:'recent'}]);await b;assert.equal(ui.state.loaded,true);assert.equal(ui.state.busy,false); ui.read.resolve({items:[]}); }); test('a failed list read ends its own loading state and cannot masquerade as an empty successful list',async()=>{ const ui=listFixture();const work=ui.load();ui.read.resolve(Promise.reject(new Error('list unavailable')));assert.equal(await work,undefined); assert.equal(ui.state.busy,false);assert.equal(ui.state.loaded,false);assert.equal(ui.state.error,'list unavailable'); }); test('ordinary and explicit historical conversations never download the unused options resource',()=>{ const start=source.indexOf(' useEffect(() => {\n if (!active || !initialLink.present');assert.notEqual(start,-1); const end=source.indexOf('\n\n',start);const code=ts.transpileModule(source.slice(start,end),{compilerOptions:{target:ts.ScriptTarget.ES2022}}).outputText; for(const [present,session,turn] of [[false,'',''],[false,'s',''],[true,'s',''],[true,'','t']]){ let reads=0;const env={useEffect:fn=>fn(),active:true,initialLink:{present},initialSessionId:session,initialTurnId:turn,optionsRequestStarted:{current:false},optionsRead:{run:()=>{reads++;}},onUnauthorized:()=>false}; new Function(...Object.keys(env),code)(...Object.values(env));assert.equal(reads,0); } }); function retryFixture(sessionId='',turnId=''){ const list=deferred(),opens=[],navigationGeneration={current:0},state={historyLoading:false}; const env={sessionId,navigationGeneration,pendingTurnLink:{current:turnId},mounted:{current:true},initialLink:{present:false},user:{id:'u'},setHistoryLoading:v=>{state.historyLoading=v;},loadSessions:()=>list.promise,api:{analysisTurn:async()=>({sessionId:'target-session'})},openSession:async(id,focus)=>opens.push([id,focus]),defaultAnalysisSession:(_u,items)=>items[0]?.id,onUnauthorized:()=>false,setError(){},apiMessage:e=>e.message}; const start=source.indexOf(' const retrySessions = async');const end=source.indexOf('\n useEffect(',start); const code=ts.transpileModule(source.slice(start,end)+'\nreturn retrySessions;',{compilerOptions:{target:ts.ScriptTarget.ES2022}}).outputText; return{list,opens,state,navigationGeneration,retry:new Function(...Object.keys(env),code)(...Object.values(env))}; } test('retrying a linked history does not wait for a slow list',async()=>{ const ui=retryFixture('selected');await ui.retry();assert.deepEqual(ui.opens,[['selected',undefined]]);ui.list.resolve([]); }); test('default-list retry cannot navigate over a newer user selection',async()=>{ const ui=retryFixture();const work=ui.retry();ui.navigationGeneration.current++;ui.list.resolve([{id:'old-default'}]);await work;assert.deepEqual(ui.opens,[]); }); test('retry of a turn-only link re-resolves the requested turn instead of opening an unrelated default',async()=>{ const ui=retryFixture('','requested-turn');ui.list.resolve([{id:'unrelated-default'}]);await ui.retry();assert.deepEqual(ui.opens,[['target-session','requested-turn']]); }); test('default-history retry locks sending until its target resolves, so a late list cannot replace a new submission',async()=>{ const ui=retryFixture();const work=ui.retry();assert.equal(ui.state.historyLoading,true); assert.equal(analysisComposerState(false,false,ui.state.historyLoading,'新问题').sendDisabled,true); ui.list.resolve([{id:'default'}]);await work;assert.equal(ui.state.historyLoading,false); });