wishforge-ide/apps/ide/provisioner/test/provisioner.test.mjs
eust-w b47a07e8d2 chore: baseline snapshot of the Codex-delivered code before review
Imports the previously untracked working tree as-is so that the review
changes that follow (requirements -> design -> implementation) can be
reviewed as diffs and reverted if needed. No content changes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 13:18:04 +08:00

118 lines
10 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import { createHmac } from 'node:crypto';
import { readConfig, renderRunResources, provisionRun, reconcileRunJobs } from '../provisioner.mjs';
import { resourceGrantPayload } from '../resource-grants.mjs';
import { releaseRun } from '../run-release.mjs';
import { createRunOperationQueue } from '../run-operations.mjs';
const env = { WF_TENANT_ID: 'tenant-a', WF_KUBE_CONTEXT: 'explicit-test-context', WF_KUBE_NAMESPACE: 'wishforge-tenant-a', WF_RUN_WORKER_IMAGE: `registry.example.invalid/worker@sha256:${'a'.repeat(64)}`, WF_RUN_STORAGE_CLASS: 'reviewed-rwx', WF_CONTROL_PLANE_URL: 'https://api.wishforge-control.svc:8443', WF_CONTROL_NAMESPACE: 'wishforge-control', TEMPORAL_ADDRESS: 'temporal.wishforge-control.svc:7233', TEMPORAL_NAMESPACE: 'wishforge' };
env.WF_RESOURCE_GRANT_SECRET = 'test-only-resource-signing-secret-longer-than-32';
const config = readConfig(env);
function grant(overrides={}) {
const issuedAt=Math.floor(Date.now()/1000);
const payload={schemaVersion:1,tenantId:'tenant-a',runId:'run-123',generation:'generation-1',planId:'pilot',planVersion:'pilot-v1',image:config.image,cpuMilli:1500,memoryMiB:3072,storageMiB:8192,issuedAt,expiresAt:issuedAt+300,...overrides};
return {...payload,signature:createHmac('sha256',env.WF_RESOURCE_GRANT_SECRET).update(resourceGrantPayload(payload)).digest('base64url')};
}
function token(kind, run = 'run-123') { return `header.${Buffer.from(JSON.stringify({ tenant_id: 'tenant-a', run_id: run, generation: 'generation-1', kind, iss: 'wishforge-control-plane', aud: 'wishforge-internal', exp: Math.floor(Date.now() / 1000) + 14400 })).toString('base64url')}.signature`; }
const request = { tenantId: 'tenant-a', runId: 'run-123', generation: 'generation-1', executorToken: token('worker'), verifierToken: token('verifier'), resourceGrant:grant() };
test('fails closed without explicit cluster, namespace, image digest and storage', () => {
assert.throws(() => readConfig({}), /unconfigured/);
assert.throws(() => readConfig({ ...env, WF_RUN_WORKER_IMAGE: 'worker:latest' }), /immutable/);
assert.throws(() => renderRunResources(config, { ...request, tenantId: 'tenant-b' }), /outside/);
assert.throws(() => renderRunResources(config, { ...request, executorToken: token('worker', 'other-run') }), /token/);
});
test('renders independent Kata jobs with role-scoped credentials and separate role PVCs', () => {
const { resources } = renderRunResources(config, request);
const jobs = resources.filter(r => r.kind === 'Job'); assert.equal(jobs.length, 2);
assert.notEqual(jobs[0].spec.template.spec.serviceAccountName, jobs[1].spec.template.spec.serviceAccountName);
for (const job of jobs) {
const pod = job.spec.template.spec, container = pod.containers[0];
assert.equal(pod.runtimeClassName, 'wishforge-kata'); assert.equal(pod.automountServiceAccountToken, false);
assert.equal(container.securityContext.allowPrivilegeEscalation, false); assert.equal(container.securityContext.readOnlyRootFilesystem, true);
assert.deepEqual(container.securityContext.capabilities.drop, ['ALL']);
assert.ok(!pod.hostNetwork && !pod.hostPID && !pod.hostIPC);
assert.ok(pod.volumes.every(v => !v.hostPath));
assert.ok(!JSON.stringify(pod).includes('docker.sock'));
assert.equal(container.env.filter(e => /TOKEN$/.test(e.name)).length, 1);
assert.ok(container.env.find(e => /TOKEN$/.test(e.name)).valueFrom.secretKeyRef);
assert.ok(!JSON.stringify(pod).includes(request.executorToken)); assert.ok(!JSON.stringify(pod).includes(request.verifierToken));
assert.equal(container.image,request.resourceGrant.image);
assert.equal(container.resources.limits.cpu,'750m');assert.equal(container.resources.limits.memory,'1536Mi');
}
const pvc = resources.filter(r => r.kind === 'PersistentVolumeClaim'); assert.equal(pvc.length, 2); assert.ok(pvc.every(claim => claim.spec.accessModes[0] === 'ReadWriteOnce'));
assert.notEqual(jobs[0].spec.template.spec.volumes[0].persistentVolumeClaim.claimName, jobs[1].spec.template.spec.volumes[0].persistentVolumeClaim.claimName);
const policy = resources.find(r => r.kind === 'NetworkPolicy'); assert.deepEqual(policy.spec.ingress, []);
assert.ok(policy.spec.egress.every(rule => rule.to.every(to => to.namespaceSelector && to.podSelector && !to.ipBlock)));
assert.ok(pvc.every(claim=>claim.spec.resources.requests.storage==='4096Mi'));
assert.ok(jobs.reduce((total,job)=>total+parseInt(job.spec.template.spec.containers[0].resources.limits.cpu),0)<=request.resourceGrant.cpuMilli);
assert.ok(jobs.reduce((total,job)=>total+parseInt(job.spec.template.spec.containers[0].resources.limits.memory),0)<=request.resourceGrant.memoryMiB);
assert.ok(pvc.reduce((total,claim)=>total+parseInt(claim.spec.resources.requests.storage),0)<=request.resourceGrant.storageMiB);
const other = renderRunResources(config, { ...request, runId: 'run-456', executorToken: token('worker', 'run-456'), verifierToken: token('verifier', 'run-456'),resourceGrant:grant({runId:'run-456'}) });
assert.notEqual(other.receipt.workspaceClaim, pvc[0].metadata.name);
});
test('rejects tampered, expired, wrong-scope and above-cap resource grants',()=>{
for(const change of [{cpuMilli:1600},{generation:'other'},{tenantId:'other'}])assert.throws(()=>renderRunResources(config,{...request,resourceGrant:{...request.resourceGrant,...change}}),/RESOURCE_GRANT_INVALID/);
assert.throws(()=>renderRunResources(config,{...request,resourceGrant:grant({runId:'other'})}),/RESOURCE_GRANT_INVALID/);
assert.throws(()=>renderRunResources(config,{...request,resourceGrant:grant({issuedAt:1,expiresAt:301})}),/RESOURCE_GRANT_EXPIRED/);
for(const change of [{cpuMilli:2001},{memoryMiB:4097},{storageMiB:10241}])assert.throws(()=>renderRunResources(config,{...request,resourceGrant:grant(change)}),/RESOURCE_LIMIT/);
});
test('pins signed previous runtime image and requires migration after its retirement',()=>{
const previous=`registry.example.invalid/worker@sha256:${'b'.repeat(64)}`;
const requestWithPrevious={...request,resourceGrant:grant({image:previous})};
const configured=readConfig({...env,WF_RUN_PREVIOUS_IMAGES:previous});
assert.ok(renderRunResources(configured,requestWithPrevious).resources.filter(r=>r.kind==='Job').every(r=>r.spec.template.spec.containers[0].image===previous));
assert.throws(()=>renderRunResources(config,requestWithPrevious),/RUNTIME_IMAGE_MIGRATION_REQUIRED/);
});
test('cleanup verifies ownership, stops matching jobs, retains PVCs and never fabricates measurement',async()=>{
const {resources}=renderRunResources(config,request);const job=resources.find(r=>r.kind==='Job');const calls=[];
const release={tenantId:request.tenantId,runId:request.runId,generation:request.generation,resourceGrant:grant({issuedAt:1,expiresAt:301,image:`registry.example.invalid/retired@sha256:${'c'.repeat(64)}`})};
const execute=async(_config,args)=>{calls.push(args);return args[0]==='get'?JSON.stringify({items:args[1]==='jobs'?[job]:[]}):'';};
const receipt=await releaseRun(config,release,execute);
assert.equal(receipt.status,'released');assert.equal(receipt.computeReleased,true);assert.equal(receipt.persistentStorageRetained,true);
assert.equal(receipt.computeSeconds,undefined);assert.ok(calls.every(args=>!args.includes('pvc')));
assert.equal(calls.filter(args=>args[0]==='delete').length,1);
await assert.rejects(releaseRun(config,release,async()=>JSON.stringify({items:[{...job,metadata:{...job.metadata,namespace:'other'}}]})),/SCOPE_MISMATCH/);
const pending=await releaseRun(config,release,async(_config,args)=>JSON.stringify({items:args[1]==='pods'?[{metadata:job.metadata,status:{phase:'Running'}}]:[]}));
assert.equal(pending.status,'releasing');assert.equal(pending.computeReleased,false);
});
test('serializes delayed provision with cleanup while allowing independent runs',async()=>{
const queue=createRunOperationQueue(),order=[];let resolve;
const first=queue('tenant-a','run-1',async()=>{order.push('provision');await new Promise(r=>{resolve=r;});order.push('provisioned');});
await Promise.resolve();
const cleanup=queue('tenant-a','run-1',async()=>{order.push('cleanup');});
await queue('tenant-a','run-2',async()=>{order.push('independent');});
assert.deepEqual(order,['provision','independent']);resolve();await Promise.all([first,cleanup]);assert.deepEqual(order,['provision','independent','provisioned','cleanup']);
await assert.rejects(queue('tenant-a','run-1',async()=>{throw new Error('fixture');}),/fixture/);
assert.equal(await queue('tenant-a','run-1',async()=> 'reconciled'),'reconciled');
});
test('applies policy before jobs, retries deterministic names and propagates infrastructure failure', async () => {
const calls = []; const apply = async (cfg, resources) => { assert.equal(cfg.context, 'explicit-test-context'); calls.push(resources); };
const first = await provisionRun(config, request, apply, async () => ({terminal:false})); const second = await provisionRun(config, request, apply, async () => ({terminal:false}));
assert.deepEqual(first, second); assert.equal(calls.length, 4);
assert.ok(calls[0].every(r => r.kind !== 'Job')); assert.ok(calls[1].every(r => r.kind === 'Job'));
await assert.rejects(provisionRun(config, request, async () => { throw new Error('KUBERNETES_APPLY_FAILED'); }, async () => ({terminal:false})), /KUBERNETES_APPLY_FAILED/);
});
test('reconciles only old owned run jobs and refuses to pretend a terminal generation resumed', async () => {
const {resources}=renderRunResources(config,request);
const job=resources.find(r=>r.kind==='Job');const calls=[];
const old={...job,metadata:{...job.metadata,labels:{...job.metadata.labels,'wishforge.io/generation':'old-generation'}}};
const execute=async(cfg,args)=>{calls.push(args);return args[0]==='get'?JSON.stringify({items:[old]}):'';};
assert.deepEqual(await reconcileRunJobs(config,request,execute),{terminal:false});
assert.deepEqual(calls[1],['delete','job',job.metadata.name,'--cascade=foreground','--wait=true','--timeout=30s']);
const terminal=await reconcileRunJobs(config,request,async()=>JSON.stringify({items:[{...job,status:{failed:1}}]}));
assert.equal(terminal.terminal,true);
let applied=false;
const response=await provisionRun(config,request,async()=>{applied=true;},async()=>terminal);
assert.equal(response.status,'failed');assert.equal(applied,false);
await assert.rejects(reconcileRunJobs(config,request,async()=>JSON.stringify({items:[{...old,metadata:{...old.metadata,namespace:'other-tenant'}}]})),/SCOPE/);
});