Files
order-notification-automation/tests/order-rules/execution-single-flight.test.cjs
T

68 lines
4.0 KiB
JavaScript

'use strict';
const test=require('node:test'),assert=require('node:assert/strict');
const {OrderExecutionCoordinator}=require('../../src/modules/order-execution/coordinator.cjs');
const now='2026-10-26T02:00:00.000Z';
function deferred(){let resolve,reject;const promise=new Promise((yes,no)=>{resolve=yes;reject=no;});return {promise,resolve,reject};}
function fixture(t){
const records=new Map(),connection={id:'c1',owner:'admin',status:'connected'};
const store={
all:kind=>[...(records.get(kind)?.values()||[])].map(value=>structuredClone(value)),
get:(kind,id)=>structuredClone(records.get(kind)?.get(id)||null),
put(kind,value){if(!records.has(kind))records.set(kind,new Map());records.get(kind).set(value.id,structuredClone(value));},
transaction:work=>work(),settings:()=>({processingEnabled:true}),
clock:()=>new Date(now),schedule:()=>({times:['11:00','17:00'],weekends:false}),calendar:()=>[],
snapshot:()=>({window:{available:false}}),
};
const execution=new OrderExecutionCoordinator({store,workspace:{snapshot:()=>({connections:[connection]})},archive:{},clock:()=>new Date(now),systemPrincipal:{user:{username:'admin',role:'admin'},sessionId:'isolated-test'}});
t.after(()=>execution.stop());
return {execution,store,notify:runId=>execution.notifyDiscovery({connectionId:connection.id,runId,rows:[],startedAt:now,finishedAt:now})};
}
test('overlapping background ticks share the running discovery pass without duplicate scans',async t=>{
const f=fixture(t),entered=deferred(),release=deferred(),calls=[];
f.notify('first');f.notify('second');
f.execution.scan=async(input,principal,hint)=>{
calls.push(hint.runId);
if(calls.length===1){entered.resolve();await release.promise;}
f.store.put('execution-scans',{id:'c1',status:'complete',startedAt:now,finishedAt:now});
};
const first=f.execution.background();await entered.promise;
const overlap=Array.from({length:4},()=>f.execution.background());
const callsWhileBlocked=[...calls];
// Arrivals during a pass remain durable and are processed by the next pass.
f.notify('third');release.resolve();await Promise.all([first,...overlap]);
assert.deepEqual(callsWhileBlocked,['first'],'a slow capture must not queue the same discovery again');
assert.deepEqual(calls,['first','second']);
assert.equal(f.store.all('execution-discovery-runs').find(hint=>hint.runId==='third').status,'pending');
await f.execution.background();
assert.deepEqual(calls,['first','second','third']);
assert.ok(f.store.all('execution-discovery-runs').every(hint=>hint.status==='complete'));
});
test('background guard releases after an unexpected failure so the next tick can recover',async t=>{
const f=fixture(t),entered=deferred(),release=deferred();let calls=0;
f.execution.performBackground=async()=>{calls++;entered.resolve();await release.promise;throw Error('isolated background failure');};
const first=f.execution.background();await entered.promise;
const second=f.execution.background();release.resolve();
const results=await Promise.allSettled([first,second]);
assert.equal(calls,1);assert.ok(results.every(result=>result.status==='rejected'));
f.execution.performBackground=async()=>{calls++;};
await f.execution.background();assert.equal(calls,2);
});
test('stop waits for the background pass to persist its final discovery receipt',async t=>{
const f=fixture(t),entered=deferred(),release=deferred();
f.notify('shutdown');
f.execution.scan=async()=>{entered.resolve();await release.promise;};
const running=f.execution.background();await entered.promise;
let stopped=false;
const stopping=f.execution.stop().then(()=>{stopped=true;});
// Allow a drain-only stop to resolve while its background continuation is pending.
await new Promise(resolve=>setImmediate(resolve));
const premature=stopped;
release.resolve();await Promise.all([running,stopping]);
assert.equal(premature,false,'shutdown must not close the store before final background writes');
assert.equal(f.store.all('execution-discovery-runs')[0].status,'complete');
assert.equal(f.store.get('execution-discoveries','c1').status,'complete');
});