@boxxy/dispatch 0.1.1 → 0.1.3

package/src/test-utils/claim-store-outbox-cases.ts

@@ -0,0 +1,281 @@
+import { brandSchemas } from '@boxxy/model';
+import { buildMockV1ItemRow } from '@boxxy/model/test-utils/build-mock-v1-item-row';
+import { buildMockFileItemChange } from './build-mock-file-item-change.ts';
+import type { ClaimStoreCase } from './types.ts';
+
+export const claimStoreOutboxCases: readonly ClaimStoreCase[] = [
+  [
+    '#markFactsSent drops the facts from the unsent facts and the counts',
+    async (store) => {
+      const first = buildMockFileItemChange(
+        buildMockV1ItemRow({ filedAt: brandSchemas.instant.parse(1000) }),
+      );
+
+      const second = buildMockFileItemChange(
+        buildMockV1ItemRow({ filedAt: brandSchemas.instant.parse(2000) }),
+      );
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(first);
+        await transaction.applyChange(second);
+      });
+
+      await store.exclusive((transaction) =>
+        transaction.markFactsSent(
+          first.facts.map((fact) => fact.id),
+          brandSchemas.instant.parse(3000),
+        ),
+      );
+
+      const outbox: unknown = await store.read(async (transaction) => {
+        const unsent = await transaction.readUnsentFacts(10);
+
+        return {
+          unsent: unsent.map((fact) => fact.factId),
+          counts: await transaction.readOutboxCounts(),
+        };
+      });
+
+      return {
+        received: outbox,
+        expected: {
+          unsent: second.facts.map((fact) => fact.id),
+          counts: { unsent: 1, parked: 0, oldestUnsentAt: 2000 },
+        },
+      };
+    },
+  ],
+  [
+    '#readUnsentFacts returns at most the limit, oldest first',
+    async (store) => {
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(buildMockFileItemChange(buildMockV1ItemRow()));
+        await transaction.applyChange(buildMockFileItemChange(buildMockV1ItemRow()));
+      });
+
+      const unsent = await store.read((transaction) => transaction.readUnsentFacts(1));
+
+      return { received: unsent.map((fact) => fact.seq), expected: [1] };
+    },
+  ],
+  [
+    '#readOutboxCounts reads no row from an empty outbox',
+    async (store) => {
+      const counts: unknown = await store.read((transaction) => transaction.readOutboxCounts());
+
+      return { received: counts, expected: { unsent: 0, parked: 0, oldestUnsentAt: null } };
+    },
+  ],
+  [
+    '#readOutboxCounts reads the earliest time of the unsent facts, whatever their order',
+    async (store) => {
+      const later = buildMockV1ItemRow({ filedAt: brandSchemas.instant.parse(2000) });
+      const earlier = buildMockV1ItemRow({ filedAt: brandSchemas.instant.parse(1000) });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(buildMockFileItemChange(later));
+        await transaction.applyChange(buildMockFileItemChange(earlier));
+      });
+
+      const counts: unknown = await store.read((transaction) => transaction.readOutboxCounts());
+
+      return { received: counts, expected: { unsent: 2, parked: 0, oldestUnsentAt: 1000 } };
+    },
+  ],
+  [
+    '#parkFacts leaves a parked fact out of the unsent facts and counts it parked',
+    async (store) => {
+      const parked = buildMockFileItemChange(
+        buildMockV1ItemRow({ filedAt: brandSchemas.instant.parse(1000) }),
+      );
+
+      const waiting = buildMockFileItemChange(
+        buildMockV1ItemRow({ filedAt: brandSchemas.instant.parse(2000) }),
+      );
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(parked);
+        await transaction.applyChange(waiting);
+      });
+
+      await store.exclusive((transaction) =>
+        transaction.parkFacts(
+          parked.facts.map((fact) => fact.id),
+          'too-large',
+          brandSchemas.instant.parse(3000),
+        ),
+      );
+
+      const outbox: unknown = await store.read(async (transaction) => {
+        const unsent = await transaction.readUnsentFacts(10);
+
+        return {
+          unsent: unsent.map((fact) => fact.factId),
+          counts: await transaction.readOutboxCounts(),
+        };
+      });
+
+      return {
+        received: outbox,
+        expected: {
+          unsent: waiting.facts.map((fact) => fact.id),
+          counts: { unsent: 1, parked: 1, oldestUnsentAt: 2000 },
+        },
+      };
+    },
+  ],
+  [
+    '#markFactsSent leaves a parked fact parked',
+    async (store) => {
+      const change = buildMockFileItemChange(buildMockV1ItemRow());
+      const ids = change.facts.map((fact) => fact.id);
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(change);
+        await transaction.parkFacts(ids, 'unknown-type', brandSchemas.instant.parse(3000));
+      });
+
+      await store.exclusive((transaction) =>
+        transaction.markFactsSent(ids, brandSchemas.instant.parse(4000)),
+      );
+
+      const counts: unknown = await store.read((transaction) => transaction.readOutboxCounts());
+
+      return { received: counts, expected: { unsent: 0, parked: 1, oldestUnsentAt: null } };
+    },
+  ],
+  [
+    '#parkFacts leaves a sent fact as it is',
+    async (store) => {
+      const change = buildMockFileItemChange(buildMockV1ItemRow());
+      const ids = change.facts.map((fact) => fact.id);
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(change);
+        await transaction.markFactsSent(ids, brandSchemas.instant.parse(3000));
+      });
+
+      await store.exclusive((transaction) =>
+        transaction.parkFacts(ids, 'too-large', brandSchemas.instant.parse(4000)),
+      );
+
+      const counts: unknown = await store.read((transaction) => transaction.readOutboxCounts());
+
+      return { received: counts, expected: { unsent: 0, parked: 0, oldestUnsentAt: null } };
+    },
+  ],
+  [
+    '#unparkFacts clears every park mark, returns the count and the facts read unsent again',
+    async (store) => {
+      const first = buildMockFileItemChange(buildMockV1ItemRow());
+      const second = buildMockFileItemChange(buildMockV1ItemRow());
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(first);
+        await transaction.applyChange(second);
+
+        await transaction.parkFacts(
+          [...first.facts, ...second.facts].map((fact) => fact.id),
+          'too-large',
+          brandSchemas.instant.parse(3000),
+        );
+      });
+
+      const cleared = await store.exclusive((transaction) => transaction.unparkFacts());
+      const unsent = await store.read((transaction) => transaction.readUnsentFacts(10));
+
+      return {
+        received: { cleared, unsent: unsent.map((fact) => [fact.parkedAt, fact.parkedReason]) },
+        expected: {
+          cleared: 2,
+          unsent: [
+            [null, null],
+            [null, null],
+          ],
+        },
+      };
+    },
+  ],
+  [
+    '#readItemBehind counts the unsent facts of one item, parked ones too',
+    async (store) => {
+      const item = buildMockV1ItemRow({ filedAt: brandSchemas.instant.parse(1000) });
+      const other = buildMockV1ItemRow();
+      const filed = buildMockFileItemChange(item);
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(filed);
+        await transaction.applyChange(buildMockFileItemChange(other));
+
+        await transaction.parkFacts(
+          filed.facts.map((fact) => fact.id),
+          'too-large',
+          brandSchemas.instant.parse(3000),
+        );
+      });
+
+      const behind: unknown = await store.read((transaction) =>
+        transaction.readItemBehind(item.id),
+      );
+
+      return { received: behind, expected: { facts: 1, oldestAt: 1000 } };
+    },
+  ],
+  [
+    '#readItemBehind reads nothing behind for an item whose facts are sent',
+    async (store) => {
+      const item = buildMockV1ItemRow();
+      const filed = buildMockFileItemChange(item);
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(filed);
+
+        await transaction.markFactsSent(
+          filed.facts.map((fact) => fact.id),
+          brandSchemas.instant.parse(3000),
+        );
+      });
+
+      const behind: unknown = await store.read((transaction) =>
+        transaction.readItemBehind(item.id),
+      );
+
+      return { received: behind, expected: { facts: 0, oldestAt: null } };
+    },
+  ],
+  [
+    '#markNoticeTried counts a failed try and keeps the notice unsent',
+    async (store) => {
+      const item = buildMockV1ItemRow();
+
+      const notice = {
+        id: 0,
+        item: item.id,
+        reason: 'attempts used up',
+        at: brandSchemas.instant.parse(3000),
+        tries: 0,
+        sentAt: null,
+      } as const;
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(buildMockFileItemChange(item));
+
+        await transaction.applyChange({
+          at: notice.at,
+          writes: [
+            { op: 'insert', table: 'notices', row: notice },
+            { op: 'insert', table: 'notices', row: notice },
+          ],
+          facts: [],
+        });
+
+        await transaction.markNoticeTried(1, brandSchemas.instant.parse(3500), false);
+        await transaction.markNoticeTried(2, brandSchemas.instant.parse(3500), true);
+      });
+
+      const unsent: unknown = await store.read((transaction) => transaction.listUnsentNotices(10));
+
+      return { received: unsent, expected: [{ ...notice, id: 1, tries: 1 }] };
+    },
+  ],
+];

package/src/test-utils/claim-store-race-cases.ts

@@ -0,0 +1,150 @@
+import { brandSchemas } from '@boxxy/model';
+import type { AttemptRow, StoreChange } from '@boxxy/model';
+import { buildMockV1AttemptRow } from '@boxxy/model/test-utils/build-mock-v1-attempt-row';
+import { buildMockV1ItemRow } from '@boxxy/model/test-utils/build-mock-v1-item-row';
+import invariant from 'tiny-invariant';
+import { buildAttemptChange } from '../attempts/build-attempt-change.ts';
+import type { MoveEvent } from '../attempts/types.ts';
+import { buildMockClaimChange } from './build-mock-claim-change.ts';
+import { buildMockFileItemChange } from './build-mock-file-item-change.ts';
+import { buildMockNewId } from './build-mock-new-id.ts';
+import type { ClaimStoreCase } from './types.ts';
+
+export const claimStoreRaceCases: readonly ClaimStoreCase[] = [
+  [
+    '#applyChange applies the attempt builder claim with its lease, seats, decision and fact',
+    async (store) => {
+      const item = buildMockV1ItemRow();
+      const workers = brandSchemas.limitName.parse('workers');
+      const pool = brandSchemas.poolName.parse('main');
+      const rulesVersion = brandSchemas.rulesVersion.parse('a'.repeat(64));
+
+      const built = buildAttemptChange({
+        actor: 'boxxy:runner:runner-1',
+        now: brandSchemas.instant.parse(5000),
+        newId: buildMockNewId(),
+        attempt: null,
+        event: {
+          kind: 'claimed',
+          attempt: buildMockV1AttemptRow().id,
+          pick: {
+            kind: 'start',
+            item: item.id,
+            phase: brandSchemas.phaseName.parse('build'),
+            round: 1,
+            pool,
+            fields: { repo: ['acme/lamps'] },
+            limits: [workers],
+          },
+          number: 1,
+          runner: brandSchemas.runnerId.parse('runner-1'),
+          leaseGen: 1,
+          recipe: { hash: brandSchemas.recipeHash.parse('c'.repeat(64)), rulesVersion },
+          skillsRef: null,
+          spawnRequest: { prompt: 'Fix the flicker.' },
+          spawnRequestHash: buildMockV1AttemptRow().spawnRequestHash,
+          input: { findings: [] },
+          mode: 'agent',
+          caller: null,
+          decision: {
+            item: item.id,
+            kind: 'start',
+            pool,
+            rulesVersion,
+            snapshotHash: brandSchemas.snapshotHash.parse('b'.repeat(64)),
+            storeVersion: 1,
+            pepysOffsets: {},
+            faults: [],
+            limits: [{ limit: workers, held: 0, max: 2 }],
+          },
+        },
+      });
+
+      invariant(built.kind === 'change', 'the attempt machine allows a claim');
+
+      await store.exclusive(async (transaction) => {
+        await transaction.syncLimits(
+          [{ name: workers, max: 2, counts: {} }],
+          brandSchemas.instant.parse(500),
+        );
+
+        await transaction.applyChange(buildMockFileItemChange(item));
+      });
+
+      const result = await store.exclusive((transaction) => transaction.applyChange(built.change));
+
+      const state: unknown = await store.read(async (transaction) => {
+        const attempts = await transaction.listItemAttempts(item.id);
+        const limits = await transaction.listLimits();
+        const facts = await transaction.readUnsentFacts(10);
+
+        return {
+          attempts: attempts.map((attempt) => [attempt.state, attempt.input]),
+          held: limits.map((limit) => limit.held),
+          facts: facts.map((fact) => fact.type),
+        };
+      });
+
+      return {
+        received: { result, state },
+        expected: {
+          result: { kind: 'applied' },
+          state: {
+            attempts: [['starting', { findings: [] }]],
+            held: [1],
+            facts: ['boxxy.item.filed', 'boxxy.attempt.claimed', 'boxxy.decision.recorded'],
+          },
+        },
+      };
+    },
+  ],
+  [
+    '#applyChange refuses the second of two attempt moves built from one read',
+    async (store) => {
+      const attempt = buildMockV1AttemptRow({ state: 'running' });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(
+          buildMockFileItemChange(buildMockV1ItemRow({ id: attempt.item })),
+        );
+
+        await transaction.applyChange(buildMockClaimChange(attempt));
+      });
+
+      const read = await store.read((transaction) => transaction.readAttempt(attempt.id));
+
+      invariant(read !== null, 'the claim stored the attempt');
+
+      const first = buildMoveChange(read, { kind: 'suspend-asked' });
+      const second = buildMoveChange(read, { kind: 'stalled' });
+
+      const results = await store.exclusive(async (transaction) => [
+        await transaction.applyChange(first),
+        await transaction.applyChange(second),
+      ]);
+
+      return {
+        received: results,
+        expected: [
+          { kind: 'applied' },
+          { kind: 'guard-mismatch', table: 'attempts', key: { id: attempt.id } },
+        ],
+      };
+    },
+  ],
+];
+
+// the attempt builder's change, which the store takes as it is
+function buildMoveChange(attempt: AttemptRow, event: MoveEvent): StoreChange {
+  const built = buildAttemptChange({
+    actor: 'boxxy:runner:runner-1',
+    now: brandSchemas.instant.parse(5000),
+    newId: buildMockNewId(),
+    attempt,
+    event,
+  });
+
+  invariant(built.kind === 'change', 'the attempt machine allows the move');
+
+  return built.change;
+}

package/src/test-utils/claim-store-rollback-cases.ts

@@ -1,8 +1,9 @@
 import { brandSchemas } from '@boxxy/model';
 import type { StoreChange } from '@boxxy/model';
-import { buildMockAttemptRow } from '@boxxy/model/test-utils/build-mock-attempt-row';
 import { buildMockFactId } from '@boxxy/model/test-utils/build-mock-fact-id';
-import { buildMockItemRow } from '@boxxy/model/test-utils/build-mock-item-row';
+import { buildMockItemRules } from '@boxxy/model/test-utils/build-mock-item-rules';
+import { buildMockV1AttemptRow } from '@boxxy/model/test-utils/build-mock-v1-attempt-row';
+import { buildMockV1ItemRow } from '@boxxy/model/test-utils/build-mock-v1-item-row';
 import { buildMockClaimChange } from './build-mock-claim-change.ts';
 import { buildMockFileItemChange } from './build-mock-file-item-change.ts';
 import { buildMockSettleChange } from './build-mock-settle-change.ts';
@@ -10,51 +11,52 @@ import type { ClaimStoreCase } from './types.ts';
 
 export const claimStoreRollbackCases: readonly ClaimStoreCase[] = [
   [
-    '#applyChange refuses a settle whose slot release names another holder whole',
+    '#applyChange takes back the lease and seat releases of a settle whose guard fails',
     async (store) => {
-      const item = buildMockItemRow();
-      const attempt = buildMockAttemptRow({ item: item.id, state: 'starting' });
-      const other = buildMockAttemptRow();
+      const workers = brandSchemas.limitName.parse('workers');
+      const item = buildMockV1ItemRow();
+      const attempt = buildMockV1AttemptRow({ item: item.id, state: 'starting' });
 
       await store.exclusive(async (transaction) => {
-        await transaction.syncPoolSlots([{ name: attempt.pool, slots: 1 }]);
-        await transaction.applyChange(buildMockFileItemChange(item));
-        await transaction.applyChange(buildMockClaimChange(attempt));
-      });
+        await transaction.syncLimits(
+          [{ name: workers, max: 1, counts: {} }],
+          brandSchemas.instant.parse(500),
+        );
 
-      const settle = buildMockSettleChange({
-        attempt: { ...attempt, slot: 1, slotGen: 1 },
-        state: 'succeeded',
+        await transaction.applyChange(buildMockFileItemChange(item));
+        await transaction.applyChange(buildMockClaimChange(attempt, [workers]));
       });
 
-      const misnamed: StoreChange = {
-        ...settle,
-        writes: [
-          ...settle.writes.filter((write) => write.op !== 'release-slot'),
-          { op: 'release-slot', pool: attempt.pool, slot: 1, holder: other.id },
-        ],
-      };
-
-      const result = await store.exclusive((transaction) => transaction.applyChange(misnamed));
+      const result = await store.exclusive((transaction) =>
+        transaction.applyChange(
+          buildMockSettleChange({ attempt: { ...attempt, state: 'running' }, state: 'failed' }),
+        ),
+      );
 
       const state: unknown = await store.read(async (transaction) => {
         const read = await transaction.readAttempt(attempt.id);
         const facts = await transaction.readUnsentFacts(10);
+        const limits = await transaction.listLimits();
 
         const view = await transaction.readItem(
           item.id,
           brandSchemas.instant.parse(5000),
-          new Map(),
+          buildMockItemRules(),
         );
 
-        return { attempt: read?.state, facts: facts.length, item: view?.derived };
+        return {
+          attempt: read?.state,
+          facts: facts.length,
+          held: limits.map((limit) => limit.held),
+          item: view?.derived,
+        };
       });
 
       return {
         received: { result, state },
         expected: {
-          result: { kind: 'stale-generation' },
-          state: { attempt: 'starting', facts: 2, item: { state: 'running' } },
+          result: { kind: 'guard-mismatch', table: 'attempts', key: { id: attempt.id } },
+          state: { attempt: 'starting', facts: 2, held: [1], item: { state: 'running' } },
         },
       };
     },
@@ -62,15 +64,20 @@ export const claimStoreRollbackCases: readonly ClaimStoreCase[] = [
   [
     '#applyChange takes back every write of a change that throws',
     async (store) => {
-      const filed = buildMockItemRow();
-      const claimed = buildMockItemRow();
-      const attempt = buildMockAttemptRow({ item: claimed.id, state: 'starting' });
+      const workers = brandSchemas.limitName.parse('workers');
+      const filed = buildMockV1ItemRow();
+      const claimed = buildMockV1ItemRow();
+      const attempt = buildMockV1AttemptRow({ item: claimed.id, state: 'starting' });
       const fileChange = buildMockFileItemChange(filed);
-      const claim = buildMockClaimChange(attempt);
+      const claim = buildMockClaimChange(attempt, [workers]);
       const reusedFactId: StoreChange = { ...claim, facts: [...claim.facts, ...fileChange.facts] };
 
       await store.exclusive(async (transaction) => {
-        await transaction.syncPoolSlots([{ name: attempt.pool, slots: 1 }]);
+        await transaction.syncLimits(
+          [{ name: workers, max: 1, counts: {} }],
+          brandSchemas.instant.parse(500),
+        );
+
         await transaction.applyChange(fileChange);
         await transaction.applyChange(buildMockFileItemChange(claimed));
         await transaction.applyChange(reusedFactId).catch(() => null);
@@ -78,23 +85,17 @@ export const claimStoreRollbackCases: readonly ClaimStoreCase[] = [
 
       const state: unknown = await store.read(async (transaction) => ({
         attempt: await transaction.readAttempt(attempt.id),
-        slots: await transaction.listPoolSlots(),
+        seats: await transaction.listLimitSeats(),
       }));
 
-      return {
-        received: state,
-        expected: {
-          attempt: null,
-          slots: [{ pool: attempt.pool, slot: 1, holder: null, gen: 0, retired: false }],
-        },
-      };
+      return { received: state, expected: { attempt: null, seats: [] } };
     },
   ],
   [
     '#applyChange keeps a heartbeat started beside a change it refuses',
     async (store) => {
-      const filed = buildMockItemRow();
-      const missing = buildMockItemRow();
+      const filed = buildMockV1ItemRow();
+      const missing = buildMockV1ItemRow();
       const runner = brandSchemas.runnerId.parse('runner-1');
 
       await store.exclusive((transaction) =>
@@ -117,12 +118,12 @@ export const claimStoreRollbackCases: readonly ClaimStoreCase[] = [
                 type: 'boxxy.item.edited',
                 entity: `boxxy:item:${missing.id}`,
                 actor: 'boxxy:owner:local',
-                payload: { title: 'Mend the gate' },
+                payload: { title: 'Mend the gate', byAttempt: null },
               },
             ],
           }),
           transaction
-            .listPoolSlots()
+            .listLimits()
             .then(() => transaction.writeHeartbeat(runner, brandSchemas.instant.parse(1000))),
         ]),
       );
@@ -135,11 +136,11 @@ export const claimStoreRollbackCases: readonly ClaimStoreCase[] = [
   [
     '#applyChange runs two changes started together on one call one at a time',
     async (store) => {
-      const claimed = buildMockItemRow();
-      const later = buildMockItemRow();
-      const first = buildMockAttemptRow({ item: claimed.id, state: 'starting', leaseGen: 1 });
+      const claimed = buildMockV1ItemRow();
+      const later = buildMockV1ItemRow();
+      const first = buildMockV1AttemptRow({ item: claimed.id, state: 'starting', leaseGen: 1 });
 
-      const second = buildMockAttemptRow({
+      const second = buildMockV1AttemptRow({
         item: claimed.id,
         state: 'starting',
         leaseGen: 2,
@@ -147,7 +148,6 @@ export const claimStoreRollbackCases: readonly ClaimStoreCase[] = [
       });
 
       await store.exclusive(async (transaction) => {
-        await transaction.syncPoolSlots([{ name: first.pool, slots: 2 }]);
         await transaction.applyChange(buildMockFileItemChange(claimed));
         await transaction.applyChange(buildMockClaimChange(first));
       });
@@ -160,13 +160,13 @@ export const claimStoreRollbackCases: readonly ClaimStoreCase[] = [
       );
 
       const read = await store.read((transaction) =>
-        transaction.readItem(later.id, brandSchemas.instant.parse(5000), new Map()),
+        transaction.readItem(later.id, brandSchemas.instant.parse(5000), buildMockItemRules()),
       );
 
       return {
         received: { results, item: read?.id },
         expected: {
-          results: [{ kind: 'lease-held' }, { kind: 'applied', slot: null }],
+          results: [{ kind: 'lease-held' }, { kind: 'applied' }],
           item: later.id,
         },
       };