[Hackathon] fix(testlist): interrupted --wait drops acknowledged run IDs and completed results #484

import assert from 'node:assert/strict';
import {spawn} from 'node:child_process';
import {mkdtemp,readFile,writeFile,rm} from 'node:fs/promises';
import {tmpdir} from 'node:os';
import {join,resolve,dirname} from 'node:path';

// Real compiled CLI subprocess + real OS signals. Only HTTP is replaced.
// No actual service, jobs, credentials or credits are involved.
const root=resolve(process.argv[2]??'work/testsprite-cli');
const dir=await mkdtemp(join(tmpdir(),'testsprite-testlist-interrupt-'));
const preload=join(dir,'fixture.mjs');
await writeFile(preload,`
import assert from 'node:assert/strict';
import {writeFileSync} from 'node:fs';
import os from 'node:os';
import {syncBuiltinESMExports} from 'node:module';
os.homedir=()=>process.env.REPRO_HOME;syncBuiltinESMExports();
const trace=[],s=JSON.parse(process.env.REPRO_CASE),ids=['a','b','c'];
const stamp='2026-10-17T00:00:00Z';
process.on('exit',()=>writeFileSync(process.env.REPRO_TRACE,JSON.stringify(trace)));
const json=(body,status=200)=>new Response(JSON.stringify(body),{status,headers:{'content-type':'application/json'}});
globalThis.fetch=async(input,init={})=>{
 const u=new URL(typeof input==='string'?input:input.url??input.href),method=init.method??'GET';
 assert.equal(u.hostname,'mock.example.com');
 const path=u.pathname.replace('/api/cli/v1',''),row={method,path,at:Date.now()};trace.push(row);
 if(path==='/testlist/list_fixture'&&method==='GET')return json({
  id:'list_fixture',name:'Fixture list',orgId:'org_fixture',caseCount:3,
  projectEnvironments:[{projectId:'project_fixture',environmentName:'prod'}],lastExecutionId:null,
  createdAt:stamp,updatedAt:stamp,lastExecutionCreated:null,
  stats:{total:3,passed:3,failed:0,blocked:0,running:0},
  cases:ids.map(id=>({testId:'test_'+id,type:'frontend',projectId:'project_fixture',projectName:'Fixture project',title:id,category:null,priority:null,modified:null,status:'passed'}))});
 if(path==='/projects/project_fixture/env')return json({environments:[{name:'prod',url:'https://example.com',isDefault:true,isTemporary:false}]});
 if(path==='/testlist/list_fixture/run'&&method==='POST'){
  const response={accepted:ids.map(id=>({testId:'test_'+id,runId:'run_'+id,enqueuedAt:stamp})),conflicts:[],deferred:[]};
  row.body=JSON.parse(String(init.body));row.response=response;return json(response,202);
 }
 const match=/^\\/runs\\/run_([abc])$/.exec(path);
 if(match&&method==='GET'){
  const id=match[1];
  if(s.signal&&id===(s.beforeAny?'a':'b')){
   row.pending=true;assert.ok(init.signal,'long poll must carry AbortSignal');
   process.send({checkpoint:'poll-pending',runId:'run_'+id});
   return new Promise((resolve,reject)=>{
    const timer=setTimeout(()=>reject(new Error('Fixture watchdog: no signal received')),10000);
    const onAbort=()=>{clearTimeout(timer);row.aborted=true;reject(init.signal.reason??new DOMException('Aborted','AbortError'));};
    if(init.signal.aborted)onAbort();else init.signal.addEventListener('abort',onAbort,{once:true});
   });
  }
  const failed=id==='a'&&s.firstFailed;row.returnedStatus=failed?'failed':'passed';
  return json({runId:'run_'+id,testId:'test_'+id,projectId:'project_fixture',userId:'fixture',status:row.returnedStatus,
   source:'cli',createdAt:stamp,startedAt:stamp,finishedAt:'2026-10-17T00:00:01Z',codeVersion:'v1',targetUrl:'https://example.com',createdFrom:'cli',
   failedStepIndex:failed?0:null,failureKind:failed?'assertion':null,error:failed?'Fixture assertion failed':null,videoUrl:null,
   stepSummary:{total:1,completed:1,passedCount:failed?0:1,failedCount:failed?1:0}});
 }
 row.unexpected=true;throw Error('Unexpected fixture route '+method+' '+path);
};
`);

const scenarios=[
 {name:'testlist-completes-control',expectedExit:0},
 {name:'testlist-no-wait-receipt-control',noWait:true,expectedExit:0},
 {name:'testlist-sigint-before-any-result',signal:'SIGINT',beforeAny:true,expectedExit:130},
 {name:'testlist-sigint-after-passed-member',signal:'SIGINT',expectedExit:130},
 {name:'testlist-sigterm-after-failed-member',signal:'SIGTERM',firstFailed:true,expectedExit:143},
 {name:'testlist-text-sigint',signal:'SIGINT',text:true,expectedExit:130},
 {name:'multi-wait-sigint-control',signal:'SIGINT',waitMany:true,expectedExit:130},
];
const results=[];
try{
 for(const s of scenarios){
  const tracePath=join(dir,s.name+'.json');
  const args=['--output',s.text?'text':'json',...(s.waitMany?['test','wait','run_a','run_b','run_c']:['testlist','run','list_fixture']),
   ...(s.waitMany?[]:[s.noWait?'--no-wait':'--wait']),...(!s.noWait?['--timeout','10','--max-concurrency','1']:[])];
  const start=performance.now();
  const child=spawn(process.execPath,['--import',preload,join(root,'dist/index.js'),...args],{
   cwd:dir,stdio:['ignore','pipe','pipe','ipc'],env:{PATH:dirname(process.execPath)+':/usr/bin:/bin',
    TESTSPRITE_API_KEY:'sk-user-offline-fixture',TESTSPRITE_API_URL:'https://mock.example.com',TESTSPRITE_NO_TELEMETRY:'1',TESTSPRITE_NO_UPDATE_NOTIFIER:'1',
    REPRO_HOME:dir,REPRO_TRACE:tracePath,REPRO_CASE:JSON.stringify(s)}});
  let stdout='',stderr='',signalAt=null,checkpoint=null,watchdog=false;
  child.stdout.on('data',b=>stdout+=b);child.stderr.on('data',b=>stderr+=b);
  child.on('message',m=>{if(signalAt===null){checkpoint=m;setTimeout(()=>{signalAt=performance.now()-start;child.kill(s.signal);},20);}});
  const timer=setTimeout(()=>{watchdog=true;child.kill('SIGKILL');},15000);
  const ended=await new Promise((res,rej)=>{child.on('error',rej);child.on('close',(code,signal)=>res({code,signal}));});clearTimeout(timer);
  const trace=JSON.parse(await readFile(tracePath,'utf8'));
  assert.equal(watchdog,false,s.name);assert.equal(ended.signal,null,s.name);assert.equal(ended.code,s.expectedExit,stderr);
  assert.ok(!trace.some(x=>x.unexpected),s.name+': unexpected HTTP');
  const dispatch=trace.find(x=>x.path==='/testlist/list_fixture/run');
  if(s.waitMany)assert.equal(dispatch,undefined);else assert.equal(dispatch.response.accepted.length,3);
  let payload=null;if(stdout.trim()&&!s.text)payload=JSON.parse(stdout);
  if(s.signal){
   assert.ok(checkpoint&&signalAt!==null);assert.ok(trace.some(x=>x.aborted));
   if(!s.beforeAny)assert.equal(trace.find(x=>x.path==='/runs/run_a').returnedStatus,s.firstFailed?'failed':'passed');
   if(s.waitMany){
    assert.deepEqual(payload.results.map(x=>x.runId),['run_a','run_b','run_c']);
    assert.equal(payload.results[0].status,'passed');assert.equal(payload.results[1].status,'running');
    assert.ok(stderr.includes('testsprite test wait run_b run_c'));
   }else{
    assert.equal(stdout,'','current bug: accepted IDs and partial result disappear');
    for(const id of ['run_a','run_b','run_c'])assert.ok(!stderr.includes(id),'current bug: concrete recovery IDs absent');
   }
  }else{
   assert.deepEqual(payload.accepted.map(x=>x.runId),['run_a','run_b','run_c']);
   if(!s.noWait)assert.ok(payload.accepted.every(x=>x.status==='passed'));
  }
  results.push({name:s.name,args,...ended,elapsedMs:performance.now()-start,signalAt,checkpoint,watchdog,stdout,stderr,payload,trace});
 }
 console.log(JSON.stringify({baseline:'988c0355bb05631e9c6c1785e443937ff2a88c0e',node:process.version,platform:process.platform,scope:'offline compiled CLI subprocesses; actual SIGINT/SIGTERM; HTTP fixtures only',results},null,2));
}finally{await rm(dir,{recursive:true,force:true});}