import {  EnvironmentId,  ProviderDriverKind,  ProviderInstanceId,  type ServerProvider,  type UsageLimitSourceAccount,  UsageLimitSourceId,} from "@t3tools/contracts";import { describe, expect, it } from "vite-plus/test"; import {  collectLimitSources,  collectLimitsGroups,  elapsedShare,  formatResetsIn,  limitsNotice,  paceOf,  providersWithLimits,} from "./usageLimits.ts"; const now = Date.parse("2026-09-03T12:00:00.000Z"); const window = {  id: "five_hour",  kind: "session",  label: "Session",  usedPercent: 40,  windowDurationMins: 300,  resetsAt: "2026-09-03T14:00:00.000Z",} as const; function provider(overrides: Partial<ServerProvider>): ServerProvider {  return {    instanceId: ProviderInstanceId.make("codex"),    driver: ProviderDriverKind.make("codex"),    enabled: true,    installed: true,    version: null,    status: "ready",    auth: { status: "authenticated" },    checkedAt: "2026-09-03T11:00:00.000Z",    models: [],    slashCommands: [],    skills: [],    ...overrides,  };} describe("pace", () => {  it("places the clock three fifths through a five-hour window with two hours left", () => {    expect(elapsedShare(window, now)).toBeCloseTo(0.6);    expect(paceOf(window, now)).toBe("under");    expect(paceOf({ ...window, usedPercent: 62 }, now)).toBe("on");    expect(paceOf({ ...window, usedPercent: 80 }, now)).toBe("ahead");  });   it("has no pace without a reset or a duration", () => {    expect(paceOf({ ...window, resetsAt: undefined }, now)).toBeNull();    expect(paceOf({ ...window, windowDurationMins: undefined }, now)).toBeNull();    expect(formatResetsIn({ ...window, resetsAt: undefined }, now)).toBeNull();  });   it("phrases the reset as a countdown", () => {    expect(formatResetsIn(window, now)).toBe("resets in 2h 0m");    expect(formatResetsIn({ ...window, resetsAt: "2026-09-06T15:30:00.000Z" }, now)).toBe(      "resets in 3d 3h",    );    expect(formatResetsIn({ ...window, resetsAt: "2026-09-03T11:00:00.000Z" }, now)).toBe(      "resets now",    );  });}); describe("limitsNotice", () => {  it("explains empty bars and passes provider messages through", () => {    const checkedAt = "2026-09-03T11:00:00.000Z";    expect(limitsNotice({ checkedAt, windows: [window] })).toBeNull();    expect(limitsNotice({ checkedAt, windows: [] })).toBe("No limits reported.");    expect(limitsNotice({ checkedAt, windows: [], unavailable: { reason: "unsupported" } })).toBe(      "This account has no subscription limits.",    );    expect(      limitsNotice({        checkedAt,        windows: [],        unavailable: { reason: "probeFailed", message: "Codex timed out." },      }),    ).toBe("Codex timed out.");  });}); describe("providersWithLimits", () => {  it("keeps only usable providers whose driver reports limits at all", () => {    const limits = { checkedAt: "2026-09-03T11:00:00.000Z", windows: [window] };    const codex = provider({ usageLimits: limits });    expect(      providersWithLimits([        codex,        provider({          instanceId: ProviderInstanceId.make("cursor"),          driver: ProviderDriverKind.make("cursor"),        }),        provider({          instanceId: ProviderInstanceId.make("off"),          enabled: false,          usageLimits: limits,        }),        provider({          instanceId: ProviderInstanceId.make("gone"),          installed: false,          usageLimits: limits,        }),        provider({          instanceId: ProviderInstanceId.make("shadow"),          availability: "unavailable",          usageLimits: limits,        }),      ]),    ).toEqual([codex]);  });}); describe("collectLimitsGroups", () => {  it("labels environments only when more than one reports limits", () => {    const limits = { checkedAt: "2026-09-03T11:00:00.000Z", windows: [window] };    const codex = provider({ usageLimits: limits });    const one = new Map([      ["env-a", { entry: { target: { label: "Laptop" } }, serverConfig: { providers: [codex] } }],      [        "env-b",        { entry: { target: { label: "Desktop" } }, serverConfig: { providers: [provider({})] } },      ],    ] as const);    expect(collectLimitsGroups(one as never).map((group) => group.environmentLabel)).toEqual([      null,    ]);     const two = new Map([      ["env-a", { entry: { target: { label: "Laptop" } }, serverConfig: { providers: [codex] } }],      ["env-b", { entry: { target: { label: "Desktop" } }, serverConfig: { providers: [codex] } }],    ] as const);    expect(collectLimitsGroups(two as never).map((group) => group.environmentLabel)).toEqual([      "Laptop",      "Desktop",    ]);  });}); describe("collectLimitSources", () => {  const source = {    id: UsageLimitSourceId.make("cliproxy-hub"),    kind: "cliproxy" as const,    label: "hub",    checkedAt: "2026-09-03T11:00:00.000Z",    accounts: [],  };  const limits = { checkedAt: source.checkedAt, windows: [window] };  const account: UsageLimitSourceAccount = {    id: "codex-personal",    driver: ProviderDriverKind.make("codex"),    email: "person@example.com",    plan: "ChatGPT Pro Subscription",    usageLimits: limits,  };  const native = provider({    displayName: "Personal",    auth: { status: "authenticated", email: account.email },    usageLimits: { ...limits, resetCredits: { availableCount: 2 } },  });   function presentations(    providers: readonly ServerProvider[],    accounts: readonly UsageLimitSourceAccount[] = [account],  ) {    return new Map([      [        EnvironmentId.make("env-a"),        {          entry: { target: { label: "Laptop" } },          serverConfig: { providers, usageLimitSources: [{ ...source, accounts }] },        },      ],    ]);  }   it.each(["codex", "claudeAgent"])(    "prefers native %s limits by email without changing provider rows or source snapshots",    (kind) => {      const driver = ProviderDriverKind.make(kind);      const first = { ...native, driver };      const second = { ...first, instanceId: ProviderInstanceId.make("work") };      const accounts = [{ ...account, driver, email: " Person@Example.COM " }];      const input = presentations([first, second], accounts);       expect(collectLimitSources(input)).toMatchObject([{ accounts: [], hiddenAccountCount: 1 }]);      expect(collectLimitsGroups(input)[0]?.providers).toEqual([first, second]);      expect(accounts).toHaveLength(1);      expect(first.usageLimits?.resetCredits?.availableCount).toBe(2);    },  );   it("matches across environments even when the hub is visited before the native provider", () => {    const input = presentations([]);    input.set(EnvironmentId.make("env-b"), {      entry: { target: { label: "Desktop" } },      serverConfig: { providers: [native], usageLimitSources: [] },    });     expect(collectLimitSources(input)).toMatchObject([      { accounts: [], hiddenAccountCount: 1, environmentId: "env-a" },    ]);  });   it("keeps other providers, other emails, and unidentified accounts with the same plan", () => {    const accounts = [      account,      { ...account, id: "other-provider", driver: ProviderDriverKind.make("claudeAgent") },      { ...account, id: "other-email", email: "other@example.com" },      { ...account, id: "unknown-email", email: undefined },    ];     expect(collectLimitSources(presentations([native], accounts))).toMatchObject([      { accounts: accounts.slice(1), hiddenAccountCount: 1 },    ]);    expect(      collectLimitSources(        presentations([{ ...native, auth: { status: "authenticated" } }], accounts),      )[0]?.accounts,    ).toEqual(accounts);  });   it.each([    { enabled: false },    { installed: false },    { availability: "unavailable" },    { usageLimits: undefined },    { usageLimits: { ...limits, windows: [] } },    { usageLimits: { ...limits, unavailable: { reason: "probeFailed" } } },    { usageLimits: { ...limits, unavailable: { reason: "unsupported" } } },  ] satisfies Partial<ServerProvider>[])(    "retains hub limits when the native provider cannot show them: %j",    (overrides) => {      expect(collectLimitSources(presentations([{ ...native, ...overrides }]))).toMatchObject([        { accounts: [account], hiddenAccountCount: 0 },      ]);    },  );   it("restores the hub account when the matching provider disappears", () => {    const input = presentations([native]);    expect(collectLimitSources(input)[0]?.accounts).toEqual([]);    input.delete(EnvironmentId.make("env-a"));    for (const [id, entry] of presentations([])) input.set(id, entry);     expect(collectLimitSources(input)[0]?.accounts).toEqual([account]);  });   it("keeps source errors and genuinely empty sources distinguishable from hidden accounts", () => {    const input = new Map([      [        EnvironmentId.make("env-a"),        {          entry: { target: { label: "Laptop" } },          serverConfig: {            providers: [native],            usageLimitSources: [{ ...source, error: "Hub unavailable" }],          },        },      ],    ]);    expect(collectLimitSources(input)).toMatchObject([      { accounts: [], hiddenAccountCount: 0, error: "Hub unavailable" },    ]);  });   it("keys sources per environment and names the environment only when several have some", () => {    const one = new Map([      [        "env-a",        { entry: { target: { label: "Laptop" } }, serverConfig: { usageLimitSources: [source] } },      ],      [        "env-b",        { entry: { target: { label: "Desktop" } }, serverConfig: { usageLimitSources: [] } },      ],    ] as const);    expect(collectLimitSources(one as never).map((entry) => [entry.key, entry.label])).toEqual([      ["env-a:cliproxy-hub", "hub"],    ]);     const two = new Map([      [        "env-a",        { entry: { target: { label: "Laptop" } }, serverConfig: { usageLimitSources: [source] } },      ],      [        "env-b",        { entry: { target: { label: "Desktop" } }, serverConfig: { usageLimitSources: [source] } },      ],    ] as const);    expect(collectLimitSources(two as never).map((entry) => entry.label)).toEqual([      "Laptop · hub",      "Desktop · hub",    ]);  });});