/** * v1.5.0 — `calculateCompliance` is a cadence-aware adapter over * `buildCadenceTimeline`. The historical wire shape (`totalExpected`, * `taken`, `skipped`, `missed`, `rate`, `streak`) is unchanged, but * the numbers now honour `daysOfWeek` and `intervalWeeks`. These * tests pin the contract for every cadence the production app * exercises: daily 1×/day, daily multi-dose, weekly Mondays-only, * bi-weekly, weekday-only multi-dose, and the DST-boundary day. * Closes #214. * * Each test uses `vi.useFakeTimers()` to pin `now` so the rolling * window is deterministic. `classifyIntakeTiming` tests below the * matrix are unchanged from the v1.4 line. */ import { describe, it, expect, beforeEach, vi, afterEach } from "vitest"; import { MIN_STABLE_DOSES, buildComplianceDisplay, buildComplianceMedicationContext, calculateCompliance, classifyIntakeTiming, expectedSlotCountForDay, expectedSlotsBetween, lastNonSkippedTakenAt, type ComplianceMedicationContext, type ComplianceSchedule, } from "../compliance"; import type { IntakeTimingClass } from "../compliance"; import { buildCadenceTimeline } from "@/lib/medications/scheduling/cadence"; import { getUserTodayBounds } from "@/lib/timezone"; import { userDayKey } from "@/lib/tz/format"; const DAY_MS = 24 * 60 * 60 * 1000; function eventAt(scheduledFor: Date, taken: boolean, skipped = false) { return { scheduledFor, takenAt: taken ? new Date(scheduledFor.getTime() + 30 * 60_000) : null, skipped, }; } describe("calculateCompliance — cadence-aware adapter", () => { // Pin `now` to a Wednesday so weekday-only schedules have a clean // count of Mondays in the trailing 30-day window. const NOW = new Date("2025-01-15T12:00:00Z"); beforeEach(() => { vi.useFakeTimers(); vi.setSystemTime(NOW); }); afterEach(() => { vi.useRealTimers(); }); it("returns the empty result when no schedules are configured", () => { const result = calculateCompliance([], [], 7); expect(result).toEqual({ totalExpected: 0, taken: 0, skipped: 0, missed: 0, rate: 100, streak: 0, }); }); it("daily 1×/day, 7 of 7 taken in a 7-day window → 100%", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null }, ]; // Anchor events to 08:30 UTC on today (NOW = 12:00 UTC, so the // morning slot is already past) and the six prior days. Going one // day further back would land the event before the rolling-window // start (NOW − 7 d = 2025-01-08T12:00Z, but the would-be event sits // at 2025-01-08T08:30Z — below the window start), which the slot // grid intentionally excludes. The original `NOW − N×DAY + 8h` // shape also landed events at 20:00 UTC on the prior day, twelve // hours away from the 08:00 slot — at the edge of the pairing // radius, which matched in Europe/Berlin and missed in UTC. const events = Array.from({ length: 7 }, (_, i) => { const at = new Date(NOW); at.setUTCDate(at.getUTCDate() - i); at.setUTCHours(8, 30, 0, 0); return eventAt(at, true); }); const result = calculateCompliance(events, schedules, 7); expect(result.rate).toBe(100); expect(result.taken).toBe(7); expect(result.missed).toBe(0); }); it("daily 1×/day, 0 of 7 taken in a 7-day window → 0%", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null }, ]; const result = calculateCompliance([], schedules, 7); expect(result.rate).toBe(0); expect(result.taken).toBe(0); expect(result.missed).toBeGreaterThan(0); }); it("daily 3×/day, 18 of 21 taken in a 7-day window → 86% (no-cadence-restriction happy path)", () => { // The pre-v1.5.0 path got this case right; pin it so the migration // doesn't regress users on a daily multi-dose schedule. const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null }, { windowStart: "13:00", windowEnd: "14:00", daysOfWeek: null }, { windowStart: "20:00", windowEnd: "21:00", daysOfWeek: null }, ]; // Generate 21 events (3/day × 7 days) and drop 3 so 18 are taken. const events = []; for (let d = 1; d <= 7; d++) { for (const hour of [8, 13, 20]) { // Drop dose #4, #11, #18 to land on 18/21 → 86%. const idx = (d - 1) * 3 + [8, 13, 20].indexOf(hour); const taken = ![3, 10, 17].includes(idx); const scheduledFor = new Date( NOW.getTime() - d * DAY_MS + hour * 3600_000, ); events.push(eventAt(scheduledFor, taken)); } } const result = calculateCompliance(events, schedules, 7); expect(result.rate).toBe(86); expect(result.taken).toBe(18); expect(result.missed).toBe(3); }); it("daily 2×/day on ONE schedule row (timesOfDay), all taken → 100%", () => { // Production shape: the wizard stores a twice-daily med as a single // MedicationSchedule row carrying `timesOfDay = ["07:00","19:00"]`, // NOT two rows. Pre-fix the legacy cadence walker only emitted the // `windowStart` slot, so the denominator was one dose/day and a // perfectly-adherent user could read 50% once a second dose was // logged. Pin the single-row twice-daily case at 100%. const schedules: ComplianceSchedule[] = [ { windowStart: "07:00", windowEnd: "07:30", daysOfWeek: null, timesOfDay: ["07:00", "19:00"], }, ]; // Log both doses for every day in (and just past) the 7-day window // so no emitted slot is left unpaired at the window boundary. NOW is // 12:00 UTC, so today's 19:00 slot is still `upcoming` (excluded). const events = []; for (let d = 0; d <= 8; d++) { const day = new Date(NOW); day.setUTCDate(day.getUTCDate() - d); const morning = new Date(day); morning.setUTCHours(7, 5, 0, 0); const evening = new Date(day); evening.setUTCHours(19, 5, 0, 0); events.push(eventAt(morning, true)); if (d > 0) events.push(eventAt(evening, true)); } const result = calculateCompliance(events, schedules, 7); expect(result.rate).toBe(100); expect(result.missed).toBe(0); // The window covers ~7 days × 2 doses, so the denominator is well // above the 7-or-so a one-slot-per-day walker would produce. The // load-bearing assertion is that BOTH daily doses are counted (the // fan-out) and every one pairs to a taken event → 100%. expect(result.totalExpected).toBeGreaterThanOrEqual(12); expect(result.taken).toBe(result.totalExpected); }); it("2×/day, delete the evening dose then re-add it → still 100% / 2 of 2", () => { // The live regression: a user on a 07:00 + 19:00 schedule deletes // the evening intake and re-adds it. The compliance must read the // re-added dose dynamically — 2 expected, 2 taken — not collapse to // 50%. Modelled here on a single calendar day with both slots in the // past so neither is `upcoming`. const lateNow = new Date("2025-01-15T22:00:00Z"); vi.setSystemTime(lateNow); const schedules: ComplianceSchedule[] = [ { windowStart: "07:00", windowEnd: "07:30", daysOfWeek: null, timesOfDay: ["07:00", "19:00"], }, ]; // Morning taken once; the evening dose was deleted (its tombstoned // row is excluded from the events array by the route's // `deletedAt: null` filter) and re-added as a fresh taken event. const morning = new Date("2025-01-15T07:05:00Z"); const eveningReAdded = new Date("2025-01-15T19:10:00Z"); const events = [ eventAt(morning, true), eventAt(eveningReAdded, true), ]; const result = calculateCompliance(events, schedules, 1, undefined, { now: lateNow, }); expect(result.taken).toBe(2); expect(result.totalExpected).toBe(2); expect(result.missed).toBe(0); expect(result.rate).toBe(100); }); it("weekly Mondays, all Mondays taken in a 30-day window → 100% (the #214 bug case)", () => { // Pre-v1.5.0 this returned ~13% (taken / (schedules × 30) = 4/30). // The fix is to honour `daysOfWeek` so the denominator is the // number of Mondays in the window, not 30. const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: "1" }, ]; // NOW = Wed 2025-01-15. Mondays in the trailing 30-day window = // 2025-01-13, 2025-01-06, 2024-12-30, 2024-12-23, 2024-12-16. const mondays = [ new Date("2025-01-13T08:30:00Z"), new Date("2025-01-06T08:30:00Z"), new Date("2024-12-30T08:30:00Z"), new Date("2024-12-23T08:30:00Z"), new Date("2024-12-16T08:30:00Z"), ]; const events = mondays.map((m) => eventAt(m, true)); const result = calculateCompliance(events, schedules, 30); expect(result.rate).toBe(100); expect(result.taken).toBeGreaterThanOrEqual(4); expect(result.missed).toBe(0); }); it("weekly Mondays, one Monday missed in a 30-day window → 75–80%", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: "1" }, ]; // Take 3 of the 4 most-recent Mondays, miss one. const events = [ eventAt(new Date("2025-01-13T08:30:00Z"), true), // 2025-01-06 missed. eventAt(new Date("2024-12-30T08:30:00Z"), true), eventAt(new Date("2024-12-23T08:30:00Z"), true), ]; const result = calculateCompliance(events, schedules, 30); expect(result.rate).toBeGreaterThanOrEqual(60); expect(result.rate).toBeLessThan(100); expect(result.missed).toBeGreaterThanOrEqual(1); }); it("bi-weekly (intervalWeeks=2), all scheduled doses taken in a 30-day window → 100%", () => { // Encoded recurrence: 2 weeks interval, Monday-anchored. const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: "i2;1" }, ]; // With NOW = Wed Jan 15 the window covers ~Dec 16–Jan 15. The // anchor week starts on the medicationCreatedAt week. Take both // possible weeks-anchored Mondays so the denominator is 2 (or 3, // depending on phase) and the rate is 100% either way. const createdAt = new Date("2024-11-04T00:00:00Z"); // Mon const events = [ eventAt(new Date("2025-01-13T08:30:00Z"), true), eventAt(new Date("2024-12-30T08:30:00Z"), true), eventAt(new Date("2024-12-16T08:30:00Z"), true), ]; const result = calculateCompliance(events, schedules, 30, createdAt); expect(result.rate).toBe(100); expect(result.missed).toBe(0); }); it("weekday-only 3×/day, every weekday dose taken in a 30-day window → 100% (the #214 metformin case)", () => { // Pre-v1.5.0 this returned ~73% (66 weekday doses ÷ 90 = 73%). // The fix is to honour `daysOfWeek` so the denominator is // 3 schedules × ~22 weekdays in the window, not 3 × 30. const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: "1,2,3,4,5" }, { windowStart: "13:00", windowEnd: "14:00", daysOfWeek: "1,2,3,4,5" }, { windowStart: "20:00", windowEnd: "21:00", daysOfWeek: "1,2,3,4,5" }, ]; // Generate events for every weekday slot inside the window — // including today's already-past slots (08:00 UTC < NOW = 12:00). const events = []; for (let d = 0; d <= 30; d++) { const day = new Date(NOW.getTime() - d * DAY_MS); const dow = day.getUTCDay(); if (dow === 0 || dow === 6) continue; // skip weekends for (const hour of [8, 13, 20]) { const at = new Date(day); at.setUTCHours(hour, 30, 0, 0); // Skip future slots (today's 13:00 and 20:00 are in the future // relative to NOW = 12:00 UTC); the timeline marks those // `upcoming` and excludes them from the denominator anyway. if (at.getTime() > NOW.getTime()) continue; events.push(eventAt(at, true)); } } const result = calculateCompliance(events, schedules, 30); expect(result.rate).toBe(100); expect(result.missed).toBe(0); }); it("skipped doses are excluded from the denominator (not a compliance failure)", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null }, ]; // 7-day window — every day has a slot, every event lands on its // own day. Two taken + one skipped + four missed. const events = [ eventAt(new Date("2025-01-14T08:30:00Z"), true), { scheduledFor: new Date("2025-01-13T08:30:00Z"), takenAt: null, skipped: true, }, eventAt(new Date("2025-01-12T08:30:00Z"), true), ]; const result = calculateCompliance(events, schedules, 7); expect(result.skipped).toBe(1); expect(result.taken).toBe(2); // The skipped day is excluded from the rate denominator. // Slots: Jan-9..Jan-15 = 7 (Jan-8 windowEnd 09:00 falls below the // window start of 12:00). Taken = 2, skipped = 1, missed = 4 // (Jan-9, 10, 11, 15). Rate = 2 taken / (2 + 4 missed) = 33%. expect(result.rate).toBe(33); }); it("excludes days before medicationCreatedAt from the denominator", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null }, ]; // Medication created 3 days ago — the prior 4 days of the 7-day // window must not count as missed. Anchor each event at 08:30 UTC // on today + the two prior days (NOW = 12:00 UTC so today's morning // slot is already past). Going to "3 days ago" would land the event // at the createdAt instant itself (08:30 < 12:00 on the cutoff day) // which slips just below the slot grid's emit-cutoff. const createdAt = new Date(NOW.getTime() - 3 * DAY_MS); const events = [0, 1, 2].map((daysAgo) => { const at = new Date(NOW); at.setUTCDate(at.getUTCDate() - daysAgo); at.setUTCHours(8, 30, 0, 0); return eventAt(at, true); }); const result = calculateCompliance(events, schedules, 7, createdAt); expect(result.rate).toBe(100); expect(result.taken).toBe(3); expect(result.missed).toBe(0); }); it("DST boundary (Europe/Berlin spring-forward) does not inflate the expected count", () => { // Spring-forward in Berlin: 2025-03-30 02:00 → 03:00. A daily // schedule across this boundary must still emit one slot per // local day — not two on the short day and zero on the next. // Pin `now` to Apr-02 noon UTC and run a 7-day window so the // boundary day is inside it. Generate one event per day // (working backwards from NOW − 1 day so each event lands inside // the window) and assert the totalExpected lands at 7 (not 8). vi.setSystemTime(new Date("2025-04-02T12:00:00Z")); const schedules: ComplianceSchedule[] = [ { windowStart: "10:00", windowEnd: "11:00", daysOfWeek: null }, ]; // Slots emitted by the timeline: Mar-27..Apr-02 (Mar-26's window // sits below the rolling-window start of Mar-26 12:00). Generate // one taken event per slot — today's 10:30 slot is also in the // past relative to NOW = 12:00 so it counts as taken too. const events = []; for (let d = 0; d <= 6; d++) { const at = new Date("2025-04-02T10:30:00Z"); at.setUTCDate(at.getUTCDate() - d); events.push(eventAt(at, true)); } const result = calculateCompliance(events, schedules, 7); // The hard contract: totalExpected stays at 7 — not 8 (which // would mean the DST short day double-emitted) and not 6 (which // would mean the short day silently dropped a slot). expect(result.totalExpected).toBe(7); expect(result.taken).toBe(7); expect(result.missed).toBe(0); expect(result.rate).toBe(100); }); it("filters events outside the rolling window", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null }, ]; const events = [ eventAt(new Date("2025-01-14T08:30:00Z"), true), eventAt(new Date("2024-12-01T08:30:00Z"), true), ]; const result = calculateCompliance(events, schedules, 7); expect(result.taken).toBe(1); }); it("caps rate at 100% when more intakes than expected exist", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null }, ]; // Same-day duplicate logs — the pair algorithm matches one and // leaves the duplicates dangling; the rate stays at or below 100. const events = Array.from({ length: 10 }, (_, i) => ({ scheduledFor: new Date(`2025-01-14T08:${String(i).padStart(2, "0")}:00Z`), takenAt: new Date(`2025-01-14T08:${String(i).padStart(2, "0")}:00Z`), skipped: false, })); const result = calculateCompliance(events, schedules, 7); expect(result.rate).toBeLessThanOrEqual(100); }); }); // ──────────────────────────────────────────────────────────────────── // v1.7.0 SB-SCHED-2 — canonical-engine-routed compliance (Option B) // // When a `medicationContext` is supplied, the expected-slot denominator // runs through the canonical recurrence engine. These golden fixtures // pin every cadence type's denominator explicitly — this is the // riskiest change of the release because it moves every adherence number // for non-daily meds. // ──────────────────────────────────────────────────────────────────── describe("calculateCompliance — engine-routed (medicationContext)", () => { // Pin `now` to a Wednesday so a weekly Monday cadence has a clean // count of Mondays in the trailing 30-day window. const NOW = new Date("2025-01-15T12:00:00Z"); beforeEach(() => { vi.useFakeTimers(); vi.setSystemTime(NOW); }); afterEach(() => { vi.useRealTimers(); }); function ctx(overrides: Partial<{ startsOn: Date | null; endsOn: Date | null; oneShot: boolean; createdAt: Date; lastIntakeAt: Date | null; timeZone: string; }> = {}) { return { startsOn: null, endsOn: null, oneShot: false, createdAt: new Date("2024-12-01T00:00:00Z"), lastIntakeAt: null, timeZone: "UTC", ...overrides, }; } it("parity: a legacy daysOfWeek-only schedule yields identical numbers with no context", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null }, ]; const events = Array.from({ length: 7 }, (_, i) => eventAt(new Date(NOW.getTime() - (i + 1) * DAY_MS), true), ); const legacy = calculateCompliance(events, schedules, 7); const withCtx = calculateCompliance(events, schedules, 7, undefined, { medicationContext: ctx(), }); // Legacy daysOfWeek-only schedule has no canonical fields → both // paths run the legacy walker → identical numbers. expect(withCtx).toEqual(legacy); }); it("FREQ=WEEKLY;BYDAY=MO — took every Monday → 100%, denominator counts only Mondays", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rrule: "FREQ=WEEKLY;BYDAY=MO", timesOfDay: ["08:00"], }, ]; // Mondays in the trailing 30 days from Wed 2025-01-15: Jan 13, 6, // Dec 30, 23, 16. Log a taken intake on each. const mondays = [ "2025-01-13T08:30:00Z", "2025-01-06T08:30:00Z", "2024-12-30T08:30:00Z", "2024-12-23T08:30:00Z", "2024-12-16T08:30:00Z", ].map((s) => ({ scheduledFor: new Date(s), takenAt: new Date(s), skipped: false, })); const result = calculateCompliance(mondays, schedules, 30, undefined, { medicationContext: ctx(), }); expect(result.rate).toBe(100); // Denominator is the count of Mondays, not 30 days. expect(result.totalExpected).toBeLessThanOrEqual(6); expect(result.totalExpected).toBeGreaterThanOrEqual(4); }); it("FREQ=WEEKLY;INTERVAL=2;BYDAY=WE — bi-weekly denominator counts only on-weeks", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rrule: "FREQ=WEEKLY;INTERVAL=2;BYDAY=WE", timesOfDay: ["08:00"], }, ]; const result = calculateCompliance([], schedules, 30, undefined, { medicationContext: ctx({ startsOn: new Date("2024-12-04T00:00:00Z") }), }); // Over ~30 days a bi-weekly Wednesday emits roughly 2 slots, never // the ~4 a weekly Wednesday would. Nothing taken → all missed. expect(result.totalExpected).toBeLessThanOrEqual(3); }); it("rolling rollingIntervalDays=7 — the open forward cycle is upcoming, not a slot (no events → empty)", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rollingIntervalDays: 7, timesOfDay: ["08:00"], }, ]; // v1.13.x — this test previously asserted the OLD forward-only behaviour // ("only the next-due slot counts"). With the retrospective rolling // expansion the grid is built from the LOGGED intakes — here there are // none, and `lastIntakeAt` is 5 days ago so the forward next-due slot is // 2 days out (future, > now) → excluded as upcoming. With no logged // intakes in the window and no past-due slot the window is empty → // empty-window contract → 100 / totalExpected 0. (A faithful history now // reads its true rate — see the dedicated 12-shot test below.) const result = calculateCompliance([], schedules, 30, undefined, { medicationContext: ctx({ lastIntakeAt: new Date(NOW.getTime() - 5 * DAY_MS), }), }); expect(result.totalExpected).toBe(0); expect(result.rate).toBe(100); }); // ────────────────────────────────────────────────────────────────── // v1.13.x — ROLLING retrospective expansion. The canonical engine's // `expandRolling` is forward-only: it emits at most the single // immediately-next slot, so a historical compliance window over a // rolling weekly injection (the GLP-1 default) saw either zero expected // slots (vacuous 100%) or one overdue slot (hard 0%) — never the true // multi-dose adherence. The compliance layer now reconstructs the // historical grid from the logged intakes (each dose is one satisfied // expected slot, with synthesized misses for skipped whole cycles + a // past-due forward slot). These tests pin that the live "0% despite many // recorded intakes" defect is fixed. // ────────────────────────────────────────────────────────────────── it("rolling rollingIntervalDays=7 — 12 weekly shots logged → high rate, not 0%/100%-vacuous", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rollingIntervalDays: 7, timesOfDay: ["08:00"], }, ]; // 12 consecutive weekly shots, each ~7 days apart, taken at varying // times of day (the real-world off-HH:mm pattern). Most recent 3 days ago. const lastShot = new Date(NOW.getTime() - 3 * DAY_MS); const intakes = Array.from({ length: 12 }, (_, i) => { const at = new Date(lastShot.getTime() - i * 7 * DAY_MS); at.setUTCHours(19 + (i % 3), 0, 0, 0); // 19:00/20:00/21:00 — off the 08:00 slot return { scheduledFor: at, takenAt: at, skipped: false }; }); const lastIntakeAt = intakes[0].takenAt; for (const days of [30, 90]) { const result = calculateCompliance(intakes, schedules, days, undefined, { medicationContext: ctx({ lastIntakeAt, startsOn: intakes[11].takenAt }), }); // Each logged shot is a satisfied expected slot → taken tracks the // number of shots in the window; rate is high; not the broken 0%. expect(result.taken).toBeGreaterThanOrEqual(days === 30 ? 4 : 12); expect(result.rate).toBeGreaterThanOrEqual(90); expect(result.missed).toBe(0); } }); it("rolling weekly — a shot logged a day late from its cycle still pairs (2 of 2, no phantom miss)", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rollingIntervalDays: 7, timesOfDay: ["08:00"], }, ]; // Two shots: cycle anchor + a second shot logged ~8 days later (1 day // late, inside the 1.5·N tolerance), then nothing — both count taken, // none missed (the late dose must NOT synthesize a phantom missed cycle). const first = new Date(NOW.getTime() - 16 * DAY_MS); const second = new Date(first.getTime() + 8 * DAY_MS); // 1 day late const intakes = [ { scheduledFor: second, takenAt: second, skipped: false }, { scheduledFor: first, takenAt: first, skipped: false }, ]; const result = calculateCompliance(intakes, schedules, 30, undefined, { medicationContext: ctx({ lastIntakeAt: second, startsOn: first }), }); expect(result.taken).toBe(2); expect(result.missed).toBe(0); expect(result.rate).toBe(100); }); it("rolling weekly — a 3-week gap between shots synthesizes the skipped cycles as missed", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rollingIntervalDays: 7, timesOfDay: ["08:00"], }, ]; // Shot A, then a 21-day gap (2 missed cycles), then shot B. const a = new Date(NOW.getTime() - 28 * DAY_MS); const b = new Date(a.getTime() + 21 * DAY_MS); const intakes = [ { scheduledFor: b, takenAt: b, skipped: false }, { scheduledFor: a, takenAt: a, skipped: false }, ]; const result = calculateCompliance(intakes, schedules, 30, undefined, { medicationContext: ctx({ lastIntakeAt: b, startsOn: a }), }); // 2 taken (A, B) + ~2 synthesized missed cycles in the gap → ~50%. expect(result.taken).toBe(2); expect(result.missed).toBeGreaterThanOrEqual(1); expect(result.rate).toBeLessThan(100); }); it("rolling weekly — last shot 3 days ago, next due in 4 days → upcoming, excluded from denominator", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rollingIntervalDays: 7, timesOfDay: ["08:00"], }, ]; const lastShot = new Date(NOW.getTime() - 3 * DAY_MS); const intakes = [ { scheduledFor: lastShot, takenAt: lastShot, skipped: false }, ]; const result = calculateCompliance(intakes, schedules, 30, undefined, { medicationContext: ctx({ lastIntakeAt: lastShot, startsOn: lastShot }), }); // The one closed cycle (the logged shot) is taken; the open forward // cycle is upcoming and must NOT count as missed → 100%, missed 0. expect(result.missed).toBe(0); expect(result.taken).toBe(1); expect(result.rate).toBe(100); }); // ────────────────────────────────────────────────────────────────── // v1.12.0 — weekly-injectable matching radius. A weekly med (Mounjaro) // is dosed once a week, but a real intake is almost never logged within // 12h of the schedule's configured HH:mm: the user takes the shot on // whichever day / time of the dosing week suits them. The pre-fix ±12h // pairing radius orphaned those intakes — every weekly slot read // `missed` and the rate collapsed to 0% across EVERY window despite // recorded intakes. The radius now scales with the cadence gap so an // intake anywhere in the dosing week pairs to that week's slot. // ────────────────────────────────────────────────────────────────── it("FREQ=WEEKLY;BYDAY=MO — Mondays taken late in the evening (22:00) still pair → 100%, not 0%", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "07:30", windowEnd: "08:30", daysOfWeek: null, rrule: "FREQ=WEEKLY;BYDAY=MO", timesOfDay: ["07:30"], }, ]; // The configured slot is 07:30; the user logs the shot the same // Monday but at 22:00 — 14.5h from the slot, outside the legacy ±12h // radius. Thirteen consecutive Mondays back from the pinned Wednesday. const lastMonday = new Date("2025-01-13T22:00:00Z"); const intakes = Array.from({ length: 13 }, (_, i) => { const at = new Date(lastMonday.getTime() - i * 7 * DAY_MS); return { scheduledFor: at, takenAt: at, skipped: false }; }); const lastIntakeAt = intakes[0].takenAt; for (const days of [7, 30, 90]) { const result = calculateCompliance(intakes, schedules, days, undefined, { medicationContext: ctx({ lastIntakeAt }), }); expect(result.rate).toBe(100); expect(result.taken).toBeGreaterThan(0); expect(result.missed).toBe(0); } }); it("FREQ=WEEKLY;BYDAY=MO — single-slot 7-day window: an off-time Monday still pairs (1/1 = 100%)", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "07:30", windowEnd: "08:30", daysOfWeek: null, rrule: "FREQ=WEEKLY;BYDAY=MO", timesOfDay: ["07:30"], }, ]; // The 7-day window holds exactly one Monday slot — the per-slot // neighbour-gap widening can't fire (no second slot), so this pins the // schedule-derived radius floor that `buildCadenceTimeline` supplies. const monday = new Date("2025-01-13T20:00:00Z"); // 12.5h after 07:30 const intakes = [{ scheduledFor: monday, takenAt: monday, skipped: false }]; const result = calculateCompliance(intakes, schedules, 7, undefined, { medicationContext: ctx({ lastIntakeAt: monday }), }); expect(result.totalExpected).toBe(1); expect(result.taken).toBe(1); expect(result.rate).toBe(100); }); it("legacy daysOfWeek='1' (Monday-only) — off-time Mondays still pair → non-zero across all windows", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "07:30", windowEnd: "08:30", daysOfWeek: "1", timesOfDay: ["07:30"], }, ]; const lastMonday = new Date("2025-01-13T21:00:00Z"); const intakes = Array.from({ length: 13 }, (_, i) => { const at = new Date(lastMonday.getTime() - i * 7 * DAY_MS); return { scheduledFor: at, takenAt: at, skipped: false }; }); const lastIntakeAt = intakes[0].takenAt; for (const days of [7, 30, 90]) { const result = calculateCompliance(intakes, schedules, days, undefined, { medicationContext: ctx({ lastIntakeAt }), }); expect(result.rate).toBe(100); expect(result.missed).toBe(0); } }); it("DAILY cadence keeps the 12h floor — an intake equidistant-far from every slot stays unmatched", () => { // Guard the widened radius against over-reach on a DENSE cadence: a // daily schedule's gap is 24h, so its match radius stays at the 12h // floor. An intake at 20:00 sits exactly 12h from the same day's 08:00 // slot and 12h from the next day's 08:00 slot — at the boundary it // claims the nearer (same-day) slot, but a single off-day intake can // never pair to a slot two days away the way the weekly widening // allows. Pin the floor by confirming one intake claims at most one // daily slot. const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rrule: "FREQ=DAILY", timesOfDay: ["08:00"], }, ]; // One intake far from every slot's 08:00 centre — 02:00, which is 6h // before that day's slot but also 18h before the prior day's: only the // same-day slot is within 12h. A single intake → at most one taken. const at = new Date("2025-01-13T02:00:00Z"); const intakes = [{ scheduledFor: at, takenAt: at, skipped: false }]; const result = calculateCompliance(intakes, schedules, 3, undefined, { medicationContext: ctx({ lastIntakeAt: at }), }); expect(result.taken).toBeLessThanOrEqual(1); }); it("one-shot — exactly one expected slot on startsOn", () => { const startsOn = new Date("2025-01-10T00:00:00Z"); const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, scheduleType: "SCHEDULED", timesOfDay: ["08:00"], }, ]; const result = calculateCompliance([], schedules, 30, undefined, { medicationContext: ctx({ oneShot: true, startsOn, endsOn: startsOn }), }); // One-shot anchored on Jan 10 → exactly one expected slot in the // trailing-30 window; nothing taken → one missed. expect(result.totalExpected).toBe(1); expect(result.missed).toBe(1); }); it("PRN — rate 100, totalExpected 0, even with a daily rrule present", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, scheduleType: "PRN", rrule: "FREQ=DAILY", timesOfDay: ["08:00"], }, ]; const result = calculateCompliance([], schedules, 30, undefined, { medicationContext: ctx(), }); expect(result.totalExpected).toBe(0); expect(result.rate).toBe(100); }); it("cyclic 2-on/1-off — off-week days are not counted in the denominator", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, scheduleType: "CYCLIC", cyclicOnWeeks: 2, cyclicOffWeeks: 1, rrule: "FREQ=DAILY", timesOfDay: ["08:00"], }, ]; const cyclicResult = calculateCompliance([], schedules, 30, undefined, { medicationContext: ctx({ startsOn: new Date("2024-12-01T00:00:00Z") }), }); const dailySchedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rrule: "FREQ=DAILY", timesOfDay: ["08:00"], }, ]; const dailyResult = calculateCompliance([], dailySchedules, 30, undefined, { medicationContext: ctx({ startsOn: new Date("2024-12-01T00:00:00Z") }), }); // Cyclic drops the off-weeks → strictly fewer expected slots than a // plain daily over the same window. expect(cyclicResult.totalExpected).toBeLessThan(dailyResult.totalExpected); }); it("DST spring-forward day (Europe/Berlin) parity — daily rate stays 100", () => { // Europe/Berlin spring-forward 2025-03-30. Pin now just after it. vi.setSystemTime(new Date("2025-03-31T12:00:00Z")); const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rrule: "FREQ=DAILY", timesOfDay: ["08:00"], }, ]; // Log a taken intake around 08:00 Berlin local for each of the past // 7 days. The ±12 h pairing radius absorbs the DST hour shift, so a // daily schedule across the spring-forward boundary stays compliant. // Log a taken intake around 08:00 Berlin local for each day spanning // the window with a one-day pad on each edge. The ±12 h pairing // radius absorbs the DST hour shift, so every expected daily slot // across the spring-forward boundary pairs with a logged intake. const events = Array.from({ length: 10 }, (_, i) => { const sched = new Date( new Date("2025-03-31T12:00:00Z").getTime() - (i - 1) * DAY_MS, ); sched.setUTCHours(6, 30, 0, 0); // ~08:00 Berlin (CET/CEST) return { scheduledFor: sched, takenAt: sched, skipped: false }; }); const result = calculateCompliance(events, schedules, 7, undefined, { medicationContext: ctx({ timeZone: "Europe/Berlin" }), }); // Daily cadence across the DST boundary stays fully compliant — no // expected slot is left unpaired. expect(result.rate).toBe(100); expect(result.missed).toBe(0); }); it("B15: legacy daysOfWeek row with two timesOfDay — 2×/day taken reads 100%, not 50%", () => { // Regression for the compliance divergence: a plain `daysOfWeek` // schedule (no rrule / rolling, SCHEDULED, not one-shot) carrying two // `timesOfDay` must expand its numerator through the same engine as // the denominator. Before the fix the numerator's local legacy walker // emitted one slot/day from `windowStart`, while the denominator's // engine counted both — collapsing a fully-adherent 2×/day med to // 1/2 = 50%. const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "19:30", daysOfWeek: null, // every day timesOfDay: ["08:00", "19:00"], // no rrule, no rollingIntervalDays, scheduleType defaults SCHEDULED }, ]; // Pin a single-day window so exactly two slots are expected. NOW is // late evening UTC so both of today's slots are in the past. vi.setSystemTime(new Date("2025-06-09T23:30:00Z")); const events = [ eventAt(new Date("2025-06-09T08:00:00Z"), true), eventAt(new Date("2025-06-09T19:00:00Z"), true), ]; const result = calculateCompliance(events, schedules, 1, undefined, { medicationContext: ctx({ startsOn: new Date("2025-05-01T00:00:00Z") }), }); // Both daily slots expand and both pair with a taken intake → 2/2. expect(result.totalExpected).toBe(2); expect(result.taken).toBe(2); expect(result.rate).toBe(100); }); it("streak is computed in the USER's timezone, not the host's", () => { // The timeline `slot.day` is minted in the user's IANA zone. The // streak walk must key days in the SAME zone — the prior host-tz // `getFullYear/getMonth/getDate` walk drifted off by a day whenever // the server clock's zone differed from the user's. Use a far-east // user zone (UTC+13) so the user-local day for a near-UTC-midnight // intake clearly differs from the host/UTC day; a daily-taken stream // must still yield an unbroken streak. const tz = "Pacific/Auckland"; vi.setSystemTime(new Date("2025-06-10T11:00:00Z")); // ~23:00 NZST. const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, timesOfDay: ["08:00"], }, ]; // Taken near 08:00 Auckland (= ~20:00 UTC previous day) for each of // the past 7 user-local days. const events = Array.from({ length: 7 }, (_, i) => { const sched = new Date( new Date("2025-06-09T20:00:00Z").getTime() - i * DAY_MS, ); return { scheduledFor: sched, takenAt: sched, skipped: false }; }); const result = calculateCompliance(events, schedules, 7, undefined, { medicationContext: ctx({ timeZone: tz, createdAt: new Date("2025-05-01T00:00:00Z"), }), }); // Every user-local day in the window was taken → a multi-day streak. // The host-tz walk would have mis-keyed the boundary days and broken // the streak early; the user-tz walk counts them all. expect(result.streak).toBeGreaterThanOrEqual(6); }); }); // ──────────────────────────────────────────────────────────────────── // v1.7.0 item 5 — per-day due / expectedCount helpers // ──────────────────────────────────────────────────────────────────── describe("expectedSlotCountForDay + lastNonSkippedTakenAt", () => { function ctx( overrides: Partial = {}, ): ComplianceMedicationContext { return buildComplianceMedicationContext( { startsOn: overrides.startsOn ?? null, endsOn: overrides.endsOn ?? null, oneShot: overrides.oneShot ?? false, createdAt: overrides.createdAt ?? new Date("2024-12-01T00:00:00Z"), }, overrides.lastIntakeAt ?? null, overrides.timeZone ?? "UTC", ); } it("weekly BYDAY — due on the matching weekday, not due otherwise", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rrule: "FREQ=WEEKLY;BYDAY=MO", timesOfDay: ["08:00"], }, ]; // 2025-01-13 is a Monday; 2025-01-14 a Tuesday. const monday = expectedSlotCountForDay( schedules, new Date("2025-01-13T00:00:00Z"), new Date("2025-01-14T00:00:00Z"), ctx(), ); const tuesday = expectedSlotCountForDay( schedules, new Date("2025-01-14T00:00:00Z"), new Date("2025-01-15T00:00:00Z"), ctx(), ); expect(monday).toBe(1); expect(tuesday).toBe(0); }); it("PRN — never due", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, scheduleType: "PRN", rrule: "FREQ=DAILY", timesOfDay: ["08:00"], }, ]; const count = expectedSlotCountForDay( schedules, new Date("2025-01-13T00:00:00Z"), new Date("2025-01-14T00:00:00Z"), ctx(), ); expect(count).toBe(0); }); it("multi time-of-day daily — expectedCount reflects each dose", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rrule: "FREQ=DAILY", timesOfDay: ["08:00", "20:00"], }, ]; const count = expectedSlotCountForDay( schedules, new Date("2025-01-13T00:00:00Z"), new Date("2025-01-14T00:00:00Z"), ctx(), ); expect(count).toBe(2); }); it("B15 invariant: legacy multi-time row — denominator and numerator expand identically", () => { // The B15 bug lived in the numerator's expander, not here — this // helper always ran the engine. Pin the convergence directly: for a // plain `daysOfWeek` row carrying two `timesOfDay` (no rrule), the // per-day denominator and the cadence numerator // (`buildCadenceTimeline`) must report the same slot count. const dayStart = new Date("2025-06-09T00:00:00Z"); const dayEnd = new Date("2025-06-10T00:00:00Z"); const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "19:30", daysOfWeek: null, timesOfDay: ["08:00", "19:00"], }, ]; const medCtx = ctx({ startsOn: new Date("2025-05-01T00:00:00Z"), timeZone: "Europe/Berlin", }); const denominator = expectedSlotCountForDay( schedules, dayStart, dayEnd, medCtx, ); const numerator = buildCadenceTimeline( [ { windowStart: "08:00", windowEnd: "19:30", daysOfWeek: null, timesOfDay: ["08:00", "19:00"], }, ], [], new Date("2025-06-09T23:59:00Z"), 1, dayStart, medCtx.timeZone, { startsOn: medCtx.startsOn, endsOn: medCtx.endsOn, oneShot: medCtx.oneShot, createdAt: medCtx.createdAt, lastIntakeAt: medCtx.lastIntakeAt, timeZone: medCtx.timeZone, }, ).length; expect(numerator).toBe(denominator); expect(numerator).toBe(2); }); it("lastNonSkippedTakenAt picks the newest non-skipped takenAt", () => { const events = [ { takenAt: new Date("2025-01-10T08:00:00Z"), skipped: false }, { takenAt: new Date("2025-01-12T08:00:00Z"), skipped: false }, { takenAt: new Date("2025-01-13T08:00:00Z"), skipped: true }, { takenAt: null, skipped: false }, ]; expect(lastNonSkippedTakenAt(events)?.toISOString()).toBe( "2025-01-12T08:00:00.000Z", ); expect(lastNonSkippedTakenAt([])).toBe(null); }); // v1.7.0 code-correctness M1 — the per-med compliance route must // anchor each daily cell on the user-tz local-day boundary so the // `due` / `expectedCount` flag attaches to the calendar cell the user // actually sees. A UTC-midnight slice would shove a tz-distant user's // dose into the adjacent day. These tests model the route's day // computation (getUserTodayBounds + userDayKey) and assert the engine // counts the dose in the cell its dateKey labels. it("anchors the due slot on the user-tz local day for a UTC+13 user", () => { const tz = "Pacific/Auckland"; // UTC+12, +13 in DST (January = NZDT +13) const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rrule: "FREQ=DAILY", timesOfDay: ["08:00"], }, ]; // A representative instant inside 2025-01-14 local (noon NZ). const representative = new Date("2025-01-14T12:00:00+13:00"); const { start, end } = getUserTodayBounds(representative, tz); const dayEnd = new Date(end.getTime() + 1); // half-open [start, dayEnd) // The cell key is the user-tz day, not the UTC slice. 08:00 NZ on // the 14th is 19:00 UTC on the 13th — a UTC slice would mislabel it. expect(userDayKey(start, tz)).toBe("2025-01-14"); const count = expectedSlotCountForDay(schedules, start, dayEnd, ctx({ timeZone: tz })); expect(count).toBe(1); }); it("does not double-count or drop a dose at the user-tz day boundary", () => { const tz = "Pacific/Auckland"; const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rrule: "FREQ=DAILY", timesOfDay: ["08:00"], }, ]; // Two adjacent local days: the 14th must hold exactly one dose, the // 13th exactly one — neither steals the other's slot. const day14 = getUserTodayBounds(new Date("2025-01-14T12:00:00+13:00"), tz); const day13 = getUserTodayBounds(new Date("2025-01-13T12:00:00+13:00"), tz); const count14 = expectedSlotCountForDay( schedules, day14.start, new Date(day14.end.getTime() + 1), ctx({ timeZone: tz }), ); const count13 = expectedSlotCountForDay( schedules, day13.start, new Date(day13.end.getTime() + 1), ctx({ timeZone: tz }), ); expect(count14).toBe(1); expect(count13).toBe(1); expect(userDayKey(day14.start, tz)).toBe("2025-01-14"); expect(userDayKey(day13.start, tz)).toBe("2025-01-13"); }); }); describe("classifyIntakeTiming", () => { // v1.4.34 IW-C — the classifier now widens the pre-window grace to // 3h and introduces an `early` bucket so a proactive logger (10 min // before the window) is no longer flushed to `very_late`. Doses up // to 3h past `windowEnd` stay `on_time`; `late` spans the next 2h // tail; anything beyond is `very_late`. Overnight windows are // exercised in parallel by the parameterised matrix below. const scheduledDate = new Date("2025-01-15T00:00:00Z"); it('returns "missed" when takenAt is null', () => { expect(classifyIntakeTiming(null, "08:00", "09:00", scheduledDate)).toBe( "missed", ); }); it('returns "on_time" when taken within the window', () => { const takenAt = new Date("2025-01-15T08:30:00Z"); expect(classifyIntakeTiming(takenAt, "08:00", "09:00", scheduledDate)).toBe( "on_time", ); }); it('returns "on_time" when taken exactly at windowStart', () => { const takenAt = new Date("2025-01-15T08:00:00Z"); expect(classifyIntakeTiming(takenAt, "08:00", "09:00", scheduledDate)).toBe( "on_time", ); }); it('returns "on_time" when taken exactly at windowEnd', () => { const takenAt = new Date("2025-01-15T09:00:00Z"); expect(classifyIntakeTiming(takenAt, "08:00", "09:00", scheduledDate)).toBe( "on_time", ); }); // Parameterised offset matrix relative to a `08:00 → 09:00` window. // Negative offsets are minutes before `windowStart` (08:00); positive // offsets are minutes after `windowEnd` (09:00). The reference // boundaries are: `early` from -180 to -1 min before start; `on_time` // from start through windowEnd + 180 min; `late` for the next 120 // min; `very_late` past that or beyond the 3h pre-window grace. it.each<[label: string, offsetMin: number, expected: IntakeTimingClass]>([ ["3.5h before window → very_late", -210, "very_late"], ["exactly 3h before window → early", -180, "early"], ["1h before window → early", -60, "early"], ["10 min before window → early", -10, "early"], ["exactly at windowStart → on_time", 0, "on_time"], ["10 min into the window → on_time", 10, "on_time"], ["20 min past windowEnd → on_time", 80, "on_time"], ["1h past windowEnd → on_time", 120, "on_time"], ["exactly 3h past windowEnd → on_time", 240, "on_time"], ["3.5h past windowEnd → late", 270, "late"], ["5h past windowEnd → late (tail boundary)", 360, "late"], ["5h 1min past windowEnd → very_late", 361, "very_late"], ])("offset case: %s", (_label, offsetMin, expected) => { // The matrix expresses offsets relative to windowStart (negative) // or relative to windowEnd (positive). 0 sits at windowStart, +60 // sits at windowEnd, then positive offsets accumulate past // windowEnd. With windowStart=08:00 and windowEnd=09:00, the // base instant is 08:00Z; positive offsets walk forward from there. const baseMs = new Date("2025-01-15T08:00:00Z").getTime(); const takenAt = new Date(baseMs + offsetMin * 60 * 1000); expect(classifyIntakeTiming(takenAt, "08:00", "09:00", scheduledDate)).toBe( expected, ); }); it('returns "very_late" when taken way before the grace period', () => { const takenAt = new Date("2025-01-15T03:00:00Z"); // 5h before 08:00 expect(classifyIntakeTiming(takenAt, "08:00", "09:00", scheduledDate)).toBe( "very_late", ); }); it('respects the configurable `lateMinutes` tail', () => { // With lateMinutes=30 the late tail collapses to 30 min after the // 3h on-time grace. windowEnd is 09:00 so `on_time` extends to // 12:00 and `late` extends to 12:30. A dose at 12:15 falls in // `late`; one at 12:45 falls in `very_late`. const takenLate = new Date("2025-01-15T12:15:00Z"); expect( classifyIntakeTiming(takenLate, "08:00", "09:00", scheduledDate, { lateMinutes: 30, }), ).toBe("late"); const takenVeryLate = new Date("2025-01-15T12:45:00Z"); expect( classifyIntakeTiming(takenVeryLate, "08:00", "09:00", scheduledDate, { lateMinutes: 30, }), ).toBe("very_late"); }); it("handles overnight windows (windowEnd < windowStart)", () => { // Schedule: 23:00 - 01:00 (overnight) const takenAt = new Date("2025-01-15T23:30:00Z"); expect(classifyIntakeTiming(takenAt, "23:00", "01:00", scheduledDate)).toBe( "on_time", ); }); it("handles overnight window early intake", () => { // Schedule: 23:00 - 01:00, taken at 22:30 (30 min before windowStart) const takenAt = new Date("2025-01-15T22:30:00Z"); expect(classifyIntakeTiming(takenAt, "23:00", "01:00", scheduledDate)).toBe( "early", ); }); it("handles overnight window late intake", () => { // Schedule: 23:00 - 01:00, taken at 04:30 (3.5h past 01:00) const takenAt = new Date("2025-01-16T04:30:00Z"); expect(classifyIntakeTiming(takenAt, "23:00", "01:00", scheduledDate)).toBe( "late", ); }); it("handles overnight window very late intake", () => { // Schedule: 23:00 - 01:00, taken at 07:00 (6h past 01:00) const takenAt = new Date("2025-01-16T07:00:00Z"); expect(classifyIntakeTiming(takenAt, "23:00", "01:00", scheduledDate)).toBe( "very_late", ); }); }); // v1.8.5 — the cadence-density rule + the per-dose uptime strip. // `buildComplianceDisplay` decides whether the card keeps the 7-/30-day // percentage bars (dense cadences) or swaps to a per-dose timeline // (sparse cadences). The 30-day window is the density yardstick. // v1.8.6 — the compliance display is always two percentage rows; only the // window day-counts scale with the dosing cadence. `selectComplianceWindows` // walks a `[7,30] → [30,90] → [90,365]` ladder and returns the densest rung // whose BOTH windows clear `MIN_STABLE_DOSES` realised expected doses, so a // daily med stays on 7 / 30, a weekly med steps up, and a rare injection // lands on the widest rung. The timeline rendering is gone. describe("buildComplianceDisplay — two rows, cadence-scaled windows", () => { const NOW = new Date("2025-06-15T12:00:00Z"); beforeEach(() => { vi.useFakeTimers(); vi.setSystemTime(NOW); }); afterEach(() => { vi.useRealTimers(); }); function ctx( overrides: Partial = {}, ): ComplianceMedicationContext { return buildComplianceMedicationContext( { startsOn: overrides.startsOn ?? null, endsOn: overrides.endsOn ?? null, oneShot: overrides.oneShot ?? false, // Created well before the windows so no day is excluded. createdAt: overrides.createdAt ?? new Date("2025-01-01T00:00:00Z"), }, overrides.lastIntakeAt ?? null, overrides.timeZone ?? "UTC", ); } it("echoes the density floor so a client can re-derive the rung", () => { const display = buildComplianceDisplay( [], [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rrule: "FREQ=DAILY", timesOfDay: ["08:00"], }, ], ctx(), { now: NOW }, ); expect(display.minStableDoses).toBe(MIN_STABLE_DOSES); }); it("daily med → 7 / 30-day windows (the densest rung clears the floor)", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rrule: "FREQ=DAILY", timesOfDay: ["08:00"], }, ]; const display = buildComplianceDisplay([], schedules, ctx(), { now: NOW }); expect(display.shortDays).toBe(7); expect(display.longDays).toBe(30); // Both windows hold ≥ 4 expected doses. expect(display.expectedShort).toBeGreaterThanOrEqual(MIN_STABLE_DOSES); expect(display.expectedLong).toBeGreaterThanOrEqual(MIN_STABLE_DOSES); }); it("weekly med → steps up to 30 / 90-day windows", () => { // Weekly Mondays-only: the 7-day window holds at most one Monday (< 4), // so the ladder steps up. The 30-day window holds ~4 Mondays and the // 90-day window ~13 — the [30, 90] rung is the densest that clears the // floor on both rows. const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rrule: "FREQ=WEEKLY;BYDAY=MO", timesOfDay: ["08:00"], }, ]; const display = buildComplianceDisplay([], schedules, ctx(), { now: NOW }); expect(display.shortDays).toBe(30); expect(display.longDays).toBe(90); expect(display.expectedShort).toBeGreaterThanOrEqual(MIN_STABLE_DOSES); expect(display.expectedLong).toBeGreaterThanOrEqual(MIN_STABLE_DOSES); }); it("35-day rolling injection → widest 90 / 365-day windows", () => { // One dose every five weeks: the 30-day window never holds ≥ 4, so the // ladder climbs to the top rung where a full year holds ~10 doses. const schedules: ComplianceSchedule[] = [ { windowStart: "10:00", windowEnd: "11:00", daysOfWeek: null, rollingIntervalDays: 35, timesOfDay: ["10:00"], }, ]; const display = buildComplianceDisplay( [], schedules, ctx({ startsOn: new Date("2024-06-01T00:00:00Z"), lastIntakeAt: new Date("2025-05-20T10:00:00Z"), }), { now: NOW }, ); expect(display.shortDays).toBe(90); expect(display.longDays).toBe(365); }); it("a brand-new sparse med still returns two rows on the widest rung", () => { // Started two days ago: no rung clears the floor. The selection falls // back to the widest rung so the card still shows two honest rows. const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rollingIntervalDays: 35, timesOfDay: ["08:00"], }, ]; const display = buildComplianceDisplay( [], schedules, ctx({ startsOn: new Date("2025-06-13T00:00:00Z") }), { now: NOW }, ); expect(display.shortDays).toBe(90); expect(display.longDays).toBe(365); }); it("the row rates match calculateCompliance over the chosen windows", () => { // Daily med, perfect adherence over the trailing two weeks → 100% both // rows. Pins that the display rate equals the cadence-aware calculator. const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rrule: "FREQ=DAILY", timesOfDay: ["08:00"], }, ]; const events = []; for (let d = 1; d <= 30; d++) { const at = new Date(NOW.getTime() - d * DAY_MS); at.setUTCHours(8, 10, 0, 0); events.push({ scheduledFor: at, takenAt: at, skipped: false }); } const context = ctx(); const display = buildComplianceDisplay(events, schedules, context, { now: NOW, }); const short = calculateCompliance( events, schedules, display.shortDays, context.createdAt, { now: NOW, medicationContext: context }, ); const long = calculateCompliance( events, schedules, display.longDays, context.createdAt, { now: NOW, medicationContext: context }, ); expect(display.short.rate).toBe(short.rate); expect(display.long.rate).toBe(long.rate); expect(display.short.streak).toBe(short.streak); }); it("never reports a timeline mode field — the display is two rows only", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rrule: "FREQ=DAILY", timesOfDay: ["08:00"], }, ]; const display = buildComplianceDisplay([], schedules, ctx(), { now: NOW }); expect(display).not.toHaveProperty("mode"); expect(display).not.toHaveProperty("doseTimeline"); expect(display.short).toBeDefined(); expect(display.long).toBeDefined(); }); it("7-day rolling injection with history → [30, 90] windows (not the widest fallback)", () => { // v1.13.x Fix 3B — after the retrospective rolling expansion, // `expectedSlotsBetween` returns the real per-cycle grid for rolling, so // a 7-day rolling injection with a faithful history clears the floor on // the [30, 90] rung instead of falling through to the widest [90, 365] // fallback (the pre-fix behaviour, where rolling emitted ≤ 1 slot). const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rollingIntervalDays: 7, timesOfDay: ["08:00"], }, ]; // ~16 weekly shots back from a most-recent shot 3 days ago. const lastShot = new Date(NOW.getTime() - 3 * DAY_MS); const events = Array.from({ length: 16 }, (_, i) => { const at = new Date(lastShot.getTime() - i * 7 * DAY_MS); at.setUTCHours(20, 0, 0, 0); return { scheduledFor: at, takenAt: at, skipped: false }; }); const display = buildComplianceDisplay( events, schedules, ctx({ startsOn: events[events.length - 1].takenAt, lastIntakeAt: events[0].takenAt, }), { now: NOW }, ); expect(display.shortDays).toBe(30); expect(display.longDays).toBe(90); expect(display.expectedShort).toBeGreaterThanOrEqual(MIN_STABLE_DOSES); expect(display.expectedLong).toBeGreaterThanOrEqual(MIN_STABLE_DOSES); }); it("currentCycle — rolling weekly, last shot 3 days ago → on_track (not a red miss)", () => { // v1.13.x Fix 4 — a between-doses sparse med must NOT render a scary // state. Last shot 3 days ago → next due in 4 days → the open cycle is // on_track with a future nextDueAt. const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rollingIntervalDays: 7, timesOfDay: ["08:00"], }, ]; const lastShot = new Date(NOW.getTime() - 3 * DAY_MS); const events = [ { scheduledFor: lastShot, takenAt: lastShot, skipped: false }, ]; const display = buildComplianceDisplay( events, schedules, ctx({ startsOn: lastShot, lastIntakeAt: lastShot }), { now: NOW }, ); expect(display.currentCycle.state).toBe("on_track"); expect(display.currentCycle.nextDueAt).not.toBeNull(); expect(display.currentCycle.nextDueAt!.getTime()).toBeGreaterThan( NOW.getTime(), ); expect(display.currentCycle.hasClosedCycles).toBe(true); }); it("currentCycle — rolling weekly overdue past grace → missed", () => { // v1.13.x Fix 4 — last shot ~10 days ago (cadence 7) → next due was 3 // days ago, well past grace → the open cycle is `missed` (the only red // state). nextDueAt is in the past. const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rollingIntervalDays: 7, timesOfDay: ["08:00"], }, ]; const lastShot = new Date(NOW.getTime() - 10 * DAY_MS); const events = [ { scheduledFor: lastShot, takenAt: lastShot, skipped: false }, ]; const display = buildComplianceDisplay( events, schedules, ctx({ startsOn: lastShot, lastIntakeAt: lastShot }), { now: NOW }, ); expect(display.currentCycle.state).toBe("missed"); expect(display.currentCycle.nextDueAt).not.toBeNull(); expect(display.currentCycle.nextDueAt!.getTime()).toBeLessThan( NOW.getTime(), ); }); it("currentCycle — brand-new sparse med with zero closed cycles → hasClosedCycles false", () => { // v1.13.x Fix 4 — a med created today with no logged intake has no // closed dose cycle; the percentage rows are vacuous and the card should // show a neutral state rather than a misleading 100% / 0%. const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rollingIntervalDays: 7, timesOfDay: ["08:00"], }, ]; const display = buildComplianceDisplay( [], schedules, ctx({ startsOn: new Date(NOW.getTime() + 4 * DAY_MS), // first dose in the future createdAt: NOW, }), { now: NOW }, ); expect(display.currentCycle.hasClosedCycles).toBe(false); expect(display.currentCycle.state).toBe("on_track"); }); it("a 2-day-old daily med's expected counts reflect its real age", () => { // Created two days ago: the expected-dose counts must reflect ~2 days // of daily doses, not the 7 / 30 a full-window walk would report. No // rung clears the floor, so the selection falls back to the widest // rung while keeping the counts age-accurate. const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rrule: "FREQ=DAILY", timesOfDay: ["08:00"], }, ]; const createdAt = new Date(NOW.getTime() - 2 * DAY_MS); const display = buildComplianceDisplay([], schedules, ctx({ createdAt }), { now: NOW, }); // ~2 days of daily doses — nowhere near the 7 a 7-day window or the 30 // a 30-day window would report before the createdAt clamp. expect(display.expectedShort).toBeLessThanOrEqual(3); expect(display.expectedLong).toBeLessThanOrEqual(3); // No rung clears the floor → widest windows still render two rows. expect(display.shortDays).toBe(90); expect(display.longDays).toBe(365); }); // v1.15.8 — the card renders the taken-of-expected count next to each rate // so two identical percentages stay distinguishable. These pin the count // numerators onto the display block and guard against a future regression // where every window collapses to the same rate AND the same count (which // would read as a stuck display rather than a real, trustworthy number). it("carries a taken-dose count on each window row", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rrule: "FREQ=DAILY", timesOfDay: ["08:00"], }, ]; // Daily med, perfect adherence over the trailing 30 days. const events = []; for (let d = 1; d <= 30; d++) { const at = new Date(NOW.getTime() - d * DAY_MS); at.setUTCHours(8, 10, 0, 0); events.push({ scheduledFor: at, takenAt: at, skipped: false }); } const display = buildComplianceDisplay(events, schedules, ctx(), { now: NOW, }); // Both rows ~100% — but the COUNTS differ (7-day window has fewer taken // doses than the 30-day window), so the two rows are distinguishable even // when the percentages are identical. expect(display.short.taken).toBeGreaterThan(0); expect(display.long.taken).toBeGreaterThan(0); expect(display.long.taken).toBeGreaterThan(display.short.taken); // The taken count never exceeds its window's expected denominator. expect(display.short.taken).toBeLessThanOrEqual(display.expectedShort); expect(display.long.taken).toBeLessThanOrEqual(display.expectedLong); }); it("a daily med with misses concentrated outside the 7-day window → 7d ≠ 30d rate", () => { // Guards the "looks broken" report from the other direction: the windows // must NOT collapse to one value. A daily med taken every day inside the // last 7 days but with a cluster of misses in the 8–30-day range yields a // perfect short window and a degraded long window, so the two rows // genuinely differ. const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rrule: "FREQ=DAILY", timesOfDay: ["08:00"], }, ]; const events = []; for (let d = 1; d <= 30; d++) { // Days 1–7: every dose taken. Days 10–20: missed (no event row). if (d >= 10 && d <= 20) continue; const at = new Date(NOW.getTime() - d * DAY_MS); at.setUTCHours(8, 10, 0, 0); events.push({ scheduledFor: at, takenAt: at, skipped: false }); } const display = buildComplianceDisplay(events, schedules, ctx(), { now: NOW, }); // Daily med stays on the 7 / 30-day rung. expect(display.shortDays).toBe(7); expect(display.longDays).toBe(30); // The recent week is clean; the month carries the 10–20-day miss cluster. // The windows MUST diverge — the short window outscores the long one, // which is the whole point of showing two rows rather than one number. expect(display.short.rate).toBeGreaterThan(display.long.rate); expect(display.long.rate).toBeLessThan(100); expect(display.short.rate).not.toBe(display.long.rate); }); it("a rolling weekly med with a partial-adherence history → short and long rates CAN differ", () => { // The operator's "every window is 100%" suspicion is real ONLY for a // faithfully-on-cadence med; once doses are missed the windows MUST be // able to diverge. A weekly rolling injection with recent perfect weeks // but missed shots further back drives the short rate above the long rate // — proving the metric does not structurally collapse to one value. const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rollingIntervalDays: 7, timesOfDay: ["08:00"], }, ]; const lastShot = new Date(NOW.getTime() - 3 * DAY_MS); // 16 weekly slots back; drop a cluster of older shots (weeks 8–12) so the // long window scores a real miss while the recent weeks stay perfect. const events = Array.from({ length: 16 }, (_, i) => i) .filter((i) => i < 6 || i > 11) .map((i) => { const at = new Date(lastShot.getTime() - i * 7 * DAY_MS); at.setUTCHours(20, 0, 0, 0); return { scheduledFor: at, takenAt: at, skipped: false }; }); const display = buildComplianceDisplay( events, schedules, ctx({ startsOn: new Date(lastShot.getTime() - 15 * 7 * DAY_MS), lastIntakeAt: lastShot, }), { now: NOW }, ); // The windows are NOT forced equal: the recent short window outscores the // longer one that carries the dropped cluster. expect(display.short.rate).toBeGreaterThan(display.long.rate); }); }); describe("expectedSlotsBetween", () => { function ctx( overrides: Partial = {}, ): ComplianceMedicationContext { return buildComplianceMedicationContext( { startsOn: overrides.startsOn ?? null, endsOn: overrides.endsOn ?? null, oneShot: overrides.oneShot ?? false, createdAt: overrides.createdAt ?? new Date("2025-01-01T00:00:00Z"), }, overrides.lastIntakeAt ?? null, overrides.timeZone ?? "UTC", ); } it("returns the occurrences themselves, ascending by instant", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rrule: "FREQ=DAILY", timesOfDay: ["08:00", "20:00"], }, ]; const slots = expectedSlotsBetween( schedules, new Date("2025-06-09T00:00:00Z"), new Date("2025-06-10T23:59:59Z"), ctx(), ); // Two days × two times = four slots, ascending. expect(slots.length).toBe(4); for (let i = 1; i < slots.length; i++) { expect(slots[i].at.getTime()).toBeGreaterThanOrEqual( slots[i - 1].at.getTime(), ); } }); it("excludes PRN schedules from the expected slots", () => { const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, scheduleType: "PRN", rrule: "FREQ=DAILY", timesOfDay: ["08:00"], }, ]; const slots = expectedSlotsBetween( schedules, new Date("2025-06-09T00:00:00Z"), new Date("2025-06-12T00:00:00Z"), ctx(), ); expect(slots.length).toBe(0); }); it("clamps the window lower bound to createdAt for a young med", () => { // A daily med created two days before the window's upper bound: the // legacy weekday walker floors on `startsOn` (none here) but not on // `createdAt`, so without the clamp this 30-day window would count // ~30 days of pre-creation slots. With the clamp only the ~2 days the // med actually existed emit a slot. const to = new Date("2025-06-15T00:00:00Z"); const from = new Date(to.getTime() - 30 * DAY_MS); const createdAt = new Date(to.getTime() - 2 * DAY_MS); const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rrule: "FREQ=DAILY", timesOfDay: ["08:00"], }, ]; const slots = expectedSlotsBetween(schedules, from, to, ctx({ createdAt })); // Daily cadence over ~2 days → at most 3 slots, never the ~30 a full // 30-day window would otherwise emit. expect(slots.length).toBeLessThanOrEqual(3); expect(slots.length).toBeGreaterThanOrEqual(1); // Every emitted slot lands at or after the creation instant. for (const s of slots) { expect(s.at.getTime()).toBeGreaterThanOrEqual(createdAt.getTime()); } }); it("leaves the window untouched when createdAt predates it", () => { // createdAt well before `from` → the clamp is a no-op and the full // window's slots survive. const to = new Date("2025-06-15T00:00:00Z"); const from = new Date(to.getTime() - 7 * DAY_MS); const schedules: ComplianceSchedule[] = [ { windowStart: "08:00", windowEnd: "09:00", daysOfWeek: null, rrule: "FREQ=DAILY", timesOfDay: ["08:00"], }, ]; const slots = expectedSlotsBetween( schedules, from, to, ctx({ createdAt: new Date("2025-01-01T00:00:00Z") }), ); // A full week of daily doses → ~7 slots. expect(slots.length).toBeGreaterThanOrEqual(7); }); });