Files
HealthLog/tests/integration/coach-history-reach.test.ts
T
Marc-André Bombeck b6da360856 refactor(db): drop the runtime schema mirror
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.
2026-11-03 20:32:35 +01:00

249 lines
7.8 KiB
TypeScript

/**
* The Coach lookback limit against real Postgres.
*
* The guard in `coach-history-reach-guard.test.ts` mocks every reader and
* proves the executor hands the limit on. This file proves the readers obey
* it: real builders, real SQL, an account with blood pressure from 200 days
* ago and from the last fortnight, weight and a lab panel only from 200 days
* ago, and a limit of 90 days saved in the account's Coach preferences.
*
* The old readings carry values that never occur in the recent ones (a
* systolic of 187, a weight of 93.7 kg, an LDL of 211), so any leak shows up
* as that number in what the Coach is given. The same calls with no limit
* ("All", the default) still return them, which pins that the default kept
* its behaviour.
*/
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { getPrismaClient, truncateAllTables } from "./setup";
import { executeCoachTool } from "@/lib/ai/coach/tools/executor";
import {
buildCoachDataInventory,
renderDataInventory,
} from "@/lib/ai/coach/tools/inventory";
import { __resetCoachSnapshotCacheForTests } from "@/lib/ai/coach/snapshot";
import { readCoachReach } from "@/lib/ai/coach/history-reach-read";
import { UNBOUNDED_REACH } from "@/lib/ai/coach/history-reach";
import { assembleTurnContext } from "@/lib/ai/coach/turn/context";
vi.mock("@/lib/jobs/boss-instance", () => ({
getGlobalBoss: vi.fn(() => null),
}));
const DAY = 86_400_000;
const OLD_SYS = 187;
const OLD_WEIGHT = 93.7;
const OLD_LDL = 211;
let seq = 0;
async function seedAccount(defaultWindow: string | null) {
seq += 1;
const prisma = getPrismaClient();
const user = await prisma.user.create({
data: {
username: `history-reach-${seq}`,
email: `history-reach-${seq}@example.test`,
role: "USER",
timezone: "UTC",
createdAt: new Date(Date.now() - 400 * DAY),
...(defaultWindow ? { coachPrefsJson: { defaultWindow } } : {}),
},
});
const now = Date.now();
const bp = (daysAgo: number, sys: number, dia: number) => [
{
userId: user.id,
type: "BLOOD_PRESSURE_SYS" as const,
value: sys,
unit: "mmHg",
measuredAt: new Date(now - daysAgo * DAY),
},
{
userId: user.id,
type: "BLOOD_PRESSURE_DIA" as const,
value: dia,
unit: "mmHg",
measuredAt: new Date(now - daysAgo * DAY),
},
];
await prisma.measurement.createMany({
data: [
...bp(200, OLD_SYS, 109),
...bp(201, OLD_SYS, 109),
...bp(202, OLD_SYS, 109),
...bp(10, 121, 79),
...bp(11, 122, 78),
...bp(12, 123, 77),
...bp(13, 124, 76),
...[200, 201, 202].map((daysAgo) => ({
userId: user.id,
type: "WEIGHT" as const,
value: OLD_WEIGHT,
unit: "kg",
measuredAt: new Date(now - daysAgo * DAY),
})),
],
});
await prisma.labResult.create({
data: {
userId: user.id,
analyte: "LDL",
value: OLD_LDL,
unit: "mg/dL",
takenAt: new Date(now - 200 * DAY),
},
});
return user;
}
function call(
userId: string,
name: string,
args: Record<string, unknown>,
reach: Awaited<ReturnType<typeof readCoachReach>>,
) {
return executeCoachTool({
userId,
name,
rawArguments: JSON.stringify(args),
fallbackWindow: "allTime",
reach,
});
}
beforeEach(async () => {
await truncateAllTables(getPrismaClient());
__resetCoachSnapshotCacheForTests();
});
afterEach(() => {
__resetCoachSnapshotCacheForTests();
});
describe("a 90-day lookback limit", () => {
it("reads the saved limit from the account's Coach preferences", async () => {
const user = await seedAccount("last90days");
expect(await readCoachReach(user.id)).toEqual({
window: "last90days",
days: 90,
});
});
it("serves only the recent readings when the model asks for all time", async () => {
const user = await seedAccount("last90days");
const reach = await readCoachReach(user.id);
const result = await call(
user.id,
"get_metric_series",
{ metric: "bp", window: "allTime" },
reach,
);
expect(result.present).toBe(true);
const payload = JSON.stringify(result.data);
expect(payload).toContain("121");
expect(payload).not.toContain(String(OLD_SYS));
});
it("names a history entirely beyond the limit without any figure from it", async () => {
const user = await seedAccount("last90days");
const reach = await readCoachReach(user.id);
const result = await call(
user.id,
"get_metric_series",
{ metric: "weight", window: "allTime" },
reach,
);
expect(result).toMatchObject({ present: false, reason: "outside_reach" });
expect(result.available).toBeUndefined();
expect(JSON.stringify(result)).not.toContain(String(OLD_WEIGHT));
});
it("refuses a year-ago table and an earlier lab panel", async () => {
const user = await seedAccount("last90days");
const reach = await readCoachReach(user.id);
const table = await call(
user.id,
"get_metric_table",
{ metric: "bp", window: "last30days", period: "yearAgo" },
reach,
);
expect(table).toMatchObject({ present: false, reason: "outside_reach" });
const labs = await call(user.id, "get_labs", {}, reach);
expect(labs).toMatchObject({ present: false, reason: "outside_reach" });
expect(JSON.stringify(labs)).not.toContain(String(OLD_LDL));
});
it("marks the old domains beyond the lookback in the inventory, with no figures", async () => {
const user = await seedAccount("last90days");
const reach = await readCoachReach(user.id);
const inventory = await buildCoachDataInventory(
user.id,
{ window: "allTime" },
reach,
);
expect(inventory.window).toBe("last90days");
expect(inventory.lookbackLimit).toBe("last90days");
const weight = inventory.entries.find((e) => e.metric === "weight");
expect(weight?.availability).toEqual({
state: "outside_reach",
reachableWithWindow: null,
});
const text = renderDataInventory(inventory);
expect(text).toContain("BEYOND LOOKBACK");
expect(text).not.toContain(String(OLD_WEIGHT));
expect(text).not.toContain(String(OLD_SYS));
});
it("caps a wider window the client sends with the turn", async () => {
const user = await seedAccount("last90days");
const ctx = await assembleTurnContext({
userId: user.id,
locale: "en",
message: "How was my blood pressure?",
scope: { window: "allTime" },
guidedQuestion: undefined,
workoutId: undefined,
conversation: {
conversationId: "history-reach-conversation",
priorTurns: [],
priorSummary: null,
} as never,
});
expect(ctx.reach.days).toBe(90);
expect(ctx.effectiveScope?.window).toBe("last90days");
expect(ctx.snapshot.snapshotJson).not.toContain(String(OLD_SYS));
expect(ctx.snapshot.snapshotJson).not.toContain(String(OLD_WEIGHT));
expect(ctx.snapshot.snapshotJson).not.toContain(String(OLD_LDL));
});
});
describe("no limit (the default)", () => {
it("still reads the whole history", async () => {
const user = await seedAccount(null);
const reach = await readCoachReach(user.id);
expect(reach).toEqual(UNBOUNDED_REACH);
const bp = await call(
user.id,
"get_metric_series",
{ metric: "bp", window: "allTime" },
reach,
);
expect(bp.present).toBe(true);
expect(JSON.stringify(bp.data)).toContain(String(OLD_SYS));
const labs = await call(user.id, "get_labs", {}, reach);
expect(labs.present).toBe(true);
expect(JSON.stringify(labs.data)).toContain(String(OLD_LDL));
const table = await call(
user.id,
"get_metric_table",
{ metric: "bp", window: "last30days", period: "yearAgo" },
reach,
);
expect(table.reason).not.toBe("outside_reach");
});
});