Files

62 lines
8.4 KiB
JavaScript

'use strict';
const {test}=require('node:test'),assert=require('node:assert/strict'),fs=require('node:fs/promises'),os=require('node:os'),path=require('node:path'),net=require('node:net'),http=require('node:http');
const {DatabaseSync}=require('node:sqlite');
const {main,createServer}=require('../../src/server.cjs');let render;
const {acquireInstanceLock}=require('../../src/platform/service/instance-lock.cjs');
const turn=()=>new Promise(r=>setImmediate(r));
const gate=()=>{let release;const promise=new Promise(r=>release=r);return {promise,release};};
async function port(){const s=net.createServer();await new Promise(r=>s.listen(0,'127.0.0.1',r));const p=s.address().port;await new Promise(r=>s.close(r));return p;}
async function fixture(){const stateDir=await fs.mkdtemp(path.join(os.tmpdir(),'order-final-lifecycle-'));return {stateDir,quiet:true,config:{port:await port(),outputDir:path.join(stateDir,'output'),dashboard:{port:await port(),host:'127.0.0.1'}}};}
const snapshot={html:'<p>fixture</p>',metadata:{order:'order',project:'project',model:'model',serial:'serial'}};
function post(port,token,{partial=false}={}){let finish;const response=new Promise((resolve,reject)=>{const req=http.request({host:'127.0.0.1',port,path:'/export',method:'POST',headers:{Origin:'chrome-extension://'+'a'.repeat(32),'X-Order-Token':token,'Content-Type':'application/json',Connection:'close'}},res=>{let body='';res.on('data',c=>body+=c);res.on('end',()=>resolve({status:res.statusCode,body:JSON.parse(body)}));});req.on('error',reject);const raw=JSON.stringify(snapshot);if(partial){req.write(raw.slice(0,5));finish=()=>req.end(raw.slice(5));}else req.end(raw);});return {response,finish:()=>finish()};}
test('application stop retains ownership and storage until accepted rendering and automatic archive settle',async t=>{
const options=await fixture(),renderGate=gate(),archiveGate=gate(),archiveStarted=gate();let app,stopping,writes=0;
render=async()=>{await renderGate.promise;return {filename:'fixture.pdf',bytes:1};};
t.after(async()=>{renderGate.release();archiveGate.release();await stopping?.catch(()=>{});await app?.stop();await fs.rm(options.stateDir,{recursive:true,force:true});});
app=await main({...options,renderSnapshot:(...args)=>render(...args)});const token=(await fs.readFile(path.join(options.stateDir,'pairing.key'),'utf8')).trim();
let storageStopped=false;const originalStop=app.storage.stop.bind(app.storage);app.storage.stop=async()=>{storageStopped=true;await originalStop();};
app.storage.automatic=async job=>{assert.equal(storageStopped,false);archiveStarted.release();await archiveGate.promise;app.storage.jobs.recordJob({...job,archiveFixture:true});writes++;};
const accepted=await post(options.config.port,token).response;assert.equal(accepted.status,202);
let done=false;stopping=app.stop().then(()=>{done=true;});await new Promise(r=>setTimeout(r,40));
assert.equal(done,false,'stop must wait for accepted renderer');assert.equal(storageStopped,false);await assert.rejects(acquireInstanceLock(options.stateDir),e=>e.code==='ORDER_INSTANCE_OWNED');
renderGate.release();await archiveStarted.promise;await turn();assert.equal(done,false,'stop must wait for automatic archive');await assert.rejects(acquireInstanceLock(options.stateDir),e=>e.code==='ORDER_INSTANCE_OWNED');
archiveGate.release();await stopping;assert.equal(writes,1);assert.equal(storageStopped,true);
const replacement=await main(options);await replacement.stop();await turn();assert.equal(writes,1);
});
test('request whose body completes after shutdown begins cannot start a new export',async t=>{
let rendered=0;render=async()=>{rendered++;return {filename:'fixture.pdf',bytes:1};};const server=createServer({token:'fixture',renderSnapshot:(...args)=>render(...args)});await new Promise(r=>server.listen(0,'127.0.0.1',r));
const received=new Promise(r=>server.once('request',r));const pending=post(server.address().port,'fixture',{partial:true});await received;
const closing=new Promise((resolve,reject)=>server.close(e=>e?reject(e):resolve()));pending.finish();const response=await pending.response;await closing;
assert.equal(response.status,503);assert.equal(rendered,0);
});
test('malformed workspace migration closes its allocated database before ownership release and permits repaired retry',async t=>{
const options=await fixture();t.after(()=>fs.rm(options.stateDir,{recursive:true,force:true}));await fs.mkdir(path.join(options.stateDir,'workspace'));const file=path.join(options.stateDir,'workspace','workspace.sqlite');const db=new DatabaseSync(file);db.exec("CREATE TABLE connections(id TEXT PRIMARY KEY,value TEXT NOT NULL); INSERT INTO connections VALUES('legacy','{broken');");db.close();
const original=DatabaseSync.prototype.exec;let allocated;
DatabaseSync.prototype.exec=function(sql){if(sql.includes('PRAGMA foreign_keys=ON'))allocated=this;return original.call(this,sql);};
try{await assert.rejects(main(options),SyntaxError);}finally{DatabaseSync.prototype.exec=original;}
try{assert.throws(()=>allocated.prepare('SELECT 1'),/not open|closed/i);}finally{try{allocated.close();}catch{}}
const repair=new DatabaseSync(file);repair.exec('DELETE FROM connections');repair.close();const app=await main(options);await app.stop();
});
test('all allocating store constructors close the database and destroy the vault when initialization fails',async t=>{
const cases=[['workspace','WorkspaceStore'],['mail','MailStore'],['notifications','NotificationStore'],['storage','StorageStore'],['assistant','AssistantStore'],['bpm/scan-store','BpmScanStore'],['dashboard/sessions','SessionStore'],['health/runtime-health','RuntimeHealth'],['../platform/service/store','SupervisorStore']];
const {BpmVault}=require('../../src/platform/security/vault.cjs');
for(const [name,exportName] of cases)await t.test(name,async()=>{const dir=await fs.mkdtemp(path.join(os.tmpdir(),'order-constructor-'));let allocated,destroyed=0;const exec=DatabaseSync.prototype.exec,destroy=BpmVault.prototype.destroy;DatabaseSync.prototype.exec=function(){allocated=this;throw new Error('initialization fixture');};BpmVault.prototype.destroy=function(){destroyed++;return destroy.call(this);};
try{const file=name.includes('/')?name:name+'/store';const Type=require('../../src/modules/'+file+'.cjs')[exportName];assert.throws(()=>new Type(exportName==='RuntimeHealth'?{stateDir:dir}:dir),/initialization fixture/);assert.throws(()=>allocated.prepare('SELECT 1'),/not open|closed/i,name);if(['mail','notifications','storage','assistant'].includes(name))assert.equal(destroyed,1,name);}
finally{DatabaseSync.prototype.exec=exec;BpmVault.prototype.destroy=destroy;try{allocated?.close();}catch{}await fs.rm(dir,{recursive:true,force:true});}
});
});
test('automatic archive remains background work and finishing it cannot clear a newer renderer busy state',async t=>{
const archive=gate(),archiveStarted=gate(),secondRender=gate();let calls=0;const records=[];
const server=createServer({token:'fixture',store:{recordJob(job){records.push(job);return job;}},storage:{automatic:async()=>{archiveStarted.release();await archive.promise;}},renderSnapshot:async()=>{if(++calls===2)await secondRender.promise;return {filename:'fixture.pdf',bytes:1};}});
await new Promise(r=>server.listen(0,'127.0.0.1',r));const p=server.address().port;
t.after(async()=>{archive.release();secondRender.release();if(server.listening)await new Promise(r=>server.close(r));});
assert.equal((await post(p,'fixture').response).status,202);await archiveStarted.promise;
assert.equal((await post(p,'fixture').response).status,202);archive.release();await turn();
assert.equal((await post(p,'fixture').response).status,409);
let done=false;const closing=new Promise(r=>server.close(r)).then(()=>{done=true;});await turn();assert.equal(done,false);secondRender.release();await closing;assert.equal(records.filter(r=>r.status==='success').length,2);
});
test('shutdown drains a synchronous renderer failure and preserves the accepted job error',async()=>{
const records=[];const server=createServer({token:'fixture',store:{recordJob:job=>{records.push(job);return job;}},renderSnapshot(){throw new Error('renderer fixture');}});await new Promise(r=>server.listen(0,'127.0.0.1',r));
const response=await post(server.address().port,'fixture').response;assert.equal(response.status,202);await new Promise(r=>server.close(r));assert.deepEqual(records.map(j=>j.status),['running','error']);assert.equal(records[1].jobId,response.body.jobId);assert.equal(records[1].error,'renderer fixture');
});