140 lines
17 KiB
JavaScript
140 lines
17 KiB
JavaScript
'use strict';
|
|
const test=require('node:test'),assert=require('node:assert/strict'),crypto=require('node:crypto'),fs=require('node:fs'),os=require('node:os'),path=require('node:path');
|
|
const {DatabaseSync}=require('node:sqlite');
|
|
const {RuleStore}=require('../../src/modules/order-rules/store.cjs');
|
|
const {BpmVault}=require('../../src/platform/security/vault.cjs');
|
|
const {seedRules}=require('../../src/modules/order-rules/catalog.cjs');
|
|
const {Store}=require('../../src/modules/dashboard/store.cjs');
|
|
const {createDashboard}=require('../../src/app/dashboard.cjs');
|
|
const {activateReferenceMapping}=require('../fixtures/activate-field-mapping.cjs');
|
|
|
|
function memoryRules(t){
|
|
const rules=Object.create(RuleStore.prototype);rules.db=new DatabaseSync(':memory:');
|
|
rules.db.exec('CREATE TABLE records(kind TEXT NOT NULL,id TEXT NOT NULL,payload BLOB NOT NULL,PRIMARY KEY(kind,id))');
|
|
rules.vault=Object.create(BpmVault.prototype);rules.vault.key=crypto.randomBytes(32);
|
|
rules.clock=()=>new Date('2026-10-27T02:00:00Z');rules.schedule=()=>({times:['11:00','17:00'],weekends:false});rules.calendar=()=>[];rules.capabilities={liveTodo:true,pdfExport:false,automaticArchive:false};
|
|
rules.put('settings',{id:'main',version:1,enabled:false,processingEnabled:true,channelId:'channel',maxMessageBytes:20971520});
|
|
for(const draft of seedRules())rules.put('rules',{id:draft.id,draft,published:null,trialVersion:null,trialDemo:null});
|
|
t.after(()=>rules.close());return rules;
|
|
}
|
|
function poisonHistory(rules){
|
|
// Any accidental historic read must fail real AES decryption, rather than pass a mock call check.
|
|
for(const kind of ['orders','batches','execution-tasks','capture-samples','audit'])rules.db.prepare('INSERT OR REPLACE INTO records VALUES(?,?,?)').run(kind,'unreadable-history',Buffer.from('not encrypted'));
|
|
}
|
|
async function dashboard(t,{rules=memoryRules(t),mail,storage}={}){
|
|
const dir=fs.mkdtempSync(path.join(os.tmpdir(),'rules-configuration-')),store=new Store(dir);store.bootstrap('admin','Test-password-123');
|
|
for(const role of ['operator','viewer'])store.addUser({username:role,password:'Test-password-123',role},'admin');
|
|
const workspace={recordSources:()=>[{id:'own',owner:'operator'},{id:'other',owner:'someone'}],record:()=>{}};
|
|
const execution={snapshot(){throw Error('execution history must not be read');}};
|
|
const server=createDashboard({store,workspace,orderRules:rules,orderExecution:execution,mail,storage,outputDir:dir});
|
|
await new Promise(resolve=>server.listen(0,'127.0.0.1',resolve));
|
|
t.after(async()=>{server.closeAllConnections();await new Promise(resolve=>server.close(resolve));fs.rmSync(dir,{recursive:true,force:true});});
|
|
const base='http://127.0.0.1:'+server.address().port,cookies={};
|
|
const request=(route,{role='admin',body}={})=>fetch(base+route,{method:body===undefined?'GET':'POST',headers:{...(cookies[role]?{Cookie:cookies[role]}:{}),...(body===undefined?{}:{Origin:base,'Content-Type':'application/json'})},body:body===undefined?undefined:JSON.stringify(body)});
|
|
for(const role of ['admin','operator','viewer']){const response=await request('/api/login',{role:'anonymous',body:{username:role,password:'Test-password-123'}});cookies[role]=response.headers.get('set-cookie').split(';')[0];}
|
|
return {rules,request};
|
|
}
|
|
const getConfiguration=async f=>{const response=await f.request('/api/order-rules/configuration');assert.equal(response.status,200);return response.json();};
|
|
|
|
test('configuration reads editable metadata without decrypting history or returning field values and message bodies',async t=>{
|
|
const rules=memoryRules(t);rules.put('scope-catalog',{id:'scope',processName:'流程A',nodeName:'审批'});rules.put('scope-process-catalog',{id:'process',processName:'流程B'});
|
|
const configured=rules.get('rules','bs-change');configured.draft.bodyTemplateId='directly-bound';rules.put('rules',configured);
|
|
rules.put('field-adapters',{id:'actual',processName:'流程A',processVersion:'2',verified:true,status:'active',label:'真实字段',sampleId:'capture',sample:{fields:{secret:'PRIVATE_FIELD'}},sources:{customer:{value:'PRIVATE_MAPPING'}}});
|
|
poisonHistory(rules);
|
|
const mail={store:{templates:()=>[{id:'active',status:'active',subject:'普通模板',notificationMode:'normal',scope:'电视',version:2,channelId:'channel',text:'PRIVATE_BODY'},{id:'bound',status:'archived',subject:'已绑定旧模板',notificationMode:'normal'},{id:'directly-bound',status:'archived',subject:'规则选中的旧模板',notificationMode:'normal'},{id:'irrelevant',status:'pending',subject:'无关模板'}],categoryBindings:()=>[{categoryId:'bs-change',templateId:'bound',version:1}]}},storage={store:{servers:()=>[{id:'server',name:'共享服务器',host:'localhost',share:'orders',directory:'archive',enabled:true,hasPassword:true,password:'PRIVATE_PASSWORD'}]}};
|
|
const f=await dashboard(t,{rules,mail,storage}),result=await getConfiguration(f);
|
|
assert.equal(result.rules.length,15);assert.equal(result.settings.processingEnabled,true);assert.equal(result.restrictedTest,null);
|
|
assert.deepEqual(result.scopeProcesses,['流程A','流程B']);assert.deepEqual(result.scopeCatalog,[{processName:'流程A',nodeName:'审批'}]);assert.equal(result.scopeError,null);
|
|
assert.deepEqual(result.resources.templates.map(x=>x.id),['active','bound','directly-bound']);assert.equal(result.resources.bindings[0].templateId,'bound');assert.equal(result.resources.servers[0].host,'localhost');assert.deepEqual(result.resources.errors,{});
|
|
assert.deepEqual(result.adapters.find(x=>x.id==='actual'),{id:'actual',processName:'流程A',processVersion:'2',verified:true,reference:false,status:'active',label:'真实字段',sampleId:'capture'});
|
|
assert.doesNotMatch(JSON.stringify(result),/PRIVATE_|"orders":|"batches":|"audit":|"samples":/);
|
|
assert.deepEqual(await(await f.request('/api/order-rules/configuration/samples')).json(),{samples:[]});
|
|
});
|
|
|
|
test('configuration reports independent resource and scope failures while preserving available editing data',async t=>{
|
|
const rules=memoryRules(t);rules.db.prepare('INSERT INTO records VALUES(?,?,?)').run('scope-catalog','corrupt',Buffer.from('unreadable'));
|
|
const f=await dashboard(t,{rules,mail:{store:{templates(){throw Error('PRIVATE_PROVIDER_ERROR');},categoryBindings:()=>[{categoryId:'bs-change',templateId:'old',version:2}]}}}),result=await getConfiguration(f);
|
|
assert.equal(result.rules.length,15);assert.equal(result.resources.templates,null);assert.equal(result.resources.servers,null);assert.equal(result.resources.bindings[0].templateId,'old');
|
|
assert.ok(result.resources.errors.templates);assert.ok(result.resources.errors.servers);assert.ok(result.scopeError);assert.doesNotMatch(JSON.stringify(result),/PRIVATE_PROVIDER_ERROR/);
|
|
});
|
|
|
|
test('sample loading honors ownership, process filters and server provenance without returning captured fields',async t=>{
|
|
const rules=memoryRules(t),sample={connectionId:'own',source:'todo',processVersion:'2',nodeName:'审批',serialNum:'SN-1',title:'订单标题',receivedAt:'2026-10-20T01:00:00Z',fields:{password:'PRIVATE_FIELD'},raw:'PRIVATE_RAW',html:'PRIVATE_HTML'};
|
|
for(const row of [{id:'old-own',processName:'流程A',sample},{id:'other-owner',processName:'流程A',sample:{...sample,connectionId:'other'}},{id:'other-process',processName:'流程B',sample},{id:'history',processName:'流程A',sample:{...sample,source:'history'}},{id:'demo',processName:'流程A',sample:{...sample,demo:true}},{id:'untrusted',processName:'流程A',provenance:'client',sample}])rules.put('capture-samples',{provenance:'server-provider',capturedAt:'2026-10-20T01:01:00Z',snapshot:{fields:[{value:'PRIVATE_FIELD'}]},...row});
|
|
const f=await dashboard(t,{rules}),route='/api/order-rules/configuration/samples?process='+encodeURIComponent('流程A')+'&process='+encodeURIComponent('流程A');
|
|
const owned=await f.request(route,{role:'operator'});assert.equal(owned.status,200);const result=await owned.json();
|
|
assert.deepEqual(result,{samples:[{id:'old-own',processName:'流程A',provenance:'server-provider',capturedAt:'2026-10-20T01:01:00Z',sample:{connectionId:'own',source:'todo',processVersion:'2',nodeName:'审批',serialNum:'SN-1',title:'订单标题',receivedAt:'2026-10-20T01:00:00Z'}}]});
|
|
assert.deepEqual((await(await f.request(route)).json()).samples.map(x=>x.id),['old-own','other-owner']);
|
|
assert.deepEqual(await(await f.request(route,{role:'viewer'})).json(),{samples:[]});
|
|
assert.deepEqual(await(await f.request('/api/order-rules/configuration/samples')).json(),{samples:[]});
|
|
assert.deepEqual((await(await f.request(route+'&process='+encodeURIComponent('流程B'),{role:'operator'})).json()).samples.map(x=>x.id),['old-own','other-process']);
|
|
});
|
|
|
|
test('configuration endpoints keep authentication, service-unavailable and malformed-query boundaries',async t=>{
|
|
const f=await dashboard(t);
|
|
for(const route of ['/api/order-rules/configuration','/api/order-rules/status','/api/order-rules/configuration/samples?process=A'])assert.equal((await f.request(route,{role:'anonymous'})).status,401);
|
|
for(const query of ['?unknown=A','?process=','?process=%20%20','?process=A%00B','?process=A%7fB','?process='+('A'.repeat(251)),'?'+Array.from({length:101},(_,i)=>'process=P'+i).join('&')])assert.equal((await f.request('/api/order-rules/configuration/samples'+query)).status,400,query);
|
|
assert.equal((await f.request('/api/order-rules/configuration/samples?'+Array.from({length:101},()=> 'process=A').join('&'))).status,200);
|
|
assert.equal((await f.request('/api/order-rules/configuration/unknown')).status,404);
|
|
const unavailable=await dashboard(t,{rules:null});for(const route of ['/api/order-rules/configuration','/api/order-rules/status','/api/order-rules/configuration/samples?process=A'])assert.equal((await unavailable.request(route)).status,503);
|
|
});
|
|
|
|
test('status reads only effective settings and in-memory capabilities',async t=>{
|
|
const rules=memoryRules(t);poisonHistory(rules);rules.db.prepare('INSERT INTO records VALUES(?,?,?)').run('rules','corrupt-rule',Buffer.from('not encrypted'));
|
|
rules.put('settings',{...rules.get('settings','main'),enabled:true});
|
|
const f=await dashboard(t,{rules}),enabled=await f.request('/api/order-rules/status',{role:'viewer'});assert.equal(enabled.status,200);assert.equal((await enabled.json()).settings.enabled,true);
|
|
rules.put('stability-test',{id:'main',enabled:true,startedAt:'2026-10-26T02:00:00Z',endsAt:'2026-10-27T02:00:00Z'});
|
|
const response=await f.request('/api/order-rules/status',{role:'viewer'});assert.equal(response.status,200);
|
|
assert.deepEqual(await response.json(),{settings:{enabled:false},capabilities:{liveTodo:true,pdfExport:false,automaticArchive:false}});
|
|
});
|
|
|
|
test('catalog and notification settings avoid history and unrelated configuration resources',async t=>{
|
|
const rules=memoryRules(t);poisonHistory(rules);
|
|
for(const kind of ['field-adapters','scope-catalog','scope-process-catalog'])rules.db.prepare('INSERT OR REPLACE INTO records VALUES(?,?,?)').run(kind,'corrupt',Buffer.from('not encrypted'));
|
|
const f=await dashboard(t,{rules});
|
|
const catalogResponse=await f.request('/api/order-rules/catalog');assert.equal(catalogResponse.status,200);
|
|
const catalog=await catalogResponse.json();assert.equal(catalog.rules.length,15);assert.equal(catalog.templateUsage.length,15);
|
|
assert.deepEqual(Object.keys(catalog.rules[0]).sort(),['categoryId','name']);assert.equal(catalog.templateUsage[0].status,'draft');
|
|
assert.doesNotMatch(JSON.stringify(catalog),/"orders":|"fields":|"adapters":|"draft":/);
|
|
const settingsResponse=await f.request('/api/order-rules/notification-settings');assert.equal(settingsResponse.status,200);
|
|
assert.deepEqual(await settingsResponse.json(),{settings:rules.settings(),restrictedTest:null});
|
|
for(const route of ['/api/order-rules/catalog','/api/order-rules/notification-settings'])assert.equal((await f.request(route,{role:'anonymous'})).status,401);
|
|
});
|
|
|
|
test('rule write receipts retain complete editor versions without historic reads or relaxing stale-version validation',async t=>{
|
|
const rules=memoryRules(t),{captured}=activateReferenceMapping(rules,'bs-change',{connectionId:'own',instanceId:'i',taskId:'t',revision:'1'});
|
|
const draft=rules.saveRule({...rules.get('rules','bs-change').draft,to:['admin@example.test'],attachPdf:false,archiveDirectory:'\\\\server\\orders',filenameDate:'appDate'},'admin');rules.capturedPreview(captured.id);
|
|
// Preserve the legitimate sample required by publish/resume while poisoning unrelated history.
|
|
for(const kind of ['orders','batches','execution-tasks','audit'])rules.db.prepare('INSERT INTO records VALUES(?,?,?)').run(kind,'unreadable-history',Buffer.from('not encrypted'));
|
|
const f=await dashboard(t,{rules}),publishedResponse=await f.request('/api/order-rules/rules/bs-change/publish',{body:{version:draft.version}});assert.equal(publishedResponse.status,200);const published=await publishedResponse.json();
|
|
assert.equal(published.id,'bs-change');assert.equal(published.activationVersion,1);assert.equal(published.publishedVersion,draft.version);assert.equal(published.hasDraft,false);assert.equal(published.restrictedTest,null);
|
|
const savedResponse=await f.request('/api/order-rules/rules',{body:{...published,intro:'新说明'}});assert.equal(savedResponse.status,200);const saved=await savedResponse.json();
|
|
assert.equal(saved.version,draft.version+1);assert.equal(saved.hasDraft,true);assert.equal(saved.activationVersion,1);assert.equal(saved.publishedVersion,draft.version);assert.equal(saved.restrictedTest,null);
|
|
assert.equal((await f.request('/api/order-rules/rules',{body:published})).status,409);
|
|
const pausedResponse=await f.request('/api/order-rules/rules/bs-change/pause',{body:{version:saved.version,activationVersion:1}});assert.equal(pausedResponse.status,200);const paused=await pausedResponse.json();assert.equal(paused.activationVersion,2);assert.equal(paused.status,'paused');assert.equal(paused.restrictedTest,null);
|
|
assert.equal((await f.request('/api/order-rules/rules/bs-change/resume',{body:{version:saved.version,publishedVersion:draft.version,activationVersion:1}})).status,409);
|
|
const resumedResponse=await f.request('/api/order-rules/rules/bs-change/resume',{body:{version:saved.version,publishedVersion:draft.version,activationVersion:2}});assert.equal(resumedResponse.status,200);const resumed=await resumedResponse.json();assert.equal(resumed.activationVersion,3);assert.equal(resumed.status,'enabled');assert.equal(resumed.hasDraft,true);assert.equal(resumed.restrictedTest,null);
|
|
assert.equal((await f.request('/api/order-rules/rules',{role:'operator',body:saved})).status,403);assert.equal((await f.request('/api/order-rules/rules/bs-change/pause',{role:'viewer',body:{version:saved.version}})).status,403);
|
|
assert.doesNotMatch(JSON.stringify(resumed),/"orders"|"batches"|"audit"|"fields"|"snapshot"/);
|
|
});
|
|
|
|
test('restricted-test apply preserves the run receipt and returns current lightweight rule editing state',async t=>{
|
|
const rules=memoryRules(t),directory=fs.mkdtempSync(path.join(os.tmpdir(),'rules-restricted-configuration-')),archive=path.join(directory,'archive');fs.mkdirSync(archive);rules.desktopRoot=directory;
|
|
t.after(()=>fs.rmSync(directory,{recursive:true,force:true}));
|
|
const unc='\\\\localhost\\'+archive[0].toLowerCase()+'$\\'+archive.slice(3);
|
|
activateReferenceMapping(rules,'bs-change',{connectionId:'own',instanceId:'i',taskId:'t',revision:'1'});
|
|
const draft=rules.saveRule({...rules.get('rules','bs-change').draft,to:['2639266652@qq.com'],attachPdf:false,archiveDirectory:unc,filenameDate:'appDate'},'admin');
|
|
const run=rules.saveRestrictedTest({version:0,enabled:true,recipient:'2639266652@qq.com',archiveRoot:unc,channelId:'channel',ruleIds:['bs-change']},{username:'admin',role:'admin'});
|
|
// An unchanged approved version need not inspect historic orders or execution tasks.
|
|
for(const kind of ['orders','batches','execution-tasks','audit'])rules.db.prepare('INSERT INTO records VALUES(?,?,?)').run(kind,'unreadable-history',Buffer.from('not encrypted'));
|
|
const f=await dashboard(t,{rules}),response=await f.request('/api/order-rules/restricted-test/apply',{body:{version:run.version,rules:[{id:'bs-change',version:draft.version}]}});assert.equal(response.status,200);const receipt=await response.json();
|
|
assert.equal(receipt.applied,true);assert.equal(receipt.count,1);assert.equal(receipt.test.version,run.version+1);assert.ok(receipt.restrictedTest);assert.equal(receipt.restrictedTest.version,run.version+1);
|
|
const updated=receipt.rules.find(rule=>rule.id==='bs-change');assert.equal(updated.testVersion,draft.version);assert.equal(updated.testStatus,'enabled');assert.equal(updated.testHasDraft,false);assert.equal(updated.hasDraft,true);
|
|
assert.equal((await f.request('/api/order-rules/restricted-test/apply',{body:{version:run.version,rules:[{id:'bs-change',version:draft.version}]}})).status,409);
|
|
assert.doesNotMatch(JSON.stringify(receipt),/"orders":|"batches":|"audit":|"fields":|"snapshot":/);
|
|
rules.db.prepare('INSERT INTO records VALUES(?,?,?)').run('capture-samples','unreadable-history',Buffer.from('not encrypted'));
|
|
const config=await getConfiguration(f);assert.equal(config.restrictedTest.readyCount,1);assert.equal(config.rules.find(rule=>rule.id==='bs-change').testVersion,draft.version);
|
|
const savedResponse=await f.request('/api/order-rules/rules',{body:{...draft,intro:'测试中的新草稿'}});assert.equal(savedResponse.status,200);const saved=await savedResponse.json();
|
|
assert.equal(saved.testVersion,draft.version);assert.equal(saved.version,draft.version+1);assert.equal(saved.testHasDraft,true);assert.equal(saved.testStatus,'enabled');assert.equal(saved.restrictedTest.readyCount,1);
|
|
});
|