mirror of
https://github.com/MBombeck/HealthLog.git
synced 2026-11-10 21:32:18 +00:00
Marc-André Bombeck
b6da360856
ensureDbCompatibility ran ALTER TABLE / CREATE TABLE IF NOT EXISTS on the login, register, token and session paths, mirroring columns every migration under prisma/migrations already creates. The entrypoint applies those migrations before the server listens and stops the boot when one fails, so the mirror never had work to do, and DDL on a request path needs the table's owner: a connection that may only read and write rows fails every login on it. Drop the module, its call sites and the mocks that stubbed it out.
512 lines
16 KiB
TypeScript
512 lines
16 KiB
TypeScript
/**
|
|
* v1.4.25 — per-section toggle integration tests.
|
|
*
|
|
* Asserts the privacy-by-default contract for mood data: when the user
|
|
* submits `sections.mood = false`, the generated PDF MUST NOT contain
|
|
* any mood-related text, and the aggregator MUST NOT have fetched the
|
|
* underlying `MoodEntry` rows in the first place.
|
|
*
|
|
* Also asserts the "skip section when toggle off" contract for the
|
|
* non-privacy-sensitive sections (BP / weight / pulse / compliance) so
|
|
* the dialog's toggles produce the expected printed artefact.
|
|
*/
|
|
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
|
|
|
process.env.ENCRYPTION_KEY ??=
|
|
"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
|
|
|
|
import { collectDoctorReportData } from "@/lib/doctor-report-data";
|
|
import { ALL_LEAF_IDS } from "@/lib/report-selection/catalogue";
|
|
import {
|
|
EMPTY_REPORT_SELECTION,
|
|
selectionFromLeaves,
|
|
} from "@/lib/report-selection/selection";
|
|
import { renderDoctorReportPdfBytes } from "@/lib/doctor-report-pdf-core";
|
|
import { getServerTranslator } from "@/lib/i18n/server-translator";
|
|
|
|
import { cookieJar, headerJar } from "./mock-next-headers";
|
|
import { getPrismaClient, truncateAllTables } from "./setup";
|
|
|
|
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);
|
|
},
|
|
})),
|
|
};
|
|
});
|
|
|
|
beforeEach(async () => {
|
|
await truncateAllTables(getPrismaClient());
|
|
cookieJar.clear();
|
|
headerJar.clear();
|
|
});
|
|
|
|
afterEach(() => {
|
|
vi.restoreAllMocks();
|
|
vi.unstubAllEnvs();
|
|
});
|
|
|
|
const RANGE = {
|
|
start: new Date("2026-01-01T00:00:00.000Z"),
|
|
end: new Date("2026-05-01T00:00:00.000Z"),
|
|
days: 120,
|
|
};
|
|
|
|
/**
|
|
* Seed a user plus one row of every measurement type the toggles
|
|
* gate. Returns the user id for the test to thread into the aggregator
|
|
* and PDF renderer.
|
|
*/
|
|
async function seedUserWithEveryDataType(username: string): Promise<string> {
|
|
const prisma = getPrismaClient();
|
|
const user = await prisma.user.create({
|
|
data: {
|
|
username,
|
|
email: `${username}@example.test`,
|
|
heightCm: 180,
|
|
},
|
|
});
|
|
const measuredAt = new Date("2026-03-01T08:00:00.000Z");
|
|
|
|
await prisma.measurement.createMany({
|
|
data: [
|
|
{
|
|
userId: user.id,
|
|
type: "WEIGHT",
|
|
value: 82.5,
|
|
unit: "kg",
|
|
measuredAt,
|
|
},
|
|
{
|
|
userId: user.id,
|
|
type: "BLOOD_PRESSURE_SYS",
|
|
value: 128,
|
|
unit: "mmHg",
|
|
measuredAt,
|
|
},
|
|
{
|
|
userId: user.id,
|
|
type: "BLOOD_PRESSURE_DIA",
|
|
value: 82,
|
|
unit: "mmHg",
|
|
measuredAt,
|
|
},
|
|
{
|
|
userId: user.id,
|
|
type: "PULSE",
|
|
value: 65,
|
|
unit: "bpm",
|
|
measuredAt,
|
|
},
|
|
// v1.18.0 module-gated data types (no `sections` toggle of their own).
|
|
{
|
|
userId: user.id,
|
|
type: "BLOOD_GLUCOSE",
|
|
value: 95,
|
|
unit: "mg/dL",
|
|
glucoseContext: "FASTING",
|
|
measuredAt,
|
|
},
|
|
{
|
|
userId: user.id,
|
|
type: "RECOVERY_SCORE",
|
|
value: 72,
|
|
unit: "score",
|
|
source: "WHOOP",
|
|
measuredAt,
|
|
},
|
|
{
|
|
userId: user.id,
|
|
type: "STRESS_SCORE",
|
|
value: 40,
|
|
unit: "score",
|
|
measuredAt,
|
|
},
|
|
{
|
|
userId: user.id,
|
|
type: "STRAIN_SCORE",
|
|
value: 12,
|
|
unit: "score",
|
|
measuredAt,
|
|
},
|
|
{
|
|
userId: user.id,
|
|
type: "ACTIVITY_STEPS",
|
|
value: 8200,
|
|
unit: "count",
|
|
measuredAt,
|
|
},
|
|
],
|
|
});
|
|
|
|
// Lab result — module `labs` owns these; the `labs` section toggle is ON by
|
|
// default so a present `labs` module surfaces the panel.
|
|
await prisma.labResult.create({
|
|
data: {
|
|
userId: user.id,
|
|
panel: "Lipids",
|
|
analyte: "LDL",
|
|
value: 110,
|
|
unit: "mg/dL",
|
|
takenAt: measuredAt,
|
|
},
|
|
});
|
|
|
|
await prisma.moodEntry.create({
|
|
data: {
|
|
userId: user.id,
|
|
score: 4,
|
|
mood: "GUT",
|
|
moodLoggedAt: measuredAt,
|
|
date: "2026-03-01",
|
|
},
|
|
});
|
|
|
|
// Medication compliance — one taken intake event against a scheduled
|
|
// medication. The ledger compliance builder (v1.17 W1a) only tallies
|
|
// medications that carry a schedule (no schedule = PRN/as-needed = no
|
|
// expected dose = excluded so the report never prints a fabricated
|
|
// 100 %), so the fixture must seed a window for the drug to appear in
|
|
// `data.compliance`.
|
|
const med = await prisma.medication.create({
|
|
data: {
|
|
userId: user.id,
|
|
name: "Metformin",
|
|
dose: "500 mg",
|
|
active: true,
|
|
schedules: {
|
|
create: [{ windowStart: "08:00", windowEnd: "10:00" }],
|
|
},
|
|
},
|
|
});
|
|
await prisma.medicationIntakeEvent.create({
|
|
data: {
|
|
userId: user.id,
|
|
medicationId: med.id,
|
|
scheduledFor: measuredAt,
|
|
takenAt: measuredAt,
|
|
},
|
|
});
|
|
|
|
return user.id;
|
|
}
|
|
|
|
/**
|
|
* Pull plain UTF-8 text out of the PDF byte stream. jsPDF's text
|
|
* operator stores the strings inline as `(...)` tokens, so a naive
|
|
* regex scan over the buffer is enough to assert presence/absence of a
|
|
* label — we don't need to actually decode the streams. False positives
|
|
* are tolerable because the assertions are negative ("doesn't contain
|
|
* `Stimmung`") and the strings are distinctive.
|
|
*/
|
|
function pdfContainsText(bytes: Uint8Array, needle: string): boolean {
|
|
const haystack = Buffer.from(bytes).toString("latin1");
|
|
return haystack.includes(needle);
|
|
}
|
|
|
|
describe("doctor-report — per-section toggles", () => {
|
|
it("drops mood data entirely when the mood leaf is not chosen", async () => {
|
|
const userId = await seedUserWithEveryDataType("dr-sections-mood-off");
|
|
|
|
const data = await collectDoctorReportData(
|
|
userId,
|
|
RANGE,
|
|
selectionFromLeaves([
|
|
"BLOOD_PRESSURE_SYS",
|
|
"BLOOD_PRESSURE_DIA",
|
|
"WEIGHT",
|
|
"PULSE",
|
|
"BODY_MASS_INDEX",
|
|
"MEDICATION_COMPLIANCE",
|
|
"SLEEP_DURATION",
|
|
]),
|
|
);
|
|
|
|
// The aggregator must NOT return mood data when the toggle is off.
|
|
// The contract: the data never leaves the DB row, so the JSON
|
|
// payload (this `data` object) is the canonical proof.
|
|
expect(data.mood).toBeNull();
|
|
|
|
// The PDF rendered from this data must not mention the German or
|
|
// English mood section header — both locales render against the
|
|
// same `data` payload so both must be clean.
|
|
const { t: tDe } = getServerTranslator("de");
|
|
const { t: tEn } = getServerTranslator("en");
|
|
const pdfDe = renderDoctorReportPdfBytes(data, {
|
|
t: tDe,
|
|
locale: "de",
|
|
timeFormat: "AUTO",
|
|
dateFormat: "AUTO",
|
|
});
|
|
const pdfEn = renderDoctorReportPdfBytes(data, {
|
|
t: tEn,
|
|
locale: "en",
|
|
timeFormat: "AUTO",
|
|
dateFormat: "AUTO",
|
|
});
|
|
|
|
expect(pdfContainsText(pdfDe, "Stimmung")).toBe(false);
|
|
expect(pdfContainsText(pdfEn, "Mood")).toBe(false);
|
|
});
|
|
|
|
it("includes mood data when the mood leaf is chosen by name", async () => {
|
|
const userId = await seedUserWithEveryDataType("dr-sections-mood-on");
|
|
|
|
const data = await collectDoctorReportData(
|
|
userId,
|
|
RANGE,
|
|
selectionFromLeaves(["MOOD"]),
|
|
);
|
|
|
|
expect(data.mood).not.toBeNull();
|
|
expect(data.mood?.count).toBe(1);
|
|
});
|
|
|
|
it("strips BP / weight / pulse / compliance when their leaves are not chosen", async () => {
|
|
const userId = await seedUserWithEveryDataType("dr-sections-others-off");
|
|
|
|
const data = await collectDoctorReportData(
|
|
userId,
|
|
RANGE,
|
|
selectionFromLeaves(["LAB_RESULTS"]),
|
|
);
|
|
|
|
expect(data.stats.BLOOD_PRESSURE_SYS).toBeUndefined();
|
|
expect(data.stats.BLOOD_PRESSURE_DIA).toBeUndefined();
|
|
expect(data.stats.WEIGHT).toBeUndefined();
|
|
expect(data.stats.PULSE).toBeUndefined();
|
|
expect(data.compliance).toEqual({});
|
|
expect(data.bmi).toBeNull();
|
|
expect(data.mood).toBeNull();
|
|
});
|
|
|
|
it("serves nothing at all for an empty selection", async () => {
|
|
// The case the release exists for. An account with data in every domain
|
|
// and a caller that named no leaf gets an empty record — not the
|
|
// "everything except mood and cycle" the old defaults produced.
|
|
const userId = await seedUserWithEveryDataType("dr-sections-defaults");
|
|
|
|
const data = await collectDoctorReportData(
|
|
userId,
|
|
RANGE,
|
|
EMPTY_REPORT_SELECTION,
|
|
);
|
|
|
|
expect(data.mood).toBeNull();
|
|
expect(data.stats).toEqual({});
|
|
expect(data.measurements).toEqual({});
|
|
expect(data.bmi).toBeNull();
|
|
expect(data.compliance).toEqual({});
|
|
expect(data.medications).toEqual([]);
|
|
expect(data.labResults).toBeNull();
|
|
expect(data.allergies).toBeNull();
|
|
expect(data.familyHistory).toBeNull();
|
|
expect(data.patient.username).toBeNull();
|
|
expect(data.patient.insurerName).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe("doctor-report — module enable/disable gating", () => {
|
|
// A fully-enabled module map (the default-on shape `resolveModuleMap` would
|
|
// return for an account that never toggled a module off).
|
|
const ALL_ON = {
|
|
cycle: true,
|
|
mood: true,
|
|
sleep: true,
|
|
glucose: true,
|
|
workouts: true,
|
|
recovery: true,
|
|
labs: true,
|
|
illness: true,
|
|
achievements: true,
|
|
coach: true,
|
|
insights: true,
|
|
medications: true,
|
|
doctorReport: true,
|
|
environment: true,
|
|
mcp: true,
|
|
inboundDocuments: true,
|
|
mentalHealth: true,
|
|
nutrients: true,
|
|
vaccinations: true,
|
|
timeline: true,
|
|
} as const;
|
|
|
|
it("includes every module's data when all modules are enabled", async () => {
|
|
const userId = await seedUserWithEveryDataType("dr-modules-all-on");
|
|
|
|
const data = await collectDoctorReportData(
|
|
userId,
|
|
RANGE,
|
|
selectionFromLeaves(ALL_LEAF_IDS),
|
|
{ moduleMap: { ...ALL_ON } },
|
|
);
|
|
|
|
expect(Object.keys(data.glucoseStats).length).toBeGreaterThan(0);
|
|
expect(data.measurements.ACTIVITY_STEPS).toBeDefined();
|
|
expect(data.measurements.BLOOD_GLUCOSE).toBeDefined();
|
|
expect(data.labResults).not.toBeNull();
|
|
expect(data.mood).not.toBeNull();
|
|
const scoreTypes = (data.wellnessScores ?? []).map((s) => s.type);
|
|
expect(scoreTypes).toEqual(
|
|
expect.arrayContaining([
|
|
"RECOVERY_SCORE",
|
|
"STRESS_SCORE",
|
|
"STRAIN_SCORE",
|
|
]),
|
|
);
|
|
});
|
|
|
|
it("excludes a disabled module's section/resources from the payload", async () => {
|
|
const userId = await seedUserWithEveryDataType("dr-modules-off");
|
|
|
|
const data = await collectDoctorReportData(
|
|
userId,
|
|
RANGE,
|
|
// Every leaf chosen at the report level, but the modules are off — the
|
|
// module gate wins, so none of these surface.
|
|
selectionFromLeaves(ALL_LEAF_IDS),
|
|
{
|
|
moduleMap: {
|
|
...ALL_ON,
|
|
glucose: false,
|
|
sleep: false,
|
|
workouts: false,
|
|
recovery: false,
|
|
labs: false,
|
|
mood: false,
|
|
},
|
|
},
|
|
);
|
|
|
|
// Glucose panel collapses entirely (stats + raw series).
|
|
expect(data.glucoseStats).toEqual({});
|
|
expect(data.glucoseRanges).toEqual({});
|
|
expect(data.measurements.BLOOD_GLUCOSE).toBeUndefined();
|
|
// Sleep series stripped (sections + module agree).
|
|
expect(data.measurements.SLEEP_DURATION).toBeUndefined();
|
|
// Workout activity series stripped.
|
|
expect(data.measurements.ACTIVITY_STEPS).toBeUndefined();
|
|
expect(data.stats.ACTIVITY_STEPS).toBeUndefined();
|
|
// Labs panel gone.
|
|
expect(data.labResults).toBeNull();
|
|
// Mood never assembled.
|
|
expect(data.mood).toBeNull();
|
|
// Recovery + strain wellness scores dropped (recovery + workouts off).
|
|
const scoreTypes = (data.wellnessScores ?? []).map((s) => s.type);
|
|
expect(scoreTypes).not.toContain("RECOVERY_SCORE");
|
|
expect(scoreTypes).not.toContain("STRESS_SCORE");
|
|
expect(scoreTypes).not.toContain("STRAIN_SCORE");
|
|
// Core clinical sections stay unconditional.
|
|
expect(data.stats.WEIGHT).toBeDefined();
|
|
expect(data.stats.BLOOD_PRESSURE_SYS).toBeDefined();
|
|
expect(data.stats.PULSE).toBeDefined();
|
|
expect(Object.keys(data.compliance).length).toBeGreaterThan(0);
|
|
});
|
|
|
|
it("gates recovery and workouts independently (recovery off, workouts on)", async () => {
|
|
const userId = await seedUserWithEveryDataType("dr-modules-recovery-off");
|
|
|
|
const data = await collectDoctorReportData(
|
|
userId,
|
|
RANGE,
|
|
selectionFromLeaves(ALL_LEAF_IDS),
|
|
{ moduleMap: { ...ALL_ON, recovery: false } },
|
|
);
|
|
|
|
const scoreTypes = (data.wellnessScores ?? []).map((s) => s.type);
|
|
// Recovery readiness scores gone…
|
|
expect(scoreTypes).not.toContain("RECOVERY_SCORE");
|
|
expect(scoreTypes).not.toContain("STRESS_SCORE");
|
|
// …but the workout-owned strain score + activity series stay.
|
|
expect(scoreTypes).toContain("STRAIN_SCORE");
|
|
expect(data.measurements.ACTIVITY_STEPS).toBeDefined();
|
|
});
|
|
});
|
|
|
|
describe("doctor-report — MedicationAdministration export cap", () => {
|
|
it("caps the administration set at the configured ceiling and flags the truncation", async () => {
|
|
// The default ceiling is 5000; pin the operator-configurable
|
|
// `FHIR_MAX_MEDICATION_ADMINISTRATIONS` to 1000 so the cap is exercised
|
|
// with a tractable row count (the cap is resolved per call).
|
|
vi.stubEnv("FHIR_MAX_MEDICATION_ADMINISTRATIONS", "1000");
|
|
const prisma = getPrismaClient();
|
|
const user = await prisma.user.create({
|
|
data: {
|
|
username: "dr-admin-cap",
|
|
email: "dr-admin-cap@example.test",
|
|
heightCm: 180,
|
|
},
|
|
});
|
|
const med = await prisma.medication.create({
|
|
data: {
|
|
userId: user.id,
|
|
name: "Metformin",
|
|
dose: "500 mg",
|
|
active: true,
|
|
},
|
|
});
|
|
|
|
// 1001 acted (taken) intakes spread across the window so the cap
|
|
// must trim exactly one — the OLDEST — keeping the most-recent 1000.
|
|
const rangeMs = RANGE.end.getTime() - RANGE.start.getTime();
|
|
const rows = Array.from({ length: 1001 }, (_, i) => {
|
|
const at = new Date(
|
|
RANGE.start.getTime() + Math.floor((rangeMs * i) / 1001),
|
|
);
|
|
return {
|
|
userId: user.id,
|
|
medicationId: med.id,
|
|
scheduledFor: at,
|
|
takenAt: at,
|
|
};
|
|
});
|
|
await prisma.medicationIntakeEvent.createMany({ data: rows });
|
|
|
|
const data = await collectDoctorReportData(
|
|
user.id,
|
|
RANGE,
|
|
selectionFromLeaves(["MEDICATION_ADMINISTRATIONS"]),
|
|
);
|
|
|
|
expect(data.medicationAdministrations).toBeDefined();
|
|
expect(data.medicationAdministrations?.length).toBe(1000);
|
|
expect(data.medicationAdministrationsTruncation).toEqual({
|
|
total: 1001,
|
|
included: 1000,
|
|
});
|
|
// The OLDEST row was dropped — the earliest surviving administration
|
|
// is strictly after the window start.
|
|
const first = data.medicationAdministrations?.[0];
|
|
expect(new Date(first!.effectiveAt).getTime()).toBeGreaterThan(
|
|
RANGE.start.getTime(),
|
|
);
|
|
});
|
|
|
|
it("leaves the set untouched (no truncation flag) below the cap", async () => {
|
|
const userId = await seedUserWithEveryDataType("dr-admin-no-cap");
|
|
|
|
const data = await collectDoctorReportData(
|
|
userId,
|
|
RANGE,
|
|
selectionFromLeaves(["MEDICATION_ADMINISTRATIONS"]),
|
|
);
|
|
|
|
expect(data.medicationAdministrations?.length).toBe(1);
|
|
expect(data.medicationAdministrationsTruncation ?? null).toBeNull();
|
|
});
|
|
});
|