src/features/reviews/intake-command.test.ts

Linked repository file from this build.

import { initialPolicy } from "@/programs/snap-negative/policy";
import { isReviewKey, reviewIdentity, reviewKey } from "./review-key";
import { expect, test } from "bun:test";
import { readFileSync } from "node:fs";
import { promoteSnapNegative } from "./intake-command";
import type { ReviewStore, StoredReview } from "./review-store";
import { demoActor } from "@/lib/auth/roster";
const actor = { ...demoActor("admin"), name: "Synthetic Admin" };
const files = {
  closedSuspended: readFileSync("public/fixtures/snap-negative/closed-suspended.txt", "utf8"),
  rejected: readFileSync("public/fixtures/snap-negative/rejected.txt", "utf8"),
};
function memory(): ReviewStore {
  const rows: StoredReview[] = [];
  return {
    async load(key) {
      return rows.findLast((row) => row.review.id === key);
    },
    async findBusiness(identity) {
      return rows.findLast(
        (row) => JSON.stringify(reviewIdentity(row.review)) === JSON.stringify(identity),
      );
    },
    async findRequest(id) {
      return rows.find((row) => row.requestId === id);
    },
    async append(value) {
      if (
        rows.some(
          (row) =>
            reviewKey(row.review) === reviewKey(value.review) && row.version === value.version,
        )
      )
        throw new Error("Conflict");
      rows.push(value);
    },
    async list() {
      return rows;
    },
  };
}
test("intake persists matched facts and complete batch lineage, supports guarded refresh", async () => {
  const store = memory();
  const first = await promoteSnapNegative(
    store,
    files,
    { program: "SNAP", fiscalYear: 2026, reviewNumber: "60002" },
    actor,
    null,
    "intake-1",
  );
  expect((await store.load(first.review.id))?.review.clientName).toBe("Casey Walker");
  expect(first.review.facts.paCap).toBeUndefined();
  expect(first.review.facts.scenarios.compI.income).toEqual([]);
  expect(first.review.state).toBe("new_active");
  expect(first.review).toHaveProperty("intake.sources.closedSuspended", files.closedSuspended);
  expect(first.review).toHaveProperty("lineage.0.sourceSystem", "sample_delim");
  const repeated = await promoteSnapNegative(
    store,
    files,
    { program: "SNAP", fiscalYear: 2026, reviewNumber: "60002" },
    actor,
    null,
    "intake-1",
  );
  expect(repeated).toEqual(first);
  const refresh = await promoteSnapNegative(
    store,
    files,
    { program: "SNAP", fiscalYear: 2026, reviewNumber: "60002" },
    actor,
    0,
    "intake-2",
  );
  expect(refresh.version).toBe(1);
  expect(isReviewKey(first.review.id)).toBe(true);
  expect(first.review.id[14]).toBe("7");
  expect(refresh.review.id).toBe(first.review.id);
  expect(refresh.review.activity).toHaveLength(2);
  await expect(
    promoteSnapNegative(
      store,
      files,
      { program: "SNAP", fiscalYear: 2026, reviewNumber: "60002" },
      actor,
      0,
      "stale",
    ),
  ).rejects.toThrow("changed elsewhere");
  await expect(
    promoteSnapNegative(
      store,
      files,
      { program: "SNAP", fiscalYear: 2026, reviewNumber: "60002" },
      { ...actor, role: "pec" },
      1,
      "pec",
    ),
  ).rejects.toThrow("Only program manager, admin and statistics");
  refresh.review.state = "dropped";
  await expect(
    promoteSnapNegative(
      store,
      files,
      { program: "SNAP", fiscalYear: 2026, reviewNumber: "60002" },
      actor,
      1,
      "examiner",
    ),
  ).rejects.toThrow("cannot refresh");
  await expect(
    promoteSnapNegative(
      store,
      files,
      { program: "SNAP", fiscalYear: 2026, reviewNumber: "60002" },
      { ...actor, role: "program_manager" },
      1,
      "manager",
    ),
  ).rejects.toThrow("cannot refresh");
});
test("intake findings block promotion and never invent a matched case", async () => {
  const store = memory();
  await expect(
    promoteSnapNegative(
      store,
      { ...files, rejected: "" },
      { program: "SNAP", fiscalYear: 2026, reviewNumber: "60002" },
      actor,
      null,
      "bad",
    ),
  ).rejects.toThrow("findings");
  await expect(
    promoteSnapNegative(
      store,
      files,
      { program: "SNAP", fiscalYear: 2026, reviewNumber: "60099" },
      actor,
      null,
      "missing",
    ),
  ).rejects.toThrow("sampled review");
  expect(await store.list()).toEqual([]);
});

test("a failed refresh append is not mislabeled as a stale write", async () => {
  const store = memory();
  await promoteSnapNegative(
    store,
    files,
    { program: "SNAP", fiscalYear: 2026, reviewNumber: "60002" },
    actor,
    null,
    "initial",
  );
  const failure = new Error("Synthetic storage failure");
  store.append = async () => {
    throw failure;
  };
  await expect(
    promoteSnapNegative(
      store,
      files,
      { program: "SNAP", fiscalYear: 2026, reviewNumber: "60002" },
      actor,
      0,
      "failed-refresh",
    ),
  ).rejects.toBe(failure);
});

test("a racing intake request ID cannot return another review", async () => {
  const base = memory();
  const current = await promoteSnapNegative(
    base,
    files,
    { program: "SNAP", fiscalYear: 2026, reviewNumber: "60002" },
    actor,
    null,
    "original",
  );
  const other = {
    ...current,
    review: { ...current.review, id: crypto.randomUUID(), reviewNumber: "60099" },
  };
  let lookup = 0;
  const store: ReviewStore = {
    async findBusiness() {
      return current;
    },
    async load() {
      return current;
    },
    async findRequest() {
      return ++lookup === 1 ? undefined : other;
    },
    async append() {
      throw new Error("Duplicate request id");
    },
    async list() {
      return [];
    },
  };
  await expect(
    promoteSnapNegative(
      store,
      files,
      { program: "SNAP", fiscalYear: 2026, reviewNumber: "60002" },
      actor,
      0,
      "collision",
    ),
  ).rejects.toThrow("Request belongs to another review");
});

test("an intake replay does not bypass program scope", async () => {
  const store = memory();
  await promoteSnapNegative(
    store,
    files,
    { program: "SNAP", fiscalYear: 2026, reviewNumber: "60002" },
    actor,
    null,
    "original",
  );
  await expect(
    promoteSnapNegative(
      store,
      files,
      { program: "SNAP", fiscalYear: 2026, reviewNumber: "60002" },
      { ...actor, staffId: "401", program: "OTHER" },
      null,
      "original",
    ),
  ).rejects.toThrow("You do not have access");
});

test("new imports reject a caller outside the imported program before writing", async () => {
  const store = memory();
  await expect(
    promoteSnapNegative(
      store,
      files,
      { program: "SNAP", fiscalYear: 2026, reviewNumber: "60002" },
      { ...actor, staffId: "401", program: "OTHER" },
      null,
      "new-import",
    ),
  ).rejects.toThrow("You do not have access");
  expect(await store.list()).toEqual([]);
});

test("intake version conflict does not disclose a saved review outside the program", async () => {
  const store = memory();
  const current = await promoteSnapNegative(
    store,
    files,
    { program: "SNAP", fiscalYear: 2026, reviewNumber: "60002" },
    actor,
    null,
    "original",
  );
  current.review.program = "OTHER";
  store.findBusiness = async () => current;
  await expect(
    promoteSnapNegative(
      store,
      files,
      { program: "SNAP", fiscalYear: 2026, reviewNumber: "60002" },
      { ...actor, staffId: "401", program: "SNAP" },
      99,
      "conflict",
    ),
  ).rejects.toThrow("You do not have access");
});

test("promotion and refresh distinguish matching review numbers by fiscal year", async () => {
  const store = memory();
  const previousFiles = {
    closedSuspended: files.closedSuspended.replaceAll("|2026|", "|2025|"),
    rejected: files.rejected.replaceAll("|2026|", "|2025|"),
  };
  const mixed = {
    closedSuspended: files.closedSuspended + "\n" + previousFiles.closedSuspended,
    rejected: files.rejected + "\n" + previousFiles.rejected,
  };
  const previous = await promoteSnapNegative(
    store,
    mixed,
    { program: "SNAP", fiscalYear: 2025, reviewNumber: "60002" },
    actor,
    null,
    "previous",
    async () => [{ ...initialPolicy, effectiveFrom: "2024-10" }],
  );
  const current = await promoteSnapNegative(
    store,
    mixed,
    { program: "SNAP", fiscalYear: 2026, reviewNumber: "60002" },
    actor,
    null,
    "current",
  );
  expect(previous.version).toBe(0);
  expect(current.version).toBe(0);
  expect(previous.review.id).not.toBe(current.review.id);
  const refreshed = await promoteSnapNegative(
    store,
    mixed,
    { program: "SNAP", fiscalYear: 2026, reviewNumber: "60002" },
    actor,
    0,
    "refresh",
  );
  expect(refreshed.version).toBe(1);
  expect((await store.load(previous.review.id))?.version).toBe(0);
  await expect(
    promoteSnapNegative(
      store,
      mixed,
      { program: "SNAP", fiscalYear: 2025, reviewNumber: "60002" },
      actor,
      0,
      "current",
    ),
  ).rejects.toThrow("Request belongs to another review");
});

test("simultaneous first promotions keep the winning UUID and resolve retries by business identity", async () => {
  const identity = { program: "SNAP", fiscalYear: 2026, reviewNumber: "60002" };
  const persisted = await promoteSnapNegative(
    memory(),
    files,
    identity,
    actor,
    null,
    "winning-request",
  );
  for (const sameRequest of [true, false]) {
    let lookups = 0;
    let identityLookups = 0;
    const store: ReviewStore = {
      load: async () => undefined,
      findBusiness: async () => (++identityLookups === 1 ? undefined : persisted),
      findRequest: async () => (++lookups === 1 || !sameRequest ? undefined : persisted),
      append: async (value) => {
        expect(value.review.id).not.toBe(persisted.review.id);
        throw new Error("Concurrent unique constraint conflict");
      },
      list: async () => [persisted],
    };
    const attempt = promoteSnapNegative(
      store,
      files,
      identity,
      actor,
      null,
      sameRequest ? persisted.requestId : "other-request",
    );
    if (sameRequest) expect((await attempt).review.id).toBe(persisted.review.id);
    else await expect(attempt).rejects.toMatchObject({ current: persisted });
  }
});