import { describe, expect, it, vi, beforeEach } from "vitest"; // Mock the seven prepare modules. Each test sets a prepare's return to a // `served` or `pending` card. The pending card's `finalize` / `timeout` are // vi.fn so we can assert the fan-out hit the right closure. vi.mock("@/lib/insights/blood-pressure-status", () => ({ prepareBloodPressureStatusForUser: vi.fn(), })); vi.mock("@/lib/insights/weight-status", () => ({ prepareWeightStatusForUser: vi.fn(), })); vi.mock("@/lib/insights/pulse-status", () => ({ preparePulseStatusForUser: vi.fn(), })); vi.mock("@/lib/insights/bmi-status", () => ({ prepareBmiStatusForUser: vi.fn(), })); vi.mock("@/lib/insights/mood-status", () => ({ prepareMoodStatusForUser: vi.fn(), })); vi.mock("@/lib/insights/medication-compliance-status", () => ({ prepareMedicationComplianceStatusForUser: vi.fn(), })); vi.mock("@/lib/insights/general-status", () => ({ prepareGeneralStatusForUser: vi.fn(), })); vi.mock("@/lib/insights/status-provider", () => ({ runStatusCompletion: vi.fn(), })); vi.mock("@/lib/ai/capabilities/gate", () => ({ aiCapabilityForJob: vi.fn(), })); // The single-card fallback path — assert it is invoked for omitted / failed // metrics, but don't re-drive a real completion. vi.mock("@/lib/insights/status-card-generation", async (importOriginal) => { const actual = await importOriginal< typeof import("@/lib/insights/status-card-generation") >(); return { ...actual, runPreparedStatusCard: vi.fn(async () => ({})) }; }); import { prepareBloodPressureStatusForUser } from "@/lib/insights/blood-pressure-status"; import { prepareWeightStatusForUser } from "@/lib/insights/weight-status"; import { preparePulseStatusForUser } from "@/lib/insights/pulse-status"; import { prepareBmiStatusForUser } from "@/lib/insights/bmi-status"; import { prepareMoodStatusForUser } from "@/lib/insights/mood-status"; import { prepareMedicationComplianceStatusForUser } from "@/lib/insights/medication-compliance-status"; import { prepareGeneralStatusForUser } from "@/lib/insights/general-status"; import { runStatusCompletion } from "@/lib/insights/status-provider"; import { runPreparedStatusCard } from "@/lib/insights/status-card-generation"; import { aiCapabilityForJob } from "@/lib/ai/capabilities/gate"; import { generateStatusBatchForUser } from "../status-batch"; function servedCard() { return { phase: "served" as const, result: { hasProvider: true, text: "cached", cached: true, updatedAt: "t" }, }; } function pendingCard( metric: string, finalize: (arg: { content: string }) => Promise = vi.fn( async (): Promise => ({}), ), ) { const timeout = vi.fn(() => ({ hasProvider: true, text: "stub", cached: true, updatedAt: null, })); return { phase: "pending" as const, metric, userId: "u1", cacheAction: `insights.${metric}-status.en`, systemPrompt: "sys", userPrompt: `snapshot for ${metric}`, snapshotHash: "h", temperature: 0.45, noProvider: { hasProvider: false, text: "nokey", cached: true, updatedAt: null, }, timeout, finalize, }; } const ALL_PREPARES = [ prepareBloodPressureStatusForUser, prepareWeightStatusForUser, preparePulseStatusForUser, prepareBmiStatusForUser, prepareMoodStatusForUser, prepareMedicationComplianceStatusForUser, prepareGeneralStatusForUser, ]; beforeEach(() => { vi.resetAllMocks(); vi.mocked(aiCapabilityForJob).mockResolvedValue({ available: true, reason: null, onDeviceAllowed: true, } as never); }); describe("generateStatusBatchForUser — the statusText capability comes first", () => { it("builds no snapshot and makes no call while statusText is unavailable", async () => { vi.mocked(aiCapabilityForJob).mockResolvedValue({ available: false, reason: "consent_required", onDeviceAllowed: false, } as never); ALL_PREPARES.forEach((prepare, i) => { vi.mocked(prepare).mockResolvedValue(pendingCard(`m${i}`) as never); }); const result = await generateStatusBatchForUser("u1", { locale: "en" }); expect(aiCapabilityForJob).toHaveBeenCalledWith("u1", "statusText"); for (const prepare of ALL_PREPARES) expect(prepare).not.toHaveBeenCalled(); expect(runStatusCompletion).not.toHaveBeenCalled(); expect(runPreparedStatusCard).not.toHaveBeenCalled(); expect(result).toMatchObject({ served: 0, batched: 0, fellBack: 0, batchCallMade: false, }); }); }); describe("generateStatusBatchForUser — one call covers all present metrics", () => { it("issues exactly ONE provider call for the seven pending cards and fans each summary into its finalize", async () => { const mkFinalize = () => vi.fn((arg: { content: string }): Promise => { void arg; return Promise.resolve({}); }); const finalizers = { "blood-pressure": mkFinalize(), weight: mkFinalize(), pulse: mkFinalize(), bmi: mkFinalize(), mood: mkFinalize(), "medication-compliance": mkFinalize(), general: mkFinalize(), } as const; vi.mocked(prepareBloodPressureStatusForUser).mockResolvedValue( pendingCard("blood-pressure", finalizers["blood-pressure"]) as never, ); vi.mocked(prepareWeightStatusForUser).mockResolvedValue( pendingCard("weight", finalizers.weight) as never, ); vi.mocked(preparePulseStatusForUser).mockResolvedValue( pendingCard("pulse", finalizers.pulse) as never, ); vi.mocked(prepareBmiStatusForUser).mockResolvedValue( pendingCard("bmi", finalizers.bmi) as never, ); vi.mocked(prepareMoodStatusForUser).mockResolvedValue( pendingCard("mood", finalizers.mood) as never, ); vi.mocked(prepareMedicationComplianceStatusForUser).mockResolvedValue( pendingCard( "medication-compliance", finalizers["medication-compliance"], ) as never, ); vi.mocked(prepareGeneralStatusForUser).mockResolvedValue( pendingCard("general", finalizers.general) as never, ); vi.mocked(runStatusCompletion).mockResolvedValue({ kind: "ok", content: JSON.stringify({ perMetric: { bp: "BP assessment.", weight: "Weight assessment.", pulse: "Pulse assessment.", bmi: "BMI assessment.", mood: "Mood assessment.", compliance: "Adherence assessment.", general: "Overview assessment.", }, }), providerType: "anthropic", model: "x", tokensUsed: 100, } as never); const result = await generateStatusBatchForUser("u1", { locale: "en" }); // ONE provider round-trip for all seven metrics. expect(runStatusCompletion).toHaveBeenCalledTimes(1); // The chokepoint re-checks the same capability at the wire. expect(runStatusCompletion).toHaveBeenCalledWith( expect.objectContaining({ capability: "statusText" }), ); expect(result.batched).toBe(7); expect(result.fellBack).toBe(0); // Each metric's finalize got its own summary, wrapped in the { summary } // envelope each card's finalize parses. for (const f of Object.values(finalizers)) { expect(f).toHaveBeenCalledTimes(1); } const bpArg = finalizers["blood-pressure"].mock.calls[0][0]; expect(JSON.parse(bpArg.content)).toEqual({ summary: "BP assessment." }); // No card fell back to a single-card call. expect(runPreparedStatusCard).not.toHaveBeenCalled(); }); }); describe("generateStatusBatchForUser — absent metrics are omitted, not fabricated", () => { it("only prompts for the metrics with data and never finalizes an absent metric", async () => { // Five metrics resolve `served` (cache hit / unchanged / no data); only // weight + pulse are pending. vi.mocked(prepareBloodPressureStatusForUser).mockResolvedValue( servedCard() as never, ); const weightFinalize = vi.fn(async () => ({})); const pulseFinalize = vi.fn(async () => ({})); vi.mocked(prepareWeightStatusForUser).mockResolvedValue( pendingCard("weight", weightFinalize) as never, ); vi.mocked(preparePulseStatusForUser).mockResolvedValue( pendingCard("pulse", pulseFinalize) as never, ); vi.mocked(prepareBmiStatusForUser).mockResolvedValue(servedCard() as never); vi.mocked(prepareMoodStatusForUser).mockResolvedValue( servedCard() as never, ); vi.mocked(prepareMedicationComplianceStatusForUser).mockResolvedValue( servedCard() as never, ); vi.mocked(prepareGeneralStatusForUser).mockResolvedValue( servedCard() as never, ); let capturedSystem = ""; vi.mocked(runStatusCompletion).mockImplementation( async (args: { systemPrompt: string }) => { capturedSystem = args.systemPrompt; return { kind: "ok", content: JSON.stringify({ perMetric: { weight: "W.", pulse: "P." }, }), providerType: "anthropic", model: "x", tokensUsed: 10, } as never; }, ); const result = await generateStatusBatchForUser("u1", { locale: "en" }); expect(result.served).toBe(5); expect(result.batched).toBe(2); // The prompt names ONLY the present keys (in prepare order: pulse before // weight, since the batch runs [bp, pulse, weight, …]). expect(capturedSystem).toContain("keys present: pulse, weight"); expect(capturedSystem).not.toContain('"bp"'); expect(weightFinalize).toHaveBeenCalledTimes(1); expect(pulseFinalize).toHaveBeenCalledTimes(1); }); }); describe("generateStatusBatchForUser — hash gate short-circuits unchanged data", () => { it("makes NO provider call when every card resolved served (cache / unchanged)", async () => { for (const prepare of ALL_PREPARES) { vi.mocked(prepare).mockResolvedValue(servedCard() as never); } const result = await generateStatusBatchForUser("u1", { locale: "en" }); expect(runStatusCompletion).not.toHaveBeenCalled(); expect(result.served).toBe(7); expect(result.batched).toBe(0); expect(result.batchCallMade).toBe(false); }); }); describe("generateStatusBatchForUser — graceful partial degradation", () => { it("falls a metric the batch omitted back to its single-card path", async () => { const weightFinalize = vi.fn(async () => ({})); const pulseFinalize = vi.fn(async () => ({})); vi.mocked(prepareWeightStatusForUser).mockResolvedValue( pendingCard("weight", weightFinalize) as never, ); vi.mocked(preparePulseStatusForUser).mockResolvedValue( pendingCard("pulse", pulseFinalize) as never, ); for (const prepare of [ prepareBloodPressureStatusForUser, prepareBmiStatusForUser, prepareMoodStatusForUser, prepareMedicationComplianceStatusForUser, prepareGeneralStatusForUser, ]) { vi.mocked(prepare).mockResolvedValue(servedCard() as never); } // The batch returns weight but OMITS pulse. vi.mocked(runStatusCompletion).mockResolvedValue({ kind: "ok", content: JSON.stringify({ perMetric: { weight: "W." } }), providerType: "anthropic", model: "x", tokensUsed: 10, } as never); const result = await generateStatusBatchForUser("u1", { locale: "en" }); expect(weightFinalize).toHaveBeenCalledTimes(1); // pulse was omitted → fell back to the single-card path, NOT finalized // from the batch. expect(pulseFinalize).not.toHaveBeenCalled(); expect(runPreparedStatusCard).toHaveBeenCalledTimes(1); expect(result.batched).toBe(1); expect(result.fellBack).toBe(1); }); it("degrades every pending metric to its single-card path on a batch provider error", async () => { const finalizers = ALL_PREPARES.map(() => vi.fn(async () => ({}))); ALL_PREPARES.forEach((prepare, i) => { vi.mocked(prepare).mockResolvedValue( pendingCard(`m${i}`, finalizers[i]) as never, ); }); vi.mocked(runStatusCompletion).mockResolvedValue({ kind: "error", } as never); const result = await generateStatusBatchForUser("u1", { locale: "en" }); // No finalize from the batch; every metric fell back. for (const f of finalizers) expect(f).not.toHaveBeenCalled(); expect(runPreparedStatusCard).toHaveBeenCalledTimes(7); expect(result.fellBack).toBe(7); expect(result.batched).toBe(0); }); it("retries once on invalid JSON, then succeeds", async () => { const wf = vi.fn(async () => ({})); const pf = vi.fn(async () => ({})); vi.mocked(prepareWeightStatusForUser).mockResolvedValue( pendingCard("weight", wf) as never, ); vi.mocked(preparePulseStatusForUser).mockResolvedValue( pendingCard("pulse", pf) as never, ); for (const prepare of [ prepareBloodPressureStatusForUser, prepareBmiStatusForUser, prepareMoodStatusForUser, prepareMedicationComplianceStatusForUser, prepareGeneralStatusForUser, ]) { vi.mocked(prepare).mockResolvedValue(servedCard() as never); } vi.mocked(runStatusCompletion) .mockResolvedValueOnce({ kind: "ok", content: "not json at all", providerType: "anthropic", model: "x", tokensUsed: 1, } as never) .mockResolvedValueOnce({ kind: "ok", content: JSON.stringify({ perMetric: { weight: "W.", pulse: "P." } }), providerType: "anthropic", model: "x", tokensUsed: 1, } as never); const result = await generateStatusBatchForUser("u1", { locale: "en" }); expect(runStatusCompletion).toHaveBeenCalledTimes(2); expect(wf).toHaveBeenCalledTimes(1); expect(pf).toHaveBeenCalledTimes(1); expect(result.batched).toBe(2); }); it("serves the no-key result for every pending card when no provider is configured", async () => { const finalizers = ALL_PREPARES.map(() => vi.fn(async () => ({}))); ALL_PREPARES.forEach((prepare, i) => { vi.mocked(prepare).mockResolvedValue( pendingCard(`m${i}`, finalizers[i]) as never, ); }); vi.mocked(runStatusCompletion).mockResolvedValue({ kind: "none", reason: "no_provider", } as never); const result = await generateStatusBatchForUser("u1", { locale: "en" }); // No finalize, no re-issued completion (the no-key result is precomputed). for (const f of finalizers) expect(f).not.toHaveBeenCalled(); expect(runPreparedStatusCard).not.toHaveBeenCalled(); expect(result.fellBack).toBe(7); expect(result.batchCallMade).toBe(false); }); });