@a5c-ai/krate 5.0.1-staging.00fa5317c

package/tests/runner-controller.test.js

@@ -0,0 +1,327 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createRunnerController, RUNNER_CONTROLLER_BOUNDARY } from '../src/runner-controller.js';
+
+function makePool(overrides = {}) {
+  return {
+    apiVersion: 'krate.a5c.ai/v1alpha1',
+    kind: 'RunnerPool',
+    metadata: {
+      name: overrides.name || 'test-pool',
+      namespace: overrides.namespace || 'krate-org-default',
+      labels: overrides.labels || {}
+    },
+    spec: {
+      organizationRef: 'organizationRef' in overrides ? overrides.organizationRef : 'default',
+      image: overrides.image || 'ubuntu:24.04',
+      warmReplicas: overrides.warmReplicas ?? 2,
+      maxReplicas: overrides.maxReplicas ?? 10,
+      trustTier: overrides.trustTier || 'trusted',
+      serviceAccount: overrides.serviceAccount || null,
+      resourceLimits: overrides.resourceLimits || {},
+      resourceRequests: overrides.resourceRequests || {}
+    },
+    status: { readyReplicas: overrides.readyReplicas ?? 2, queueDepth: 0 }
+  };
+}
+
+function makeJob(name = 'job-001') {
+  return {
+    apiVersion: 'krate.a5c.ai/v1alpha1',
+    kind: 'Job',
+    metadata: { name, namespace: 'krate-org-default' },
+    spec: { pipeline: 'pipe-1', step: 'test' }
+  };
+}
+
+// ============================================================
+// BOUNDARY export
+// ============================================================
+
+test('RUNNER_CONTROLLER_BOUNDARY is exported and describes the controller', () => {
+  assert.equal(RUNNER_CONTROLLER_BOUNDARY.role, 'runner-controller');
+  assert.ok(RUNNER_CONTROLLER_BOUNDARY.owns.includes('pool validation'));
+  assert.ok(RUNNER_CONTROLLER_BOUNDARY.owns.includes('pod spec generation'));
+  assert.ok(RUNNER_CONTROLLER_BOUNDARY.mustNotOwn.includes('Kubernetes API calls'));
+});
+
+// ============================================================
+// validateRunnerPool
+// ============================================================
+
+test('validateRunnerPool returns valid for a well-formed RunnerPool', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool();
+  const result = ctrl.validateRunnerPool(pool);
+  assert.equal(result.valid, true);
+  assert.equal(result.name, 'test-pool');
+  assert.equal(result.warmReplicas, 2);
+  assert.equal(result.maxReplicas, 10);
+  assert.equal(result.organizationRef, 'default');
+});
+
+test('validateRunnerPool rejects missing resource', () => {
+  const ctrl = createRunnerController();
+  const result = ctrl.validateRunnerPool(null);
+  assert.equal(result.valid, false);
+  assert.equal(result.reason, 'missing-resource');
+});
+
+test('validateRunnerPool rejects missing metadata.name', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool();
+  delete pool.metadata.name;
+  const result = ctrl.validateRunnerPool(pool);
+  assert.equal(result.valid, false);
+  assert.equal(result.reason, 'missing-name');
+});
+
+test('validateRunnerPool rejects missing organizationRef', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool({ organizationRef: '' });
+  const result = ctrl.validateRunnerPool(pool);
+  assert.equal(result.valid, false);
+  assert.equal(result.reason, 'missing-org');
+});
+
+test('validateRunnerPool rejects warmReplicas > maxReplicas', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool({ warmReplicas: 15, maxReplicas: 5 });
+  const result = ctrl.validateRunnerPool(pool);
+  assert.equal(result.valid, false);
+  assert.equal(result.reason, 'replicas-conflict');
+});
+
+test('validateRunnerPool rejects negative warmReplicas', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool({ warmReplicas: -1 });
+  const result = ctrl.validateRunnerPool(pool);
+  assert.equal(result.valid, false);
+  assert.equal(result.reason, 'invalid-min-replicas');
+});
+
+// ============================================================
+// getPoolStatus
+// ============================================================
+
+test('getPoolStatus returns Empty when no runners exist', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool();
+  const status = ctrl.getPoolStatus(pool);
+  assert.equal(status.phase, 'Empty');
+  assert.equal(status.idle, 0);
+  assert.equal(status.active, 0);
+  assert.equal(status.total, 0);
+});
+
+test('getPoolStatus reflects Idle runners after createRunner', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool();
+  ctrl.createRunner(pool, null);
+  ctrl.createRunner(pool, null);
+  const status = ctrl.getPoolStatus(pool);
+  assert.equal(status.idle, 2);
+  assert.equal(status.active, 0);
+  assert.equal(status.phase, 'Idle');
+});
+
+test('getPoolStatus reflects Active runners after job assignment', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool();
+  ctrl.createRunner(pool, 'run-1');
+  const status = ctrl.getPoolStatus(pool);
+  assert.equal(status.active, 1);
+  assert.equal(status.phase, 'Active');
+});
+
+// ============================================================
+// getCapacity
+// ============================================================
+
+test('getCapacity returns full capacity when pool is empty', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool({ maxReplicas: 5 });
+  const cap = ctrl.getCapacity(pool);
+  assert.equal(cap.maxReplicas, 5);
+  assert.equal(cap.used, 0);
+  assert.equal(cap.available, 5);
+  assert.equal(cap.utilizationPct, 0);
+});
+
+test('getCapacity accounts for Running runners', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool({ maxReplicas: 4 });
+  ctrl.createRunner(pool, 'job-a');
+  ctrl.createRunner(pool, 'job-b');
+  const cap = ctrl.getCapacity(pool);
+  assert.equal(cap.used, 2);
+  assert.equal(cap.available, 2);
+  assert.equal(cap.utilizationPct, 50);
+});
+
+// ============================================================
+// createRunner
+// ============================================================
+
+test('createRunner creates an Idle runner when no runRef given', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool();
+  const result = ctrl.createRunner(pool, null);
+  assert.equal(result.error, false);
+  assert.ok(result.runnerId);
+  assert.equal(result.runner.status, 'Idle');
+  assert.equal(result.runner.runRef, null);
+  assert.equal(result.runner.poolName, 'test-pool');
+});
+
+test('createRunner creates a Running runner when runRef given', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool();
+  const result = ctrl.createRunner(pool, 'run-42');
+  assert.equal(result.error, false);
+  assert.equal(result.runner.status, 'Running');
+  assert.equal(result.runner.runRef, 'run-42');
+});
+
+test('createRunner returns error when pool has no name', () => {
+  const ctrl = createRunnerController();
+  const result = ctrl.createRunner({ spec: {} }, null);
+  assert.equal(result.error, true);
+  assert.equal(result.reason, 'missing-pool');
+});
+
+// ============================================================
+// terminateRunner
+// ============================================================
+
+test('terminateRunner removes runner from registry', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool();
+  const { runnerId } = ctrl.createRunner(pool, null);
+  const result = ctrl.terminateRunner(runnerId);
+  assert.equal(result.error, false);
+  assert.ok(result.terminatedAt);
+  assert.equal(ctrl.getRunner(runnerId), null);
+});
+
+test('terminateRunner returns error for unknown runner', () => {
+  const ctrl = createRunnerController();
+  const result = ctrl.terminateRunner('no-such-runner');
+  assert.equal(result.error, true);
+  assert.equal(result.reason, 'not-found');
+});
+
+// ============================================================
+// scheduleJob
+// ============================================================
+
+test('scheduleJob assigns an idle runner to a job', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool();
+  ctrl.createRunner(pool, null); // seed an idle runner
+  const job = makeJob('job-x');
+  const result = ctrl.scheduleJob(pool, job);
+  assert.equal(result.error, false);
+  assert.ok(result.runnerId);
+  assert.equal(result.reused, false);
+  const runner = ctrl.getRunnerForJob('job-x');
+  assert.ok(runner);
+  assert.equal(runner.status, 'Running');
+});
+
+test('scheduleJob creates a new runner when no idle runner exists', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool({ maxReplicas: 5 });
+  const job = makeJob('job-new');
+  const result = ctrl.scheduleJob(pool, job);
+  assert.equal(result.error, false);
+  assert.ok(result.runnerId);
+});
+
+test('scheduleJob returns no-capacity error when pool is full', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool({ maxReplicas: 1 });
+  ctrl.createRunner(pool, 'run-already'); // fill the pool
+  const job = makeJob('job-over-limit');
+  const result = ctrl.scheduleJob(pool, job);
+  assert.equal(result.error, true);
+  assert.equal(result.reason, 'no-capacity');
+});
+
+test('scheduleJob is idempotent for already-assigned job', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool();
+  const job = makeJob('job-dup');
+  const first = ctrl.scheduleJob(pool, job);
+  const second = ctrl.scheduleJob(pool, job);
+  assert.equal(first.runnerId, second.runnerId);
+  assert.equal(second.reused, true);
+});
+
+// ============================================================
+// getRunnerForJob
+// ============================================================
+
+test('getRunnerForJob returns null for unscheduled job', () => {
+  const ctrl = createRunnerController();
+  assert.equal(ctrl.getRunnerForJob('no-job'), null);
+});
+
+// ============================================================
+// generatePodSpec
+// ============================================================
+
+test('generatePodSpec returns valid K8s Pod with workspace volume mount', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool({ organizationRef: 'acme' });
+  const workspace = { runRef: 'run-99', mountPath: '/workspace', pvcName: 'krate-ws-run-99' };
+  const podSpec = ctrl.generatePodSpec({ runnerId: 'runner-abc', pool }, workspace);
+  assert.equal(podSpec.kind, 'Pod');
+  assert.equal(podSpec.spec.containers[0].image, 'ubuntu:24.04');
+  assert.ok(podSpec.spec.volumes.some((v) => v.persistentVolumeClaim?.claimName === 'krate-ws-run-99'));
+  assert.ok(podSpec.spec.containers[0].volumeMounts.some((m) => m.mountPath === '/workspace'));
+});
+
+test('generatePodSpec injects required env vars', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool({ organizationRef: 'myorg' });
+  const podSpec = ctrl.generatePodSpec({ runnerId: 'runner-xyz', pool }, { runRef: 'run-7', mountPath: '/workspace', pvcName: 'krate-ws-run-7' });
+  const env = podSpec.spec.containers[0].env;
+  assert.ok(env.some((e) => e.name === 'KRATE_ORG' && e.value === 'myorg'));
+  assert.ok(env.some((e) => e.name === 'KRATE_RUN_ID'));
+  assert.ok(env.some((e) => e.name === 'KRATE_WORKSPACE_PATH'));
+});
+
+test('generatePodSpec uses serviceAccount from pool spec', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool({ serviceAccount: 'custom-sa' });
+  pool.spec.serviceAccount = 'custom-sa';
+  const podSpec = ctrl.generatePodSpec({ runnerId: 'r', pool }, null);
+  assert.equal(podSpec.spec.serviceAccountName, 'custom-sa');
+});
+
+test('generatePodSpec applies resource limits from pool config', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool();
+  pool.spec.resourceLimits = { cpu: '4', memory: '8Gi' };
+  pool.spec.resourceRequests = { cpu: '1', memory: '2Gi' };
+  const podSpec = ctrl.generatePodSpec({ runnerId: 'r', pool }, null);
+  assert.equal(podSpec.spec.containers[0].resources.limits.cpu, '4');
+  assert.equal(podSpec.spec.containers[0].resources.requests.memory, '2Gi');
+});
+
+test('generatePodSpec has no volumes when workspace is null', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool();
+  const podSpec = ctrl.generatePodSpec({ runnerId: 'r', pool }, null);
+  assert.equal(podSpec.spec.volumes.length, 0);
+  assert.equal(podSpec.spec.containers[0].volumeMounts.length, 0);
+});
+
+test('generatePodSpec sets pool and org labels on Pod', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool({ name: 'my-pool', organizationRef: 'acme' });
+  const podSpec = ctrl.generatePodSpec({ runnerId: 'r', pool }, null);
+  assert.equal(podSpec.metadata.labels['krate.a5c.ai/pool'], 'my-pool');
+  assert.equal(podSpec.metadata.labels['krate.a5c.ai/org'], 'acme');
+});

package/tests/runner-integration.test.js

@@ -0,0 +1,231 @@
+/**
+ * Runner controller integration tests
+ *
+ * Exercises end-to-end runner workflows: pool creation with workspace,
+ * job scheduling, pod spec generation with volume mounts, and capacity checks.
+ */
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createRunnerController } from '../src/runner-controller.js';
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+function makePool(overrides = {}) {
+  return {
+    apiVersion: 'krate.a5c.ai/v1alpha1',
+    kind: 'RunnerPool',
+    metadata: {
+      name: overrides.name || 'integration-pool',
+      namespace: overrides.namespace || 'krate-org-default',
+    },
+    spec: {
+      organizationRef: overrides.organizationRef ?? 'default',
+      image: overrides.image || 'ubuntu:24.04',
+      warmReplicas: overrides.warmReplicas ?? 2,
+      maxReplicas: overrides.maxReplicas ?? 8,
+      trustTier: overrides.trustTier || 'trusted',
+      serviceAccount: overrides.serviceAccount || null,
+      resourceLimits: overrides.resourceLimits || {},
+      resourceRequests: overrides.resourceRequests || {},
+    },
+    status: { readyReplicas: overrides.readyReplicas ?? 2, queueDepth: 0 },
+  };
+}
+
+function makeWorkspace(runRef = 'run-ws-001') {
+  return {
+    runRef,
+    mountPath: '/workspace',
+    pvcName: `krate-ws-${runRef}`,
+  };
+}
+
+function makeJob(name = 'job-int-001') {
+  return {
+    apiVersion: 'krate.a5c.ai/v1alpha1',
+    kind: 'Job',
+    metadata: { name, namespace: 'krate-org-default' },
+    spec: { pipeline: 'pipe-int', step: 'build' },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// createRunner with workspace generates correct pod spec
+// ---------------------------------------------------------------------------
+
+test('createRunner with workspace: generatePodSpec includes workspace volume mount', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool({ organizationRef: 'acme', name: 'acme-pool' });
+  const workspace = makeWorkspace('run-42');
+
+  const { runnerId, runner } = ctrl.createRunner(pool, 'run-42');
+  assert.equal(runner.status, 'Running');
+
+  const podSpec = ctrl.generatePodSpec({ runnerId, pool }, workspace);
+
+  // Volume is present
+  const vol = podSpec.spec.volumes.find(
+    (v) => v.persistentVolumeClaim?.claimName === 'krate-ws-run-42'
+  );
+  assert.ok(vol, 'pod spec must include the workspace PVC volume');
+
+  // Volume mount is present on the container
+  const mount = podSpec.spec.containers[0].volumeMounts.find(
+    (m) => m.mountPath === '/workspace'
+  );
+  assert.ok(mount, 'pod spec container must mount the workspace at /workspace');
+});
+
+test('createRunner with workspace: pod spec has correct org label', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool({ organizationRef: 'my-org', name: 'my-pool' });
+  const workspace = makeWorkspace('run-99');
+
+  const { runnerId } = ctrl.createRunner(pool, 'run-99');
+  const podSpec = ctrl.generatePodSpec({ runnerId, pool }, workspace);
+
+  assert.equal(podSpec.metadata.labels['krate.a5c.ai/org'], 'my-org');
+  assert.equal(podSpec.metadata.labels['krate.a5c.ai/pool'], 'my-pool');
+});
+
+// ---------------------------------------------------------------------------
+// scheduleJob assigns runner to job
+// ---------------------------------------------------------------------------
+
+test('scheduleJob assigns an idle pre-warmed runner to a job', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool({ maxReplicas: 5 });
+
+  // Pre-warm two idle runners
+  ctrl.createRunner(pool, null);
+  ctrl.createRunner(pool, null);
+
+  const job = makeJob('job-sched-001');
+  const result = ctrl.scheduleJob(pool, job);
+
+  assert.equal(result.error, false);
+  assert.ok(result.runnerId, 'scheduleJob must return a runnerId');
+  assert.equal(result.reused, false, 'first schedule should not reuse an existing assignment');
+
+  const runner = ctrl.getRunnerForJob('job-sched-001');
+  assert.ok(runner, 'runner must be retrievable by job name after scheduling');
+  assert.equal(runner.status, 'Running');
+});
+
+test('scheduleJob is idempotent: same runnerId returned on repeat calls for same job', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool();
+  const job = makeJob('job-idem-001');
+
+  const first = ctrl.scheduleJob(pool, job);
+  const second = ctrl.scheduleJob(pool, job);
+
+  assert.equal(first.runnerId, second.runnerId, 'repeated scheduleJob must return same runner');
+  assert.equal(second.reused, true);
+});
+
+test('scheduleJob returns no-capacity when pool is exhausted', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool({ maxReplicas: 2 });
+
+  ctrl.createRunner(pool, 'run-a');
+  ctrl.createRunner(pool, 'run-b');
+
+  const job = makeJob('job-over-cap');
+  const result = ctrl.scheduleJob(pool, job);
+
+  assert.equal(result.error, true);
+  assert.equal(result.reason, 'no-capacity');
+});
+
+// ---------------------------------------------------------------------------
+// generatePodSpec includes workspace volume mount
+// ---------------------------------------------------------------------------
+
+test('generatePodSpec with workspace sets KRATE_WORKSPACE_PATH env var', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool({ organizationRef: 'corp' });
+  const workspace = makeWorkspace('run-77');
+  const { runnerId } = ctrl.createRunner(pool, 'run-77');
+
+  const podSpec = ctrl.generatePodSpec({ runnerId, pool }, workspace);
+  const env = podSpec.spec.containers[0].env;
+
+  const wsPathEnv = env.find((e) => e.name === 'KRATE_WORKSPACE_PATH');
+  assert.ok(wsPathEnv, 'KRATE_WORKSPACE_PATH env var must be present');
+  assert.equal(wsPathEnv.value, '/workspace');
+});
+
+test('generatePodSpec without workspace has empty volumes and volumeMounts', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool({ organizationRef: 'corp' });
+  const { runnerId } = ctrl.createRunner(pool, null);
+
+  const podSpec = ctrl.generatePodSpec({ runnerId, pool }, null);
+
+  assert.equal(podSpec.spec.volumes.length, 0);
+  assert.equal(podSpec.spec.containers[0].volumeMounts.length, 0);
+});
+
+// ---------------------------------------------------------------------------
+// getCapacity returns correct available slots
+// ---------------------------------------------------------------------------
+
+test('getCapacity returns correct available slots after active runners are created', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool({ maxReplicas: 6 });
+
+  ctrl.createRunner(pool, 'run-c1');
+  ctrl.createRunner(pool, 'run-c2');
+  // Only Running (active) runners count toward utilization; Idle runners do not
+  ctrl.createRunner(pool, null); // idle runner does NOT count as used
+
+  const cap = ctrl.getCapacity(pool);
+  assert.equal(cap.maxReplicas, 6);
+  assert.equal(cap.used, 2);     // only the two Running runners
+  assert.equal(cap.available, 4);
+});
+
+test('getCapacity shows 0% utilization on empty pool', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool({ maxReplicas: 10 });
+  const cap = ctrl.getCapacity(pool);
+
+  assert.equal(cap.used, 0);
+  assert.equal(cap.available, 10);
+  assert.equal(cap.utilizationPct, 0);
+});
+
+test('getCapacity shows 100% utilization when pool is full', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool({ maxReplicas: 3 });
+  ctrl.createRunner(pool, 'run-f1');
+  ctrl.createRunner(pool, 'run-f2');
+  ctrl.createRunner(pool, 'run-f3');
+
+  const cap = ctrl.getCapacity(pool);
+  assert.equal(cap.available, 0);
+  assert.equal(cap.utilizationPct, 100);
+});
+
+// ---------------------------------------------------------------------------
+// Full workflow: pool → schedule → terminate → verify capacity restored
+// ---------------------------------------------------------------------------
+
+test('terminating a runner restores pool capacity', () => {
+  const ctrl = createRunnerController();
+  const pool = makePool({ maxReplicas: 2 });
+
+  const { runnerId } = ctrl.createRunner(pool, 'run-term-1');
+  ctrl.createRunner(pool, 'run-term-2');
+
+  const beforeTerminate = ctrl.getCapacity(pool);
+  assert.equal(beforeTerminate.available, 0);
+
+  ctrl.terminateRunner(runnerId);
+
+  const afterTerminate = ctrl.getCapacity(pool);
+  assert.equal(afterTerminate.available, 1);
+});