/** * Integration suite for the heart-rate curve on `GET /api/workouts/{id}`. * * The curve is the one part of the workout-detail envelope that is * assembled from rows the workout does not own: when a session carries no * stored sensor stream, the server reconstructs it from the account's raw * `PULSE` measurements around the session. Two boundaries decide whether * that reconstruction is honest, and neither is provable from a unit test * with a mocked Prisma: * * - the WINDOW. A reading taken after the session ended is not part of * the session. The query pads by five minutes so a boundary reading * still lands in the first / last bucket, and the fold then clamps to * the session itself — a pad reading must not extend the curve past * the finish. * - the OWNER. The measurement read is scoped to the calling account. * Another account's pulse at the same wall-clock minute must not * enter this curve. * * Both run through the real route against a real Postgres, and the * fixture places a reading on the far side of each boundary with a bpm * value no in-window reading has, so a leak is visible in the numbers * rather than only in a count. */ import { NextRequest } from "next/server"; import { beforeEach, describe, expect, it, vi } from "vitest"; import { cookieJar, headerJar } from "./mock-next-headers"; import { getPrismaClient, truncateAllTables } from "./setup"; process.env.ENCRYPTION_KEY = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"; const TEST_USER_ID = "user-workout-hr-series"; const OTHER_USER_ID = "user-workout-hr-series-other"; 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), })); const { GET } = await import("@/app/api/workouts/[id]/route"); /** * Session window: 07:00 → 07:30 UTC ten days ago. The pulse-window fallback * only reconstructs a curve inside the dense-intraday retention horizon * (`DENSE_INTRADAY_RETENTION_DAYS`, 90 days), so the fixture day must stay * relative to the test run — a fixed calendar date silently aged past the * horizon and turned every curve assertion red on day 91. */ const SESSION_DAY = new Date(Date.now() - 10 * 24 * 60 * 60 * 1000) .toISOString() .slice(0, 10); const STARTED_AT = new Date(`${SESSION_DAY}T07:00:00.000Z`); const ENDED_AT = new Date(`${SESSION_DAY}T07:30:00.000Z`); const SPAN_SEC = 1800; /** * In-window readings sit in this band; every out-of-window reading is * placed outside it, so an assertion on the curve's bpm bounds names any * leak directly. */ const IN_WINDOW_LOW = 120; const IN_WINDOW_HIGH = 168; /** After the finish but inside the query's five-minute pad. */ const PAD_TAIL_BPM = 44; /** Well outside the padded window on either side. */ const FAR_BEFORE_BPM = 201; const FAR_AFTER_BPM = 51; /** Another account's reading in the middle of this session. */ const FOREIGN_BPM = 199; interface HrSeriesPoint { tSec: number; mean: number; min: number; max: number; } interface WorkoutDetailBody { data: { id: string; hrSeries: { source: string; bucketSec: number; envelope: boolean; points: HrSeriesPoint[]; } | null; } | null; error: string | null; } async function createUser(id: string, username: string) { await getPrismaClient().user.create({ data: { id, username, email: `${username}@example.test` }, }); } beforeEach(async () => { await truncateAllTables(getPrismaClient()); cookieJar.clear(); headerJar.clear(); await createUser(TEST_USER_ID, "workout-hr-series"); await createUser(OTHER_USER_ID, "workout-hr-series-other"); const session = await getPrismaClient().session.create({ data: { userId: TEST_USER_ID, expiresAt: new Date(Date.now() + 60 * 60 * 1000), }, }); cookieJar.set("healthlog_session", session.id); }); /** * The session under test, with no stored sample stream — so the route has * to reconstruct the curve from `PULSE` rows and the boundaries above are * the ones that decide what it sees. */ async function createWorkout(): Promise { const row = await getPrismaClient().workout.create({ data: { userId: TEST_USER_ID, sportType: "running", startedAt: STARTED_AT, endedAt: ENDED_AT, durationSec: SPAN_SEC, avgHeartRate: 144, maxHeartRate: IN_WINDOW_HIGH, source: "MANUAL", }, select: { id: true }, }); return row.id; } function pulseRow(userId: string, offsetSec: number, value: number) { return { userId, type: "PULSE" as const, value, unit: "bpm", measuredAt: new Date(STARTED_AT.getTime() + offsetSec * 1000), }; } /** * A dense in-window sweep plus one reading on the far side of each * boundary. The sweep alternates across the in-window band so the fold * has a real shape to carry. */ async function seedPulse() { const rows = [] as ReturnType[]; for (let offset = 0; offset < SPAN_SEC; offset += 5) { const swing = Math.round( ((IN_WINDOW_HIGH - IN_WINDOW_LOW) / 2) * (1 + Math.sin((offset / SPAN_SEC) * Math.PI * 4)), ); rows.push(pulseRow(TEST_USER_ID, offset, IN_WINDOW_LOW + swing)); } // Two minutes after the finish: inside the query's pad, outside the // session. The query returns it; the curve must not. rows.push(pulseRow(TEST_USER_ID, SPAN_SEC + 120, PAD_TAIL_BPM)); // Far outside the padded window on both sides. rows.push(pulseRow(TEST_USER_ID, -20 * 60, FAR_BEFORE_BPM)); rows.push(pulseRow(TEST_USER_ID, SPAN_SEC + 15 * 60, FAR_AFTER_BPM)); // Another account, mid-session. rows.push(pulseRow(OTHER_USER_ID, Math.floor(SPAN_SEC / 2), FOREIGN_BPM)); await getPrismaClient().measurement.createMany({ data: rows }); } async function fetchDetail(id: string): Promise { const request = new NextRequest( `http://localhost/api/workouts/${id}?compact=1`, ); const response = await GET(request, { params: Promise.resolve({ id }) }); return (await response.json()) as WorkoutDetailBody; } describe("GET /api/workouts/{id} — reconstructed heart-rate curve", () => { it("reconstructs the curve from the account's pulse readings", async () => { const id = await createWorkout(); await seedPulse(); const body = await fetchDetail(id); expect(body.error).toBeNull(); const series = body.data?.hrSeries; expect(series).not.toBeNull(); expect(series!.source).toBe("pulse_window"); expect(series!.points.length).toBeGreaterThan(2); }); it("stops the curve at the finish — a reading inside the query pad is not part of the session", async () => { const id = await createWorkout(); await seedPulse(); const series = (await fetchDetail(id)).data!.hrSeries!; const lastTSec = series.points[series.points.length - 1].tSec; expect(lastTSec).toBeLessThan(SPAN_SEC); // The pad reading is the only source of a sub-100 bpm value in the // fixture, so naming the value proves it stayed out rather than // merely proving a count. expect(series.points.map((p) => p.min)).not.toContain(PAD_TAIL_BPM); expect(Math.min(...series.points.map((p) => p.min))).toBeGreaterThanOrEqual( IN_WINDOW_LOW, ); }); it("keeps readings from outside the window and from other accounts out of the curve", async () => { const id = await createWorkout(); await seedPulse(); const series = (await fetchDetail(id)).data!.hrSeries!; const maxima = series.points.map((p) => p.max); expect(maxima).not.toContain(FAR_BEFORE_BPM); expect(maxima).not.toContain(FOREIGN_BPM); expect(series.points.map((p) => p.min)).not.toContain(FAR_AFTER_BPM); expect(Math.max(...maxima)).toBeLessThanOrEqual(IN_WINDOW_HIGH); }); it("serves no curve when the account's readings do not cover the session", async () => { const id = await createWorkout(); // A handful of opportunistic readings in the first minute. Enough // rows to clear the sample floor, nowhere near enough to describe a // half-hour session — the route says nothing rather than drawing a // curve out of a corner of it. await getPrismaClient().measurement.createMany({ data: Array.from({ length: 12 }, (_, i) => pulseRow(TEST_USER_ID, i * 4, 130 + i), ), }); const body = await fetchDetail(id); expect(body.error).toBeNull(); expect(body.data?.hrSeries).toBeNull(); }); it("does not reach the reconstruction at all for another account's workout", async () => { const foreign = await getPrismaClient().workout.create({ data: { userId: OTHER_USER_ID, sportType: "running", startedAt: STARTED_AT, endedAt: ENDED_AT, durationSec: SPAN_SEC, source: "MANUAL", }, select: { id: true }, }); await seedPulse(); const request = new NextRequest( `http://localhost/api/workouts/${foreign.id}?compact=1`, ); const response = await GET(request, { params: Promise.resolve({ id: foreign.id }), }); expect(response.status).toBe(404); }); });