@boxxy/dispatch 0.1.0 → 0.1.1

package/src/test-utils/claim-store-attempt-reader-cases.ts

@@ -0,0 +1,327 @@
+import { expect } from 'bun:test';
+import { brandSchemas } from '@boxxy/model';
+import { buildMockAttemptRow } from '@boxxy/model/test-utils/build-mock-attempt-row';
+import { buildMockItemRow } from '@boxxy/model/test-utils/build-mock-item-row';
+import { buildMockClaimChange } from './build-mock-claim-change.ts';
+import { buildMockFileItemChange } from './build-mock-file-item-change.ts';
+import { buildMockPauseChange } from './build-mock-pause-change.ts';
+import { buildMockPullRequestChange } from './build-mock-pull-request-change.ts';
+import { buildMockSettleChange } from './build-mock-settle-change.ts';
+import { buildMockStartChange } from './build-mock-start-change.ts';
+import type { ClaimStoreCase } from './types.ts';
+
+export const claimStoreAttemptReaderCases: readonly ClaimStoreCase[] = [
+  [
+    '#readLastLeaseGen returns 0 for an item phase with no lease',
+    async (store) => {
+      const generation = await store.read((transaction) =>
+        transaction.readLastLeaseGen(buildMockItemRow().id, brandSchemas.phaseName.parse('build')),
+      );
+
+      return { received: generation, expected: 0 };
+    },
+  ],
+  [
+    '#readLastLeaseGen returns the highest gen after a released lease',
+    async (store) => {
+      const item = buildMockItemRow();
+      const attempt = buildMockAttemptRow({ item: item.id, state: 'starting', leaseGen: 3 });
+
+      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.applyChange(
+          buildMockSettleChange({ attempt: { ...attempt, slot: 1, slotGen: 1 }, state: 'failed' }),
+        );
+      });
+
+      const generation = await store.read((transaction) =>
+        transaction.readLastLeaseGen(item.id, attempt.phase),
+      );
+
+      return { received: generation, expected: 3 };
+    },
+  ],
+  [
+    '#listLiveAttempts returns the attempts that have not settled',
+    async (store) => {
+      const first = buildMockItemRow();
+      const second = buildMockItemRow();
+      const live = buildMockAttemptRow({ item: first.id, state: 'starting' });
+      const settled = buildMockAttemptRow({ item: second.id, state: 'starting' });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.syncPoolSlots([{ name: live.pool, slots: 2 }]);
+        await transaction.applyChange(buildMockFileItemChange(first));
+        await transaction.applyChange(buildMockFileItemChange(second));
+        await transaction.applyChange(buildMockClaimChange(live));
+        await transaction.applyChange(buildMockClaimChange(settled));
+
+        await transaction.applyChange(
+          buildMockSettleChange({ attempt: { ...settled, slot: 2, slotGen: 1 }, state: 'failed' }),
+        );
+      });
+
+      const listed = await store.read((transaction) => transaction.listLiveAttempts());
+
+      return { received: listed.map((attempt) => attempt.id), expected: [live.id] };
+    },
+  ],
+  [
+    '#listSucceededAttemptsWithoutPr skips an attempt with a linked PR',
+    async (store) => {
+      const first = buildMockItemRow();
+      const second = buildMockItemRow();
+      const linked = buildMockAttemptRow({ item: first.id, state: 'starting' });
+      const unlinked = buildMockAttemptRow({ item: second.id, state: 'starting' });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.syncPoolSlots([{ name: linked.pool, slots: 2 }]);
+        await transaction.applyChange(buildMockFileItemChange(first));
+        await transaction.applyChange(buildMockFileItemChange(second));
+        await transaction.applyChange(buildMockClaimChange(linked));
+        await transaction.applyChange(buildMockClaimChange(unlinked));
+
+        await transaction.applyChange(
+          buildMockSettleChange({
+            attempt: { ...linked, slot: 1, slotGen: 1 },
+            state: 'succeeded',
+          }),
+        );
+
+        await transaction.applyChange(
+          buildMockSettleChange({
+            attempt: { ...unlinked, slot: 2, slotGen: 1 },
+            state: 'succeeded',
+          }),
+        );
+
+        await transaction.applyChange(
+          buildMockPullRequestChange({ attempt: linked, state: 'open' }),
+        );
+      });
+
+      const listed = await store.read((transaction) =>
+        transaction.listSucceededAttemptsWithoutPr(),
+      );
+
+      return { received: listed.map((attempt) => attempt.id), expected: [unlinked.id] };
+    },
+  ],
+  [
+    '#findAttemptBySession returns the attempt with an atc session id',
+    async (store) => {
+      const item = buildMockItemRow();
+      const attempt = buildMockAttemptRow({ 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.applyChange(buildMockStartChange(attempt));
+      });
+
+      const found = await store.read((transaction) =>
+        transaction.findAttemptBySession(brandSchemas.atcSessionId.parse('atc-session-1')),
+      );
+
+      return { received: found?.id, expected: attempt.id };
+    },
+  ],
+  [
+    '#markPullRequestChecked sets the checked time of a watched PR',
+    async (store) => {
+      const item = buildMockItemRow();
+      const attempt = buildMockAttemptRow({ 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.applyChange(buildMockPullRequestChange({ attempt, state: 'open' }));
+      });
+
+      await store.exclusive((transaction) =>
+        transaction.markPullRequestChecked(
+          { repo: brandSchemas.repoName.parse('acme/lamps'), number: 7 },
+          brandSchemas.instant.parse(9000),
+        ),
+      );
+
+      const watched = await store.read((transaction) => transaction.listWatchedPullRequests());
+
+      return { received: watched[0]?.checkedAt, expected: brandSchemas.instant.parse(9000) };
+    },
+  ],
+  [
+    '#listWatchedPullRequests skips a merged PR',
+    async (store) => {
+      const item = buildMockItemRow();
+      const attempt = buildMockAttemptRow({ 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.applyChange(buildMockPullRequestChange({ attempt, state: 'merged' }));
+      });
+
+      const watched = await store.read((transaction) => transaction.listWatchedPullRequests());
+
+      return { received: watched, expected: [] };
+    },
+  ],
+  [
+    '#listEvidence returns the evidence of one attempt',
+    async (store) => {
+      const item = buildMockItemRow();
+      const attempt = buildMockAttemptRow({ 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.applyChange(buildMockPullRequestChange({ attempt, state: 'open' }));
+      });
+
+      const evidence: unknown = await store.read((transaction) =>
+        transaction.listEvidence(attempt.id),
+      );
+
+      return {
+        received: evidence,
+        expected: [
+          {
+            factId: expect.stringMatching(/^manual:/u),
+            attempt: attempt.id,
+            kind: 'pr',
+            ref: 'https://github.com/acme/lamps/pull/7',
+            observed: null,
+            source: 'hook',
+            at: 4000,
+          },
+        ],
+      };
+    },
+  ],
+  [
+    '#markFactsSent drops the facts from the unsent facts and the outbox lag',
+    async (store) => {
+      const first = buildMockFileItemChange(
+        buildMockItemRow({ filedAt: brandSchemas.instant.parse(1000) }),
+      );
+
+      const second = buildMockFileItemChange(
+        buildMockItemRow({ 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),
+          lag: await transaction.readOutboxLag(),
+        };
+      });
+
+      return {
+        received: outbox,
+        expected: {
+          unsent: second.facts.map((fact) => fact.id),
+          lag: { unsent: 1, oldestUnsentAt: 2000 },
+        },
+      };
+    },
+  ],
+  [
+    '#readUnsentFacts returns at most the limit, oldest first',
+    async (store) => {
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(buildMockFileItemChange(buildMockItemRow()));
+        await transaction.applyChange(buildMockFileItemChange(buildMockItemRow()));
+      });
+
+      const unsent = await store.read((transaction) => transaction.readUnsentFacts(1));
+
+      return { received: unsent.map((fact) => fact.seq), expected: [1] };
+    },
+  ],
+  [
+    '#readOutboxLag reads no lag from an empty outbox',
+    async (store) => {
+      const lag: unknown = await store.read((transaction) => transaction.readOutboxLag());
+
+      return { received: lag, expected: { unsent: 0, oldestUnsentAt: null } };
+    },
+  ],
+  [
+    '#readOutboxLag reads the earliest time of the unsent facts, whatever their order',
+    async (store) => {
+      const later = buildMockItemRow({ filedAt: brandSchemas.instant.parse(2000) });
+      const earlier = buildMockItemRow({ filedAt: brandSchemas.instant.parse(1000) });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(buildMockFileItemChange(later));
+        await transaction.applyChange(buildMockFileItemChange(earlier));
+      });
+
+      const lag: unknown = await store.read((transaction) => transaction.readOutboxLag());
+
+      return { received: lag, expected: { unsent: 2, oldestUnsentAt: 1000 } };
+    },
+  ],
+  [
+    '#writeHeartbeat inserts the runner row on its first beat, not paused',
+    async (store) => {
+      const runner = brandSchemas.runnerId.parse('runner-1');
+
+      await store.exclusive((transaction) =>
+        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 } };
+    },
+  ],
+  [
+    '#writeHeartbeat moves the heartbeat and keeps the paused flag',
+    async (store) => {
+      const runner = brandSchemas.runnerId.parse('runner-1');
+
+      await store.exclusive(async (transaction) => {
+        await transaction.writeHeartbeat(runner, brandSchemas.instant.parse(1000));
+        await transaction.applyChange(buildMockPauseChange(runner));
+        await transaction.writeHeartbeat(runner, brandSchemas.instant.parse(2000));
+      });
+
+      const read: unknown = await store.read((transaction) => transaction.readRunner(runner));
+
+      return { received: read, expected: { id: 'runner-1', heartbeatAt: 2000, paused: true } };
+    },
+  ],
+  [
+    '#readRunner returns null before the first heartbeat',
+    async (store) => {
+      const read = await store.read((transaction) =>
+        transaction.readRunner(brandSchemas.runnerId.parse('runner-1')),
+      );
+
+      return { received: read, expected: null };
+    },
+  ],
+];

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

@@ -0,0 +1,231 @@
+import { brandSchemas } from '@boxxy/model';
+import { buildMockAttemptRow } from '@boxxy/model/test-utils/build-mock-attempt-row';
+import { buildMockItemRow } from '@boxxy/model/test-utils/build-mock-item-row';
+import { buildMockLeverRow } from '@boxxy/model/test-utils/build-mock-lever-row';
+import { buildMockClaimChange } from './build-mock-claim-change.ts';
+import { buildMockFileItemChange } from './build-mock-file-item-change.ts';
+import { buildMockLeverChange } from './build-mock-lever-change.ts';
+import type { ClaimStoreCase } from './types.ts';
+
+export const claimStoreClaimCases: readonly ClaimStoreCase[] = [
+  [
+    '#applyChange returns lease-held for a second live lease on one item phase',
+    async (store) => {
+      const item = buildMockItemRow();
+      const first = buildMockAttemptRow({ item: item.id, state: 'starting', leaseGen: 1 });
+
+      const second = buildMockAttemptRow({
+        item: item.id,
+        state: 'starting',
+        leaseGen: 2,
+        number: 2,
+      });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.syncPoolSlots([{ name: first.pool, slots: 2 }]);
+        await transaction.applyChange(buildMockFileItemChange(item));
+        await transaction.applyChange(buildMockClaimChange(first));
+      });
+
+      const result = await store.exclusive((transaction) =>
+        transaction.applyChange(buildMockClaimChange(second)),
+      );
+
+      return { received: result, expected: { kind: 'lease-held' } };
+    },
+  ],
+  [
+    '#applyChange writes no row of a change that returns lease-held',
+    async (store) => {
+      const item = buildMockItemRow();
+      const first = buildMockAttemptRow({ item: item.id, state: 'starting', leaseGen: 1 });
+
+      const second = buildMockAttemptRow({
+        item: item.id,
+        state: 'starting',
+        leaseGen: 2,
+        number: 2,
+      });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.syncPoolSlots([{ name: first.pool, slots: 2 }]);
+        await transaction.applyChange(buildMockFileItemChange(item));
+        await transaction.applyChange(buildMockClaimChange(first));
+        await transaction.applyChange(buildMockClaimChange(second));
+      });
+
+      const state: unknown = await store.read(async (transaction) => {
+        const snapshot = await transaction.readSnapshot(
+          brandSchemas.instant.parse(5000),
+          new Map(),
+        );
+
+        return {
+          attempt: await transaction.readAttempt(second.id),
+          slots: await transaction.listPoolSlots(),
+          lastGen: await transaction.readLastLeaseGen(item.id, first.phase),
+          version: snapshot.storeVersion,
+        };
+      });
+
+      return {
+        received: state,
+        expected: {
+          attempt: null,
+          slots: [
+            { pool: first.pool, slot: 1, holder: first.id, gen: 1, retired: false },
+            { pool: first.pool, slot: 2, holder: null, gen: 0, retired: false },
+          ],
+          lastGen: 1,
+          version: 2,
+        },
+      };
+    },
+  ],
+  [
+    '#applyChange returns no-free-slot and changes no row when every slot is held',
+    async (store) => {
+      const held = buildMockItemRow();
+      const waiting = buildMockItemRow();
+      const first = buildMockAttemptRow({ item: held.id, state: 'starting' });
+      const second = buildMockAttemptRow({ item: waiting.id, state: 'starting' });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.syncPoolSlots([{ name: first.pool, slots: 1 }]);
+        await transaction.applyChange(buildMockFileItemChange(held));
+        await transaction.applyChange(buildMockFileItemChange(waiting));
+        await transaction.applyChange(buildMockClaimChange(first));
+      });
+
+      const result = await store.exclusive((transaction) =>
+        transaction.applyChange(buildMockClaimChange(second)),
+      );
+
+      const state: unknown = await store.read(async (transaction) => {
+        const snapshot = await transaction.readSnapshot(
+          brandSchemas.instant.parse(5000),
+          new Map(),
+        );
+
+        return {
+          attempt: await transaction.readAttempt(second.id),
+          lastGen: await transaction.readLastLeaseGen(waiting.id, second.phase),
+          version: snapshot.storeVersion,
+        };
+      });
+
+      return {
+        received: { result, state },
+        expected: {
+          result: { kind: 'no-free-slot' },
+          state: { attempt: null, lastGen: 0, version: 3 },
+        },
+      };
+    },
+  ],
+  [
+    '#applyChange gives a claim the lowest free slot and its new gen',
+    async (store) => {
+      const item = buildMockItemRow();
+      const attempt = buildMockAttemptRow({ item: item.id, state: 'starting' });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.syncPoolSlots([{ name: attempt.pool, slots: 2 }]);
+        await transaction.applyChange(buildMockFileItemChange(item));
+      });
+
+      const result = await store.exclusive((transaction) =>
+        transaction.applyChange(buildMockClaimChange(attempt)),
+      );
+
+      return {
+        received: result,
+        expected: {
+          kind: 'applied',
+          slot: { pool: attempt.pool, slot: 1, gen: 1 },
+        },
+      };
+    },
+  ],
+  [
+    '#applyChange writes the taken slot and slot gen into the attempt row',
+    async (store) => {
+      const item = buildMockItemRow();
+      const attempt = buildMockAttemptRow({ item: item.id, state: 'starting' });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.syncPoolSlots([{ name: attempt.pool, slots: 2 }]);
+        await transaction.applyChange(buildMockFileItemChange(item));
+        await transaction.applyChange(buildMockClaimChange(attempt));
+      });
+
+      const read = await store.read((transaction) => transaction.readAttempt(attempt.id));
+
+      return { received: read, expected: { ...attempt, slot: 1, slotGen: 1 } };
+    },
+  ],
+  [
+    '#applyChange writes the taken slot and slot gen into the claimed fact',
+    async (store) => {
+      const item = buildMockItemRow();
+      const attempt = buildMockAttemptRow({ item: item.id, state: 'starting' });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.syncPoolSlots([{ name: attempt.pool, slots: 2 }]);
+        await transaction.applyChange(buildMockFileItemChange(item));
+        await transaction.applyChange(buildMockClaimChange(attempt));
+      });
+
+      const facts = await store.read((transaction) => transaction.readUnsentFacts(10));
+
+      return {
+        received: facts[1]?.payload,
+        expected: {
+          item: item.id,
+          phase: attempt.phase,
+          number: attempt.number,
+          pool: attempt.pool,
+          slot: 1,
+          gen: 1,
+          recipeHash: attempt.recipeHash,
+          rulesVersion: attempt.rulesVersion,
+        },
+      };
+    },
+  ],
+  [
+    '#applyChange gives each lever insert its seq, in the row and the fact',
+    async (store) => {
+      const item = buildMockItemRow();
+      const defer = buildMockLeverRow({ seq: 0, item: item.id, kind: 'plan.defer' });
+      const expedite = buildMockLeverRow({ seq: 0, item: item.id, kind: 'plan.expedite' });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(buildMockFileItemChange(item));
+        await transaction.applyChange(buildMockLeverChange(defer));
+        await transaction.applyChange(buildMockLeverChange(expedite));
+      });
+
+      const state: unknown = await store.read(async (transaction) => {
+        const items = await transaction.listItems({}, brandSchemas.instant.parse(5000), new Map());
+        const facts = await transaction.readUnsentFacts(10);
+
+        return { levers: items[0]?.levers, payloads: facts.slice(1).map((fact) => fact.payload) };
+      });
+
+      return {
+        received: state,
+        expected: {
+          levers: [
+            { ...defer, seq: 1 },
+            { ...expedite, seq: 2 },
+          ],
+          payloads: [
+            { ...defer, seq: 1 },
+            { ...expedite, seq: 2 },
+          ],
+        },
+      };
+    },
+  ],
+];

package/src/test-utils/claim-store-contract.ts

@@ -0,0 +1,18 @@
+import { claimStoreAttemptReaderCases } from './claim-store-attempt-reader-cases.ts';
+import { claimStoreClaimCases } from './claim-store-claim-cases.ts';
+import { claimStoreExclusiveCases } from './claim-store-exclusive-cases.ts';
+import { claimStoreGuardCases } from './claim-store-guard-cases.ts';
+import { claimStoreItemReaderCases } from './claim-store-item-reader-cases.ts';
+import { claimStorePoolCases } from './claim-store-pool-cases.ts';
+import { claimStoreRollbackCases } from './claim-store-rollback-cases.ts';
+import type { ClaimStoreCase } from './types.ts';
+
+export const claimStoreContract: readonly ClaimStoreCase[] = [
+  ...claimStoreExclusiveCases,
+  ...claimStoreClaimCases,
+  ...claimStoreGuardCases,
+  ...claimStoreRollbackCases,
+  ...claimStorePoolCases,
+  ...claimStoreItemReaderCases,
+  ...claimStoreAttemptReaderCases,
+];