src/lib/perf/data-and-compute.test.ts

Linked repository file from this build.

import { reportRowFromReview } from "@/features/reports/report-input";
import { describe, expect, test } from "bun:test";
import { aggregateReport as aggregateRows } from "@/features/reports/report-data";
import { CommandDraft } from "@/features/reviews/command-draft";
import { selectFinal } from "@/programs/snap-negative/calculation";
import { runFullEditCheck } from "@/programs/snap-negative/validation";
import {
  createDemoSeed,
  createImportTemplate,
  generateResetBaselineBatch,
} from "@/programs/snap-negative/seed";
import { budgets } from "./budgets";
import { catalogPage, gzipBytes, jsonBytes, medianMs, storedReview } from "./measure";
import { demoActor } from "@/lib/auth/roster";

const examiner = { ...demoActor("examiner"), name: "Alex Examiner" };
const meta = { id: "perf-1", at: "2026-09-08T12:00:00.000Z" };
const month = generateResetBaselineBatch().reviews;

describe("data: payload size", () => {
  test("one review snapshot stays small enough for a workspace GET", () => {
    const stored = storedReview(month[0]!);
    expect(jsonBytes(stored)).toBeLessThan(budgets.oneReviewJson);
    expect(gzipBytes(stored)).toBeLessThan(budgets.oneReviewGzip);
  });

  test("a catalog page of 10 rows stays small", () => {
    const page = catalogPage(month);
    expect(page).toHaveLength(10);
    expect(jsonBytes(page)).toBeLessThan(budgets.catalogPageJson);
    expect(gzipBytes(page)).toBeLessThan(budgets.catalogPageGzip);
  });

  test("import template used as a client placeholder is a single small review", () => {
    const template = createImportTemplate();
    expect(jsonBytes(template)).toBeLessThan(budgets.oneReviewJson);
  });

  test("demo seed JSON is one review, not the 100-review batch", () => {
    const demo = createDemoSeed();
    expect(demo.reviewNumber).toBe("60001");
    expect(jsonBytes(demo)).toBeLessThan(budgets.oneReviewJson);
  });

  test("one month of report totals stays under the endpoint payload target", () => {
    const summary = aggregateReport(month);
    expect(jsonBytes(summary)).toBeLessThan(budgets.reportsApi);
    expect(gzipBytes(summary)).toBeLessThan(budgets.reportsGzip);
  });
});

describe("compute: hot paths", () => {
  test("createDemoSeed stays off the critical path", () => {
    expect(medianMs(() => void createDemoSeed(), 3)).toBeLessThan(budgets.createDemoSeedMs);
  });

  test("reset baseline batch of 100 reviews stays cheap to generate", () => {
    expect(medianMs(() => void generateResetBaselineBatch(), 3)).toBeLessThan(budgets.resetBatchMs);
  });

  test("identity draft keystrokes stay inside a frame with large stored evidence", () => {
    const review = createDemoSeed();
    review.notes = Array.from({ length: 200 }, (_, index) => ({
      id: `note-${index}`,
      body: "Evidence ".repeat(1000),
      actor: examiner,
      createdAt: meta.at,
    }));
    review.documents = Array.from({ length: 100 }, (_, index) => ({
      id: `document-${index}`,
      name: "Evidence",
      filename: "evidence.pdf",
      category: "Evidence",
      mimeType: "application/pdf",
      size: 100_000,
      storageKey: `evidence-${index}`,
      actor: examiner,
      createdAt: meta.at,
      description: "Supporting evidence ".repeat(100),
    }));
    const draft = new CommandDraft();
    expect(
      medianMs(() => {
        draft.stage(review, {
          command: { type: "identity", value: { clientName: "Taylor" } },
          actor: examiner,
          ...meta,
        });
      }),
    ).toBeLessThan(budgets.keystrokeMs);
  });

  test("Final Results and edit check stay inside a frame", () => {
    const review = createImportTemplate();
    expect(medianMs(() => void selectFinal(review))).toBeLessThan(budgets.applyFinalMs);
    expect(medianMs(() => void runFullEditCheck(review))).toBeLessThan(budgets.applyFinalMs);
  });

  test("report aggregation over one month stays interactive", () => {
    expect(medianMs(() => void aggregateReport(month), 3)).toBeLessThan(budgets.reportMonthMs);
  });
});

test("records one-month versus fiscal-year data and report-compute scaling", () => {
  const year = Array.from({ length: 12 }, (_, monthIndex) =>
    month.map((review, index) => ({
      ...review,
      reviewNumber: String(70000 + monthIndex * 100 + index),
      sampleMonth: `2026-${String(monthIndex + 1).padStart(2, "0")}`,
    })),
  ).flat();
  const rows = [month, year].map((reviews) => ({
    reviews: reviews.length,
    reportJsonBytes: jsonBytes(aggregateReport(reviews)),
    catalogPageJsonBytes: jsonBytes(catalogPage(reviews)),
    reportMedianMs: medianMs(() => void aggregateReport(reviews), 3),
  }));
  console.table(rows);
  expect(aggregateReport(year).total).toBe(1200);
  expect(rows[1].catalogPageJsonBytes).toBeLessThan(budgets.catalogPageJson);
  expect(rows[1].reportJsonBytes).toBeLessThan(budgets.reportsApi);
});

function aggregateReport(reviews: Parameters<typeof reportRowFromReview>[0][], filters = {}) {
  return aggregateRows(reviews.map(reportRowFromReview), filters);
}