133 lines
14 KiB
JavaScript
133 lines
14 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');
|
|
const {RuleStore}=require('../../src/modules/order-rules/store.cjs');
|
|
const {activateReferenceMapping}=require('../fixtures/activate-field-mapping.cjs');
|
|
const restricted=require('../../src/modules/order-rules/restricted-test.cjs');
|
|
const admin={username:'admin',role:'admin'};
|
|
function fixture(t,{testing=false}={}){
|
|
const dir=fs.mkdtempSync(path.join(os.tmpdir(),'task-admission-')),desktop=path.join(dir,'Desktop'),local=path.join(desktop,'run');fs.mkdirSync(local,{recursive:true});
|
|
const root='\\\\localhost\\'+local[0]+'$'+local.slice(2);
|
|
const store=new RuleStore(path.join(dir,'state'),{clock:()=>new Date('2026-10-23T02:00:00Z'),desktopRoot:desktop,capabilities:{liveTodo:true,pdfExport:true,automaticArchive:true}});
|
|
t.after(()=>{store.close();fs.rmSync(dir,{recursive:true,force:true});});
|
|
const {sample,captured,active}=activateReferenceMapping(store,'bs-change',{connectionId:'c1',instanceId:'i1',taskId:'t1',receivedAt:store.now()});
|
|
const current=store.get('rules','bs-change').draft;
|
|
store.saveRule({...current,adapterIds:[active.id],to:['test@qq.com'],cc:[],attachPdf:false,archiveDirectory:root+'\\bs-change',filenameDate:'receivedAt'},'admin');
|
|
store.capturedPreview(captured.id);store.publish('bs-change',{version:store.get('rules','bs-change').draft.version},'admin');
|
|
if(testing){store.saveRestrictedTest({version:0,enabled:true,recipient:'test@qq.com',archiveRoot:root,channelId:'test-channel',ruleIds:['bs-change']},admin);store.saveSettings({...store.settings(),channelId:'test-channel'},'admin');}
|
|
return {store,sample,root};
|
|
}
|
|
function scan(store,rows){return restricted.recordCurrentScan(store,{connectionId:'c1',rows,startedAt:store.now(),finishedAt:store.now()});}
|
|
test('business revision is optional and repeated source-task remains one record across accounts',t=>{
|
|
const {store,sample}=fixture(t);delete sample.revision;
|
|
assert.equal(store.previewUntrusted(sample).valid,true);
|
|
const order=store.ingest(sample,'admin');
|
|
assert.equal(store.ingest({...sample,connectionId:'c2'},'admin').id,order.id);
|
|
assert.equal(Object.hasOwn(order.sample,'revision'),false);assert.equal(store.all('orders').length,1);
|
|
});
|
|
test('same source-task changed revision, instance, node or content conflicts; new task same order is independent',t=>{
|
|
const {store,sample}=fixture(t),first=store.ingest(sample,'admin');
|
|
for(const patch of [{revision:'actual-revision-2'},{instanceId:'another'},{nodeName:'BOM'},{title:'changed'}])assert.throws(()=>store.ingest({...sample,...patch},'admin'),{status:409});
|
|
assert.notEqual(store.ingest({...sample,taskId:'new-notification'},'admin').id,first.id);assert.equal(store.all('orders').length,2);
|
|
});
|
|
test('portal native sources stay distinct while multiple legacy records require manual review',t=>{
|
|
const {store,sample}=fixture(t),a=store.ingest({...sample,portalSource:'todo-v4'},'admin'),b=store.ingest({...sample,portalSource:'todo-v8'},'admin');assert.notEqual(a.id,b.id);
|
|
store.put('orders',{...a,id:'old-a'});assert.throws(()=>store.ingest({...sample,portalSource:'todo-v4'},'admin'),/人工|多条/);assert.equal(store.all('orders').length,3);
|
|
});
|
|
test('legacy receipt ids and frozen evidence survive identity lookup without recreating success',t=>{
|
|
const {store,sample}=fixture(t),old=store.ingest(sample,'admin');store.db.prepare('DELETE FROM records WHERE kind=? AND id=?').run('orders',old.id);
|
|
const legacy={...old,id:'original-receipt-id',status:'sent',archive:{original:'frozen'},batchId:'frozen-mail'};delete legacy.taskKey;store.put('orders',legacy);
|
|
assert.equal(store.ingest(sample,'admin').id,legacy.id);assert.deepEqual(store.get('orders',legacy.id),legacy);assert.equal(store.all('orders').length,1);
|
|
assert.throws(()=>store.ingest({...sample,revision:'2'},'admin'),{status:409});
|
|
});
|
|
test('only fresh server-scanned exact frozen scopes can enroll current backlog with original time preserved',t=>{
|
|
const {store,sample}=fixture(t,{testing:true}),old={...sample,receivedAt:'2026-10-20T01:00:00Z'};
|
|
assert.throws(()=>restricted.admitCurrent(store,[{...old,admittedAt:store.now(),serverVerified:true}],admin),{status:409});
|
|
scan(store,[old]);const entries=restricted.admitCurrent(store,[old],admin);assert.equal(entries.length,1);assert.equal(entries[0].originalReceivedAt,old.receivedAt);
|
|
const order=store.ingest(old,'admin');assert.equal(order.status,'identified',order.error);assert.equal(order.event.receivedAt,old.receivedAt);assert.equal(restricted.orderTime(store,order),store.now());
|
|
for(const patch of [{nodeName:'BOM'},{processVersion:'different'},{instanceId:'different'},{receivedAt:'2026-10-20T01:00:01Z'}])assert.throws(()=>restricted.assertEvent(store,{...old,...patch}),{status:409});
|
|
assert.throws(()=>store.ingest({...old,taskId:'unenrolled-history',admittedAt:store.now()},'admin'),{status:409});
|
|
});
|
|
test('enrollment rejects historical evidence, unconfirmed BOM, processed receipts and stale scans',t=>{
|
|
const {store,sample}=fixture(t,{testing:true});
|
|
for(const patch of [{source:'history',configurationOnly:true},{nodeName:'BOM'}]){const row={...sample,...patch};scan(store,[row]);assert.throws(()=>restricted.admitCurrent(store,[row],admin),{status:409});}
|
|
store.put('processed-task-receipts',{id:'original-success',source:'todo',taskId:sample.taskId,status:'sent',evidenceHash:'a'.repeat(64)});
|
|
scan(store,[sample]);assert.throws(()=>restricted.admitCurrent(store,[sample],admin),{status:409});assert.throws(()=>store.ingest(sample,'admin'),{status:409});
|
|
const row={...sample,taskId:'stale',receivedAt:'2026-10-20T01:00:00Z'};scan(store,[row]);store.clock=()=>new Date('2026-10-23T02:06:00Z');assert.throws(()=>restricted.admitCurrent(store,[row],admin),{status:409});
|
|
});
|
|
test('native coordinator discovers absent revision once and holds changed node or revision on original task',async t=>{
|
|
const {store,sample}=fixture(t);delete sample.revision;let row={...sample},captures=0,exports=0;
|
|
const connection={id:'c1',owner:'admin',status:'connected'},principal={user:admin,sessionId:'s'};
|
|
const execution=new (require('../../src/modules/order-execution/coordinator.cjs').OrderExecutionCoordinator)({store,workspace:{getConnection:()=>connection,snapshot:()=>({connections:[connection]})},clock:store.clock,
|
|
provider:{scan:async()=>[row],capabilities:()=>({liveTodo:true,pdfExport:true}),capture:async()=>{captures++;return {sample:{...row},snapshot:{processVersion:row.processVersion,fields:Object.entries(row.fields).map(([path,value])=>({path,value}))}};}},
|
|
archive:{capabilities:()=>({automaticArchive:true,pdfExport:true}),probe:async()=>({automaticArchive:true,pdfExport:true}),archive:async()=>{exports++;return {archivedAt:store.now(),files:[{name:'one.pdf',path:'C:\\archive\\one.pdf',size:1,sha256:'a'.repeat(64),kind:'pdf'}]};}}
|
|
});t.after(()=>execution.stop());
|
|
await execution.scan({connectionId:'c1',idempotencyKey:'first'},principal);await execution.scan({connectionId:'c1',idempotencyKey:'again'},principal);
|
|
const original=store.all('execution-tasks')[0];assert.equal(store.all('execution-tasks').length,1);assert.equal(exports,1);assert.equal(captures,1);
|
|
row={...row,nodeName:'BOM',revision:'actual-2'};await execution.scan({connectionId:'c1',idempotencyKey:'node-conflict'},principal);
|
|
const current=store.get('execution-tasks',original.id);assert.equal(current.conflict,true);assert.equal(current.conflictRow.revision,'actual-2');assert.equal(store.all('execution-tasks').length,1);assert.equal(exports,1);
|
|
await assert.rejects(execution.resolve(current.id,{version:current.version,idempotencyKey:'no-new-archive',resolution:'adopt',note:'不能用修订重复已归档任务'},principal),{status:409});
|
|
});
|
|
test('admitted backlog stays queued until the next configured window, including a missed first cutoff',t=>{
|
|
const {store,sample}=fixture(t,{testing:true}),old={...sample,receivedAt:'2026-10-20T01:00:00Z'};scan(store,[old]);restricted.admitCurrent(store,[old],admin);
|
|
const order=store.ingest(old,'admin');
|
|
store.recordArchive(order.id,{archivedAt:store.now(),files:[{name:'one.pdf',path:order.ruleSnapshot.archiveDirectory+'\\one.pdf',size:1,sha256:'a'.repeat(64),kind:'pdf'}]},'admin');
|
|
assert.equal(store.prepare('2026-10-23T03:00:00Z','admin').length,0,'cannot freeze ahead of the configured cutoff');
|
|
store.clock=()=>new Date('2026-10-23T03:02:00Z');scan(store,[old]);
|
|
assert.equal(store.prepare('2026-10-23T03:00:00Z','admin').length,0,'cannot catch up immediately after a missed window');assert.equal(store.get('orders',order.id).status,'pending');
|
|
store.clock=()=>new Date('2026-10-23T09:00:00Z');scan(store,[old]);const batches=store.prepare('2026-10-23T09:00:00Z','admin');assert.equal(batches.length,1);assert.deepEqual(batches[0].orderIds,[order.id]);assert.equal(store.get('orders',order.id).event.receivedAt,old.receivedAt);
|
|
});
|
|
test('legacy fabricated zero can reconcile missing revision without changing a successful receipt',t=>{
|
|
const {store,sample}=fixture(t),old=store.ingest({...sample,revision:'0'},'admin');delete old.taskKey;old.id='legacy-success';old.status='sent';old.archive={original:'success'};
|
|
store.db.prepare('DELETE FROM records WHERE kind=?').run('orders');store.put('orders',old);
|
|
const incoming={...sample};delete incoming.revision;
|
|
assert.equal(store.ingest(incoming,'admin').id,old.id);assert.deepEqual(store.get('orders',old.id),old);
|
|
const realZero={...old,id:'real-zero',taskId:'real',sample:{...old.sample,taskId:'real',reportedRevision:'0'}};store.put('orders',realZero);
|
|
assert.throws(()=>store.ingest({...incoming,taskId:'real'},'admin'),{status:409});
|
|
});
|
|
test('unconfirmed native nodes remain visible candidates and do not block confirmed categories',async t=>{
|
|
const {store,sample}=fixture(t),connection={id:'c1',owner:'admin',status:'connected'},principal={user:admin,sessionId:'s'},row={...sample,nodeName:'BOM资料编制'};
|
|
const execution=new (require('../../src/modules/order-execution/coordinator.cjs').OrderExecutionCoordinator)({store,workspace:{getConnection:()=>connection,snapshot:()=>({connections:[connection]})},clock:store.clock,provider:{scan:async()=>[row],capabilities:()=>({liveTodo:true,pdfExport:true})},archive:{capabilities:()=>({automaticArchive:true,pdfExport:true})}});t.after(()=>execution.stop());
|
|
await execution.scan({connectionId:'c1',idempotencyKey:'unconfirmed'},principal);
|
|
assert.equal(execution.snapshot(principal).candidates.length,1);assert.equal(execution.snapshot(principal).candidates[0].status,'candidate');assert.match(execution.snapshot(principal).candidates[0].reason,/不在.*通知范围/);assert.equal(store.all('execution-tasks').length,0);assert.equal(store.categoryIncomplete('bs-change',store.snapshot().window),false);
|
|
});
|
|
test('enrolled backlog must still be present unchanged in a fresh provider scan before freezing',t=>{
|
|
const {store,sample}=fixture(t,{testing:true}),old={...sample,receivedAt:'2026-10-20T01:00:00Z'};scan(store,[old]);restricted.admitCurrent(store,[old],admin);
|
|
const order=store.ingest(old,'admin');store.recordArchive(order.id,{archivedAt:store.now(),files:[{name:'one.pdf',path:order.ruleSnapshot.archiveDirectory+'\\one.pdf',size:1,sha256:'a'.repeat(64),kind:'pdf'}]},'admin');
|
|
store.clock=()=>new Date('2026-10-23T03:00:00Z');scan(store,[]);assert.equal(store.prepare('2026-10-23T03:00:00Z','admin').length,0);assert.equal(store.get('orders',order.id).status,'pending');
|
|
scan(store,[{...old,title:'changed after enrollment'}]);assert.equal(store.prepare('2026-10-23T03:00:00Z','admin').length,0);
|
|
scan(store,[old]);assert.equal(store.prepare('2026-10-23T03:00:00Z','admin').length,1);
|
|
});
|
|
|
|
test('proof-admitted backlog survives a later processing baseline and keeps its original received time',async t=>{
|
|
const {store,sample,root}=fixture(t,{testing:true});
|
|
const old={...sample,receivedAt:'2026-10-20T01:00:00Z'};
|
|
scan(store,[old]);
|
|
const entries=restricted.admitCurrent(store,[old],admin);
|
|
assert.equal(entries.length,1);
|
|
const admission=structuredClone(entries[0]);
|
|
assert.equal(restricted.isAdmitted(store,old),true);
|
|
store.clock=()=>new Date('2026-10-23T02:01:00Z');
|
|
store.saveSettings({...store.settings(),processingEnabled:true},'admin');
|
|
const unadmitted={...sample,taskId:'unadmitted',receivedAt:'2026-10-23T02:00:30Z',admittedAt:'2026-10-23T02:02:00Z',serverVerified:true};
|
|
const historical={...unadmitted,taskId:'historical',receivedAt:'2026-10-20T01:00:00Z'};
|
|
let archives=0;
|
|
const connection={id:'c1',owner:'admin',status:'connected'},principal={user:admin,sessionId:'admitted-baseline'};
|
|
const execution=new (require('../../src/modules/order-execution/coordinator.cjs').OrderExecutionCoordinator)({store,clock:store.clock,
|
|
workspace:{getConnection:()=>connection,snapshot:()=>({connections:[connection]})},
|
|
provider:{scan:async()=>[old,unadmitted,historical],capabilities:()=>({liveTodo:true,pdfExport:true}),capture:async(_connection,_principal,row)=>({sample:{...row},snapshot:{processVersion:row.processVersion,fields:Object.entries(row.fields).map(([path,value])=>({path,value}))}})},
|
|
archive:{capabilities:()=>({automaticArchive:true,pdfExport:true}),archive:async()=>{archives++;return {archivedAt:store.now(),files:[{name:'one.pdf',path:root+'\\bs-change\\one.pdf',size:1,sha256:'a'.repeat(64),kind:'pdf'}]};}},
|
|
});
|
|
t.after(()=>execution.stop());
|
|
await execution.scan({connectionId:'c1',idempotencyKey:'admitted-after-baseline'},principal);
|
|
const task=store.all('execution-tasks')[0];
|
|
assert.ok(task,'proof-admitted task must not be skipped by processingSince');
|
|
assert.deepEqual(store.all('execution-tasks').map(item=>item.row.taskId),['t1']);
|
|
const order=store.get('orders',task.orderId);
|
|
assert.equal(order.status,'pending',order.error);
|
|
assert.equal(order.event.receivedAt,old.receivedAt);
|
|
assert.equal(restricted.orderTime(store,order),'2026-10-23T02:00:00.000Z');
|
|
assert.equal(store.settings().processingSince,'2026-10-23T02:01:00.000Z');
|
|
assert.deepEqual(restricted.state(store).currentBacklog,[admission]);
|
|
assert.equal(archives,1);
|
|
});
|