import { describe, expect, it, vi } from "vite-plus/test";import { EnvironmentId } from "@t3tools/contracts"; import {  createProjectFaviconCache,  createProjectFaviconImageLoader,  PROJECT_FAVICON_CACHE_MAX_BYTES,  PROJECT_FAVICON_CACHE_MAX_ENTRIES,  PROJECT_FAVICON_MAX_DATA_URL_LENGTH,  PROJECT_FAVICON_MAX_SOURCE_BYTES,  type ProjectFaviconEntry,  type ProjectFaviconStorage,} from "./projectFaviconCache.ts"; const target = { environmentId: EnvironmentId.make("remote"), cwd: "/workspace" };const url = "https://remote.test/api/assets/token-a/vabc-icon.svg";const image = "data:image/png;base64,aWNvbg==";const replacement = "data:image/png;base64,bmV3";const signal = () => new AbortController().signal; function deferred<A>() {  let resolve!: (value: A) => void;  const promise = new Promise<A>((done) => {    resolve = done;  });  return { promise, resolve };} function fixture() {  const records = new Map<string, ProjectFaviconEntry>();  const load = vi.fn(async () => image);  const storage: ProjectFaviconStorage = {    list: async () => [...records.values()],    put: async (key, entry) => {      records.set(key, entry);    },    remove: async (key) => {      records.delete(key);    },  };  return {    storage,    load,    records,    cache: createProjectFaviconCache({ storage, load }),  };} describe("persistent project favicon cache", () => {  it("restores image bytes in a fresh client before any remote response", async () => {    const { cache, storage, load } = fixture();    expect(await cache.resolve(target, url, signal())).toBe(image);    await cache.flush();    const reloaded = createProjectFaviconCache({ storage, load });    await reloaded.hydrate();    expect(reloaded.peek(target)).toBe(image);    expect(await reloaded.resolve(target, null, signal())).toBe(image);    expect(load).toHaveBeenCalledTimes(1);  });   it("reuses the image when signed URLs or connection origins change", async () => {    const { cache, load } = fixture();    await cache.resolve(target, url, signal());    expect(      await cache.resolve(target, "https://new.test/api/assets/token-b/vabc-icon.svg", signal()),    ).toBe(image);    expect(load).toHaveBeenCalledTimes(1);  });   it("keeps the old image during refresh and failures, then persists its replacement", async () => {    const { cache, load, storage } = fixture();    await cache.resolve(target, url, signal());    const next = deferred<string>();    load.mockImplementationOnce(() => next.promise);    const refreshing = cache.resolve(target, url.replace("vabc", "vdef"), signal());    expect(cache.peek(target)).toBe(image);    next.resolve(replacement);    expect(await refreshing).toBe(replacement);    load.mockRejectedValueOnce(new Error("offline"));    expect(await cache.resolve(target, url, signal())).toBe(replacement);    await cache.flush();    expect(await createProjectFaviconCache({ storage, load }).resolve(target, null, signal())).toBe(      replacement,    );  });   it("persists confirmed removal and ignores an aborted older download", async () => {    const { cache, load, storage } = fixture();    await cache.resolve(target, url, signal());    const next = deferred<string>();    const started = deferred<void>();    load.mockImplementationOnce(() => {      started.resolve();      return next.promise;    });    const controller = new AbortController();    const pending = cache.resolve(target, url.replace("vabc", "vdef"), controller.signal);    await started.promise;    controller.abort();    expect(      await cache.resolve(        target,        "https://remote.test/api/assets/token/project-favicon-missing",        signal(),      ),    ).toBeNull();    next.resolve(replacement);    await pending;    await cache.flush();    expect(      await createProjectFaviconCache({ storage, load }).resolve(target, null, signal()),    ).toBeNull();  });   it("isolates environments, workspaces, and icon selections", async () => {    const { cache } = fixture();    await cache.resolve(target, url, signal());    expect(cache.peek({ ...target, faviconPath: null })).toBe(image);    expect(cache.peek({ ...target, faviconPath: "brand.svg" })).toBeNull();    expect(cache.peek({ ...target, cwd: "/other" })).toBeNull();    expect(cache.peek({ ...target, environmentId: EnvironmentId.make("other") })).toBeNull();  });   it.each([    {      scope: "one environment",      clear: (cache: ReturnType<typeof fixture>["cache"]) =>        cache.clearEnvironment(target.environmentId),      remaining: 1,    },    {      scope: "every environment",      clear: (cache: ReturnType<typeof fixture>["cache"]) => cache.clearAll(),      remaining: 0,    },  ])(    "does not restore images for $scope removed during a download",    async ({ clear, remaining }) => {      const { cache, load, records } = fixture();      const other = { ...target, environmentId: EnvironmentId.make("other") };      await cache.resolve(other, url, signal());      const next = deferred<string>();      const started = deferred<void>();      load.mockImplementationOnce(() => {        started.resolve();        return next.promise;      });      const pending = cache.resolve(target, url, signal());      await started.promise;      await clear(cache);      next.resolve(image);      await pending;      await cache.flush();      expect(cache.peek(target)).toBeNull();      expect(records.size).toBe(remaining);    },  );   it("discards a download that starts while the environment is being cleared", async () => {    const records = new Map<string, ProjectFaviconEntry>();    const removal = deferred<void>();    const load = vi.fn(async () => image);    const storage: ProjectFaviconStorage = {      list: async () => [...records.values()],      put: async (key, entry) => {        records.set(key, entry);      },      remove: async (key) => {        await removal.promise;        records.delete(key);      },    };    const cache = createProjectFaviconCache({ storage, load });    await cache.resolve(target, url, signal());    await cache.flush();    const clearing = cache.clearEnvironment(target.environmentId);    await Promise.resolve();    const late = cache.resolve(target, url.replace("vabc", "vdef"), signal());    removal.resolve();    await clearing;    expect(records.size).toBe(0);    expect(cache.peek(target)).toBeNull();    expect(load).toHaveBeenCalledTimes(1);    expect(await late).toBe(image);    expect(load).toHaveBeenCalledTimes(2);  });   it("bounds individual images, total bytes, and entry count in storage", async () => {    const { cache, load, records } = fixture();    load.mockResolvedValueOnce(      `data:image/png;base64,${"a".repeat(PROJECT_FAVICON_MAX_DATA_URL_LENGTH)}`,    );    expect(await cache.resolve(target, url, signal())).toBe(url);    expect(cache.peek(target)).toBeNull();    const large = `data:image/png;base64,${"a".repeat(PROJECT_FAVICON_MAX_DATA_URL_LENGTH - 32)}`;    load.mockResolvedValue(large);    for (let i = 0; i < 40; i++) {      await cache.resolve({ ...target, cwd: `/large-${i}` }, url, signal());    }    await cache.flush();    expect(      [...records.values()].reduce((total, entry) => total + entry.dataUrl.length, 0),    ).toBeLessThanOrEqual(PROJECT_FAVICON_CACHE_MAX_BYTES);    expect(cache.peek({ ...target, cwd: "/large-0" })).toBeNull();    expect(cache.peek({ ...target, cwd: "/large-39" })).toBe(large);    load.mockResolvedValue(image);    for (let i = 0; i <= PROJECT_FAVICON_CACHE_MAX_ENTRIES; i++) {      await cache.resolve({ ...target, cwd: `/small-${i}` }, url, signal());    }    await cache.flush();    expect(records.size).toBe(PROJECT_FAVICON_CACHE_MAX_ENTRIES);    expect(cache.peek({ ...target, cwd: "/small-0" })).toBeNull();  });   it("skips corrupt records and tolerates unavailable storage", async () => {    const corrupt = createProjectFaviconCache({      storage: {        list: async () => [          { ...target, faviconPath: null, revision: "r", dataUrl: image },          { ...target, cwd: "/broken", faviconPath: null, revision: "r", dataUrl: "not-an-image" },          "garbage",        ],        put: async () => {},        remove: async () => {},      },      load: async () => replacement,    });    await corrupt.hydrate();    expect(corrupt.peek(target)).toBe(image);    expect(corrupt.peek({ ...target, cwd: "/broken" })).toBeNull();     const unavailable = createProjectFaviconCache({      storage: {        list: async () => {          throw new Error("storage unavailable");        },        put: async () => {          throw new Error("quota exceeded");        },        remove: async () => {          throw new Error("quota exceeded");        },      },      load: async () => image,    });    expect(await unavailable.resolve(target, url, signal())).toBe(image);    await unavailable.flush();    expect(unavailable.peek(target)).toBe(image);  });}); describe("project favicon image loader", () => {  const svg =    '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><rect width="16" height="16"/></svg>';  const svgBase64 = btoa(svg);   function loader(response: Response, downscale = vi.fn(async () => replacement)) {    return {      downscale,      load: createProjectFaviconImageLoader({ fetch: async () => response, downscale }),    };  }   it("inlines small icons exactly as served without rasterizing", async () => {    const { load, downscale } = loader(      new Response(svg, { headers: { "content-type": "image/svg+xml; charset=utf-8" } }),    );    expect(await load(url, signal())).toBe(`data:image/svg+xml;base64,${svgBase64}`);    expect(downscale).not.toHaveBeenCalled();  });   it("falls back to the file extension when the response has no image type", async () => {    const { load } = loader(new Response(svg, { headers: { "content-type": "text/plain" } }));    expect(await load(url, signal())).toBe(`data:image/svg+xml;base64,${svgBase64}`);  });   it("downscales large bitmaps and refuses large vector icons", async () => {    const bytes = new Uint8Array(PROJECT_FAVICON_MAX_DATA_URL_LENGTH);    const bitmap = loader(new Response(bytes, { headers: { "content-type": "image/png" } }));    expect(await bitmap.load("https://remote.test/api/assets/t/v1-icon.png", signal())).toBe(      replacement,    );    expect(bitmap.downscale).toHaveBeenCalledWith(      expect.objectContaining({ mimeType: "image/png", bytes }),      expect.any(AbortSignal),    );    const vector = loader(new Response(bytes, { headers: { "content-type": "image/svg+xml" } }));    await expect(vector.load(url, signal())).rejects.toThrow("exceeds the cache limit");    expect(vector.downscale).not.toHaveBeenCalled();  });   it("stops reading a response that exceeds the source limit", async () => {    let pulled = 0;    const chunk = new Uint8Array(1024 * 1024);    const stream = new ReadableStream<Uint8Array>({      pull(controller) {        pulled += 1;        controller.enqueue(chunk);      },    });    const { load, downscale } = loader(      new Response(stream, { headers: { "content-type": "image/png" } }),    );    await expect(load(url, signal())).rejects.toThrow("too large");    expect(pulled).toBeLessThan(PROJECT_FAVICON_MAX_SOURCE_BYTES / chunk.byteLength + 3);    expect(downscale).not.toHaveBeenCalled();    const declared = loader(      new Response("x", {        headers: { "content-type": "image/png", "content-length": String(2 ** 40) },      }),    );    await expect(declared.load(url, signal())).rejects.toThrow("too large");  });   it("rejects failed responses and non-image payloads", async () => {    const failed = loader(new Response("nope", { status: 404 }));    await expect(failed.load(url, signal())).rejects.toThrow("404");    const html = loader(new Response("<html/>", { headers: { "content-type": "text/html" } }));    await expect(      html.load("https://remote.test/api/assets/t/v1-favicon", signal()),    ).rejects.toThrow("no image type");  });});