import { EnvironmentId } from "@t3tools/contracts";import { describe, expect, it, vi } from "vite-plus/test"; import {  writeUsagePrices,  type UsagePriceTarget,  type UsagePriceWriteResult,} from "./usagePriceTargets"; const price = { inputCostPerMillionTokens: 2, outputCostPerMillionTokens: 8 };const target = (id: string, overrides: Partial<UsagePriceTarget> = {}): UsagePriceTarget => ({  environmentId: EnvironmentId.make(id),  label: id,  prices: { example: price },  unavailable: null,  ...overrides,}); describe("model price writes", () => {  it("sends all table changes in one patch per environment and skips unchanged destinations", async () => {    const write = vi.fn(async () => ({ _tag: "Success" as const }));    const onResult = vi.fn();    await writeUsagePrices({      targets: [target("edited"), target("unchanged")],      changes: new Map([        [          EnvironmentId.make("edited"),          [            { model: "new-model", price },            { model: "example", price: null },          ],        ],      ]),      write,      onResult,    });    expect(write).toHaveBeenCalledExactlyOnceWith({      environmentId: "edited",      input: { patch: { usagePriceOverrides: { "new-model": price, example: null } } },    });    expect(onResult).toHaveBeenCalledWith("unchanged", { status: "saved" });  });   it("saves independently, skips unavailable targets, and retries failures without rewriting successes", async () => {    let resolveSlow!: (result: { _tag: "Success" | "Failure" }) => void;    const slow = new Promise<{ _tag: "Success" | "Failure" }>((resolve) => {      resolveSlow = resolve;    });    let resolveFastSaved!: () => void;    const fastSaved = new Promise<void>((resolve) => {      resolveFastSaved = resolve;    });    const targets = [target("fast"), target("slow"), target("offline", { unavailable: "Offline" })];    const results = new Map<EnvironmentId, UsagePriceWriteResult>();    const write = vi.fn(async ({ environmentId }: { environmentId: EnvironmentId }) =>      environmentId === "slow" ? slow : { _tag: "Success" as const },    );    const change = { model: "example", price };    const running = writeUsagePrices({      targets,      changes: new Map(targets.map((target) => [target.environmentId, [change]])),      write,      onResult: (id, result) => {        results.set(id, result);        if (id === "fast") resolveFastSaved();      },    });    await fastSaved;    expect(results.get(EnvironmentId.make("fast"))).toEqual({ status: "saved" });    expect(results.get(EnvironmentId.make("offline"))).toEqual({      status: "failed",      error: "Offline",    });    expect(results.has(EnvironmentId.make("slow"))).toBe(false);    resolveSlow({ _tag: "Failure" });    await running;    expect(write).toHaveBeenCalledTimes(2);    expect(write).toHaveBeenCalledWith({      environmentId: "fast",      input: { patch: { usagePriceOverrides: { example: price } } },    });    const retry = vi.fn(async () => ({ _tag: "Success" as const }));    await writeUsagePrices({      targets: targets        .filter((entry) => results.get(entry.environmentId)?.status === "failed")        .map((entry) => ({ ...entry, unavailable: null })),      changes: new Map(targets.map((target) => [target.environmentId, [change]])),      write: retry,      onResult: (id, result) => {        results.set(id, result);      },    });    expect(retry.mock.calls).toHaveLength(2);    expect(retry).not.toHaveBeenCalledWith(expect.objectContaining({ environmentId: "fast" }));    expect([...results.values()].every((result) => result.status === "saved")).toBe(true);  });   it("resets only the chosen model on the selected destination", async () => {    const write = vi.fn(async () => ({ _tag: "Success" as const }));    const onResult = vi.fn();    await writeUsagePrices({      targets: [target("selected")],      changes: new Map([[EnvironmentId.make("selected"), [{ model: "example", price: null }]]]),      write,      onResult,    });    expect(write).toHaveBeenCalledExactlyOnceWith({      environmentId: "selected",      input: { patch: { usagePriceOverrides: { example: null } } },    });    expect(onResult).toHaveBeenCalledWith("selected", { status: "saved" });  });   it("reports thrown writes and permission/version restrictions without aborting other saves", async () => {    const onResult = vi.fn();    const write = vi.fn(async () => {      throw new Error("connection lost");    });    await writeUsagePrices({      targets: [        target("lost"),        target("denied", { unavailable: "Read-only access" }),        target("old", { unavailable: "Update server to edit prices" }),      ],      changes: new Map([[EnvironmentId.make("lost"), [{ model: "example", price }]]]),      write,      onResult,    });    expect(write).toHaveBeenCalledTimes(1);    expect(onResult).toHaveBeenCalledWith("lost", {      status: "failed",      error: "Could not save. Try again.",    });    expect(onResult).toHaveBeenCalledWith("denied", {      status: "failed",      error: "Read-only access",    });    expect(onResult).toHaveBeenCalledWith("old", {      status: "failed",      error: "Update server to edit prices",    });  });});