@boxxy/dispatch 0.1.0 → 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

@@ -0,0 +1,175 @@
+import { brandSchemas } from '@boxxy/model';
+import type { StoreChange } from '@boxxy/model';
+import { buildMockFactId } from '@boxxy/model/test-utils/build-mock-fact-id';
+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';
+import type { ClaimStoreCase } from './types.ts';
+
+export const claimStoreRollbackCases: readonly ClaimStoreCase[] = [
+  [
+    '#applyChange takes back the lease and seat releases of a settle whose guard fails',
+    async (store) => {
+      const workers = brandSchemas.limitName.parse('workers');
+      const item = buildMockV1ItemRow();
+      const attempt = buildMockV1AttemptRow({ item: item.id, state: 'starting' });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.syncLimits(
+          [{ name: workers, max: 1, counts: {} }],
+          brandSchemas.instant.parse(500),
+        );
+
+        await transaction.applyChange(buildMockFileItemChange(item));
+        await transaction.applyChange(buildMockClaimChange(attempt, [workers]));
+      });
+
+      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),
+          buildMockItemRules(),
+        );
+
+        return {
+          attempt: read?.state,
+          facts: facts.length,
+          held: limits.map((limit) => limit.held),
+          item: view?.derived,
+        };
+      });
+
+      return {
+        received: { result, state },
+        expected: {
+          result: { kind: 'guard-mismatch', table: 'attempts', key: { id: attempt.id } },
+          state: { attempt: 'starting', facts: 2, held: [1], item: { state: 'running' } },
+        },
+      };
+    },
+  ],
+  [
+    '#applyChange takes back every write of a change that throws',
+    async (store) => {
+      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, [workers]);
+      const reusedFactId: StoreChange = { ...claim, facts: [...claim.facts, ...fileChange.facts] };
+
+      await store.exclusive(async (transaction) => {
+        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);
+      });
+
+      const state: unknown = await store.read(async (transaction) => ({
+        attempt: await transaction.readAttempt(attempt.id),
+        seats: await transaction.listLimitSeats(),
+      }));
+
+      return { received: state, expected: { attempt: null, seats: [] } };
+    },
+  ],
+  [
+    '#applyChange keeps a heartbeat started beside a change it refuses',
+    async (store) => {
+      const filed = buildMockV1ItemRow();
+      const missing = buildMockV1ItemRow();
+      const runner = brandSchemas.runnerId.parse('runner-1');
+
+      await store.exclusive((transaction) =>
+        Promise.all([
+          transaction.applyChange({
+            at: brandSchemas.instant.parse(3000),
+            writes: [
+              { op: 'insert', table: 'items', row: filed },
+              {
+                op: 'update',
+                table: 'items',
+                key: { id: missing.id },
+                expect: {},
+                set: { title: 'Mend the gate' },
+              },
+            ],
+            facts: [
+              {
+                id: buildMockFactId(),
+                type: 'boxxy.item.edited',
+                entity: `boxxy:item:${missing.id}`,
+                actor: 'boxxy:owner:local',
+                payload: { title: 'Mend the gate', byAttempt: null },
+              },
+            ],
+          }),
+          transaction
+            .listLimits()
+            .then(() => transaction.writeHeartbeat(runner, brandSchemas.instant.parse(1000))),
+        ]),
+      );
+
+      const read: unknown = await store.read((transaction) => transaction.readRunner(runner));
+
+      return { received: read, expected: { id: 'runner-1', heartbeatAt: 1000, paused: false } };
+    },
+  ],
+  [
+    '#applyChange runs two changes started together on one call one at a time',
+    async (store) => {
+      const claimed = buildMockV1ItemRow();
+      const later = buildMockV1ItemRow();
+      const first = buildMockV1AttemptRow({ item: claimed.id, state: 'starting', leaseGen: 1 });
+
+      const second = buildMockV1AttemptRow({
+        item: claimed.id,
+        state: 'starting',
+        leaseGen: 2,
+        number: 2,
+      });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(buildMockFileItemChange(claimed));
+        await transaction.applyChange(buildMockClaimChange(first));
+      });
+
+      const results = await store.exclusive((transaction) =>
+        Promise.all([
+          transaction.applyChange(buildMockClaimChange(second)),
+          transaction.applyChange(buildMockFileItemChange(later)),
+        ]),
+      );
+
+      const read = await store.read((transaction) =>
+        transaction.readItem(later.id, brandSchemas.instant.parse(5000), buildMockItemRules()),
+      );
+
+      return {
+        received: { results, item: read?.id },
+        expected: {
+          results: [{ kind: 'lease-held' }, { kind: 'applied' }],
+          item: later.id,
+        },
+      };
+    },
+  ],
+];