src/lib/db/export-store.integration.test.ts

Linked repository file from this build.

import { afterAll, beforeAll, expect, test } from "bun:test";
import { inArray } from "drizzle-orm";
import { demoActor } from "@/lib/auth/roster";
import { exportMonthSummary, generateMonthExport } from "@/features/exports/month-export";
import { createSeed } from "@/programs/snap-negative/seed";
import type { SnapReview } from "@/programs/snap-negative/types";
import { queryExportMonths, exportReviews } from "./export-store";
import { reviewStore } from "./review-store";
import { getDb } from "./index";
import { inboxEvents, reviewIndex, reviewSnapshots, reviewTouches } from "./schema";

const enabled = process.env.QC_DB_INTEGRATION === "1";
const integration = enabled ? test : test.skip;
const program = `export-test-${crypto.randomUUID()}`;
const actor = { ...demoActor("statistics"), program };
const manager = { ...demoActor("program_manager"), program };
const at = "2026-09-13T12:00:00Z";
const numbers: string[] = [];
beforeAll(async () => {
  if (!enabled) return;
  const base = {
    ...createSeed(),
    id: crypto.randomUUID(),
    program,
    examiner: "101",
    supervisor: "201",
    sampleMonth: "2026-04",
  };
  const flag = { actor: manager, at };
  const cases: Partial<SnapReview>[] = [
    { state: "released_to_reporting", outcome: "error", errorSummaryReleased: flag },
    { state: "dropped", outcome: "drop", dropApproved: flag },
    { state: "awaiting_cao_response", outcome: "error", memoApproved: flag },
    { state: "dropped", outcome: "drop" },
    { state: "released_to_reporting", outcome: "clean" },
    { state: "awaiting_manager", outcome: "error", supervisorApproved: flag, pecApproved: flag },
  ];
  for (const [index, patch] of cases.entries()) {
    const review = {
      ...structuredClone(base),
      ...patch,
      id: crypto.randomUUID(),
      reviewNumber: `${program}-${index}`,
    };
    review.facts.answers.variances = [
      { element: "416", nature: "096" },
      { element: "540", nature: "096" },
    ];
    numbers.push(review.reviewNumber);
    await reviewStore.append({
      review,
      version: 0,
      requestId: crypto.randomUUID(),
      actor,
      savedAt: at,
    });
  }
});
afterAll(async () => {
  if (!numbers.length) return;
  for (const table of [reviewTouches, inboxEvents, reviewIndex, reviewSnapshots])
    await getDb().delete(table).where(inArray(table.reviewNumber, numbers));
});

integration("export projections and fallback use release plus manager drop approval", async () => {
  const reviews = (await reviewStore.list())
    .filter((row) => row.review.program === program)
    .map((row) => row.review);
  for (const role of ["statistics", "supervisor", "program_manager"] as const) {
    const reader = { ...demoActor(role), program };
    const projected = await queryExportMonths(reader);
    expect(projected).toEqual(exportMonthSummary(reviews, reader));
    expect(projected[0]).toMatchObject({
      total: 6,
      eligible: 2,
      dropped: 1,
      incomplete: 2,
      awaitingRelease: 1,
    });
    const selected = await exportReviews(reader, ["2026-04"]);
    expect(selected.every((row) => ["released_to_reporting", "dropped"].includes(row.state))).toBe(
      true,
    );
    const kind = role === "statistics" ? "fns" : "epp";
    const result = generateMonthExport(selected, reader, kind, ["2026-04"]);
    expect(result).toEqual(generateMonthExport(reviews, reader, kind, ["2026-04"]));
    expect(result.count).toBe(kind === "fns" ? 2 : 1);
    if (kind === "fns") {
      expect(result.content).toContain(numbers[1]);
      expect(result.content).not.toContain("element2");
      expect(result.content).not.toContain("540\t096");
      expect(result.content).not.toContain(numbers[3]);
      expect(result.content).not.toContain(numbers[4]);
    }
    expect(await queryExportMonths({ ...reader, program: "missing" })).toEqual([]);
  }
  await expect(queryExportMonths({ ...actor, role: "examiner" })).rejects.toThrow();
  await expect(exportReviews(actor, ["invalid"])).rejects.toThrow();
});