src/features/reviews/downstream.test.ts

Linked repository file from this build.

import { expect, test } from "bun:test";
import { createSeed, completedReviewAnswers } from "@/programs/snap-negative/seed";
import { execute } from "./commands";
import {
  assertDownstreamEligible,
  assertSummaryRelease,
  buildEppHandoff,
  deriveFfyFromSampleMonth,
  memoEligibility,
  queryErcOutcomes,
  transmittalEligible,
} from "./downstream";
import type { SnapReview } from "@/programs/snap-negative/types";
import type { Actor } from "./types";
import { demoActor } from "@/lib/auth/roster";
import { actorRef } from "@/lib/auth/actor";

const examiner: Actor = { ...demoActor("examiner"), name: "Examiner" };
const supervisor: Actor = { ...demoActor("supervisor"), name: "Supervisor" };
const manager: Actor = { ...demoActor("program_manager"), name: "Manager" };
const pec: Actor = { ...demoActor("pec"), name: "PEC" };
const meta = { id: "event", at: "2026-09-13T12:00:00Z" };
const stamp = { actor: actorRef(manager), at: meta.at };
function managerReview() {
  let review = execute(
    createSeed(),
    { type: "answers", value: completedReviewAnswers({ finding: "2" }) },
    examiner,
    meta,
  );
  review = execute(review, { type: "apply_final" }, examiner, meta);
  // This fixture represents a confirmed PEC queue item, not an invented routing map.
  review.state = "awaiting_pec_approval";
  review.supervisorApproved = { actor: supervisor, at: meta.at };
  return execute(
    review,
    { type: "policy_decision", decision: "approve", policyNote: "" },
    pec,
    meta,
  );
}

test("PEC approval creates an editable manager memo and received snapshot without release", () => {
  const review = managerReview();
  expect(review.state).toBe("awaiting_manager");
  expect(review.pecApproved?.actor).toEqual(actorRef(pec));
  expect(review.receivedSnapshots?.program_manager?.facts).toEqual(review.facts);
  expect(review.memos?.[0].body).toContain(review.reviewNumber);
  expect(review.memos?.[0].type).toBeUndefined();
  expect(memoEligibility(review, manager).canCreate).toBe(true);
  expect(memoEligibility(review, supervisor).canCreate).toBe(false);
  expect(memoEligibility({ ...review, outcome: "clean" }, manager).canCreate).toBe(true);
  expect(() => execute(review, { type: "approve_memo" }, manager, meta)).toThrow("defect map");
  expect(() => assertDownstreamEligible(review)).toThrow("release");
  expect(transmittalEligible(review)).toBe(false);
});

test("memo approval records outbound status and locks the letter before the CAO cycle", () => {
  let review = managerReview();
  // A known type stands in for the future management-confirmed classifier.
  review.memos![0].type = "benefit_error";
  review = execute(review, { type: "memo", body: "Verified assignment and letter" }, manager, meta);
  review = execute(review, { type: "approve_memo" }, manager, meta);
  expect(review.memoApproved).toEqual(stamp);
  expect(review.memos![0].outboundAt).toBe(meta.at);
  expect(review.state).toBe("awaiting_cao_response");
  expect(transmittalEligible(review)).toBe(false);
  expect(() => execute(review, { type: "memo", body: "Changed" }, manager, meta)).toThrow("fixed");
  expect(() => execute(review, { type: "outcome", value: "clean" }, manager, meta)).toThrow(
    "examiner",
  );
});

test("CAO agreement needs a root cause and only the manager releases the shared inclusion flag", () => {
  let review: SnapReview = {
    ...managerReview(),
    state: "awaiting_cao_response",
    memoApproved: stamp,
  };
  expect(() =>
    execute(
      review,
      { type: "cao_response", status: "agree", rootCause: "", note: "" },
      manager,
      meta,
    ),
  ).toThrow("root cause");
  expect(() => assertSummaryRelease(review, meta.at)).toThrow("root cause");
  review = execute(
    review,
    { type: "cao_response", status: "agree", rootCause: "CAO reported training gap", note: "" },
    manager,
    meta,
  );
  expect(() => execute(review, { type: "release_summary" }, supervisor, meta)).toThrow(
    "Only the program manager",
  );
  review = execute(review, { type: "release_summary" }, manager, meta);
  expect(review.errorSummaryReleased).toEqual(stamp);
  expect(review.state).toBe("released_to_reporting");
  expect(transmittalEligible(review)).toBe(true);
  assertDownstreamEligible(review);
  expect(
    queryErcOutcomes([review, { ...review, outcome: "clean" }, { ...review, outcome: "drop" }])
      .eligibleReviewCount,
  ).toBe(2);
});

test("a passed deadline permits explicit no response, while a dispute remains held", () => {
  let review: SnapReview = {
    ...managerReview(),
    state: "awaiting_cao_response",
    memoApproved: stamp,
  };
  review = execute(review, { type: "cao_deadline", value: "2026-09-13" }, manager, meta);
  expect(() =>
    execute(
      review,
      { type: "cao_response", status: "no_response", rootCause: "", note: "" },
      manager,
      meta,
    ),
  ).toThrow("deadline");
  review = execute(review, { type: "cao_deadline", value: "2026-09-12" }, manager, meta);
  review = execute(
    review,
    {
      type: "cao_response",
      status: "dispute",
      rootCause: "",
      note: "Another office owns this error",
    },
    manager,
    meta,
  );
  expect(() => assertSummaryRelease(review, meta.at)).toThrow("dispute");
  expect(() =>
    execute(
      review,
      { type: "cao_response", status: "no_response", rootCause: "", note: "" },
      manager,
      meta,
    ),
  ).toThrow("dispute");
  delete review.caoResponse;
  review = execute(
    review,
    { type: "cao_response", status: "no_response", rootCause: "", note: "Follow-up scheduled" },
    manager,
    meta,
  );
  expect(() => assertSummaryRelease(review, meta.at)).not.toThrow();
  review = execute(review, { type: "cao_deadline", value: "2026-09-20" }, manager, meta);
  expect(() => assertSummaryRelease(review, meta.at)).toThrow("deadline");
});

test("drops require supervisor then manager approval, with no narrative or computation rules", () => {
  for (const covering of [supervisor, manager]) {
    let review = createSeed();
    review.facts.answers.narrative = "";
    delete review.facts.final;
    review = execute(review, { type: "outcome", value: "drop" }, examiner, meta);
    expect(() =>
      execute(review, { type: "transition", action: "submit", note: "" }, examiner, meta),
    ).toThrow("drop kind");
    review = execute(review, { type: "drop_kind", value: "failure_to_comply" }, examiner, meta);
    review = execute(review, { type: "transition", action: "submit", note: "" }, examiner, meta);
    review = execute(review, { type: "transition", action: "approve", note: "" }, covering, meta);
    expect(review.state).toBe("awaiting_manager");
    expect(review.supervisorApproved?.actor).toEqual(actorRef(covering));
    expect(transmittalEligible(review)).toBe(false);
    expect(() =>
      execute(review, { type: "transition", action: "approve", note: "" }, supervisor, meta),
    ).toThrow("not available");
    review = execute(review, { type: "transition", action: "approve", note: "" }, manager, meta);
    expect(review.state).toBe("dropped");
    expect(transmittalEligible(review)).toBe(true);
    expect(review.memos).toBeUndefined();
    expect(() => assertDownstreamEligible(review)).toThrow("excludes drops");
  }
});

test("PEC conditional approval holds the item for PEC and does not release or generate a memo", () => {
  const review = managerReview();
  review.state = "awaiting_pec_approval";
  delete review.pecApproved;
  delete review.memos;
  const next = execute(
    review,
    { type: "policy_decision", decision: "conditional", policyNote: "Confirm source" },
    pec,
    meta,
  );
  expect(next.state).toBe("awaiting_pec_approval");
  expect(next.pecApproved).toBeUndefined();
  expect(next.memos).toBeUndefined();
});

test("FFY October boundary and verified adapter fields remain explicit", () => {
  expect(deriveFfyFromSampleMonth("2026-09")).toBe(2026);
  expect(deriveFfyFromSampleMonth("2026-10")).toBe(2027);
  expect(() => deriveFfyFromSampleMonth("2026-13")).toThrow();
  const review = { ...managerReview(), errorSummaryReleased: stamp };
  const payload = buildEppHandoff(review, manager);
  expect(payload.key.QC_Record_Number).toBe(review.reviewNumber);
  expect(payload.columns.Record_Number).toBe(review.caseNumber);
  expect(payload.adapterStatus).toBe("pending_external_connection");
  expect(payload.missingMapping.length).toBeGreaterThan(0);
  expect(() => buildEppHandoff(review, examiner)).toThrow("supervisor or program manager");
});