HealthLog/src/lib/oura/__tests__/sync.test.ts

import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";

const {
  getConnMock,
  storeTokensMock,
  getCredsMock,
  fetchReadinessMock,
  fetchSleepMock,
  fetchActivityMock,
  fetchDailySleepMock,
  fetchSpo2Mock,
  fetchVo2MaxMock,
  fetchCardioAgeMock,
  fetchResilienceMock,
  refreshMock,
  upsertMock,
  recordSuccessMock,
  recordFailureMock,
  recomputeMock,
  invalidateMock,
} = vi.hoisted(() => ({
  getConnMock: vi.fn(),
  storeTokensMock: vi.fn(),
  getCredsMock: vi.fn(),
  fetchReadinessMock: vi.fn(),
  fetchSleepMock: vi.fn(),
  fetchActivityMock: vi.fn(),
  fetchDailySleepMock: vi.fn(),
  fetchSpo2Mock: vi.fn(),
  fetchVo2MaxMock: vi.fn(),
  fetchCardioAgeMock: vi.fn(),
  fetchResilienceMock: vi.fn(),
  refreshMock: vi.fn(),
  upsertMock: vi.fn(),
  recordSuccessMock: vi.fn(),
  recordFailureMock: vi.fn(),
  recomputeMock: vi.fn(),
  invalidateMock: vi.fn(),
}));

vi.mock("../credentials", () => ({
  getOuraConnection: getConnMock,
  storeOuraTokens: storeTokensMock,
  getOuraClientCredentials: getCredsMock,
}));

vi.mock("@/lib/db", () => ({
  prisma: { measurement: { upsert: upsertMock } },
}));

vi.mock("@/lib/integrations/status", async (importOriginal) => ({
  ...(await importOriginal<typeof import("@/lib/integrations/status")>()),
  recordSyncSuccess: recordSuccessMock,
  recordSyncFailure: recordFailureMock,
}));

vi.mock("@/lib/rollups/measurement-rollups", () => ({
  collapseToTypeDayKeys: (rows: Array<{ type: string; measuredAt: Date }>) =>
    rows.map((r) => ({ type: r.type, measuredAt: r.measuredAt })),
  recomputeBucketsForMeasurement: recomputeMock,
}));

vi.mock("@/lib/insights/comprehensive-generate", () => ({
  invalidateStatusInsightsForTypes: invalidateMock,
}));

vi.mock("../client", async (importOriginal) => {
  const actual = await importOriginal<typeof import("../client")>();
  return {
    ...actual,
    fetchReadiness: fetchReadinessMock,
    fetchSleep: fetchSleepMock,
    fetchDailyActivity: fetchActivityMock,
    fetchDailySleep: fetchDailySleepMock,
    fetchDailySpo2: fetchSpo2Mock,
    fetchVo2Max: fetchVo2MaxMock,
    fetchCardiovascularAge: fetchCardioAgeMock,
    fetchResilience: fetchResilienceMock,
    refreshAccessToken: refreshMock,
  };
});

import { syncUserOura } from "../sync";
import { OuraApiError } from "../response-classifier";

const CONN = {
  accessToken: "acc",
  refreshToken: "ref",
  refreshTokenCiphertext: "enc(ref)",
};

beforeEach(() => {
  getConnMock.mockReset();
  // The compare-and-swap persist returns the access token the caller should use
  // (its own on a CAS win) — default to the freshly minted one.
  storeTokensMock.mockReset().mockResolvedValue("newAcc");
  getCredsMock
    .mockReset()
    .mockResolvedValue({ clientId: "c", clientSecret: "s" });
  fetchReadinessMock.mockReset().mockResolvedValue([]);
  fetchSleepMock.mockReset().mockResolvedValue([]);
  fetchActivityMock.mockReset().mockResolvedValue([]);
  fetchDailySleepMock.mockReset().mockResolvedValue([]);
  fetchSpo2Mock.mockReset().mockResolvedValue([]);
  fetchVo2MaxMock.mockReset().mockResolvedValue([]);
  fetchCardioAgeMock.mockReset().mockResolvedValue([]);
  fetchResilienceMock.mockReset().mockResolvedValue([]);
  refreshMock.mockReset();
  upsertMock.mockReset().mockResolvedValue({});
  recordSuccessMock.mockReset().mockResolvedValue(undefined);
  recordFailureMock.mockReset().mockResolvedValue(undefined);
  recomputeMock.mockReset().mockResolvedValue(undefined);
  invalidateMock.mockReset().mockResolvedValue(undefined);
});

afterEach(() => vi.clearAllMocks());

function err401() {
  return new OuraApiError({
    verb: "fetchReadiness",
    classification: "reauth_required",
    httpStatus: 401,
    reason: "http_401",
  });
}

describe("syncUserOura", () => {
  it("no-ops cleanly when unconnected", async () => {
    getConnMock.mockResolvedValue(null);
    expect(await syncUserOura("u1")).toBe(0);
    expect(recordSuccessMock).not.toHaveBeenCalled();
  });

  it("writes a readiness RECOVERY_SCORE with source OURA", async () => {
    getConnMock.mockResolvedValue(CONN);
    fetchReadinessMock.mockResolvedValue([
      { id: "x", day: "2026-06-10", score: 84 },
    ]);
    const imported = await syncUserOura("u1");
    expect(imported).toBe(1);
    const arg = upsertMock.mock.calls[0]![0];
    expect(arg.where.userId_type_source_externalId).toMatchObject({
      type: "RECOVERY_SCORE",
      source: "OURA",
      externalId: "readiness:2026-06-10:recovery",
    });
    expect(arg.create.value).toBe(84);
    expect(recordSuccessMock).toHaveBeenCalledWith("u1", "oura");
  });

  it("refreshes the token on a 401 and retries once", async () => {
    getConnMock.mockResolvedValue(CONN);
    // First call (with old token) 401s; after refresh the retry succeeds.
    fetchReadinessMock
      .mockRejectedValueOnce(err401())
      .mockResolvedValueOnce([{ id: "x", day: "2026-06-10", score: 70 }]);
    refreshMock.mockResolvedValue({
      access_token: "newAcc",
      refresh_token: "newRef",
      expires_in: 86400,
    });
    const imported = await syncUserOura("u1");
    expect(refreshMock).toHaveBeenCalledWith("ref", expect.anything());
    expect(storeTokensMock).toHaveBeenCalledWith(
      "u1",
      "newAcc",
      "newRef",
      "enc(ref)",
    );
    expect(imported).toBe(1);
    expect(recordSuccessMock).toHaveBeenCalledWith("u1", "oura");
  });

  it("reuses the peer's rotated token on a lost CAS race and still completes (no reauth)", async () => {
    getConnMock.mockResolvedValue(CONN);
    fetchReadinessMock
      .mockRejectedValueOnce(err401())
      .mockResolvedValueOnce([{ id: "x", day: "2026-06-10", score: 70 }]);
    refreshMock.mockResolvedValue({
      access_token: "newAcc",
      refresh_token: "newRef",
      expires_in: 86400,
    });
    // A concurrent sync rotated first → the persist returns the PEER's token.
    storeTokensMock.mockResolvedValue("peerAcc");

    const imported = await syncUserOura("u1");

    // The retry runs with the peer's token rather than the invalidated one.
    expect(fetchReadinessMock).toHaveBeenLastCalledWith(
      "peerAcc",
      expect.anything(),
    );
    expect(imported).toBe(1);
    expect(recordFailureMock).not.toHaveBeenCalled();
  });

  it("records reauth_required when the refresh itself fails", async () => {
    getConnMock.mockResolvedValue(CONN);
    fetchReadinessMock.mockRejectedValue(err401());
    refreshMock.mockRejectedValue(
      new OuraApiError({
        verb: "refreshAccessToken",
        classification: "reauth_required",
        httpStatus: 400,
        reason: "http_400",
        upstreamError: "invalid_grant",
      }),
    );
    await expect(syncUserOura("u1")).rejects.toBeInstanceOf(OuraApiError);
    expect(recordFailureMock).toHaveBeenCalledWith(
      expect.objectContaining({ integration: "oura", kind: "reauth_required" }),
    );
    expect(recordSuccessMock).not.toHaveBeenCalled();
  });

  it("keeps a nap and the main sleep distinct via record-scoped externalIds (B2)", async () => {
    getConnMock.mockResolvedValue(CONN);
    // Two sleep records on the same day: a main sleep + a nap.
    fetchSleepMock.mockResolvedValue([
      { id: "main", day: "2026-06-10", deep_sleep_duration: 3600 },
      { id: "nap", day: "2026-06-10", deep_sleep_duration: 1200 },
    ]);
    await syncUserOura("u1");
    const externalIds = upsertMock.mock.calls.map(
      (c) => c[0].where.userId_type_source_externalId.externalId,
    );
    expect(externalIds).toContain("sleep:main:sleep_deep");
    expect(externalIds).toContain("sleep:nap:sleep_deep");
    // The legacy day-keyed collapse would have produced one shared key.
    expect(new Set(externalIds).size).toBe(externalIds.length);
  });

  it("writes the Sleep Score and SpO2 from the new collections", async () => {
    getConnMock.mockResolvedValue(CONN);
    fetchDailySleepMock.mockResolvedValue([
      { id: "s", day: "2026-06-10", score: 80 },
    ]);
    fetchSpo2Mock.mockResolvedValue([
      { id: "o", day: "2026-06-10", spo2_percentage: { average: 97 } },
    ]);
    await syncUserOura("u1");
    const written = upsertMock.mock.calls.map((c) => ({
      type: c[0].where.userId_type_source_externalId.type,
      externalId: c[0].where.userId_type_source_externalId.externalId,
      value: c[0].create.value,
    }));
    expect(written).toContainEqual({
      type: "SLEEP_SCORE",
      externalId: "daily_sleep:2026-06-10:sleep_score",
      value: 80,
    });
    expect(written).toContainEqual({
      type: "OXYGEN_SATURATION",
      externalId: "spo2:2026-06-10:spo2",
      value: 97,
    });
  });

  it("writes VO2_MAX from the dedicated collection", async () => {
    getConnMock.mockResolvedValue(CONN);
    fetchVo2MaxMock.mockResolvedValue([
      { id: "v", day: "2026-06-10", vo2_max: 47.3 },
    ]);
    await syncUserOura("u1");
    const written = upsertMock.mock.calls.map((c) => ({
      type: c[0].where.userId_type_source_externalId.type,
      externalId: c[0].where.userId_type_source_externalId.externalId,
      value: c[0].create.value,
    }));
    expect(written).toContainEqual({
      type: "VO2_MAX",
      externalId: "vo2max:2026-06-10:vo2_max",
      value: 47.3,
    });
    // daily_stress → STRESS_SCORE is withdrawn pending ladder wiring.
    expect(written.some((w) => w.type === "STRESS_SCORE")).toBe(false);
  });

  it("writes RESILIENCE ordinal-encoded from the daily_resilience collection", async () => {
    getConnMock.mockResolvedValue(CONN);
    fetchResilienceMock.mockResolvedValue([
      { id: "r", day: "2026-06-10", level: "strong" },
    ]);
    const imported = await syncUserOura("u1");
    expect(imported).toBe(1);
    const arg = upsertMock.mock.calls[0]![0];
    expect(arg.where.userId_type_source_externalId).toMatchObject({
      type: "RESILIENCE",
      source: "OURA",
      externalId: "resilience:2026-06-10:resilience",
    });
    expect(arg.create.value).toBe(4);
    expect(arg.create.unit).toBe("level");
  });

  it("skips an unrecognised resilience level (no row)", async () => {
    getConnMock.mockResolvedValue(CONN);
    fetchResilienceMock.mockResolvedValue([
      { id: "r", day: "2026-06-10", level: "godlike" },
    ]);
    const imported = await syncUserOura("u1");
    expect(imported).toBe(0);
    expect(upsertMock).not.toHaveBeenCalled();
  });

  it("re-sync of the same day upserts RESILIENCE in place (overwrite, not duplicate)", async () => {
    getConnMock.mockResolvedValue(CONN);
    // Oura finalises a day's level after the night; a re-fetch reports a
    // different level on the SAME day → the day-keyed externalId stays stable
    // so the upsert update branch overwrites in place.
    fetchResilienceMock
      .mockResolvedValueOnce([
        { id: "r", day: "2026-06-10", level: "adequate" },
      ])
      .mockResolvedValueOnce([{ id: "r", day: "2026-06-10", level: "solid" }]);
    await syncUserOura("u1");
    await syncUserOura("u1");
    const keys = upsertMock.mock.calls.map(
      (c) => c[0].where.userId_type_source_externalId.externalId,
    );
    expect(keys).toEqual([
      "resilience:2026-06-10:resilience",
      "resilience:2026-06-10:resilience",
    ]);
    // The second sync carries the re-scored value through the update branch.
    expect(upsertMock.mock.calls[0]![0].create.value).toBe(2);
    expect(upsertMock.mock.calls[1]![0].update.value).toBe(3);
  });

  it("does NOT refresh on a 403 (not an expiry case)", async () => {
    getConnMock.mockResolvedValue(CONN);
    fetchReadinessMock.mockRejectedValue(
      new OuraApiError({
        verb: "fetchReadiness",
        classification: "reauth_required",
        httpStatus: 403,
        reason: "http_403",
      }),
    );
    await expect(syncUserOura("u1")).rejects.toBeInstanceOf(OuraApiError);
    expect(refreshMock).not.toHaveBeenCalled();
  });
});