@boxxy/dispatch 0.1.0 → 0.1.3

package/src/test-utils/build-mock-file-item-change.ts

@@ -0,0 +1,20 @@
+import type { ItemRow, StoreChange } from '@boxxy/model';
+import { buildMockFactId } from '@boxxy/model/test-utils/build-mock-fact-id';
+
+export function buildMockFileItemChange(item: ItemRow): StoreChange {
+  const { keptSession: _keptSession, ...filed } = item;
+
+  return {
+    at: item.filedAt,
+    writes: [{ op: 'insert', table: 'items', row: item }],
+    facts: [
+      {
+        id: buildMockFactId(),
+        type: 'boxxy.item.filed',
+        entity: `boxxy:item:${item.id}`,
+        actor: 'boxxy:owner:local',
+        payload: filed,
+      },
+    ],
+  };
+}

package/src/test-utils/build-mock-lever-change.ts

@@ -0,0 +1,18 @@
+import type { LeverRow, StoreChange } from '@boxxy/model';
+import { buildMockFactId } from '@boxxy/model/test-utils/build-mock-fact-id';
+
+export function buildMockLeverChange(lever: LeverRow): StoreChange {
+  return {
+    at: lever.at,
+    writes: [{ op: 'insert', table: 'levers', row: lever }],
+    facts: [
+      {
+        id: buildMockFactId(),
+        type: 'boxxy.lever.recorded',
+        entity: `boxxy:item:${lever.item}`,
+        actor: lever.actor,
+        payload: lever,
+      },
+    ],
+  };
+}

package/src/test-utils/build-mock-new-id.ts

@@ -0,0 +1,12 @@
+import type { NewId } from '@boxxy/model';
+
+// A new-ID source that gives version 7 UUIDs in order: 1, 2, 3, … in the last group.
+export function buildMockNewId(): NewId {
+  let count = 0;
+
+  return () => {
+    count += 1;
+
+    return `0190a6f4-0000-7000-8000-${String(count).padStart(12, '0')}`;
+  };
+}

package/src/test-utils/build-mock-note-change.ts

@@ -0,0 +1,18 @@
+import type { NoteRow, StoreChange } from '@boxxy/model';
+import { buildMockFactId } from '@boxxy/model/test-utils/build-mock-fact-id';
+
+export function buildMockNoteChange(note: NoteRow): StoreChange {
+  return {
+    at: note.at,
+    writes: [{ op: 'insert', table: 'notes', row: note }],
+    facts: [
+      {
+        id: buildMockFactId(),
+        type: 'boxxy.item.noted',
+        entity: `boxxy:item:${note.item}`,
+        actor: note.by,
+        payload: { seq: note.seq, text: note.text },
+      },
+    ],
+  };
+}

package/src/test-utils/build-mock-pause-change.ts

@@ -0,0 +1,19 @@
+import { brandSchemas } from '@boxxy/model';
+import type { RunnerId, StoreChange } from '@boxxy/model';
+
+// The fact catalog has no runner fact, so the pause writes the row and no fact.
+export function buildMockPauseChange(runner: RunnerId): StoreChange {
+  return {
+    at: brandSchemas.instant.parse(1500),
+    writes: [
+      {
+        op: 'update',
+        table: 'runners',
+        key: { id: runner },
+        expect: { paused: false },
+        set: { paused: true },
+      },
+    ],
+    facts: [],
+  };
+}

package/src/test-utils/build-mock-pull-request-change.ts

@@ -0,0 +1,63 @@
+import { brandSchemas } from '@boxxy/model';
+import type { AttemptRow, PullRequestRow, StoreChange } from '@boxxy/model';
+import { buildMockFactId } from '@boxxy/model/test-utils/build-mock-fact-id';
+import { buildMockV1PullRequestRow } from '@boxxy/model/test-utils/build-mock-v1-pull-request-row';
+
+interface PullRequestInput {
+  readonly attempt: AttemptRow;
+  readonly state: PullRequestRow['state'];
+  readonly number?: number;
+}
+
+// The hook links a pull request of `acme/lamps` to the attempt, with its evidence row.
+export function buildMockPullRequestChange(input: PullRequestInput): StoreChange {
+  const attempt = input.attempt;
+  const linkedAt = brandSchemas.instant.parse(4000);
+  const factId = buildMockFactId();
+  const number = input.number ?? 7;
+
+  const pullRequest = buildMockV1PullRequestRow({
+    repo: brandSchemas.repoName.parse('acme/lamps'),
+    number,
+    attempt: attempt.id,
+    githubId: 2_000_000 + number,
+    state: input.state,
+    checkedAt: linkedAt,
+  });
+
+  return {
+    at: linkedAt,
+    writes: [
+      { op: 'insert', table: 'pull_requests', row: pullRequest },
+      {
+        op: 'insert',
+        table: 'evidence',
+        row: {
+          factId,
+          attempt: attempt.id,
+          kind: 'pull_request',
+          ref: pullRequest.url,
+          observed: null,
+          source: 'hook',
+          at: linkedAt,
+        },
+      },
+    ],
+    facts: [
+      {
+        id: factId,
+        type: 'boxxy.pull_request.linked',
+        entity: `boxxy:item:${attempt.item}`,
+        actor: `boxxy:hook:${attempt.id}`,
+        payload: {
+          attempt: attempt.id,
+          repo: pullRequest.repo,
+          number,
+          url: pullRequest.url,
+          pullRequestId: String(pullRequest.githubId),
+          source: 'hook',
+        },
+      },
+    ],
+  };
+}

package/src/test-utils/build-mock-relation-change.ts

@@ -0,0 +1,40 @@
+import { brandSchemas } from '@boxxy/model';
+import type { ItemId, StoreChange } from '@boxxy/model';
+import { buildMockFactId } from '@boxxy/model/test-utils/build-mock-fact-id';
+
+interface RelationInput {
+  readonly source: ItemId;
+  readonly target: ItemId;
+}
+
+export function buildMockRelationChange(input: RelationInput): StoreChange {
+  const type = brandSchemas.relationTypeName.parse('blocks');
+  const addedAt = brandSchemas.instant.parse(3500);
+
+  return {
+    at: addedAt,
+    writes: [
+      {
+        op: 'insert',
+        table: 'relations',
+        row: {
+          source: input.source,
+          target: input.target,
+          type,
+          addedBy: 'boxxy:owner:local',
+          addedAt,
+          removedAt: null,
+        },
+      },
+    ],
+    facts: [
+      {
+        id: buildMockFactId(),
+        type: 'boxxy.relation.added',
+        entity: `boxxy:item:${input.source}`,
+        actor: 'boxxy:owner:local',
+        payload: { source: input.source, target: input.target, type },
+      },
+    ],
+  };
+}

package/src/test-utils/build-mock-running-reading.ts

@@ -0,0 +1,19 @@
+import type { SessionReading } from '@boxxy/model';
+import { brandSchemas } from '@boxxy/model';
+
+type RunningReading = Extract<SessionReading, { kind: 'running' }>;
+
+// A working session with an agent session ID, no caller and no usage limit, active at time 0.
+export function buildMockRunningReading(overrides: Partial<RunningReading> = {}): RunningReading {
+  return {
+    kind: 'running',
+    atcSession: brandSchemas.atcSessionId.parse('atc-1'),
+    agentSession: brandSchemas.agentSessionId.parse('agent-1'),
+    caller: null,
+    attention: 'working',
+    lastActivityAt: brandSchemas.instant.parse(0),
+    lastOwnerAt: brandSchemas.instant.parse(0),
+    usageLimitResetsAt: null,
+    ...overrides,
+  };
+}

package/src/test-utils/build-mock-settle-change.ts

@@ -0,0 +1,70 @@
+import { brandSchemas } from '@boxxy/model';
+import type { AttemptRow, StoreChange } from '@boxxy/model';
+import { buildMockFactId } from '@boxxy/model/test-utils/build-mock-fact-id';
+
+interface SettleInput {
+  readonly attempt: AttemptRow;
+  readonly state: 'succeeded' | 'failed';
+}
+
+// A settle under the live lease and hold generations: it releases the lease and the seats. A
+// succeeded attempt ends `built`; a failed one ends `lost` with `closeout-missing`.
+export function buildMockSettleChange(input: SettleInput): StoreChange {
+  const attempt = input.attempt;
+  const endedAt = brandSchemas.instant.parse(3000);
+  const isSucceeded = input.state === 'succeeded';
+  const failure = isSucceeded ? null : 'closeout-missing';
+  const outcome = isSucceeded ? brandSchemas.outcomeName.parse('built') : 'lost';
+
+  return {
+    at: endedAt,
+    under: {
+      item: attempt.item,
+      phase: attempt.phase,
+      gen: attempt.leaseGen,
+      holdGen: attempt.holdGen,
+    },
+    writes: [
+      {
+        op: 'update',
+        table: 'attempts',
+        key: { id: attempt.id },
+        expect: { state: attempt.state },
+        set: { state: input.state, failure, outcome, endedAt },
+      },
+      {
+        op: 'update',
+        table: 'leases',
+        key: { item: attempt.item, phase: attempt.phase, gen: attempt.leaseGen },
+        expect: { releasedAt: null },
+        set: { releasedAt: endedAt },
+      },
+      { op: 'release-seats', release: { attempt: attempt.id, holdGen: attempt.holdGen } },
+    ],
+    facts: [
+      {
+        id: buildMockFactId(),
+        type: 'boxxy.attempt.settled',
+        entity: `boxxy:item:${attempt.item}`,
+        actor: `boxxy:runner:${attempt.runner}`,
+        payload: {
+          attempt: attempt.id,
+          phase: attempt.phase,
+          round: attempt.round,
+          state: input.state,
+          failure,
+          outcome,
+          returnedOutcome: null,
+          closing: null,
+          asleep: false,
+          sessionStopped: true,
+          endedAt,
+          criteria: [],
+          matched: [],
+          frictionDropped: 0,
+          skippedEffects: [],
+        },
+      },
+    ],
+  };
+}

package/src/test-utils/build-mock-start-change.ts

@@ -0,0 +1,38 @@
+import { brandSchemas } from '@boxxy/model';
+import type { AttemptRow, CallerIdentity, StoreChange } from '@boxxy/model';
+import { buildMockFactId } from '@boxxy/model/test-utils/build-mock-fact-id';
+import invariant from 'tiny-invariant';
+
+// The start of a `starting` attempt on its own atc session, with the caller the worker reported.
+export function buildMockStartChange(
+  attempt: AttemptRow,
+  caller: CallerIdentity | null = null,
+): StoreChange {
+  const atcSession = attempt.atcSession;
+  const startedAt = brandSchemas.instant.parse(2500);
+
+  invariant(atcSession !== null, 'a started attempt names its atc session');
+
+  return {
+    at: startedAt,
+    under: { item: attempt.item, phase: attempt.phase, gen: attempt.leaseGen },
+    writes: [
+      {
+        op: 'update',
+        table: 'attempts',
+        key: { id: attempt.id },
+        expect: { state: 'starting' },
+        set: { state: 'running', atcSession, caller, startedAt },
+      },
+    ],
+    facts: [
+      {
+        id: buildMockFactId(),
+        type: 'boxxy.attempt.started',
+        entity: `boxxy:item:${attempt.item}`,
+        actor: `boxxy:runner:${attempt.runner}`,
+        payload: { attempt: attempt.id, atcSession, resumeFallback: false, caller },
+      },
+    ],
+  };
+}

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

@@ -0,0 +1,357 @@
+import { expect } from 'bun:test';
+import { brandSchemas } 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 { 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(
+          buildMockV1ItemRow().id,
+          brandSchemas.phaseName.parse('build'),
+        ),
+      );
+
+      return { received: generation, expected: 0 };
+    },
+  ],
+  [
+    '#readLastLeaseGen returns the highest gen after a released lease',
+    async (store) => {
+      const item = buildMockV1ItemRow();
+      const attempt = buildMockV1AttemptRow({ item: item.id, state: 'starting', leaseGen: 3 });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(buildMockFileItemChange(item));
+        await transaction.applyChange(buildMockClaimChange(attempt));
+        await transaction.applyChange(buildMockSettleChange({ attempt, state: 'failed' }));
+      });
+
+      const generation = await store.read((transaction) =>
+        transaction.readLastLeaseGen(item.id, attempt.phase),
+      );
+
+      return { received: generation, expected: 3 };
+    },
+  ],
+  [
+    '#listLiveAttempts returns every attempt that has not settled, a sleeping one too',
+    async (store) => {
+      const live = buildMockV1AttemptRow({
+        state: 'starting',
+        claimedAt: brandSchemas.instant.parse(1000),
+      });
+
+      const sleeping = buildMockV1AttemptRow({
+        state: 'sleeping',
+        claimedAt: brandSchemas.instant.parse(1100),
+      });
+
+      const settled = buildMockV1AttemptRow({ state: 'starting' });
+
+      await store.exclusive(async (transaction) => {
+        for (const attempt of [live, sleeping, settled]) {
+          await transaction.applyChange(
+            buildMockFileItemChange(buildMockV1ItemRow({ id: attempt.item })),
+          );
+
+          await transaction.applyChange(buildMockClaimChange(attempt));
+        }
+
+        await transaction.applyChange(buildMockSettleChange({ attempt: settled, state: 'failed' }));
+      });
+
+      const listed = await store.read((transaction) => transaction.listLiveAttempts());
+
+      return { received: listed.map((attempt) => attempt.id), expected: [live.id, sleeping.id] };
+    },
+  ],
+  [
+    '#listItemAttempts returns the attempts of one item, oldest first',
+    async (store) => {
+      const item = buildMockV1ItemRow();
+
+      const second = buildMockV1AttemptRow({
+        item: item.id,
+        state: 'starting',
+        number: 2,
+        leaseGen: 2,
+        claimedAt: brandSchemas.instant.parse(4000),
+      });
+
+      const first = buildMockV1AttemptRow({
+        item: item.id,
+        state: 'starting',
+        claimedAt: brandSchemas.instant.parse(1000),
+      });
+
+      const other = buildMockV1AttemptRow({ state: 'starting' });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(buildMockFileItemChange(item));
+
+        await transaction.applyChange(
+          buildMockFileItemChange(buildMockV1ItemRow({ id: other.item })),
+        );
+
+        await transaction.applyChange(buildMockClaimChange(first));
+        await transaction.applyChange(buildMockSettleChange({ attempt: first, state: 'failed' }));
+        await transaction.applyChange(buildMockClaimChange(second));
+        await transaction.applyChange(buildMockClaimChange(other));
+      });
+
+      const listed = await store.read((transaction) => transaction.listItemAttempts(item.id));
+
+      return { received: listed.map((attempt) => attempt.id), expected: [first.id, second.id] };
+    },
+  ],
+  [
+    '#listSucceededAttemptsWithoutPullRequest skips an attempt with a linked pull request',
+    async (store) => {
+      const first = buildMockV1ItemRow();
+      const second = buildMockV1ItemRow();
+      const linked = buildMockV1AttemptRow({ item: first.id, state: 'starting' });
+      const unlinked = buildMockV1AttemptRow({ item: second.id, state: 'starting' });
+
+      await store.exclusive(async (transaction) => {
+        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, state: 'succeeded' }),
+        );
+
+        await transaction.applyChange(
+          buildMockSettleChange({ attempt: unlinked, state: 'succeeded' }),
+        );
+
+        await transaction.applyChange(
+          buildMockPullRequestChange({ attempt: linked, state: 'open' }),
+        );
+      });
+
+      const listed = await store.read((transaction) =>
+        transaction.listSucceededAttemptsWithoutPullRequest(),
+      );
+
+      return { received: listed.map((attempt) => attempt.id), expected: [unlinked.id] };
+    },
+  ],
+  [
+    '#findAttemptBySession returns the attempt with an atc session id',
+    async (store) => {
+      const item = buildMockV1ItemRow();
+
+      const attempt = buildMockV1AttemptRow({
+        item: item.id,
+        state: 'starting',
+        atcSession: brandSchemas.atcSessionId.parse('atc-session-1'),
+      });
+
+      await store.exclusive(async (transaction) => {
+        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 };
+    },
+  ],
+  [
+    '#findAttemptBySession returns the latest of two attempts on one kept session',
+    async (store) => {
+      const item = buildMockV1ItemRow();
+      const atcSession = brandSchemas.atcSessionId.parse('atc-session-1');
+
+      const earlier = buildMockV1AttemptRow({
+        item: item.id,
+        state: 'starting',
+        atcSession,
+        claimedAt: brandSchemas.instant.parse(1000),
+      });
+
+      const later = buildMockV1AttemptRow({
+        item: item.id,
+        state: 'starting',
+        number: 2,
+        leaseGen: 2,
+        atcSession,
+        claimedAt: brandSchemas.instant.parse(4000),
+      });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(buildMockFileItemChange(item));
+        await transaction.applyChange(buildMockClaimChange(earlier));
+        await transaction.applyChange(buildMockSettleChange({ attempt: earlier, state: 'failed' }));
+        await transaction.applyChange(buildMockClaimChange(later));
+      });
+
+      const found = await store.read((transaction) => transaction.findAttemptBySession(atcSession));
+
+      return { received: found?.id, expected: later.id };
+    },
+  ],
+  [
+    '#markPullRequestChecked sets the checked time of a watched pull request',
+    async (store) => {
+      const item = buildMockV1ItemRow();
+      const attempt = buildMockV1AttemptRow({ item: item.id, state: 'starting' });
+
+      await store.exclusive(async (transaction) => {
+        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) };
+    },
+  ],
+  [
+    '#readPullRequestRow returns a merged pull request, and null for one never linked',
+    async (store) => {
+      const item = buildMockV1ItemRow();
+      const attempt = buildMockV1AttemptRow({ item: item.id, state: 'starting' });
+      const repo = brandSchemas.repoName.parse('acme/lamps');
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(buildMockFileItemChange(item));
+        await transaction.applyChange(buildMockClaimChange(attempt));
+        await transaction.applyChange(buildMockPullRequestChange({ attempt, state: 'merged' }));
+      });
+
+      const found = await store.read((transaction) =>
+        transaction.readPullRequestRow({ repo, number: 7 }),
+      );
+
+      const missing = await store.read((transaction) =>
+        transaction.readPullRequestRow({ repo, number: 8 }),
+      );
+
+      return { received: [found?.state, missing], expected: ['merged', null] };
+    },
+  ],
+  [
+    '#listWatchedPullRequests returns an open pull request with its GitHub id and url',
+    async (store) => {
+      const item = buildMockV1ItemRow();
+      const attempt = buildMockV1AttemptRow({ item: item.id, state: 'starting' });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(buildMockFileItemChange(item));
+        await transaction.applyChange(buildMockClaimChange(attempt));
+        await transaction.applyChange(buildMockPullRequestChange({ attempt, state: 'merged' }));
+
+        await transaction.applyChange(
+          buildMockPullRequestChange({ attempt, state: 'open', number: 8 }),
+        );
+      });
+
+      const watched = await store.read((transaction) => transaction.listWatchedPullRequests());
+
+      return {
+        received: watched.map((pullRequest) => [
+          pullRequest.number,
+          pullRequest.githubId,
+          pullRequest.url,
+        ]),
+        expected: [[8, 2_000_008, 'https://github.com/acme/lamps/pull/8']],
+      };
+    },
+  ],
+  [
+    '#listEvidence returns the evidence of one attempt',
+    async (store) => {
+      const item = buildMockV1ItemRow();
+      const attempt = buildMockV1AttemptRow({ item: item.id, state: 'starting' });
+
+      await store.exclusive(async (transaction) => {
+        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(/^[0-9a-f]{8}-[0-9a-f]{4}-7/u),
+            attempt: attempt.id,
+            kind: 'pull_request',
+            ref: 'https://github.com/acme/lamps/pull/7',
+            observed: null,
+            source: 'hook',
+            at: 4000,
+          },
+        ],
+      };
+    },
+  ],
+  [
+    '#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 };
+    },
+  ],
+];