import { describe, expect, it } from "bun:test";
import { HostStorageManager, HostStorageRequest } from "../HostStorageManager";

describe("HostStorageManager", () => {
  it("sends requests and resolves host responses", async () => {
    const manager = new HostStorageManager();
    const requests: HostStorageRequest[] = [];
    manager.connect((request) => requests.push(request));

    const getPromise = manager.getItem("settings");
    expect(requests[0]).toMatchObject({
      operation: "getItem",
      key: "settings",
    });
    manager.handleResponse({
      id: requests[0].id,
      type: "success",
      value: "dark",
    });
    expect(await getPromise).toBe("dark");

    const setPromise = manager.setItem("settings", "light");
    expect(requests[1]).toMatchObject({
      operation: "setItem",
      key: "settings",
      value: "light",
    });
    manager.handleResponse({ id: requests[1].id, type: "success" });
    await expect(setPromise).resolves.toBeUndefined();

    const removePromise = manager.removeItem("settings");
    expect(requests[2]).toMatchObject({
      operation: "removeItem",
      key: "settings",
    });
    manager.handleResponse({ id: requests[2].id, type: "success" });
    await expect(removePromise).resolves.toBeUndefined();
  });

  it("rejects errors returned by the host", async () => {
    const manager = new HostStorageManager();
    let request: HostStorageRequest | undefined;
    manager.connect((nextRequest) => {
      request = nextRequest;
    });

    const promise = manager.setItem("settings", "value");
    manager.handleResponse({
      id: request!.id,
      type: "error",
      error: "Storage quota exceeded",
    });

    await expect(promise).rejects.toThrow("Storage quota exceeded");
  });

  it("rejects calls when host storage is unavailable", async () => {
    const manager = new HostStorageManager();

    await expect(manager.getItem("settings")).rejects.toThrow(
      "only available when the app is embedded"
    );
  });

  it("rejects pending calls when the host disconnects", async () => {
    const manager = new HostStorageManager();
    const disconnect = manager.connect(() => {});
    const promise = manager.getItem("settings");

    disconnect();

    await expect(promise).rejects.toThrow(
      "only available when the app is embedded"
    );
  });
});