@boxxy/dispatch 0.1.1 → 0.1.3

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

@@ -0,0 +1,270 @@
+import { brandSchemas } from '@boxxy/model';
+import type { 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 { 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 claimStoreSeatCases: readonly ClaimStoreCase[] = [
+  [
+    '#syncLimits stores the loaded limits by name, each with no seat held',
+    async (store) => {
+      await store.exclusive((transaction) =>
+        transaction.syncLimits(
+          [
+            { name: brandSchemas.limitName.parse('workers'), max: 7, counts: {} },
+            {
+              name: brandSchemas.limitName.parse('owner-design'),
+              max: 1,
+              counts: { designMode: ['attended'] },
+            },
+          ],
+          brandSchemas.instant.parse(500),
+        ),
+      );
+
+      const limits: unknown = await store.read((transaction) => transaction.listLimits());
+
+      return {
+        received: limits,
+        expected: [
+          { name: 'owner-design', max: 1, counts: { designMode: ['attended'] }, held: 0 },
+          { name: 'workers', max: 7, counts: {}, held: 0 },
+        ],
+      };
+    },
+  ],
+  [
+    '#syncLimits releases the seats of a limit the rules no longer name',
+    async (store) => {
+      const workers = brandSchemas.limitName.parse('workers');
+      const reviews = brandSchemas.limitName.parse('reviews');
+      const attempt = buildMockV1AttemptRow({ state: 'starting' });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.syncLimits(
+          [
+            { name: workers, max: 2, counts: {} },
+            { name: reviews, max: 2, counts: {} },
+          ],
+          brandSchemas.instant.parse(500),
+        );
+
+        await transaction.applyChange(
+          buildMockFileItemChange(buildMockV1ItemRow({ id: attempt.item })),
+        );
+
+        await transaction.applyChange(buildMockClaimChange(attempt, [workers, reviews]));
+      });
+
+      await store.exclusive((transaction) =>
+        transaction.syncLimits(
+          [{ name: workers, max: 2, counts: {} }],
+          brandSchemas.instant.parse(6000),
+        ),
+      );
+
+      const state: unknown = await store.read(async (transaction) => {
+        const limits = await transaction.listLimits();
+        const seats = await transaction.listLimitSeats();
+
+        return {
+          limits: limits.map((limit) => [limit.name, limit.held]),
+          seats: seats.map((seat) => seat.limit),
+        };
+      });
+
+      return {
+        received: state,
+        expected: { limits: [['workers', 1]], seats: ['workers'] },
+      };
+    },
+  ],
+  [
+    '#syncLimits releases a seat whose limit no longer counts the attempt fields',
+    async (store) => {
+      const ownerDesign = brandSchemas.limitName.parse('owner-design');
+
+      const attempt = buildMockV1AttemptRow({
+        state: 'starting',
+        fields: { designMode: ['attended'] },
+      });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.syncLimits(
+          [{ name: ownerDesign, max: 1, counts: { designMode: ['attended'] } }],
+          brandSchemas.instant.parse(500),
+        );
+
+        await transaction.applyChange(
+          buildMockFileItemChange(buildMockV1ItemRow({ id: attempt.item })),
+        );
+
+        await transaction.applyChange(buildMockClaimChange(attempt, [ownerDesign]));
+      });
+
+      await store.exclusive((transaction) =>
+        transaction.syncLimits(
+          [{ name: ownerDesign, max: 1, counts: { designMode: ['agent'] } }],
+          brandSchemas.instant.parse(6000),
+        ),
+      );
+
+      const seats = await store.read((transaction) => transaction.listLimitSeats());
+
+      return { received: seats, expected: [] };
+    },
+  ],
+  [
+    '#syncLimits gives a seated attempt a seat past max in a new limit that counts it',
+    async (store) => {
+      const workers = brandSchemas.limitName.parse('workers');
+      const builds = brandSchemas.limitName.parse('builds');
+      const first = buildMockV1AttemptRow({ state: 'starting' });
+      const second = buildMockV1AttemptRow({ state: 'starting' });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.syncLimits(
+          [{ name: workers, max: 2, counts: {} }],
+          brandSchemas.instant.parse(500),
+        );
+
+        await transaction.applyChange(
+          buildMockFileItemChange(buildMockV1ItemRow({ id: first.item })),
+        );
+
+        await transaction.applyChange(
+          buildMockFileItemChange(buildMockV1ItemRow({ id: second.item })),
+        );
+
+        await transaction.applyChange(buildMockClaimChange(first, [workers]));
+        await transaction.applyChange(buildMockClaimChange(second, [workers]));
+      });
+
+      await store.exclusive((transaction) =>
+        transaction.syncLimits(
+          [
+            { name: workers, max: 2, counts: {} },
+            { name: builds, max: 1, counts: {} },
+          ],
+          brandSchemas.instant.parse(6000),
+        ),
+      );
+
+      const state: unknown = await store.read(async (transaction) => {
+        const limits = await transaction.listLimits();
+        const seats = await transaction.listLimitSeats();
+
+        return {
+          limits: limits.map((limit) => [limit.name, limit.held]),
+          overCap: seats
+            .filter((seat) => seat.limit === 'builds')
+            .map((seat) => seat.overCap)
+            .toSorted((left, right) => Number(left) - Number(right)),
+        };
+      });
+
+      return {
+        received: state,
+        expected: {
+          limits: [
+            ['builds', 2],
+            ['workers', 2],
+          ],
+          overCap: [false, true],
+        },
+      };
+    },
+  ],
+  [
+    '#syncLimits gives no seat to a sleeping attempt',
+    async (store) => {
+      const builds = brandSchemas.limitName.parse('builds');
+      const attempt = buildMockV1AttemptRow({ state: 'sleeping' });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(
+          buildMockFileItemChange(buildMockV1ItemRow({ id: attempt.item })),
+        );
+
+        await transaction.applyChange(buildMockClaimChange(attempt));
+
+        await transaction.syncLimits(
+          [{ name: builds, max: 1, counts: {} }],
+          brandSchemas.instant.parse(6000),
+        );
+      });
+
+      const seats = await store.read((transaction) => transaction.listLimitSeats());
+
+      return { received: seats, expected: [] };
+    },
+  ],
+  [
+    '#applyChange takes a seat over the cap past a full limit',
+    async (store) => {
+      const workers = brandSchemas.limitName.parse('workers');
+      const holder = buildMockV1AttemptRow({ state: 'starting' });
+      const waking = buildMockV1AttemptRow({ state: 'starting' });
+      const claim = buildMockClaimChange(waking);
+
+      const overCap: StoreChange = {
+        ...claim,
+        writes: [
+          {
+            op: 'take-seats',
+            take: { limits: [workers], attempt: waking.id, holdGen: 1, overCap: true },
+          },
+          ...claim.writes.filter((write) => write.op !== 'take-seats'),
+        ],
+      };
+
+      await store.exclusive(async (transaction) => {
+        await transaction.syncLimits(
+          [{ name: workers, max: 1, counts: {} }],
+          brandSchemas.instant.parse(500),
+        );
+
+        await transaction.applyChange(
+          buildMockFileItemChange(buildMockV1ItemRow({ id: holder.item })),
+        );
+
+        await transaction.applyChange(
+          buildMockFileItemChange(buildMockV1ItemRow({ id: waking.item })),
+        );
+
+        await transaction.applyChange(buildMockClaimChange(holder, [workers]));
+      });
+
+      const result = await store.exclusive((transaction) => transaction.applyChange(overCap));
+      const limits = await store.read((transaction) => transaction.listLimits());
+
+      return {
+        received: { result, held: limits.map((limit) => limit.held) },
+        expected: { result: { kind: 'applied' }, held: [2] },
+      };
+    },
+  ],
+  [
+    '#applyChange applies a seat release of an attempt that holds no seat',
+    async (store) => {
+      const attempt = buildMockV1AttemptRow({ state: 'starting' });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(
+          buildMockFileItemChange(buildMockV1ItemRow({ id: attempt.item })),
+        );
+
+        await transaction.applyChange(buildMockClaimChange(attempt));
+      });
+
+      const result = await store.exclusive((transaction) =>
+        transaction.applyChange(buildMockSettleChange({ attempt, state: 'failed' })),
+      );
+
+      return { received: result, expected: { kind: 'applied' } };
+    },
+  ],
+];

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

@@ -0,0 +1,289 @@
+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 { buildMockSettleChange } from './build-mock-settle-change.ts';
+import { buildMockStartChange } from './build-mock-start-change.ts';
+import type { ClaimStoreCase } from './types.ts';
+
+export const claimStoreSessionCases: readonly ClaimStoreCase[] = [
+  [
+    '#findSessionByCaller returns the session whose latest attempt holds the caller',
+    async (store) => {
+      const caller = { issuer: 'https://id.example.test', subject: 'worker-1' };
+      const attempt = buildMockV1AttemptRow({ state: 'starting' });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(
+          buildMockFileItemChange(buildMockV1ItemRow({ id: attempt.item })),
+        );
+
+        await transaction.applyChange(buildMockClaimChange(attempt));
+        await transaction.applyChange(buildMockStartChange(attempt, caller));
+      });
+
+      const found = await store.read((transaction) => transaction.findSessionByCaller(caller));
+
+      return { received: found, expected: attempt.atcSession };
+    },
+  ],
+  [
+    '#findSessionByCaller returns null when only an older attempt of the session holds the caller',
+    async (store) => {
+      const caller = { issuer: 'https://id.example.test', subject: 'worker-1' };
+      const item = buildMockV1ItemRow();
+
+      const earlier = buildMockV1AttemptRow({
+        item: item.id,
+        state: 'starting',
+        caller,
+        claimedAt: brandSchemas.instant.parse(1000),
+      });
+
+      const later = buildMockV1AttemptRow({
+        item: item.id,
+        state: 'starting',
+        number: 2,
+        leaseGen: 2,
+        atcSession: earlier.atcSession,
+        caller: { issuer: 'https://id.example.test', subject: 'worker-2' },
+        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.findSessionByCaller(caller));
+
+      return { received: found, expected: null };
+    },
+  ],
+  [
+    '#findSessionByCaller returns ambiguous when the latest attempts of two sessions hold it',
+    async (store) => {
+      const caller = { issuer: 'https://id.example.test', subject: 'worker-1' };
+      const first = buildMockV1AttemptRow({ state: 'starting', caller });
+      const second = buildMockV1AttemptRow({ state: 'starting', caller });
+
+      await store.exclusive(async (transaction) => {
+        for (const attempt of [first, second]) {
+          await transaction.applyChange(
+            buildMockFileItemChange(buildMockV1ItemRow({ id: attempt.item })),
+          );
+
+          await transaction.applyChange(buildMockClaimChange(attempt));
+        }
+      });
+
+      const found = await store.read((transaction) => transaction.findSessionByCaller(caller));
+
+      return { received: found, expected: 'ambiguous' };
+    },
+  ],
+  [
+    '#findSessionByCaller returns null for a caller no attempt holds',
+    async (store) => {
+      const found = await store.read((transaction) =>
+        transaction.findSessionByCaller({ issuer: 'https://id.example.test', subject: 'nobody' }),
+      );
+
+      return { received: found, expected: null };
+    },
+  ],
+  [
+    '#listKeptSessions returns the kept session of each item, oldest kept first',
+    async (store) => {
+      const later = {
+        atcSession: brandSchemas.atcSessionId.parse('atc-session-2'),
+        target: 'worker-host-a',
+        attempt: buildMockV1AttemptRow().id,
+        keptAt: brandSchemas.instant.parse(4000),
+        caller: null,
+      };
+
+      const earlier = {
+        atcSession: brandSchemas.atcSessionId.parse('atc-session-1'),
+        target: 'worker-host-b',
+        attempt: buildMockV1AttemptRow().id,
+        keptAt: brandSchemas.instant.parse(3000),
+        caller: { issuer: 'https://id.example.test', subject: 'worker-1' },
+      };
+
+      const laterItem = buildMockV1ItemRow({ keptSession: later });
+      const earlierItem = buildMockV1ItemRow({ keptSession: earlier });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(buildMockFileItemChange(laterItem));
+        await transaction.applyChange(buildMockFileItemChange(earlierItem));
+        await transaction.applyChange(buildMockFileItemChange(buildMockV1ItemRow()));
+      });
+
+      const kept: unknown = await store.read((transaction) => transaction.listKeptSessions());
+
+      return {
+        received: kept,
+        expected: [
+          { item: earlierItem.id, kept: earlier },
+          { item: laterItem.id, kept: later },
+        ],
+      };
+    },
+  ],
+  [
+    '#listSessionsToForget returns a succeeded session at once and a failed one past the cutoff',
+    async (store) => {
+      const succeeded = buildMockV1AttemptRow({
+        state: 'succeeded',
+        endedAt: brandSchemas.instant.parse(5000),
+        claimedAt: brandSchemas.instant.parse(1000),
+      });
+
+      const failedOld = buildMockV1AttemptRow({
+        state: 'failed',
+        endedAt: brandSchemas.instant.parse(2000),
+        claimedAt: brandSchemas.instant.parse(1100),
+      });
+
+      const failedNew = buildMockV1AttemptRow({
+        state: 'failed',
+        endedAt: brandSchemas.instant.parse(5000),
+        claimedAt: brandSchemas.instant.parse(1200),
+      });
+
+      const forgotten = buildMockV1AttemptRow({
+        state: 'succeeded',
+        endedAt: brandSchemas.instant.parse(2000),
+        sessionForgottenAt: brandSchemas.instant.parse(2500),
+        claimedAt: brandSchemas.instant.parse(1300),
+      });
+
+      const running = buildMockV1AttemptRow({ claimedAt: brandSchemas.instant.parse(1400) });
+
+      await store.exclusive(async (transaction) => {
+        for (const attempt of [succeeded, failedOld, failedNew, forgotten, running]) {
+          await transaction.applyChange(
+            buildMockFileItemChange(buildMockV1ItemRow({ id: attempt.item })),
+          );
+
+          await transaction.applyChange(buildMockClaimChange(attempt));
+        }
+      });
+
+      const listed = await store.read((transaction) =>
+        transaction.listSessionsToForget(brandSchemas.instant.parse(3000)),
+      );
+
+      return {
+        received: listed.map((attempt) => attempt.id),
+        expected: [succeeded.id, failedOld.id],
+      };
+    },
+  ],
+  [
+    '#listSessionsToForget leaves out a kept session, an unstopped stray and an older attempt',
+    async (store) => {
+      const keptSession = brandSchemas.atcSessionId.parse('atc-session-1');
+
+      const kept = buildMockV1AttemptRow({
+        state: 'succeeded',
+        atcSession: keptSession,
+        endedAt: brandSchemas.instant.parse(2000),
+        claimedAt: brandSchemas.instant.parse(1000),
+      });
+
+      const stray = buildMockV1AttemptRow({
+        state: 'failed',
+        endedAt: brandSchemas.instant.parse(2000),
+        strayedAt: brandSchemas.instant.parse(2000),
+        claimedAt: brandSchemas.instant.parse(1100),
+      });
+
+      const older = buildMockV1AttemptRow({
+        state: 'succeeded',
+        endedAt: brandSchemas.instant.parse(2000),
+        claimedAt: brandSchemas.instant.parse(1200),
+      });
+
+      const newer = buildMockV1AttemptRow({
+        item: older.item,
+        phase: brandSchemas.phaseName.parse('review'),
+        atcSession: older.atcSession,
+        claimedAt: brandSchemas.instant.parse(2500),
+      });
+
+      const keptItem = buildMockV1ItemRow({
+        id: kept.item,
+        keptSession: {
+          atcSession: keptSession,
+          target: 'worker-host-a',
+          attempt: kept.id,
+          keptAt: brandSchemas.instant.parse(2000),
+          caller: null,
+        },
+      });
+
+      await store.exclusive(async (transaction) => {
+        await transaction.applyChange(buildMockFileItemChange(keptItem));
+
+        await transaction.applyChange(
+          buildMockFileItemChange(buildMockV1ItemRow({ id: stray.item })),
+        );
+
+        await transaction.applyChange(
+          buildMockFileItemChange(buildMockV1ItemRow({ id: older.item })),
+        );
+
+        for (const attempt of [kept, stray, older, newer]) {
+          await transaction.applyChange(buildMockClaimChange(attempt));
+        }
+      });
+
+      const listed = await store.read((transaction) =>
+        transaction.listSessionsToForget(brandSchemas.instant.parse(3000)),
+      );
+
+      return { received: listed, expected: [] };
+    },
+  ],
+  [
+    '#listStrayAttempts returns the strays since a time whose session has not stopped',
+    async (store) => {
+      const recent = buildMockV1AttemptRow({
+        state: 'failed',
+        strayedAt: brandSchemas.instant.parse(5000),
+      });
+
+      const stopped = buildMockV1AttemptRow({
+        state: 'failed',
+        strayedAt: brandSchemas.instant.parse(5000),
+        sessionStoppedAt: brandSchemas.instant.parse(5500),
+      });
+
+      const old = buildMockV1AttemptRow({
+        state: 'failed',
+        strayedAt: brandSchemas.instant.parse(1000),
+      });
+
+      await store.exclusive(async (transaction) => {
+        for (const attempt of [recent, stopped, old]) {
+          await transaction.applyChange(
+            buildMockFileItemChange(buildMockV1ItemRow({ id: attempt.item })),
+          );
+
+          await transaction.applyChange(buildMockClaimChange(attempt));
+        }
+      });
+
+      const listed = await store.read((transaction) =>
+        transaction.listStrayAttempts(brandSchemas.instant.parse(4000)),
+      );
+
+      return { received: listed.map((attempt) => attempt.id), expected: [recent.id] };
+    },
+  ],
+];

package/src/test-utils/collect-memory-limit-fills.ts

@@ -0,0 +1,15 @@
+import type { LimitFill } from '@boxxy/model';
+import { compareText } from './compare-text.ts';
+import type { MemoryTables } from './types.ts';
+
+export function collectMemoryLimitFills(tables: MemoryTables): LimitFill[] {
+  const fills = tables.limits.map((limit) => {
+    const held = tables.limit_seats.filter(
+      (seat) => seat.limit === limit.name && seat.releasedAt === null,
+    );
+
+    return { ...limit, held: held.length };
+  });
+
+  return fills.toSorted((first, second) => compareText(first.name, second.name));
+}

package/src/test-utils/compare-text.ts

@@ -0,0 +1,8 @@
+// SQLite's ORDER BY compares text byte by byte, and localeCompare doesn't
+export function compareText(first: string, second: string): number {
+  if (first === second) {
+    return 0;
+  }
+
+  return first < second ? -1 : 1;
+}

package/src/test-utils/create-fake-backoff.ts

@@ -0,0 +1,16 @@
+import type { CapacityBackoff, Instant, PoolName } from '@boxxy/model';
+
+// The runner's memory of the pools in backoff. A second hold of a pool keeps the later end.
+export function createFakeBackoff(): CapacityBackoff {
+  const until = new Map<PoolName, Instant>();
+
+  return {
+    hold: (pool, end) => {
+      const held = until.get(pool);
+      const later = held !== undefined && held > end ? held : end;
+
+      until.set(pool, later);
+    },
+    listHeld: (now) => [...until].filter(([, end]) => end > now).map(([pool]) => pool),
+  };
+}

package/src/test-utils/create-fake-clock.ts

@@ -0,0 +1,20 @@
+import type { Clock, Instant } from '@boxxy/model';
+import { brandSchemas } from '@boxxy/model';
+
+export interface FakeClock extends Clock {
+  advance: (byMs: number) => Instant;
+}
+
+// A clock that moves only when the test moves it.
+export function createFakeClock(startMs = 1_000_000): FakeClock {
+  let nowMs = startMs;
+
+  return {
+    now: () => brandSchemas.instant.parse(nowMs),
+    advance: (byMs) => {
+      nowMs += byMs;
+
+      return brandSchemas.instant.parse(nowMs);
+    },
+  };
+}

package/src/test-utils/create-fake-fact-sink.ts

@@ -0,0 +1,74 @@
+import type { FactId, FactSink, OutboxFact, SinkAnswer } from '@boxxy/model';
+
+export interface FakeFactSink extends FactSink {
+  // every call, in order
+  readonly sends: readonly (readonly FactId[])[];
+
+  // one copy per fact ID, as a pepys consumer keeps them
+  readonly facts: ReadonlyMap<FactId, OutboxFact>;
+
+  // the answers of the next calls, one for each call; then the fake answers as ingest does
+  answerNext: (...answers: SinkAnswer[]) => void;
+
+  // any batch that holds the fact is refused whole, with the status
+  refuseFact: (id: FactId, status: 413 | 422) => void;
+}
+
+// A sink that stores a batch whole and answers `stored`, unless a scripted answer or a refused fact
+// says otherwise. A scripted `stored` stores the batch; any other scripted answer stores nothing.
+export function createFakeFactSink(): FakeFactSink {
+  const sends: FactId[][] = [];
+
+  const facts = new Map<FactId, OutboxFact>();
+  const refused = new Map<FactId, 413 | 422>();
+
+  const scripted: SinkAnswer[] = [];
+
+  const keepBatch = (batch: readonly OutboxFact[]): void => {
+    for (const fact of batch) {
+      if (!facts.has(fact.factId)) {
+        facts.set(fact.factId, fact);
+      }
+    }
+  };
+
+  return {
+    sends,
+    facts,
+    answerNext: (...answers) => {
+      scripted.push(...answers);
+    },
+    refuseFact: (id, status) => {
+      refused.set(id, status);
+    },
+    send: (batch) => {
+      sends.push(batch.map((fact) => fact.factId));
+
+      const next = scripted.shift();
+
+      if (next !== undefined) {
+        if (next.kind === 'stored') {
+          keepBatch(batch);
+        }
+
+        return Promise.resolve(next);
+      }
+
+      const status = batch
+        .map((fact) => refused.get(fact.factId))
+        .find((found) => found !== undefined);
+
+      if (status !== undefined) {
+        return Promise.resolve({
+          kind: 'refused-batch',
+          status,
+          reason: 'a fact of the batch is refused',
+        });
+      }
+
+      keepBatch(batch);
+
+      return Promise.resolve({ kind: 'stored' });
+    },
+  };
+}