@boxxy/dispatch 0.1.0 → 0.1.1

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

@@ -0,0 +1,257 @@
+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 { buildMockLinkChange } from './build-mock-link-change.ts';
+import { buildMockPullRequestChange } from './build-mock-pull-request-change.ts';
+import { buildMockSettleChange } from './build-mock-settle-change.ts';
+import type { ClaimStoreCase } from './types.ts';
+
+export const claimStoreItemReaderCases: readonly ClaimStoreCase[] = [
+  [
+    '#readSnapshot holds the open items, the store version and the free slots',
+    async (store) => {
+      const open = buildMockItemRow();
+      const archived = buildMockItemRow({ closedAt: brandSchemas.instant.parse(1500) });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.syncPoolSlots([{ name: brandSchemas.poolName.parse('build'), slots: 2 }]);
+        await transaction.applyChange(buildMockFileItemChange(open));
+        await transaction.applyChange(buildMockFileItemChange(archived));
+      });
+
+      const snapshot: unknown = await store.read((transaction) =>
+        transaction.readSnapshot(brandSchemas.instant.parse(5000), new Map()),
+      );
+
+      return {
+        received: snapshot,
+        expected: {
+          storeVersion: 2,
+          items: [{ ...open, derived: { state: 'ready' } }],
+          links: [],
+          levers: [],
+          freeSlots: { build: 2 },
+        },
+      };
+    },
+  ],
+  [
+    '#readSnapshot drops a done item',
+    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(
+          buildMockSettleChange({
+            attempt: { ...attempt, slot: 1, slotGen: 1 },
+            state: 'succeeded',
+          }),
+        );
+
+        await transaction.applyChange(buildMockPullRequestChange({ attempt, state: 'merged' }));
+      });
+
+      const snapshot = await store.read((transaction) =>
+        transaction.readSnapshot(brandSchemas.instant.parse(5000), new Map()),
+      );
+
+      return { received: snapshot.items, expected: [] };
+    },
+  ],
+  [
+    '#readItem returns null for an unknown item',
+    async (store) => {
+      const read = await store.read((transaction) =>
+        transaction.readItem(buildMockItemRow().id, brandSchemas.instant.parse(5000), new Map()),
+      );
+
+      return { received: read, expected: null };
+    },
+  ],
+  [
+    '#readItem derives blocked for the target of a live link from a ready item',
+    async (store) => {
+      const source = buildMockItemRow();
+      const target = buildMockItemRow();
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(buildMockFileItemChange(source));
+        await transaction.applyChange(buildMockFileItemChange(target));
+
+        await transaction.applyChange(
+          buildMockLinkChange({ source: source.id, target: target.id }),
+        );
+      });
+
+      const read = await store.read((transaction) =>
+        transaction.readItem(target.id, brandSchemas.instant.parse(5000), new Map()),
+      );
+
+      return { received: read?.derived, expected: { state: 'blocked' } };
+    },
+  ],
+  [
+    '#readItem derives ready for the target of a link from an archived item',
+    async (store) => {
+      const source = buildMockItemRow({ closedAt: brandSchemas.instant.parse(1500) });
+      const target = buildMockItemRow();
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(buildMockFileItemChange(source));
+        await transaction.applyChange(buildMockFileItemChange(target));
+
+        await transaction.applyChange(
+          buildMockLinkChange({ source: source.id, target: target.id }),
+        );
+      });
+
+      const read = await store.read((transaction) =>
+        transaction.readItem(target.id, brandSchemas.instant.parse(5000), new Map()),
+      );
+
+      return { received: read?.derived, expected: { state: 'ready' } };
+    },
+  ],
+  [
+    '#readItem derives attempts used up from the max attempts of the kind',
+    async (store) => {
+      const item = buildMockItemRow();
+      const attempt = buildMockAttemptRow({ item: item.id, state: 'starting' });
+
+      const phases = new Map([[attempt.phase, 1]]);
+
+      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 read = await store.read((transaction) =>
+        transaction.readItem(
+          item.id,
+          brandSchemas.instant.parse(5000),
+          new Map([[item.kind, phases]]),
+        ),
+      );
+
+      return {
+        received: read?.derived,
+        expected: { state: 'waiting', reason: 'attempts used up' },
+      };
+    },
+  ],
+  [
+    '#listItems keeps the items of one state and repo, oldest first',
+    async (store) => {
+      const repo = brandSchemas.repoName.parse('acme/lamps');
+      const older = buildMockItemRow({ repo, filedAt: brandSchemas.instant.parse(1000) });
+      const newer = buildMockItemRow({ repo, filedAt: brandSchemas.instant.parse(2000) });
+      const idea = buildMockItemRow({ repo, acceptance: [] });
+      const elsewhere = buildMockItemRow({ repo: brandSchemas.repoName.parse('acme/fans') });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(buildMockFileItemChange(newer));
+        await transaction.applyChange(buildMockFileItemChange(older));
+        await transaction.applyChange(buildMockFileItemChange(idea));
+        await transaction.applyChange(buildMockFileItemChange(elsewhere));
+      });
+
+      const listed = await store.read((transaction) =>
+        transaction.listItems(
+          { state: 'ready', repo },
+          brandSchemas.instant.parse(5000),
+          new Map(),
+        ),
+      );
+
+      return { received: listed.map((item) => item.id), expected: [older.id, newer.id] };
+    },
+  ],
+  [
+    '#listOpenIssues returns the open core.issue items of one repo',
+    async (store) => {
+      const repo = brandSchemas.repoName.parse('acme/lamps');
+      const open = buildMockItemRow({ repo });
+      const closed = buildMockItemRow({ repo, closedAt: brandSchemas.instant.parse(1500) });
+      const elsewhere = buildMockItemRow({ repo: brandSchemas.repoName.parse('acme/fans') });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(buildMockFileItemChange(open));
+        await transaction.applyChange(buildMockFileItemChange(closed));
+        await transaction.applyChange(buildMockFileItemChange(elsewhere));
+      });
+
+      const listed: unknown = await store.read((transaction) =>
+        transaction.listOpenIssues(repo, brandSchemas.instant.parse(5000), new Map()),
+      );
+
+      return { received: listed, expected: [{ ...open, derived: { state: 'ready' } }] };
+    },
+  ],
+  [
+    '#readItemDetail returns the item with its attempts, links, evidence and PRs',
+    async (store) => {
+      const item = buildMockItemRow();
+      const blocker = 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(buildMockFileItemChange(blocker));
+        await transaction.applyChange(buildMockClaimChange(attempt));
+
+        await transaction.applyChange(
+          buildMockSettleChange({
+            attempt: { ...attempt, slot: 1, slotGen: 1 },
+            state: 'succeeded',
+          }),
+        );
+
+        await transaction.applyChange(buildMockPullRequestChange({ attempt, state: 'open' }));
+        await transaction.applyChange(buildMockLinkChange({ source: blocker.id, target: item.id }));
+      });
+
+      const detail: unknown = await store.read((transaction) =>
+        transaction.readItemDetail(item.id, brandSchemas.instant.parse(5000), new Map()),
+      );
+
+      return {
+        received: detail,
+        expected: {
+          item: { ...item, derived: { state: 'waiting', reason: 'PR open' }, levers: [] },
+          attempts: [expect.objectContaining({ id: attempt.id, state: 'succeeded' })],
+          links: [expect.objectContaining({ source: blocker.id, target: item.id })],
+          evidence: [expect.objectContaining({ attempt: attempt.id, kind: 'pr' })],
+          pullRequests: [expect.objectContaining({ attempt: attempt.id, state: 'open' })],
+        },
+      };
+    },
+  ],
+  [
+    '#readItemDetail returns null for an unknown item',
+    async (store) => {
+      const detail = await store.read((transaction) =>
+        transaction.readItemDetail(
+          buildMockItemRow().id,
+          brandSchemas.instant.parse(5000),
+          new Map(),
+        ),
+      );
+
+      return { received: detail, expected: null };
+    },
+  ],
+];

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

@@ -0,0 +1,178 @@
+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 { buildMockSettleChange } from './build-mock-settle-change.ts';
+import type { ClaimStoreCase } from './types.ts';
+
+export const claimStorePoolCases: readonly ClaimStoreCase[] = [
+  [
+    '#syncPoolSlots adds a row for each slot of each pool',
+    async (store) => {
+      await store.exclusive((transaction) =>
+        transaction.syncPoolSlots([
+          { name: brandSchemas.poolName.parse('build'), slots: 2 },
+          { name: brandSchemas.poolName.parse('review'), slots: 1 },
+        ]),
+      );
+
+      const slots: unknown = await store.read((transaction) => transaction.listPoolSlots());
+
+      return {
+        received: slots,
+        expected: [
+          { pool: 'build', slot: 1, holder: null, gen: 0, retired: false },
+          { pool: 'build', slot: 2, holder: null, gen: 0, retired: false },
+          { pool: 'review', slot: 1, holder: null, gen: 0, retired: false },
+        ],
+      };
+    },
+  ],
+  [
+    '#syncPoolSlots retires the rows above a smaller count and deletes none',
+    async (store) => {
+      const pool = brandSchemas.poolName.parse('build');
+
+      await store.exclusive(async (transaction) => {
+        await transaction.syncPoolSlots([{ name: pool, slots: 3 }]);
+        await transaction.syncPoolSlots([{ name: pool, slots: 1 }]);
+      });
+
+      const slots = await store.read((transaction) => transaction.listPoolSlots());
+
+      const retired: unknown = slots.map((slot) => [slot.slot, slot.retired]);
+
+      return {
+        received: retired,
+        expected: [
+          [1, false],
+          [2, true],
+          [3, true],
+        ],
+      };
+    },
+  ],
+  [
+    '#syncPoolSlots retires every row of a pool the rules no longer name',
+    async (store) => {
+      const build = brandSchemas.poolName.parse('build');
+      const review = brandSchemas.poolName.parse('review');
+
+      await store.exclusive(async (transaction) => {
+        await transaction.syncPoolSlots([
+          { name: build, slots: 1 },
+          { name: review, slots: 2 },
+        ]);
+
+        await transaction.syncPoolSlots([{ name: build, slots: 1 }]);
+      });
+
+      const slots = await store.read((transaction) => transaction.listPoolSlots());
+
+      const retired: unknown = slots.map((slot) => [slot.pool, slot.slot, slot.retired]);
+
+      return {
+        received: retired,
+        expected: [
+          ['build', 1, false],
+          ['review', 1, true],
+          ['review', 2, true],
+        ],
+      };
+    },
+  ],
+  [
+    '#syncPoolSlots leaves the holder on a slot it retires',
+    async (store) => {
+      const first = buildMockItemRow();
+      const second = buildMockItemRow();
+      const lower = buildMockAttemptRow({ item: first.id, state: 'starting' });
+      const upper = buildMockAttemptRow({ item: second.id, state: 'starting' });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.syncPoolSlots([{ name: lower.pool, slots: 2 }]);
+        await transaction.applyChange(buildMockFileItemChange(first));
+        await transaction.applyChange(buildMockFileItemChange(second));
+        await transaction.applyChange(buildMockClaimChange(lower));
+        await transaction.applyChange(buildMockClaimChange(upper));
+        await transaction.syncPoolSlots([{ name: lower.pool, slots: 1 }]);
+      });
+
+      const slots = await store.read((transaction) => transaction.listPoolSlots());
+
+      return {
+        received: slots[1],
+        expected: {
+          pool: upper.pool,
+          slot: 2,
+          holder: upper.id,
+          gen: 1,
+          retired: true,
+        },
+      };
+    },
+  ],
+  [
+    '#applyChange never takes a retired slot',
+    async (store) => {
+      const first = buildMockItemRow();
+      const second = buildMockItemRow();
+      const held = buildMockAttemptRow({ item: first.id, state: 'starting' });
+      const refused = buildMockAttemptRow({ item: second.id, state: 'starting' });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.syncPoolSlots([{ name: held.pool, slots: 2 }]);
+        await transaction.syncPoolSlots([{ name: held.pool, slots: 1 }]);
+        await transaction.applyChange(buildMockFileItemChange(first));
+        await transaction.applyChange(buildMockFileItemChange(second));
+        await transaction.applyChange(buildMockClaimChange(held));
+      });
+
+      const result = await store.exclusive((transaction) =>
+        transaction.applyChange(buildMockClaimChange(refused)),
+      );
+
+      return { received: result, expected: { kind: 'no-free-slot' } };
+    },
+  ],
+  [
+    '#syncPoolSlots reuses a retired row with its gen when the pool grows again',
+    async (store) => {
+      const first = buildMockItemRow();
+      const second = buildMockItemRow();
+      const third = buildMockItemRow();
+      const lower = buildMockAttemptRow({ item: first.id, state: 'starting' });
+      const upper = buildMockAttemptRow({ item: second.id, state: 'starting' });
+      const later = buildMockAttemptRow({ item: third.id, state: 'starting' });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.syncPoolSlots([{ name: lower.pool, slots: 2 }]);
+        await transaction.applyChange(buildMockFileItemChange(first));
+        await transaction.applyChange(buildMockFileItemChange(second));
+        await transaction.applyChange(buildMockFileItemChange(third));
+        await transaction.applyChange(buildMockClaimChange(lower));
+        await transaction.applyChange(buildMockClaimChange(upper));
+
+        await transaction.applyChange(
+          buildMockSettleChange({ attempt: { ...upper, slot: 2, slotGen: 1 }, state: 'failed' }),
+        );
+
+        await transaction.syncPoolSlots([{ name: lower.pool, slots: 1 }]);
+        await transaction.syncPoolSlots([{ name: lower.pool, slots: 2 }]);
+      });
+
+      const result = await store.exclusive((transaction) =>
+        transaction.applyChange(buildMockClaimChange(later)),
+      );
+
+      return {
+        received: result,
+        expected: {
+          kind: 'applied',
+          slot: { pool: later.pool, slot: 2, gen: 2 },
+        },
+      };
+    },
+  ],
+];

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 { 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 { 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 refuses a settle whose slot release names another holder whole',
+    async (store) => {
+      const item = buildMockItemRow();
+      const attempt = buildMockAttemptRow({ item: item.id, state: 'starting' });
+      const other = buildMockAttemptRow();
+
+      await store.exclusive(async (transaction) => {
+        await transaction.syncPoolSlots([{ name: attempt.pool, slots: 1 }]);
+        await transaction.applyChange(buildMockFileItemChange(item));
+        await transaction.applyChange(buildMockClaimChange(attempt));
+      });
+
+      const settle = buildMockSettleChange({
+        attempt: { ...attempt, slot: 1, slotGen: 1 },
+        state: 'succeeded',
+      });
+
+      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 state: unknown = await store.read(async (transaction) => {
+        const read = await transaction.readAttempt(attempt.id);
+        const facts = await transaction.readUnsentFacts(10);
+
+        const view = await transaction.readItem(
+          item.id,
+          brandSchemas.instant.parse(5000),
+          new Map(),
+        );
+
+        return { attempt: read?.state, facts: facts.length, item: view?.derived };
+      });
+
+      return {
+        received: { result, state },
+        expected: {
+          result: { kind: 'stale-generation' },
+          state: { attempt: 'starting', facts: 2, item: { state: 'running' } },
+        },
+      };
+    },
+  ],
+  [
+    '#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 fileChange = buildMockFileItemChange(filed);
+      const claim = buildMockClaimChange(attempt);
+      const reusedFactId: StoreChange = { ...claim, facts: [...claim.facts, ...fileChange.facts] };
+
+      await store.exclusive(async (transaction) => {
+        await transaction.syncPoolSlots([{ name: attempt.pool, slots: 1 }]);
+        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),
+        slots: await transaction.listPoolSlots(),
+      }));
+
+      return {
+        received: state,
+        expected: {
+          attempt: null,
+          slots: [{ pool: attempt.pool, slot: 1, holder: null, gen: 0, retired: false }],
+        },
+      };
+    },
+  ],
+  [
+    '#applyChange keeps a heartbeat started beside a change it refuses',
+    async (store) => {
+      const filed = buildMockItemRow();
+      const missing = buildMockItemRow();
+      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' },
+              },
+            ],
+          }),
+          transaction
+            .listPoolSlots()
+            .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 = buildMockItemRow();
+      const later = buildMockItemRow();
+      const first = buildMockAttemptRow({ item: claimed.id, state: 'starting', leaseGen: 1 });
+
+      const second = buildMockAttemptRow({
+        item: claimed.id,
+        state: 'starting',
+        leaseGen: 2,
+        number: 2,
+      });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.syncPoolSlots([{ name: first.pool, slots: 2 }]);
+        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), new Map()),
+      );
+
+      return {
+        received: { results, item: read?.id },
+        expected: {
+          results: [{ kind: 'lease-held' }, { kind: 'applied', slot: null }],
+          item: later.id,
+        },
+      };
+    },
+  ],
+];