Files
order-notification-automation/tests/app/account-cleanup.test.cjs
T

95 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'),crypto=require('node:crypto');
const {Store}=require('../../src/modules/dashboard/store.cjs'),{WorkspaceStore}=require('../../src/modules/workspace/store.cjs'),{SessionStore}=require('../../src/modules/dashboard/sessions.cjs'),{createAuth}=require('../../src/modules/dashboard/auth.cjs'),{BpmSessionManager}=require('../../src/modules/bpm/session-manager.cjs'),{BpmConnectionLifecycle}=require('../../src/modules/bpm/connection-lifecycle.cjs'),{workspaceApi}=require('../../src/modules/workspace/api.cjs');
function fixture(t){
const dir=fs.mkdtempSync(path.join(os.tmpdir(),'cleanup-retry-')),store=new Store(path.join(dir,'dashboard')),workspace=new WorkspaceStore(path.join(dir,'workspace')),admin=store.bootstrap('admin','Synthetic-password-123'),worker=store.addUser({username:'worker',role:'operator',password:'Synthetic-password-123'},'admin'),next=store.addUser({username:'nextuser',role:'operator',password:'Synthetic-password-123'},'admin'),sessions=new SessionStore(path.dirname(store.file)),manager=new BpmSessionManager({stateDir:path.join(dir,'bpm'),browserFactory:()=>{throw Error('No browser allowed');}}),monitor={stopConnection:async()=>{}},lifecycle=new BpmConnectionLifecycle({workspace,manager,monitor});
let auth=createAuth({store,workspace,bpmSessions:manager,bpmMonitor:monitor,bpmLifecycle:lifecycle});
const adminToken=sessions.issue(admin.id).token,workerToken=sessions.issue(worker.id).token;
const call=async(route,body,token=adminToken)=>{let result;await auth.authenticate({request:{method:body===undefined?'GET':'POST',headers:{host:'localhost',cookie:'order_session='+token},socket:{remoteAddress:'127.0.0.1'}},response:{setHeader(){}},route,body,reply:(status,data)=>{result={status,...data};},fail:(status,message)=>{throw Object.assign(Error(message),{status});}});return result;};
const lease=(id,token=adminToken)=>{const value={id,sessionId:token,context:{close:async()=>{value.closed=true;}}};manager.sessions.set(id,value);return value;};
t.after(async()=>{auth.close();sessions.close();await manager.shutdown();workspace.close();fs.rmSync(dir,{recursive:true,force:true});});
return {store,workspace,admin,worker,next,sessions,manager,monitor,lifecycle,call,lease,workerToken,reopen(){auth.close();auth=createAuth({store,workspace,bpmSessions:manager,bpmMonitor:monitor,bpmLifecycle:lifecycle});},owner:async(id,body)=>{let result;await workspaceApi({store,workspace,user:admin,route:'/api/connections/'+id+'/owner',method:'POST',body,bpmSessions:manager,bpmMonitor:monitor,bpmLifecycle:lifecycle,reply:(_,data)=>{result=data;}});return result;}};
}
const deferred=()=>{let resolve;const promise=new Promise(r=>resolve=r);return {promise,resolve};};
test('unfinished account retry revokes a newly issued session and its real manager lease',async t=>{
const f=fixture(t),id=f.workspace.createConnection({name:'Synthetic',owner:'worker'},f.admin,f.store.users()).id,oldLease=f.lease(id,f.workerToken),update=f.store.updateUser.bind(f.store);
f.store.updateUser=()=>{throw Error('synthetic save failure');};
const first=await f.call('/api/users/'+f.worker.id+'/revoke-sessions',{version:1});
assert.equal(first.status,503);assert.equal(oldLease.closed,true);assert.equal(first.cleanup.stages.account,false);
const fresh=f.sessions.issue(f.worker.id,Date.now(),f.store.passwordVersion(f.worker.id)).token,newLease=f.lease(id,fresh);
f.store.updateUser=update;
const second=await f.call('/api/users/'+f.worker.id+'/revoke-sessions',{version:1});
assert.equal(second.cleanupPending,false);assert.equal(newLease.closed,true);assert.equal(f.sessions.userSessionHashes(f.worker.id).length,0);
for(const token of [f.workerToken,fresh])assert.throws(()=>f.manager.authorize(f.workspace.getConnection(id),{user:f.worker,sessionId:token}),{status:401});
});
test('unfinished retry captures fresh hashes before retrying failed session row pruning',async t=>{
const f=fixture(t),id=f.workspace.createConnection({name:'Synthetic',owner:'worker'},f.admin,f.store.users()).id,update=f.store.updateUser.bind(f.store),revoke=SessionStore.prototype.revokeUser;
t.after(()=>{SessionStore.prototype.revokeUser=revoke;});f.store.updateUser=()=>{throw Error('synthetic save failure');};SessionStore.prototype.revokeUser=()=>{throw Error('synthetic session row failure');};
const first=await f.call('/api/users/'+f.worker.id+'/revoke-sessions',{version:1});assert.equal(first.cleanup.stages.sessionRows,false);assert.equal(first.cleanup.stages.sessionHashes,true);
const fresh=f.sessions.issue(f.worker.id,Date.now(),f.store.passwordVersion(f.worker.id)).token,lease=f.lease(id,fresh);
f.store.updateUser=update;SessionStore.prototype.revokeUser=revoke;
const second=await f.call('/api/users/'+f.worker.id+'/revoke-sessions',{version:1});
assert.equal(second.cleanupPending,false);assert.equal(lease.closed,true);assert.throws(()=>f.manager.authorize(f.workspace.getConnection(id),{user:f.worker,sessionId:fresh}),{status:401});
});
for(const transfer of [false,true])test(`account commit revalidates assignments added during cleanup wait (transfer=${transfer})`,async t=>{
const f=fixture(t);
const operation=f.call('/api/users/'+f.worker.id+'/lifecycle',{version:1,enabled:false,role:'operator',...(transfer?{transferTo:'nextuser'}:{})});
const id=f.workspace.createConnection({name:'New assignment',owner:'worker'},f.admin,f.store.users()).id,lease=f.lease(id);
if(!transfer){await assert.rejects(operation,{status:409});assert.equal(f.store.user(f.worker.id).enabled,true);return;}
const result=await operation;
assert.equal(result.cleanupPending,false);assert.deepEqual(result.transfer.connections,[id]);assert.equal(f.workspace.getConnection(id).owner,'nextuser');assert.equal(lease.closed,true);assert.equal(f.manager.disabled.has(id),true);
assert.throws(()=>f.workspace.createConnection({name:'Too late',owner:'worker'},f.admin,f.store.users()));
});
for(const transfer of [false,true])test(`account commit revalidates unresolved exceptions added during cleanup wait (transfer=${transfer})`,async t=>{
const f=fixture(t),operation=f.call('/api/users/'+f.worker.id+'/lifecycle',{version:1,enabled:false,role:'operator',...(transfer?{transferTo:'nextuser'}:{})});
const issue=f.workspace.createException({title:'Synthetic late issue',description:'Synthetic',component:'system',priority:'normal',owner:'worker'},f.admin,f.store.users());
if(!transfer){await assert.rejects(operation,{status:409});assert.equal(f.store.user(f.worker.id).enabled,true);return;}
const result=await operation;assert.deepEqual(result.transfer.exceptions,[issue.id]);assert.deepEqual(f.workspace.ownedWork('worker'),{connections:[],exceptions:[]});
});
test('unfinished account handoff includes new assignments and re-drains previously transferred connections',async t=>{
const f=fixture(t),firstId=f.workspace.createConnection({name:'First',owner:'worker'},f.admin,f.store.users()).id,update=f.store.updateUser.bind(f.store);
f.store.updateUser=()=>{throw Error('synthetic save failure');};
const first=await f.call('/api/users/'+f.worker.id+'/lifecycle',{version:1,enabled:false,role:'operator',transferTo:'nextuser'});assert.equal(first.status,503);
f.workspace.transferConnection(firstId,{version:1,owner:'worker'},f.admin,f.store.users());
const secondId=f.workspace.createConnection({name:'Second',owner:'worker'},f.admin,f.store.users()).id,leases=[f.lease(firstId),f.lease(secondId)];
f.store.updateUser=update;
const result=await f.call('/api/users/'+f.worker.id+'/lifecycle',{version:1,enabled:false,role:'operator',transferTo:'nextuser'});
assert.equal(result.cleanupPending,false);assert.deepEqual(new Set(result.transfer.connections),new Set([firstId,secondId]));assert.deepEqual(f.workspace.ownedWork('worker'),{connections:[],exceptions:[]});assert.equal(leases.every(lease=>lease.closed),true);
});
test('account handoff rejects ownership set drift while acquiring connection locks',async t=>{
const f=fixture(t),id=f.workspace.createConnection({name:'First',owner:'worker'},f.admin,f.store.users()).id,gate=deferred(),started=deferred();t.after(()=>gate.resolve());
const holding=f.lifecycle.run(id,async()=>{started.resolve();await gate.promise;});await started.promise;
const operation=f.call('/api/users/'+f.worker.id+'/lifecycle',{version:1,enabled:false,role:'operator',transferTo:'nextuser'});
await new Promise(r=>setImmediate(r));
const added=f.workspace.createConnection({name:'During lock wait',owner:'worker'},f.admin,f.store.users()).id;
const rejection=assert.rejects(operation,{status:409});gate.resolve();await holding;await rejection;
assert.equal(f.store.user(f.worker.id).enabled,true);assert.equal(f.workspace.getConnection(added).owner,'worker');assert.equal(f.workspace.getConnection(id).owner,'worker');
});
test('retained hash cleanup survives session pruning and auth restart',async t=>{
const f=fixture(t),id=f.workspace.createConnection({name:'Synthetic',owner:'worker'},f.admin,f.store.users()).id,lease=f.lease(id,f.workerToken),original=f.manager.releaseSessionHashes.bind(f.manager);let fail=true;
f.manager.releaseSessionHashes=async hashes=>{if(fail)throw Error('synthetic failure');return original(hashes);};
const first=await f.call('/api/users/'+f.worker.id+'/revoke-sessions',{version:1});assert.equal(first.cleanupPending,true);assert.equal(f.sessions.userSessionHashes(f.worker.id).length,0);assert.equal(lease.closed,undefined);
const pending=await f.call('/api/users');assert.equal(pending.cleanupPending,true);assert.equal(pending.cleanup.stages.sessionHashes,false);assert.doesNotMatch(JSON.stringify(pending),new RegExp(crypto.createHash('sha256').update(f.workerToken).digest('hex')));
f.reopen();fail=false;const second=await f.call('/api/users/'+f.worker.id+'/revoke-sessions',{version:2});assert.equal(second.cleanupPending,false);assert.equal(lease.closed,true);assert.equal(f.manager.revokedSessionHashes.has(crypto.createHash('sha256').update(f.workerToken).digest('hex')),true);
assert.equal(second.cleanup.stages.sessionHashes,true);
});
test('owner transfer drains a real manager lease and serializes concurrent enable',async t=>{
const f=fixture(t),id=f.workspace.createConnection({name:'Synthetic',owner:'worker'},f.admin,f.store.users()).id,lease=f.lease(id),gate=deferred(),started=deferred();t.after(()=>gate.resolve());f.monitor.stopConnection=async()=>{started.resolve();await gate.promise;};
const transfer=f.owner(id,{version:0,owner:'nextuser'});await started.promise;assert.equal(f.manager.disabled.has(id),true);let enabled=false;const enable=f.lifecycle.change(id,true,{version:1},f.admin).then(()=>{enabled=true;});await new Promise(r=>setImmediate(r));assert.equal(enabled,false);gate.resolve();const result=await transfer;await enable;assert.equal(result.cleanupPending,false);assert.equal(lease.closed,true);assert.equal(f.manager.sessions.has(id),false);assert.equal(f.workspace.getConnection(id).status,'unchecked');assert.equal(f.manager.disabled.has(id),false);
});
test('account handoff suspends another administrator lease before waiting for monitor',async t=>{
const f=fixture(t),id=f.workspace.createConnection({name:'Synthetic',owner:'worker'},f.admin,f.store.users()).id,lease=f.lease(id),gate=deferred(),started=deferred();t.after(()=>gate.resolve());f.monitor.stopConnection=async()=>{started.resolve();await gate.promise;};
const operation=f.call('/api/users/'+f.worker.id+'/lifecycle',{version:1,enabled:false,role:'operator',transferTo:'nextuser'});await started.promise;assert.equal(f.manager.disabled.has(id),true);gate.resolve();const result=await operation;assert.equal(result.cleanupPending,false);assert.equal(lease.closed,true);assert.equal(f.manager.sessions.has(id),false);
});
test('failed handoff drain retains connection IDs and protects disabled connections until retry',async t=>{
const f=fixture(t),id=f.workspace.createConnection({name:'Synthetic',owner:'worker'},f.admin,f.store.users()).id,lease=f.lease(id),original=f.manager.suspend.bind(f.manager);let fail=true;
f.manager.suspend=async id=>{f.manager.disabled.add(id);if(fail)throw Error('synthetic drain failure');return original(id);};
const first=await f.call('/api/users/'+f.worker.id+'/lifecycle',{version:1,enabled:false,role:'operator',transferTo:'nextuser'});assert.equal(first.cleanupPending,true);await assert.rejects(f.lifecycle.change(id,true,{version:1},f.admin),{status:503});f.reopen();fail=false;
const second=await f.call('/api/users/'+f.worker.id+'/lifecycle',{version:2,enabled:false,role:'operator'});assert.equal(second.cleanupPending,false);assert.equal(lease.closed,true);assert.equal(f.workspace.getConnection(id).version,1);assert.equal(f.workspace.getConnection(id).owner,'nextuser');assert.equal(f.manager.disabled.has(id),true);
});
test('account save failure after handoff invalidates sessions and retains resumable stages',async t=>{
const f=fixture(t),id=f.workspace.createConnection({name:'Synthetic',owner:'worker'},f.admin,f.store.users()).id,lease=f.lease(id),original=f.store.updateUser.bind(f.store);f.store.updateUser=()=>{throw Error('synthetic account persistence failure');};
const first=await f.call('/api/users/'+f.worker.id+'/lifecycle',{version:1,enabled:false,role:'operator',transferTo:'nextuser'});assert.equal(first.status,503);assert.equal(first.cleanupPending,true);assert.equal(first.cleanup.stages.account,false);assert.equal(lease.closed,true);await assert.rejects(f.call('/api/me',undefined,f.workerToken),{status:401});assert.equal(f.workspace.getConnection(id).owner,'nextuser');
f.store.updateUser=original;f.reopen();const second=await f.call('/api/users/'+f.worker.id+'/lifecycle',{version:1,enabled:false,role:'operator',transferTo:'nextuser'});assert.equal(second.cleanupPending,false);assert.equal(second.user.enabled,false);assert.equal(f.workspace.getConnection(id).version,1);
});