Build the agent-native compute CRM platform

apps/api/test/capacity-writes.test.ts

@@ -0,0 +1,185 @@
+import { strict as assert } from 'node:assert';
+import { describe, it } from 'node:test';
+import type { Allocation, Database } from '@pig/db';
+import type { Principal } from '../src/lib/auth';
+import { executeMutation } from '../src/lib/mutation';
+import { createAllocationMutationDefinition } from '../src/routes/capacity-writes';
+import {
+  findCapacityViolation,
+  type CommitmentCapacity,
+  type ReservationCapacity,
+} from '../src/services/capacity-writes';
+
+const HOUR = 3_600_000;
+const START = new Date('2026-01-01T00:00:00.000Z');
+
+function at(hour: number): Date {
+  return new Date(START.getTime() + hour * HOUR);
+}
+
+function commitment(overrides: Partial<CommitmentCapacity> = {}): CommitmentCapacity {
+  return {
+    id: '10000000-0000-4000-8000-000000000001',
+    gpuCount: 8,
+    startsAt: at(0),
+    endsAt: at(10),
+    totalGpuHours: 80,
+    shape: null,
+    oversubscriptionPct: 0,
+    terminatedAt: null,
+    ...overrides,
+  };
+}
+
+function reservation(overrides: Partial<ReservationCapacity> = {}): ReservationCapacity {
+  return {
+    gpuHours: 80,
+    startsAt: at(0),
+    endsAt: at(10),
+    status: 'committed',
+    holdExpiresAt: null,
+    ...overrides,
+  };
+}
+
+describe('allocation availability invariant', () => {
+  it('permits only the oversubscription explicitly recorded on the commitment', () => {
+    const existing = reservation();
+    const extra = reservation({ gpuHours: 20 });
+
+    assert.equal(
+      findCapacityViolation(
+        commitment({ totalGpuHours: 100, oversubscriptionPct: 25 }),
+        [existing],
+        extra,
+        at(-1),
+      ),
+      null,
+    );
+    assert.equal(
+      findCapacityViolation(commitment({ totalGpuHours: 100 }), [existing], extra, at(-1))?.code,
+      'shape_capacity_exceeded',
+    );
+  });
+
+  it('ignores expired holds but live holds still reserve capacity', () => {
+    const expired = reservation({
+      status: 'planned',
+      holdExpiresAt: at(-1),
+    });
+    const live = reservation({
+      status: 'planned',
+      holdExpiresAt: at(1),
+    });
+    const requested = reservation();
+
+    assert.equal(findCapacityViolation(commitment(), [expired], requested, at(0)), null);
+    assert.equal(
+      findCapacityViolation(commitment(), [live], requested, at(0))?.code,
+      'total_capacity_exceeded',
+    );
+  });
+
+  it('checks each authoritative shape interval instead of averaging the term', () => {
+    const shaped = commitment({
+      endsAt: at(20),
+      totalGpuHours: 120,
+      shape: {
+        intervals: [at(0).toISOString(), at(10).toISOString(), at(20).toISOString()],
+        quantities: [8, 4],
+      },
+    });
+    const firstTranche = reservation({ gpuHours: 60 });
+    const overlapsRamp = reservation({ gpuHours: 30 });
+    const fitsLaterTranche = reservation({
+      gpuHours: 40,
+      startsAt: at(10),
+      endsAt: at(20),
+    });
+
+    assert.equal(
+      findCapacityViolation(shaped, [firstTranche], overlapsRamp, at(-1))?.code,
+      'shape_capacity_exceeded',
+    );
+    assert.equal(findCapacityViolation(shaped, [firstTranche], fitsLaterTranche, at(-1)), null);
+  });
+});
+
+const principal: Principal = {
+  userId: '00000000-0000-4000-8000-000000000001',
+  email: 'seller@example.com',
+  name: 'Seller',
+  isPlatformAdmin: false,
+  teams: [{ team: 'demand', role: 'member' }],
+  via: 'jwt',
+  scopes: ['read', 'write'],
+};
+
+describe('allocation mutation transaction', () => {
+  it('passes the mutation transaction through the capacity check and audit write', async () => {
+    const events: string[] = [];
+    const tx = {
+      insert: () => ({
+        values: async () => {
+          events.push('activity');
+        },
+      }),
+    };
+    const db = {
+      transaction: async (work: (transaction: unknown) => Promise<unknown>) => {
+        events.push('begin');
+        const result = await work(tx);
+        events.push('commit');
+        return result;
+      },
+    } as unknown as Database;
+
+    const definition = createAllocationMutationDefinition((transaction) => {
+      assert.equal(transaction, tx);
+      return {
+        createAllocation: async (input) => {
+          events.push('lock-check-insert');
+          return {
+            allocation: {
+              id: '30000000-0000-4000-8000-000000000003',
+              capacityCommitmentId: input.capacityCommitmentId,
+              demandDealId: input.demandDealId,
+              gpuHours: String(input.gpuHours),
+              pricePerGpuHourCents: input.pricePerGpuHourCents,
+              status: input.status,
+            } as Allocation,
+            commitment: {
+              id: input.capacityCommitmentId,
+              name: 'Eight H100s',
+            },
+            deal: {
+              id: input.demandDealId,
+              accountId: '40000000-0000-4000-8000-000000000004',
+            },
+          };
+        },
+        createCommitment: async () => assert.fail('wrong mutation'),
+        updateCommitment: async () => assert.fail('wrong mutation'),
+        createHold: async () => assert.fail('wrong mutation'),
+        releaseAllocation: async () => assert.fail('wrong mutation'),
+      };
+    });
+
+    await executeMutation(
+      db,
+      principal,
+      async () => ({
+        capacityCommitmentId: '10000000-0000-4000-8000-000000000001',
+        demandDealId: '20000000-0000-4000-8000-000000000002',
+        gpuHours: 8,
+        pricePerGpuHourCents: 225,
+        startsAt: '2026-01-01T00:00:00.000Z',
+        endsAt: '2026-01-01T01:00:00.000Z',
+        status: 'committed',
+      }),
+      definition,
+    );
+
+    assert.deepEqual(events, ['begin', 'lock-check-insert', 'activity', 'commit']);
+  });
+});