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

139 lines
18 KiB
JavaScript

'use strict';
const test=require('node:test'),assert=require('node:assert/strict'),fs=require('node:fs'),os=require('node:os'),path=require('node:path'),crypto=require('node:crypto');
const {RuleStore}=require('../../src/modules/order-rules/store.cjs');
const {OrderExecutionCoordinator}=require('../../src/modules/order-execution/coordinator.cjs');
const {OrderRuleDispatcher}=require('../../src/modules/order-rules/dispatcher.cjs');
const admin={username:'admin',role:'admin'},principal={user:admin,sessionId:'test-session'};
function fixture(t){
const dir=fs.mkdtempSync(path.join(os.tmpdir(),'execution-'));const now=()=>new Date('2026-10-19T02:00:00Z');
const store=new RuleStore(dir,{clock:now});t.after(()=>{store.close();fs.rmSync(dir,{recursive:true,force:true});});
const connection={id:'c1',owner:'admin',status:'connected'},workspace={getConnection:()=>connection,snapshot:()=>({connections:[connection]})};
let captures=0,exports=0,failCapture=false;
const row={source:'todo',instanceId:'i1',taskId:'t1',revision:'1',processName:'备损订单更改评审',nodeName:'订单专员(订单通知书)',processVersion:'1.4',receivedAt:'2026-10-19T01:00:00Z',serialNum:'S1',title:'订单号:SO-1 客户简称:真实客户'};
const provider={capabilities:()=>({liveTodo:true,pdfExport:true,message:'actual probe'}),scan:async(c,p)=>{assert.equal(p.sessionId,'test-session');return [row];},capture:async()=>{captures++;if(failCapture)throw Error('capture unavailable');return {sample:{...row,connectionId:'c1',brief:'摘要',fields:{order:'SO-1',brief:'真实摘要'}},snapshot:{processVersion:'1.4',html:'<p>real fixture</p>',fields:[{path:'order',label:'订单号',value:'SO-1'},{path:'brief',label:'摘要',value:'真实摘要'}]}};}};
const archive={probe:async()=>({automaticArchive:true,pdfExport:true,message:'runtime'}),capabilities:()=>({automaticArchive:true,pdfExport:true}),archive:async()=>{exports++;const content=Buffer.from('%PDF-1.7\nfixture');const file=path.join(dir,'order.pdf');fs.writeFileSync(file,content);return {archivedAt:now().toISOString(),files:[{name:'order.pdf',path:file,size:content.length,sha256:crypto.createHash('sha256').update(content).digest('hex'),kind:'pdf'}]};}};
const execution=new OrderExecutionCoordinator({store,workspace,provider,archive,clock:now});
return {store,execution,row,provider,archive,principal,setFail:v=>{failCapture=v;},counts:()=>({captures,exports})};
}
async function configure(f){
await f.execution.scan({connectionId:'c1',idempotencyKey:'first'},principal);
const captured=f.store.fields().samples[0];
const adapter=f.store.saveAdapter({sampleId:captured.id,processName:f.row.processName,processVersion:'1.4',fields:{orderNo:'order',brief:'brief'}},admin);
const current=f.store.snapshot().rules.find(r=>r.id==='bs-change');
const saved=f.store.saveRule({...current,adapterIds:[adapter.id],to:['orders@example.test'],archiveDirectory:'\\\\server\\orders',filenameDate:'receivedAt'},'admin');
assert.equal(f.store.capturedPreview(captured.id).valid,true);f.store.publish(saved.id,{version:saved.version},'admin');
}
test('capture-backed dynamic binding recovers blocked task with stable identity and exports only once',async t=>{
const f=fixture(t);await configure(f);await f.execution.scan({connectionId:'c1',idempotencyKey:'second'},principal);
assert.equal(f.store.all('orders')[0].status,'pending');assert.equal(f.execution.snapshot().tasks.length,1);assert.equal(f.counts().exports,1);
await f.execution.scan({connectionId:'c1',idempotencyKey:'third'},principal);assert.equal(f.counts().exports,1);assert.equal(f.execution.snapshot().capabilities.automaticArchive,true);
assert.throws(()=>f.store.saveAdapter({sampleId:f.store.fields().samples[0].id,processName:f.row.processName,processVersion:'1.4',fields:{orderNo:'invented',brief:'brief'}},admin),/字段/);
});
test('capture failures block the entire category rather than silently omitting an order',async t=>{
const f=fixture(t);await configure(f);await f.execution.scan({connectionId:'c1',idempotencyKey:'second'},principal);
f.row.taskId='t2';f.row.instanceId='i2';f.setFail(true);await f.execution.scan({connectionId:'c1',idempotencyKey:'third'},principal);
assert.equal(f.execution.snapshot().tasks.filter(t=>t.status==='failed').length,1);
assert.equal(f.store.prepare('2026-10-19T03:00:00Z','admin').length,0);
});
test('failed frozen batch resend is versioned admin-only idempotent and cannot replay unknown',async t=>{
const f=fixture(t);await configure(f);await f.execution.scan({connectionId:'c1',idempotencyKey:'second'},principal);
f.store.saveSettings({...f.store.settings(),channelId:'channel1'},'admin');const batch=f.store.prepare('2026-10-19T03:00:00Z','admin')[0];f.store.finishSending(batch.id,'failed','SMTP verify failed');
let sends=0;const mail={exclusive:async(id,fn)=>fn(),store:{channelSecret:id=>({id,version:1,email:'sender@example.test',name:'s',smtp:{}}),guard:()=>{}},smtpFactory:()=>({verify:async()=>{},sendMail:async message=>{sends++;assert.deepEqual(message.to,['orders@example.test']);return {accepted:message.to,rejected:[]};},close:()=>{}})};
const dispatcher=new OrderRuleDispatcher({store:f.store,mail,clock:()=>new Date('2026-10-21T00:00:00Z'),providersReady:()=>true});
const input={version:f.store.get('batches',batch.id).version,idempotencyKey:'resend1',note:'已检查SMTP已修复'};
await assert.rejects(dispatcher.resend(batch.id,input,{username:'op',role:'operator'}),{status:403});
const sent=await dispatcher.resend(batch.id,input,admin);assert.equal(sent.status,'sent');assert.equal(sent.parentBatchId,batch.id);
assert.equal((await dispatcher.resend(batch.id,input,admin)).id,sent.id);assert.equal(sends,1);
await assert.rejects(dispatcher.resend(batch.id,{...input,note:'与原请求不同的依据'},admin),{status:409});
await assert.rejects(dispatcher.resend(batch.id,{...input,idempotencyKey:'again'},admin),{status:409});
});
test('scope, calendar and pause gates survive actual persisted capture provenance',async t=>{
const f=fixture(t);await configure(f);
assert.equal(f.execution.snapshot({user:{username:'other',role:'operator'},sessionId:'other'}).fields.samples.length,0);
assert.equal(f.execution.snapshot({user:{username:'other',role:'operator'},sessionId:'other'}).tasks.length,0);
await assert.rejects(f.execution.scan({connectionId:'c1',idempotencyKey:'foreign'}, {user:{username:'other',role:'operator'},sessionId:'other'}),{status:403});
let scans=0;const scan=f.provider.scan;f.provider.scan=async(...args)=>{scans++;return scan(...args);};
f.execution.systemPrincipal=principal;await f.execution.background();assert.equal(scans,0);
f.store.saveSettings({...f.store.settings(),enabled:true,channelId:'channel1'},'admin');f.execution.settings=()=>({schedule:{times:['11:00','17:00'],weekends:false}});f.execution.calendar=()=>[{date:'2026-10-19',kind:'pause',scan:false,send:false}];
await f.execution.background();assert.equal(scans,0);
f.execution.calendar=()=>[];await f.execution.background();assert.equal(scans,1);
const captured=f.store.fields().samples[0],adapter=f.store.fields().adapters.find(a=>a.sampleId===captured.id);
f.store.saveAdapter({sampleId:captured.id,processName:captured.processName,processVersion:captured.processVersion,fields:adapter.fields,version:adapter.version},admin);
assert.equal(f.store.get('rules','bs-change').published.status,'paused');
assert.throws(()=>f.store.publish('bs-change',{version:f.store.get('rules','bs-change').draft.version},'admin'),{status:409});
});
test('restart converts a never-sent manual attempt into a reachable failed attempt',async t=>{
const dir=fs.mkdtempSync(path.join(os.tmpdir(),'resend-restart-'));let store=new RuleStore(dir);t.after(()=>{store.close();fs.rmSync(dir,{recursive:true,force:true});});
store.put('orders',{id:'o1',status:'batched',batchId:'manual1'});store.put('batches',{id:'manual1',version:1,manual:true,status:'prepared',orderIds:['o1']});
store.close();store=new RuleStore(dir);assert.equal(store.get('batches','manual1').status,'failed');assert.equal(store.get('orders','o1').status,'pending');
store.put('batches',{id:'manual2',version:1,manual:true,status:'sending',orderIds:['o1']});store.put('orders',{id:'o1',status:'batched',batchId:'manual2'});
store.close();store=new RuleStore(dir);assert.equal(store.get('batches','manual2').status,'unknown');assert.equal(store.get('orders','o1').status,'unknown');
});
test('workspace exceptions deduplicate per task and recovery requests verification without claiming manual closure',async t=>{
const {WorkspaceStore}=require('../../src/modules/workspace/store.cjs');const f=fixture(t),dir=fs.mkdtempSync(path.join(os.tmpdir(),'execution-exception-')),workspace=new WorkspaceStore(dir);t.after(()=>{workspace.close();fs.rmSync(dir,{recursive:true,force:true});});
const connection=f.execution.workspace.getConnection('c1');f.execution.workspace={getConnection:()=>connection,snapshot:()=>({...workspace.snapshot(),connections:[connection]}),createException:workspace.createException.bind(workspace),actOnException:workspace.actOnException.bind(workspace),record:workspace.record.bind(workspace)};
await configure(f);await f.execution.scan({connectionId:'c1',idempotencyKey:'recover'},principal);assert.equal(workspace.snapshot().exceptions.length,1);assert.equal(workspace.snapshot().exceptions[0].status,'verifying');assert.equal(f.execution.snapshot().tasks[0].recovery.status,'awaiting_verification');
connection.owner='';f.row.taskId='unassigned';f.row.instanceId='unassigned';f.setFail(true);await f.execution.scan({connectionId:'c1',idempotencyKey:'failed-unassigned'},principal);
f.setFail(false);await f.execution.scan({connectionId:'c1',idempotencyKey:'recover-unassigned'},principal);const item=workspace.snapshot().exceptions.find(e=>!e.owner);assert.equal(item.status,'open');assert.equal(f.execution.snapshot().tasks.find(t=>t.row.taskId==='unassigned').recovery.status,'awaiting_verification');assert.equal(workspace.snapshot().exceptions.filter(e=>e.status==='resolved').length,0);
});
test('interrupted archive recovery is explicitly retried and never silently replayed by scan',async t=>{
const f=fixture(t);await configure(f);f.archive.supportsRecovery=true;
const archive=f.archive.archive;f.archive.archive=async()=>{throw Error('worker interrupted');};
await f.execution.scan({connectionId:'c1',idempotencyKey:'second'},principal);
const task=f.execution.snapshot().tasks[0];assert.equal(task.status,'failed');assert.equal(task.step,'archive');
f.archive.archive=archive;await f.execution.scan({connectionId:'c1',idempotencyKey:'third'},principal);assert.equal(f.counts().exports,0);
await f.execution.retry(task.id,{version:task.version,idempotencyKey:'retry',note:'已核对归档幂等凭据'},principal);
assert.equal(f.execution.snapshot().tasks[0].status,'pending');assert.equal(f.counts().exports,1);
const running=f.store.get('execution-tasks',task.id);running.status='archiving';f.store.put('execution-tasks',running);
const restarted=new OrderExecutionCoordinator({...f.execution,store:f.store,workspace:f.execution.workspace,provider:f.provider,archive:f.archive});
assert.equal(restarted.snapshot().tasks[0].status,'failed');await restarted.stop();
});
test('unknown send first requires recorded verification; only then frozen manual resend is reachable',async t=>{
const f=fixture(t);await configure(f);await f.execution.scan({connectionId:'c1',idempotencyKey:'second'},principal);
f.store.saveSettings({...f.store.settings(),channelId:'channel1'},'admin');const batch=f.store.prepare('2026-10-19T03:00:00Z','admin')[0];
f.store.beginSending(batch.id);f.store.finishSending(batch.id,'unknown','connection lost');
const dispatcher=new OrderRuleDispatcher({store:f.store,mail:{exclusive:async(id,fn)=>fn()},providersReady:()=>true});
await assert.rejects(dispatcher.resend(batch.id,{version:f.store.get('batches',batch.id).version,idempotencyKey:'bad',note:'尚未完成服务端核对'},admin),{status:409});
const resolveInput={version:f.store.get('batches',batch.id).version,idempotencyKey:'verified',resolution:'retry',note:'服务器确认未接受本次邮件'};
assert.throws(()=>f.store.resolve(batch.id,{...resolveInput,version:0},'admin',{controlled:true}),{status:409});
const resolved=f.store.resolve(batch.id,resolveInput,'admin',{controlled:true});assert.equal(resolved.status,'failed');
assert.equal(f.store.resolve(batch.id,resolveInput,'admin',{controlled:true}).status,'failed');
assert.throws(()=>f.store.resolve(batch.id,{...resolveInput,note:'与原来不同的核验结论'},'admin',{controlled:true}),{status:409});
assert.equal(f.store.prepare('2026-10-19T03:00:00Z','system').length,0);
});
test('all fifteen categories capture actual fixture fields, archive to temporary files and send through real loopback SMTP',async t=>{
const {SMTPServer}=require('smtp-server'),nodemailer=require('nodemailer'),{simpleParser}=require('mailparser');
const f=fixture(t),rows=f.store.snapshot().rules.map((rule,i)=>({...f.row,instanceId:'i'+i,taskId:'t'+i,processName:rule.processNames[0],nodeName:rule.nodeNames[0],processVersion:'fixture-1',title:'订单号:SO-'+i,serialNum:'S'+i}));
f.provider.scan=async()=>rows;
f.provider.capture=async(connection,principal,row)=>({sample:{...row,connectionId:connection.id,fields:{'actual.order':'SO-'+row.taskId,'actual.summary':'采集摘要'}},snapshot:{processVersion:row.processVersion,html:'<p>captured fixture</p>',fields:[{path:'actual.order',label:'订单号',value:'SO-'+row.taskId},{path:'actual.summary',label:'摘要',value:'采集摘要'}]}});
await f.execution.scan({connectionId:'c1',idempotencyKey:'capture15'},principal);
for(const [index,current] of f.store.snapshot().rules.entries()){
const captured=f.store.fields().samples.find(s=>s.processName===rows[index].processName);
const adapter=f.store.saveAdapter({sampleId:captured.id,processName:captured.processName,processVersion:captured.processVersion,fields:{orderNo:'actual.order',brief:'actual.summary'}},admin);
const saved=f.store.saveRule({...current,processNames:[captured.processName],nodeNames:[rows[index].nodeName],adapterIds:[adapter.id],to:['orders@example.test'],archiveDirectory:'\\\\server\\orders',filenameDate:'receivedAt'},'admin');
assert.equal(f.store.capturedPreview(captured.id).valid,true);f.store.publish(saved.id,{version:saved.version},'admin');
}
await f.execution.scan({connectionId:'c1',idempotencyKey:'archive15'},principal);assert.equal(f.store.all('orders').filter(o=>o.status==='pending').length,15);
let messages=[];const smtp=new SMTPServer({secure:false,hideSTARTTLS:true,authOptional:true,disabledCommands:['AUTH'],onData(stream,session,cb){const chunks=[];stream.on('data',chunk=>chunks.push(chunk));stream.on('end',()=>{messages.push(Buffer.concat(chunks));cb();});}});
await new Promise(resolve=>smtp.listen(0,'127.0.0.1',resolve));t.after(()=>new Promise(resolve=>smtp.close(resolve)));
const mail={exclusive:async(id,work)=>work(),store:{channelSecret:id=>({id,version:1,email:'sender@example.test',name:'通知',smtp:{}}),guard:()=>{}},smtpFactory:()=>nodemailer.createTransport({host:'127.0.0.1',port:smtp.server.address().port,secure:false,ignoreTLS:true})};
f.store.saveSettings({...f.store.settings(),enabled:true,channelId:'channel1'},'admin');
let now=new Date('2026-10-19T02:59:00Z');const dispatcher=new OrderRuleDispatcher({store:f.store,mail,settings:()=>({schedule:{times:['11:00','17:00'],weekends:false}}),clock:()=>now,providersReady:()=>true,templateResolver:()=>({id:'template',version:1,subject:'ignored',text:'模板{{订单列表}}',html:'<div>{{订单列表}}</div>',to:['intruder@example.test'],attachments:[]})});
await dispatcher.tick();now=new Date('2026-10-19T03:00:00Z');await dispatcher.tick();await dispatcher.stop();
assert.equal(messages.length,15);assert.equal(f.store.all('batches').filter(b=>b.status==='sent').length,15);
for(const [index,raw] of messages.entries()){const message=await simpleParser(raw);assert.deepEqual(message.to.value.map(x=>x.address),['orders@example.test']);assert.match(message.text,/模板/);assert.match(message.text,/SO-/);assert.equal(message.attachments.length,f.store.all('batches')[index].ruleSnapshot.attachPdf?1:0);}
assert.equal(f.counts().exports,15);
});
for(const partial of [false,true])test(`real loopback SMTP ${partial?'partial refusal stays unknown':'complete envelope refusal is explicitly failed'}`,async t=>{
const {SMTPServer}=require('smtp-server'),nodemailer=require('nodemailer');const f=fixture(t);await configure(f);
const current=f.store.snapshot().rules.find(r=>r.id==='bs-change'),saved=f.store.saveRule({...current,to:['accepted@example.test'],cc:['rejected@example.test']},'admin');
f.store.capturedPreview(f.store.fields().samples[0].id);f.store.publish(saved.id,{version:saved.version},'admin');
await f.execution.scan({connectionId:'c1',idempotencyKey:'archive'},principal);f.store.saveSettings({...f.store.settings(),enabled:true,channelId:'channel1'},'admin');
let messages=0;const smtp=new SMTPServer({secure:false,hideSTARTTLS:true,authOptional:true,disabledCommands:['AUTH'],onRcptTo(address,session,cb){if(!partial||address.address==='rejected@example.test'){const error=Error('Recipient refused');error.responseCode=550;return cb(error);}cb();},onData(stream,session,cb){stream.resume();stream.on('end',()=>{messages++;cb();});}});
await new Promise(resolve=>smtp.listen(0,'127.0.0.1',resolve));t.after(()=>new Promise(resolve=>smtp.close(resolve)));
const mail={exclusive:async(id,work)=>work(),store:{channelSecret:id=>({id,version:1,email:'sender@example.test',name:'通知',smtp:{}}),guard:()=>{}},smtpFactory:()=>nodemailer.createTransport({host:'127.0.0.1',port:smtp.server.address().port,secure:false,ignoreTLS:true})};
let now=new Date('2026-10-19T02:59:00Z');const dispatcher=new OrderRuleDispatcher({store:f.store,mail,settings:()=>({schedule:{times:['11:00','17:00'],weekends:false}}),clock:()=>now,providersReady:()=>true});
await dispatcher.tick();now=new Date('2026-10-19T03:00:00Z');await dispatcher.tick();await dispatcher.stop();assert.equal(f.store.all('batches')[0].status,partial?'unknown':'failed');assert.equal(messages,partial?1:0);
assert.equal(f.store.prepare('2026-10-19T03:00:00Z','system').length,0);
});