mirror of
https://github.com/MBombeck/HealthLog.git
synced 2026-11-16 07:13:29 +00:00
The detail surface at /insights/workouts/[id] gains a real heart-rate curve, effort zones, an aspect-true GPS route, and per-kilometre splits — all read from data already stored, no new integration, no migration. - HR curve: one server path with strict provenance — stored WorkoutSamples series first, a raw-PULSE window reconstruction second (quality-gated so sparse data hides rather than lies), nothing third. Adaptive bucketing keeps on-screen density constant across a 20-minute HIIT and a 6-hour ride; a min/max envelope surfaces intervals. - Effort zones: five %HRmax bands via the Tanaka HRmax, with a device's own reported time-in-zone winning when present. Descriptive only. - GPS route: self-rendered inline SVG with an equirectangular cos(midLat) longitude correction (fixes the ~40% horizontal stretch), aspect-clamped viewBox, RDP downsampling, start/end markers, and an optional elevation profile. Nothing leaves the origin — no map tiles. - Per-km splits and a GPX export, both derived client/server-side from the geometry already on the payload. - The endpoint extends additively (hrSeries, zones, splits, sportContext, a reserved insight seam) behind an opt-in compact=1 param that drops the raw sample/timestamp blobs for the web client; without the param the response is unchanged. - Every data-less section now hides instead of rendering an empty card; the growing detail component is split into a workout-detail/ directory. - List rows flag which sessions open into a rich detail.
324 lines
10 KiB
TypeScript
324 lines
10 KiB
TypeScript
/**
|
|
* Unit suite for `GET /api/workouts/{id}` — single-workout detail.
|
|
*
|
|
* v1.4.32 — paired with the list endpoint so the iOS detail screen +
|
|
* the `/insights/workouts/[id]` web page consume one envelope per
|
|
* workout. The test pins:
|
|
* - 200 + iOS-contract field names for a row the caller owns;
|
|
* - 401 without a session;
|
|
* - 404 (existence-channel sealed) when the row belongs to another
|
|
* user;
|
|
* - 404 when no row exists;
|
|
* - `canonicalId` resolves to the cluster winner — the requested id
|
|
* when the row is the canonical pick, the winner id when it is a
|
|
* non-canonical twin;
|
|
* - the optional `route` field flows through GeoJSON geometry when a
|
|
* `WorkoutRoute` row is attached, and is null when missing.
|
|
*/
|
|
import { describe, expect, it, vi, beforeEach } from "vitest";
|
|
import { NextRequest } from "next/server";
|
|
|
|
vi.mock("@/lib/db", () => ({
|
|
prisma: {
|
|
workout: {
|
|
findUnique: vi.fn(),
|
|
findMany: vi.fn(),
|
|
},
|
|
user: {
|
|
findUnique: vi.fn(),
|
|
},
|
|
measurement: {
|
|
findMany: vi.fn(),
|
|
},
|
|
},
|
|
}));
|
|
|
|
vi.mock("@/lib/auth/session", () => ({ getSession: vi.fn() }));
|
|
vi.mock("@/lib/auth/audit", () => ({
|
|
auditLog: vi.fn().mockResolvedValue(undefined),
|
|
}));
|
|
vi.mock("@/lib/logging/transports", () => ({ emitIfSampled: vi.fn() }));
|
|
vi.mock("next/headers", () => ({
|
|
headers: vi.fn(async () => ({ get: () => null })),
|
|
cookies: vi.fn(async () => ({
|
|
get: () => undefined,
|
|
set: () => {},
|
|
delete: () => {},
|
|
})),
|
|
}));
|
|
|
|
vi.mock("@/lib/modules/gate", async (importOriginal) => {
|
|
const actual = await importOriginal<typeof import("@/lib/modules/gate")>();
|
|
return {
|
|
...actual,
|
|
resolveModuleMap: vi.fn(async () => ({})),
|
|
requireModuleEnabled: vi.fn(async () => ({ enabled: true })),
|
|
};
|
|
});
|
|
|
|
import { GET } from "../[id]/route";
|
|
import { prisma } from "@/lib/db";
|
|
import { getSession } from "@/lib/auth/session";
|
|
import { requireModuleEnabled } from "@/lib/modules/gate";
|
|
|
|
const SESSION_OK = {
|
|
session: { id: "sess-1", expiresAt: new Date(Date.now() + 3_600_000) },
|
|
user: { id: "user-1", username: "testuser", role: "USER" as const },
|
|
};
|
|
|
|
function makeRequest(): NextRequest {
|
|
return new NextRequest("http://localhost/api/workouts/w-1", {
|
|
method: "GET",
|
|
});
|
|
}
|
|
|
|
function makeParams(id: string) {
|
|
return { params: Promise.resolve({ id }) };
|
|
}
|
|
|
|
const BASE_ROW = {
|
|
id: "w-1",
|
|
userId: "user-1",
|
|
sportType: "RUNNING",
|
|
startedAt: new Date("2026-05-15T07:00:00Z"),
|
|
endedAt: new Date("2026-05-15T07:30:00Z"),
|
|
durationSec: 1800,
|
|
totalDistanceM: 5000,
|
|
totalEnergyKcal: 320,
|
|
avgHeartRate: 145,
|
|
maxHeartRate: 170,
|
|
minHeartRate: 110,
|
|
stepCount: 5800,
|
|
elevationM: 12.5,
|
|
pauseDurationSec: null,
|
|
source: "APPLE_HEALTH" as const,
|
|
externalId: "ext-w-1",
|
|
externalSourceVersion: null,
|
|
metadata: { hkVersion: "1" },
|
|
createdAt: new Date("2026-05-15T07:30:00Z"),
|
|
updatedAt: new Date("2026-05-15T07:30:00Z"),
|
|
route: null,
|
|
};
|
|
|
|
describe("GET /api/workouts/{id}", () => {
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
vi.mocked(getSession).mockResolvedValue(SESSION_OK as never);
|
|
vi.mocked(prisma.user.findUnique).mockResolvedValue({
|
|
sourcePriorityJson: null,
|
|
dateOfBirth: null,
|
|
} as never);
|
|
// #67 — the enrichment reads: the HR-curve pulse-window fallback
|
|
// (`measurement.findMany`) and the sport-context average (a SECOND
|
|
// `workout.findMany`). Default both to empty; each test's
|
|
// `mockResolvedValueOnce` still wins for the cluster call.
|
|
vi.mocked(prisma.workout.findMany).mockResolvedValue([] as never);
|
|
vi.mocked(prisma.measurement.findMany).mockResolvedValue([] as never);
|
|
// clearAllMocks wipes the factory default; re-seed the gate to pass.
|
|
vi.mocked(requireModuleEnabled).mockResolvedValue({
|
|
enabled: true,
|
|
} as never);
|
|
});
|
|
|
|
it("returns the workout with iOS-contract field names", async () => {
|
|
vi.mocked(prisma.workout.findUnique).mockResolvedValueOnce(
|
|
BASE_ROW as never,
|
|
);
|
|
vi.mocked(prisma.workout.findMany).mockResolvedValueOnce([
|
|
{
|
|
id: "w-1",
|
|
source: "APPLE_HEALTH",
|
|
startedAt: BASE_ROW.startedAt,
|
|
sportType: "RUNNING",
|
|
},
|
|
] as never);
|
|
|
|
const res = await GET(makeRequest(), makeParams("w-1"));
|
|
const body = await res.json();
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(body.data.id).toBe("w-1");
|
|
expect(body.data.distanceM).toBe(5000);
|
|
expect(body.data.activeEnergyKcal).toBe(320);
|
|
expect(body.data.avgHr).toBe(145);
|
|
expect(body.data.maxHr).toBe(170);
|
|
expect(body.data.canonicalId).toBe("w-1");
|
|
expect(body.data.route).toBeNull();
|
|
});
|
|
|
|
it("returns 401 without a session", async () => {
|
|
vi.mocked(getSession).mockResolvedValueOnce(null);
|
|
const res = await GET(makeRequest(), makeParams("w-1"));
|
|
expect(res.status).toBe(401);
|
|
});
|
|
|
|
it("returns 403 module.disabled when the workouts module is off", async () => {
|
|
vi.mocked(requireModuleEnabled).mockResolvedValueOnce({
|
|
enabled: false,
|
|
response: new Response(
|
|
JSON.stringify({ data: null, error: "Module disabled" }),
|
|
{ status: 403 },
|
|
),
|
|
} as never);
|
|
const res = await GET(makeRequest(), makeParams("w-1"));
|
|
expect(res.status).toBe(403);
|
|
// The detail query never runs once the gate refuses.
|
|
expect(prisma.workout.findUnique).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("returns 404 when the row belongs to another user", async () => {
|
|
vi.mocked(prisma.workout.findUnique).mockResolvedValueOnce({
|
|
...BASE_ROW,
|
|
userId: "user-2",
|
|
} as never);
|
|
|
|
const res = await GET(makeRequest(), makeParams("w-1"));
|
|
expect(res.status).toBe(404);
|
|
});
|
|
|
|
it("returns 404 when no row exists", async () => {
|
|
vi.mocked(prisma.workout.findUnique).mockResolvedValueOnce(null);
|
|
const res = await GET(makeRequest(), makeParams("w-1"));
|
|
expect(res.status).toBe(404);
|
|
});
|
|
|
|
it("resolves canonicalId to the Apple Health twin when the requested row is the Withings sibling", async () => {
|
|
// Same 5-minute slot + sportType, but the caller asked for the
|
|
// Withings row. The picker's default ladder makes Apple Health win
|
|
// the cluster, so canonicalId points at the Apple row.
|
|
const withingsRow = {
|
|
...BASE_ROW,
|
|
id: "w-withings",
|
|
source: "WITHINGS" as const,
|
|
externalId: "withings-1",
|
|
};
|
|
vi.mocked(prisma.workout.findUnique).mockResolvedValueOnce(
|
|
withingsRow as never,
|
|
);
|
|
vi.mocked(prisma.workout.findMany).mockResolvedValueOnce([
|
|
{
|
|
id: "w-apple",
|
|
source: "APPLE_HEALTH",
|
|
startedAt: BASE_ROW.startedAt,
|
|
sportType: "RUNNING",
|
|
},
|
|
{
|
|
id: "w-withings",
|
|
source: "WITHINGS",
|
|
startedAt: BASE_ROW.startedAt,
|
|
sportType: "RUNNING",
|
|
},
|
|
] as never);
|
|
|
|
const res = await GET(makeRequest(), makeParams("w-withings"));
|
|
const body = await res.json();
|
|
|
|
expect(res.status).toBe(200);
|
|
expect(body.data.id).toBe("w-withings");
|
|
expect(body.data.canonicalId).toBe("w-apple");
|
|
});
|
|
|
|
it("adds the #67 enrichment fields and strips raw blobs under compact=1", async () => {
|
|
const startMs = BASE_ROW.startedAt.getTime();
|
|
const storedSamples = Array.from({ length: 40 }, (_, i) => ({
|
|
t: new Date(startMs + i * 45_000).toISOString(),
|
|
hr: 140 + (i % 6),
|
|
}));
|
|
vi.mocked(prisma.workout.findUnique).mockResolvedValueOnce({
|
|
...BASE_ROW,
|
|
// WHOOP device zones win → zones render even without profile age.
|
|
metadata: {
|
|
zoneDurations: {
|
|
zone_one_milli: 60_000,
|
|
zone_two_milli: 300_000,
|
|
zone_three_milli: 600_000,
|
|
zone_four_milli: 200_000,
|
|
zone_five_milli: 40_000,
|
|
},
|
|
},
|
|
route: {
|
|
id: "wr-1",
|
|
geometry: {
|
|
type: "LineString",
|
|
coordinates: [
|
|
[11, 49],
|
|
[11.01, 49.01],
|
|
],
|
|
},
|
|
sampleTimestamps: ["2026-05-15T07:00:00Z", "2026-05-15T07:01:00Z"],
|
|
createdAt: BASE_ROW.createdAt,
|
|
},
|
|
samples: { sampleCount: storedSamples.length, samples: storedSamples },
|
|
} as never);
|
|
vi.mocked(prisma.workout.findMany).mockResolvedValueOnce([
|
|
{
|
|
id: "w-1",
|
|
source: "APPLE_HEALTH",
|
|
startedAt: BASE_ROW.startedAt,
|
|
sportType: "RUNNING",
|
|
},
|
|
] as never);
|
|
|
|
const res = await GET(
|
|
new NextRequest("http://localhost/api/workouts/w-1?compact=1", {
|
|
method: "GET",
|
|
}),
|
|
makeParams("w-1"),
|
|
);
|
|
const body = await res.json();
|
|
|
|
expect(res.status).toBe(200);
|
|
// Stored series wins → provenance is the native workout series.
|
|
expect(body.data.hrSeries.source).toBe("workout_series");
|
|
expect(body.data.hrSeries.points.length).toBeGreaterThanOrEqual(2);
|
|
// WHOOP device zones.
|
|
expect(body.data.zones.model).toBe("whoop");
|
|
// Additive keys present; reserved seam is null.
|
|
expect(body.data).toHaveProperty("splits");
|
|
expect(body.data).toHaveProperty("sportContext");
|
|
expect(body.data.aiInsight).toBeNull();
|
|
// compact=1 drops the raw blobs but keeps count + geometry.
|
|
expect(body.data.samples.sampleCount).toBe(40);
|
|
expect(body.data.samples.samples).toBeNull();
|
|
expect(body.data.route.geometry).not.toBeNull();
|
|
expect(body.data.route.sampleTimestamps).toBeNull();
|
|
});
|
|
|
|
it("exposes the WorkoutRoute geometry when present", async () => {
|
|
const routeGeometry = {
|
|
type: "LineString",
|
|
coordinates: [
|
|
[11.0, 49.0],
|
|
[11.01, 49.01],
|
|
],
|
|
};
|
|
vi.mocked(prisma.workout.findUnique).mockResolvedValueOnce({
|
|
...BASE_ROW,
|
|
route: {
|
|
id: "wr-1",
|
|
geometry: routeGeometry,
|
|
sampleTimestamps: ["2026-05-15T07:00:00Z", "2026-05-15T07:01:00Z"],
|
|
createdAt: BASE_ROW.createdAt,
|
|
},
|
|
} as never);
|
|
vi.mocked(prisma.workout.findMany).mockResolvedValueOnce([
|
|
{
|
|
id: "w-1",
|
|
source: "APPLE_HEALTH",
|
|
startedAt: BASE_ROW.startedAt,
|
|
sportType: "RUNNING",
|
|
},
|
|
] as never);
|
|
|
|
const res = await GET(makeRequest(), makeParams("w-1"));
|
|
const body = await res.json();
|
|
|
|
expect(body.data.route).not.toBeNull();
|
|
expect(body.data.route.geometry).toEqual(routeGeometry);
|
|
expect(body.data.route.sampleTimestamps).toEqual([
|
|
"2026-05-15T07:00:00Z",
|
|
"2026-05-15T07:01:00Z",
|
|
]);
|
|
});
|
|
});
|