/** * `GET /api/labs/overview` against a real Postgres, on a long history. * * The Labs list used to group the newest 500 raw rows in the browser, so on * an account with thousands of readings every marker measured only long ago * had no row at all. The overview groups server-side over every live row; * this suite seeds 2,000 readings over 25 years and checks that each marker * comes back once, with its full count, its newest reading and a trend. */ import { NextRequest } from "next/server"; import { beforeEach, describe, expect, it, vi } from "vitest"; import { cookieJar } from "./mock-next-headers"; import { getPrismaClient, truncateAllTables } from "./setup"; const USER_ID = "user-labs-overview-test"; const OTHER_USER_ID = "user-labs-overview-other"; const DAY_MS = 24 * 60 * 60 * 1000; vi.mock("next/headers", async () => { const { cookieJar, headerJar } = await import("./mock-next-headers"); return { headers: vi.fn(async () => ({ get: (name: string) => headerJar.get(name.toLowerCase()) ?? null, })), cookies: vi.fn(async () => ({ get: (name: string) => { const value = cookieJar.get(name); return value ? { name, value } : undefined; }, set: (name: string, value: string) => { cookieJar.set(name, value); }, delete: (name: string) => { cookieJar.delete(name); }, })), }; }); vi.mock("@/lib/db-compat", () => ({ ensureDbCompatibility: vi.fn().mockResolvedValue(undefined), })); /** Days before now, so the fixture never ages out of its own windows. */ const daysAgo = (days: number) => new Date(Date.now() - days * DAY_MS); const FREQUENT_READINGS = 1_700; const RARE_MARKERS = 58; const RARE_READINGS_EACH = 5; const LEGACY_READINGS = 10; const TOTAL = FREQUENT_READINGS + RARE_MARKERS * RARE_READINGS_EACH + LEGACY_READINGS; interface Seeded { frequentId: string; rareIds: string[]; } /** * 2,000 live readings over 25 years: one marker measured almost daily over * the last five years (1,700), 58 markers measured five times each between 25 * and 6 years ago (290), and one legacy unlinked marker whose ten readings * spell the analyte in different cases (10). The newest 500 rows are all the * frequent marker, which is exactly the history the capped list lost. */ async function seedLongHistory(): Promise { const prisma = getPrismaClient(); const frequent = await prisma.biomarker.create({ data: { userId: USER_ID, name: "Glucose", unit: "mg/dL", lowerBound: 70, upperBound: 99, }, }); const rare = await Promise.all( Array.from({ length: RARE_MARKERS }, (_, i) => prisma.biomarker.create({ data: { userId: USER_ID, name: `Rare marker ${String(i).padStart(2, "0")}`, unit: "U/L", lowerBound: 1, upperBound: 50, }, }), ), ); const rows: Array<{ userId: string; biomarkerId: string | null; analyte: string; value: number; unit: string; takenAt: Date; }> = []; for (let i = 0; i < FREQUENT_READINGS; i++) { rows.push({ userId: USER_ID, biomarkerId: frequent.id, analyte: "Glucose", value: 80 + (i % 20), unit: "mg/dL", takenAt: daysAgo(1 + i), }); } rare.forEach((marker, m) => { for (let k = 0; k < RARE_READINGS_EACH; k++) { rows.push({ userId: USER_ID, biomarkerId: marker.id, analyte: marker.name, value: 10 + k, unit: "U/L", // Between ~25 and ~6 years ago, one marker per fortnight-ish slot. takenAt: daysAgo(25 * 365 - m * 120 - k * 20), }); } }); for (let k = 0; k < LEGACY_READINGS; k++) { rows.push({ userId: USER_ID, biomarkerId: null, analyte: k % 2 === 0 ? "Vitamin X" : "VITAMIN x", value: 1 + k, unit: "nmol/L", takenAt: daysAgo(24 * 365 - k * 30), }); } await prisma.labResult.createMany({ data: rows }); // Noise that must not count: a deleted reading of a rare marker, and // another account's reading. await prisma.labResult.create({ data: { userId: USER_ID, biomarkerId: rare[0].id, analyte: rare[0].name, value: 99, unit: "U/L", takenAt: daysAgo(0), deletedAt: daysAgo(0), }, }); await prisma.labResult.create({ data: { userId: OTHER_USER_ID, analyte: "Other account marker", value: 1, unit: "U/L", takenAt: daysAgo(0), }, }); return { frequentId: frequent.id, rareIds: rare.map((m) => m.id) }; } beforeEach(async () => { await truncateAllTables(getPrismaClient()); cookieJar.clear(); const prisma = getPrismaClient(); await prisma.user.createMany({ data: [ { id: USER_ID, username: "labs-ov", email: "labs-ov@example.test" }, { id: OTHER_USER_ID, username: "labs-ov-other", email: "labs-ov-other@example.test", }, ], }); const session = await prisma.session.create({ data: { userId: USER_ID, expiresAt: new Date(Date.now() + 60 * 60 * 1000) }, }); cookieJar.set("healthlog_session", session.id); }); interface OverviewBody { data: { markers: Array<{ key: string; count: number; trend: (number | null)[]; latest: { id: string; biomarkerId: string | null; analyte: string; value: number | null; takenAt: string; }; }>; }; } async function getOverview(query = "") { const { GET } = await import("@/app/api/labs/overview/route"); return GET(new NextRequest(`http://localhost/api/labs/overview${query}`)); } describe("GET /api/labs/overview on a 25-year history", () => { it("returns every marker once, with its full count and newest reading", async () => { const seeded = await seedLongHistory(); const res = await getOverview(); expect(res.status).toBe(200); const { markers } = ((await res.json()) as OverviewBody).data; // 1 frequent + 58 rare + 1 legacy, and nothing from the other account. expect(markers).toHaveLength(1 + RARE_MARKERS + 1); expect(markers.reduce((sum, m) => sum + m.count, 0)).toBe(TOTAL); expect(TOTAL).toBe(2_000); const byKey = new Map(markers.map((m) => [m.key, m])); for (const id of seeded.rareIds) { const marker = byKey.get(`bm:${id}`); expect(marker, `marker ${id} missing`).toBeDefined(); // The deleted reading neither counts nor becomes the newest one. expect(marker!.count).toBe(RARE_READINGS_EACH); expect(marker!.latest.value).toBe(14); expect(marker!.trend).toEqual([10, 11, 12, 13, 14]); } const frequent = byKey.get(`bm:${seeded.frequentId}`)!; expect(frequent.count).toBe(FREQUENT_READINGS); // Capped trend, oldest first, ending on the newest reading. expect(frequent.trend).toHaveLength(50); expect(frequent.trend.at(-1)).toBe(frequent.latest.value); expect(frequent.latest.value).toBe(80); // Legacy rows group case-insensitively by analyte. const legacy = byKey.get("analyte:vitamin x")!; expect(legacy.count).toBe(LEGACY_READINGS); expect(legacy.latest.biomarkerId).toBeNull(); expect(legacy.latest.value).toBe(LEGACY_READINGS); // Newest reading first. expect(markers[0].key).toBe(`bm:${seeded.frequentId}`); const times = markers.map((m) => Date.parse(m.latest.takenAt)); expect([...times].sort((a, b) => b - a)).toEqual(times); expect( markers.some((m) => m.latest.analyte === "Other account marker"), ).toBe(false); }); it("covers the markers a 500-row page of the list endpoint drops", async () => { await seedLongHistory(); const { GET } = await import("@/app/api/labs/route"); const page = await GET( new NextRequest("http://localhost/api/labs?limit=500&sortDir=desc"), ); const pageBody = (await page.json()) as { data: { results: Array<{ biomarkerId: string | null }> }; }; const onPage = new Set(pageBody.data.results.map((r) => r.biomarkerId)); // The old list's view of this account: one marker. expect(onPage.size).toBe(1); const { markers } = ((await (await getOverview()).json()) as OverviewBody) .data; expect(markers).toHaveLength(1 + RARE_MARKERS + 1); }); it("refuses a query parameter instead of ignoring it", async () => { const res = await getOverview("?limit=500"); expect(res.status).toBe(422); }); it("answers an empty list for an account without readings", async () => { const res = await getOverview(); expect(res.status).toBe(200); expect(((await res.json()) as OverviewBody).data.markers).toEqual([]); }); });