mirror of
https://github.com/MBombeck/HealthLog.git
synced 2026-11-16 07:13:29 +00:00
Merge branch 'main' into feat/encounter-phase-2
This commit is contained in:
commit
f28c6df861
43 files changed
+5333
-7
No files matched your search
@@ -175,6 +175,86 @@ describe("level-A blocks reach the feature set with their own ages", () => {
|
||||
expect(features.mood?.dimensionsAsOfNote).toBeUndefined();
|
||||
});
|
||||
|
||||
it("carries the day's forecast with its own age, and its own instruction", async () => {
|
||||
await seedUser();
|
||||
// Enough rated days that the account is above the forecast floor: the read
|
||||
// path re-checks the ladder and refuses below it, stale row or not, so a
|
||||
// one-entry account would (correctly) get an absence here rather than the
|
||||
// present forecast this case is about. One statement rather than a loop of
|
||||
// awaits, to keep the write short.
|
||||
await getPrismaClient().moodEntry.createMany({
|
||||
data: Array.from({ length: 35 }, (_, d) => ({
|
||||
userId: USER,
|
||||
date: shiftDateKey(todayKey(), -d),
|
||||
tz: TZ,
|
||||
mood: "GUT",
|
||||
score: 4,
|
||||
moodA1: 7,
|
||||
stressA2: 3,
|
||||
source: "MANUAL" as const,
|
||||
moodLoggedAt: new Date(Date.now() - d * DAY_MS),
|
||||
})),
|
||||
});
|
||||
// A forecast about the day before yesterday. Written straight to the
|
||||
// table: the job's own path is proven in `mood-prognosis-ladder.test.ts`,
|
||||
// and what this case is about is what the assistant is handed.
|
||||
await getPrismaClient().moodPrediction.create({
|
||||
data: {
|
||||
userId: USER,
|
||||
date: shiftDateKey(todayKey(), -3),
|
||||
predicted: 5.4,
|
||||
ciLow: 4.1,
|
||||
ciHigh: 6.8,
|
||||
n: 42,
|
||||
modelVersion: "mood-ridge-1",
|
||||
features: JSON.stringify([
|
||||
{ feature: "dimension:a2", contribution: 0.9 },
|
||||
]),
|
||||
computedAt: new Date(Date.now() - 3 * DAY_MS),
|
||||
},
|
||||
});
|
||||
|
||||
const features = await extractFeatures(USER, false);
|
||||
const prognosis = features.mood?.prognosis;
|
||||
expect(
|
||||
prognosis,
|
||||
"features.mood carries no prognosis block; the assistant sees neither the value nor the fact that there is none",
|
||||
).toBeDefined();
|
||||
expect(prognosis!.present).toBe(true);
|
||||
expect(prognosis!.predicted).toBe(5.4);
|
||||
expect(prognosis!.n).toBe(42);
|
||||
expect(prognosis!.ciLow).toBe(4.1);
|
||||
expect(prognosis!.ciHigh).toBe(6.8);
|
||||
// Three days old: the same freshness rule the dimensions use, from the
|
||||
// same module, so nothing may state it as today.
|
||||
expect(prognosis!.daysAgo).toBe(3);
|
||||
expect(prognosis!.current).toBe(false);
|
||||
expect(
|
||||
prognosis!.staleNotice,
|
||||
"a stale forecast ships without the instruction that makes it safe to read",
|
||||
).toBeTruthy();
|
||||
expect(prognosis!.staleNotice).toContain(shiftDateKey(todayKey(), -3));
|
||||
expect(prognosis!.staleNotice!.toLowerCase()).toContain("do not describe");
|
||||
// And the wording rule rides with the values rather than being inferred.
|
||||
expect(prognosis!.note.toLowerCase()).toContain("counterfactual");
|
||||
expect(prognosis!.note.toLowerCase()).toContain("never merge");
|
||||
});
|
||||
|
||||
it("states the absence of a forecast rather than omitting it", async () => {
|
||||
await seedUser();
|
||||
await seedEntry(0, { mood: "GUT", score: 4, a1: 7 });
|
||||
|
||||
const features = await extractFeatures(USER, false);
|
||||
const prognosis = features.mood?.prognosis;
|
||||
expect(prognosis).toBeDefined();
|
||||
// Absence is a field, not a missing key: a model told "there is none yet"
|
||||
// says so, and a model told nothing estimates one.
|
||||
expect(prognosis!.present).toBe(false);
|
||||
expect(prognosis!.reason).toBe("no-output-yet");
|
||||
expect(prognosis!.entries).toBe(1);
|
||||
expect(prognosis!.predicted).toBeUndefined();
|
||||
});
|
||||
|
||||
it("leaves the legacy scale line untouched", async () => {
|
||||
await seedUser();
|
||||
await seedEntry(0, { mood: "GUT", score: 4, a1: 7 });
|
||||
|
||||
@@ -0,0 +1,432 @@
|
||||
/**
|
||||
* The ladder, the job and the route, against real Postgres and the real rows.
|
||||
*
|
||||
* The unit tests prove the arithmetic and the gates in isolation. This proves
|
||||
* the assembly: that an account one day short of the threshold really gets
|
||||
* nothing written, that the day it crosses really gets a row, that switching
|
||||
* the module off really takes the rows away again, and that deleting back
|
||||
* below the threshold does not leave a forecast standing with a fresh date on
|
||||
* it. Every one of those is a claim about what is IN THE TABLE, so every
|
||||
* assertion reads the table rather than a return value.
|
||||
*
|
||||
* It is also the automated half of the ladder walk the phase plan asks a human
|
||||
* to do. What is left for a browser is what a browser is for: that the band is
|
||||
* legible at 390 px and that the count sits beside the number rather than in a
|
||||
* tooltip.
|
||||
*/
|
||||
import { NextRequest } from "next/server";
|
||||
import { beforeEach, describe, expect, it, vi } from "vitest";
|
||||
|
||||
import { cookieJar } from "./mock-next-headers";
|
||||
import { getPrismaClient, switchSessionTo, truncateAllTables } from "./setup";
|
||||
|
||||
const USER = "user-mood-prognosis";
|
||||
const TZ = "Europe/Berlin";
|
||||
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),
|
||||
}));
|
||||
|
||||
/** Fixed clock: a ladder test that slides with the calendar is a date bomb. */
|
||||
const NOW = new Date("2026-08-08T09:00:00.000Z");
|
||||
|
||||
function dayKey(daysAgo: number): string {
|
||||
return new Date(NOW.getTime() - daysAgo * DAY_MS).toISOString().slice(0, 10);
|
||||
}
|
||||
|
||||
async function seedUser(): Promise<void> {
|
||||
await getPrismaClient().user.create({
|
||||
data: {
|
||||
id: USER,
|
||||
username: "mood-prognosis",
|
||||
email: "mood-prognosis@example.test",
|
||||
timezone: TZ,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* `count` consecutive days, each carrying a rating and a stress value the
|
||||
* rating follows. A clean relationship on purpose: the point of this file is
|
||||
* the plumbing, and a fixture the screening refuses would test the refusal
|
||||
* path twice and the write path never.
|
||||
*/
|
||||
async function seedDays(count: number): Promise<void> {
|
||||
for (let i = 0; i < count; i++) {
|
||||
const stress = i % 11;
|
||||
await getPrismaClient().moodEntry.create({
|
||||
data: {
|
||||
userId: USER,
|
||||
date: dayKey(i),
|
||||
tz: TZ,
|
||||
mood: "OKAY",
|
||||
score: 3,
|
||||
moodA1: Math.round(0.8 * (10 - stress) + 1),
|
||||
stressA2: stress,
|
||||
source: "MANUAL",
|
||||
moodLoggedAt: new Date(NOW.getTime() - i * DAY_MS),
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
async function runJob() {
|
||||
const { runMoodPrognosisRefresh } =
|
||||
await import("@/lib/jobs/mood-prognosis-refresh");
|
||||
return runMoodPrognosisRefresh(NOW);
|
||||
}
|
||||
|
||||
function storedRows() {
|
||||
return getPrismaClient().moodPrediction.findMany({
|
||||
where: { userId: USER },
|
||||
orderBy: { date: "asc" },
|
||||
});
|
||||
}
|
||||
|
||||
beforeEach(async () => {
|
||||
await truncateAllTables(getPrismaClient());
|
||||
cookieJar.clear();
|
||||
});
|
||||
|
||||
describe("the minimum-n ladder, end to end", () => {
|
||||
it("writes nothing at one day short of the threshold, and says why", async () => {
|
||||
await seedUser();
|
||||
await seedDays(29);
|
||||
|
||||
const summary = await runJob();
|
||||
expect(summary.refreshed).toBe(0);
|
||||
// The account is not in the cohort at all: the job's cheap cut is the same
|
||||
// threshold, so an account a day short is never even read. The next case
|
||||
// is the other half of the evidence — one more day and `scanned` is 1, so
|
||||
// this zero is the cut landing in the right place rather than a sweep that
|
||||
// matched nothing.
|
||||
expect(summary.scanned).toBe(0);
|
||||
expect(await storedRows()).toEqual([]);
|
||||
|
||||
const { readMoodPrognosis } =
|
||||
await import("@/lib/analytics/mood-prognosis/read");
|
||||
const reading = await readMoodPrognosis(USER, NOW, TZ);
|
||||
expect(reading.present).toBe(false);
|
||||
if (!reading.present) {
|
||||
expect(reading.reason).toBe("learning-phase");
|
||||
expect(reading.entries).toBe(29);
|
||||
expect(reading.nextThreshold).toBe(30);
|
||||
}
|
||||
});
|
||||
|
||||
it("writes a banded, counted, provisional forecast on the day it crosses", async () => {
|
||||
await seedUser();
|
||||
await seedDays(30);
|
||||
|
||||
const summary = await runJob();
|
||||
expect(summary.scanned).toBe(1);
|
||||
expect(summary.refreshed).toBe(1);
|
||||
|
||||
const rows = await storedRows();
|
||||
expect(rows.length).toBeGreaterThan(0);
|
||||
// The trailing window, not the whole year of days.
|
||||
expect(rows.length).toBeLessThanOrEqual(7);
|
||||
|
||||
for (const row of rows) {
|
||||
expect(row.predicted).toBeGreaterThanOrEqual(0);
|
||||
expect(row.predicted).toBeLessThanOrEqual(10);
|
||||
// The band and the count are part of the value, not decoration.
|
||||
expect(row.ciLow).not.toBeNull();
|
||||
expect(row.ciHigh).not.toBeNull();
|
||||
expect(row.ciLow!).toBeLessThanOrEqual(row.predicted);
|
||||
expect(row.ciHigh!).toBeGreaterThanOrEqual(row.predicted);
|
||||
expect(row.n).toBe(30);
|
||||
expect(row.modelVersion).toBe("mood-ridge-1");
|
||||
// The stored evidence the explanation is generated from.
|
||||
const contributions = JSON.parse(row.features) as Array<{
|
||||
feature: string;
|
||||
contribution: number;
|
||||
}>;
|
||||
expect(contributions.length).toBeGreaterThan(0);
|
||||
expect(contributions[0].feature).toBe("dimension:a2");
|
||||
expect(typeof contributions[0].contribution).toBe("number");
|
||||
}
|
||||
|
||||
const { readMoodPrognosis } =
|
||||
await import("@/lib/analytics/mood-prognosis/read");
|
||||
const reading = await readMoodPrognosis(USER, NOW, TZ);
|
||||
expect(reading.present).toBe(true);
|
||||
if (reading.present) {
|
||||
// Thirty days is a forecast, and a forecast at thirty days is labelled.
|
||||
expect(reading.provisional).toBe(true);
|
||||
expect(reading.stage).toBe("provisional");
|
||||
expect(reading.n).toBe(30);
|
||||
// The self-assessment is returned unchanged beside it, never merged.
|
||||
const entry = await getPrismaClient().moodEntry.findFirstOrThrow({
|
||||
where: { userId: USER, date: reading.date },
|
||||
});
|
||||
expect(reading.selfAssessment).toBe(entry.moodA1);
|
||||
expect(reading.deviation).not.toBeNull();
|
||||
}
|
||||
});
|
||||
|
||||
it("drops the provisional label once the account has enough days", async () => {
|
||||
await seedUser();
|
||||
await seedDays(70);
|
||||
await runJob();
|
||||
|
||||
const { readMoodPrognosis } =
|
||||
await import("@/lib/analytics/mood-prognosis/read");
|
||||
const reading = await readMoodPrognosis(USER, NOW, TZ);
|
||||
expect(reading.present).toBe(true);
|
||||
if (reading.present) {
|
||||
expect(reading.provisional).toBe(false);
|
||||
expect(reading.stage).toBe("regular");
|
||||
expect(reading.seasonalUnlocked).toBe(false);
|
||||
}
|
||||
});
|
||||
|
||||
it("computes nothing and stores nothing while the mood module is off", async () => {
|
||||
await seedUser();
|
||||
await seedDays(40);
|
||||
await runJob();
|
||||
expect((await storedRows()).length).toBeGreaterThan(0);
|
||||
|
||||
await getPrismaClient().user.update({
|
||||
where: { id: USER },
|
||||
data: { modulePreferencesJson: { mood: false } },
|
||||
});
|
||||
|
||||
const summary = await runJob();
|
||||
expect(summary.moduleOff).toBe(1);
|
||||
expect(summary.refreshed).toBe(0);
|
||||
// And the rows it wrote before are gone: a forecast that outlives the
|
||||
// switch that turned its module off is a claim nobody asked for.
|
||||
expect(await storedRows()).toEqual([]);
|
||||
});
|
||||
|
||||
it("clears a stale forecast when the account falls back below the threshold", async () => {
|
||||
await seedUser();
|
||||
await seedDays(40);
|
||||
await runJob();
|
||||
const before = await storedRows();
|
||||
expect(before.length).toBeGreaterThan(0);
|
||||
|
||||
// Delete back under the threshold. The account is no longer in the
|
||||
// eligibility half of the cohort at all, so the pass only reaches it
|
||||
// through the rows it already holds.
|
||||
await getPrismaClient().moodEntry.deleteMany({
|
||||
where: { userId: USER, date: { gte: dayKey(28) } },
|
||||
});
|
||||
|
||||
const summary = await runJob();
|
||||
expect(summary.scanned).toBe(1);
|
||||
expect(summary.refused).toBe(1);
|
||||
expect(
|
||||
await storedRows(),
|
||||
"the forecast outlived its own eligibility — a stale claim with a fresh date on it",
|
||||
).toEqual([]);
|
||||
});
|
||||
|
||||
it("replaces rather than accumulates across passes", async () => {
|
||||
await seedUser();
|
||||
await seedDays(40);
|
||||
await runJob();
|
||||
const first = await storedRows();
|
||||
|
||||
// A row from a pass that will not be repeated: an older day, written by
|
||||
// hand the way a previous window would have left it.
|
||||
await getPrismaClient().moodPrediction.create({
|
||||
data: {
|
||||
userId: USER,
|
||||
date: dayKey(200),
|
||||
predicted: 5,
|
||||
ciLow: 4,
|
||||
ciHigh: 6,
|
||||
n: 99,
|
||||
modelVersion: "mood-ridge-0",
|
||||
features: "[]",
|
||||
computedAt: new Date(NOW.getTime() - 200 * DAY_MS),
|
||||
},
|
||||
});
|
||||
|
||||
await runJob();
|
||||
const after = await storedRows();
|
||||
expect(after.map((r) => r.date)).toEqual(first.map((r) => r.date));
|
||||
expect(after.some((r) => r.modelVersion === "mood-ridge-0")).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe("GET /api/mood/prognosis", () => {
|
||||
/**
|
||||
* A signed-in browser session.
|
||||
*
|
||||
* The expiry is off the REAL clock, not the fixture's: the seeded days are
|
||||
* dated against `NOW` so the ladder cannot slide with the calendar, but a
|
||||
* session stamped from a fixed instant expires the moment the wall clock
|
||||
* passes it, and every route then answers 401 for a reason that has nothing
|
||||
* to do with what the case is about.
|
||||
*
|
||||
* `actingOn` is passed only for a delegate. Switching an owner's session
|
||||
* into their own record would make the request a delegated one against a
|
||||
* grant that does not exist, and the refusal would look like the scope
|
||||
* refusal this file is trying to prove.
|
||||
*/
|
||||
async function signIn(userId: string, actingOn?: string) {
|
||||
const session = await getPrismaClient().session.create({
|
||||
data: {
|
||||
userId,
|
||||
expiresAt: new Date(Date.now() + 60 * 60 * 1000),
|
||||
},
|
||||
});
|
||||
cookieJar.set("healthlog_session", session.id);
|
||||
if (actingOn) await switchSessionTo(session.id, actingOn);
|
||||
return session;
|
||||
}
|
||||
|
||||
it("answers the owner with both readings", async () => {
|
||||
await seedUser();
|
||||
await seedDays(40);
|
||||
await runJob();
|
||||
await signIn(USER);
|
||||
|
||||
const { GET } = await import("@/app/api/mood/prognosis/route");
|
||||
const res = await GET(
|
||||
new NextRequest("http://localhost/api/mood/prognosis"),
|
||||
);
|
||||
expect(res.status).toBe(200);
|
||||
const body = (await res.json()) as {
|
||||
data: { present: boolean; n: number; predicted: number; ciLow: number };
|
||||
};
|
||||
expect(body.data.present).toBe(true);
|
||||
expect(body.data.n).toBe(40);
|
||||
expect(typeof body.data.predicted).toBe("number");
|
||||
expect(typeof body.data.ciLow).toBe("number");
|
||||
});
|
||||
|
||||
it("refuses below the floor even while a stale row survives, and never emits an out-of-enum stage", async () => {
|
||||
// The gap the read path has to close on its own. The job runs nightly, so
|
||||
// between an entry deletion and the next 04:35 pass a MoodPrediction row
|
||||
// outlives its own eligibility. If the read path trusted the row it would
|
||||
// answer present:true with a value the account no longer has the data to
|
||||
// support — and with stage "insufficient", which is not in the published
|
||||
// enum, so a strict client decode fails the whole payload. The read path
|
||||
// must agree with the job's own stale rule: below the floor is absence.
|
||||
await seedUser();
|
||||
await seedDays(40);
|
||||
await runJob();
|
||||
expect((await storedRows()).length).toBeGreaterThan(0);
|
||||
|
||||
// Delete back to 20 rated days — under the 30-day forecast floor, but
|
||||
// still inside the learning band, so the refusal reason is a real rung
|
||||
// rather than the empty-account one. Deliberately DO NOT run the job: the
|
||||
// point is what the route answers in the window before the sweep clears
|
||||
// the row. The existing "clears a stale forecast" case runs the job before
|
||||
// reading, which is exactly why it never saw this.
|
||||
await getPrismaClient().moodEntry.deleteMany({
|
||||
where: { userId: USER, date: { gte: dayKey(20) } },
|
||||
});
|
||||
expect(
|
||||
(await storedRows()).length,
|
||||
"the row must still be on disk — otherwise this proves nothing about the read path",
|
||||
).toBeGreaterThan(0);
|
||||
|
||||
await signIn(USER);
|
||||
const { GET } = await import("@/app/api/mood/prognosis/route");
|
||||
const res = await GET(
|
||||
new NextRequest("http://localhost/api/mood/prognosis"),
|
||||
);
|
||||
expect(res.status).toBe(200);
|
||||
const body = (await res.json()) as {
|
||||
data: {
|
||||
present: boolean;
|
||||
reason?: string;
|
||||
stage?: string;
|
||||
predicted?: number;
|
||||
};
|
||||
};
|
||||
expect(
|
||||
body.data.present,
|
||||
"the read path served a forecast to an account below every floor",
|
||||
).toBe(false);
|
||||
expect(body.data).not.toHaveProperty("predicted");
|
||||
// The out-of-enum stage a strict Codable decode chokes on must never leave
|
||||
// the route at all.
|
||||
expect(body.data.stage).toBeUndefined();
|
||||
expect(body.data.reason).toBe("learning-phase");
|
||||
});
|
||||
|
||||
it("refuses a delegate whose grant does not open the whole record", async () => {
|
||||
await seedUser();
|
||||
await seedDays(40);
|
||||
await runJob();
|
||||
const rows = await storedRows();
|
||||
expect(rows.length).toBeGreaterThan(0);
|
||||
|
||||
const delegate = await getPrismaClient().user.create({
|
||||
data: {
|
||||
id: "user-mood-prognosis-delegate",
|
||||
username: "mood-prognosis-delegate",
|
||||
email: "mood-prognosis-delegate@example.test",
|
||||
timezone: TZ,
|
||||
},
|
||||
});
|
||||
await getPrismaClient().accountGrant.create({
|
||||
data: {
|
||||
grantorId: USER,
|
||||
granteeId: delegate.id,
|
||||
access: "READ",
|
||||
acceptedAt: new Date(),
|
||||
// Only the mind section. The forecast reads across sections and names
|
||||
// what it read, so it is not a mind payload.
|
||||
scopeJson: ["mind"] as never,
|
||||
},
|
||||
});
|
||||
await signIn(delegate.id, USER);
|
||||
|
||||
const { GET } = await import("@/app/api/mood/prognosis/route");
|
||||
const res = await GET(
|
||||
new NextRequest("http://localhost/api/mood/prognosis"),
|
||||
);
|
||||
expect(res.status).toBe(403);
|
||||
|
||||
// Asserted on the bytes, not on a parsed field: the point is that not one
|
||||
// figure of the owner's reached the response.
|
||||
const raw = await res.text();
|
||||
expect(raw).not.toContain("predicted");
|
||||
expect(raw).not.toContain("ciLow");
|
||||
expect(raw).not.toContain("dimension:a2");
|
||||
expect(raw).not.toContain(String(rows[0].n));
|
||||
expect(raw).not.toContain(rows[0].date);
|
||||
});
|
||||
|
||||
it("blanks the surface when the mood module is off", async () => {
|
||||
await seedUser();
|
||||
await seedDays(40);
|
||||
await runJob();
|
||||
await getPrismaClient().user.update({
|
||||
where: { id: USER },
|
||||
data: { modulePreferencesJson: { mood: false } },
|
||||
});
|
||||
await signIn(USER);
|
||||
|
||||
const { GET } = await import("@/app/api/mood/prognosis/route");
|
||||
const res = await GET(
|
||||
new NextRequest("http://localhost/api/mood/prognosis"),
|
||||
);
|
||||
expect(res.status).toBe(403);
|
||||
});
|
||||
});
|
||||
Reference in new issue
Block a user