Files
canina/backend/src/orchestration/approval-queue-db.spec.ts
T
2026-10-24 06:16:20 +00:00

60 lines
4.8 KiB
TypeScript

import { PrismaClient } from '@prisma/client';
import { PrepareWorkflowService } from './prepare-workflow.service';
const enabled=process.env.WORKFLOW_DB==='1';
(enabled?describe:describe.skip)('approval queue PostgreSQL atomicity',()=>{
const db=new PrismaClient();
const service=new PrepareWorkflowService(db,{workerIds:['pmo','worker'],stageCiIds:[]});
const owner={id:'pmo',role:'Admin'}, reviewer={id:'reviewer',role:'SUPER_ADMIN'},worker={id:'worker',role:'WORKFLOW_WORKER'};
async function pending(){const t=await service.create({key:`queue-${crypto.randomUUID()}`,title:'QA',department:'CONTENT',operationMode:'PREPARE',budgetLimitCents:20,metadata:{scope:'Isolated QA',acceptanceCriteria:['Test queue'],commitSha:'a'.repeat(40)}},owner);return service.transition(t.id,{toState:'GATE1_PENDING',expectedVersion:t.version,idempotencyKey:`submit-${t.id}`},owner);}
afterAll(()=>db.$disconnect());
it('racing approvals serialize once, replay once, and queue can immediately claim',async()=>{
const t=await pending();const dto={decision:'APPROVED',expectedVersion:t.version,idempotencyKey:`approve-${t.id}`};
const results=await Promise.all([service.decide(t.id,1,dto,reviewer),service.decide(t.id,1,dto,reviewer)]);
expect(results.every(t=>t.state==='READY')).toBe(true);
expect(await db.orchestrationApprovalDecision.count({where:{taskId:t.id}})).toBe(1);
expect(await db.prepareWorkflowOutbox.count({where:{taskId:t.id}})).toBe(1);
const claims=await Promise.all([service.claim(worker,t.id),service.claim(worker,t.id)]);
expect(claims.filter(Boolean)).toHaveLength(1);
});
it('scheduled work cannot claim early via targeted or polling claim; becomes claimable at due time',async()=>{
const t=await pending();const notBefore=new Date(Date.now()+3600000).toISOString();
await service.decide(t.id,1,{decision:'APPROVED',expectedVersion:t.version,idempotencyKey:`schedule-${t.id}`,notBefore},reviewer);
expect(await service.claim(worker,t.id)).toBeNull();
expect(await service.claim(worker)).toBeNull();
const o=await db.prepareWorkflowOutbox.findUniqueOrThrow({where:{taskId:t.id}});
expect(o.notBefore).toEqual(new Date(notBefore));
const approval=await db.orchestrationApprovalDecision.findFirstOrThrow({where:{taskId:t.id}});
expect(approval.expiresAt.getTime()).toBeGreaterThan(Date.parse(notBefore));
await db.prepareWorkflowOutbox.update({where:{taskId:t.id},data:{notBefore:new Date(0)}});
expect(await service.claim(worker,t.id)).toMatchObject({taskId:t.id,attempt:1});
});
it('hold and rejection never queue',async()=>{
const t=await pending();const held=await service.transition(t.id,{toState:'GATE1_HELD',expectedVersion:t.version,idempotencyKey:`hold-${t.id}`,reason:'Revise scope'},reviewer);
expect(await db.prepareWorkflowOutbox.count({where:{taskId:t.id}})).toBe(0);
await service.decide(t.id,1,{decision:'REJECTED',expectedVersion:held.version,idempotencyKey:`reject-${t.id}`},reviewer);
expect(await db.prepareWorkflowOutbox.count({where:{taskId:t.id}})).toBe(0);
});
it('expired approval cannot claim and immutable decision is not edited',async()=>{
const t=await pending();await service.decide(t.id,1,{decision:'APPROVED',expectedVersion:t.version,idempotencyKey:`expire-${t.id}`,expiresAt:new Date(Date.now()+300).toISOString()},reviewer);
await new Promise(r=>setTimeout(r,350));
await expect(service.claim(worker,t.id)).rejects.toThrow(/expired/i);
expect(await db.orchestrationRun.count({where:{taskId:t.id}})).toBe(0);
});
it('PMO recovery queues stored v3 approval without creating a decision, no impersonation',async()=>{
const t=await pending();
await db.orchestrationTask.update({where:{id:t.id},data:{state:'GATE1_APPROVED',version:3}});
await db.orchestrationApprovalDecision.create({data:{taskId:t.id,gate:1,decision:'APPROVED',actorId:'independent',expiresAt:new Date(Date.now()+60000),idempotencyKey:`legacy-${t.id}`}});
const dto={taskId:t.id,expectedVersion:3,idempotencyKey:`recover-${t.id}`};
const result=await Promise.all([service.enqueueApproved({id:'pmo',role:'WORKFLOW_WORKER'},dto),service.enqueueApproved({id:'pmo',role:'WORKFLOW_WORKER'},dto)]);
expect(result.every(t=>t.state==='READY'&&t.version===4)).toBe(true);
expect(await db.orchestrationApprovalDecision.count({where:{taskId:t.id}})).toBe(1);
expect(await db.prepareWorkflowOutbox.count({where:{taskId:t.id}})).toBe(1);
});
it('outbox failure rolls back immutable approval and READY together',async()=>{
const t=await pending();await db.prepareWorkflowOutbox.create({data:{taskId:t.id}});
await expect(service.decide(t.id,1,{decision:'APPROVED',expectedVersion:t.version,idempotencyKey:`fail-${t.id}`},reviewer)).rejects.toThrow();
expect((await db.orchestrationTask.findUniqueOrThrow({where:{id:t.id}})).state).toBe('GATE1_PENDING');
expect(await db.orchestrationApprovalDecision.count({where:{taskId:t.id}})).toBe(0);
});
});