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("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("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("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();
let cancelled = false;
const declaredStream = new ReadableStream<Uint8Array>({
cancel() {
cancelled = true;
},
});
const declared = loader(
new Response(declaredStream, {
headers: { "content-type": "image/png", "content-length": String(2 ** 40) },
}),
);
await expect(declared.load(url, signal())).rejects.toThrow("too large");
expect(cancelled).toBe(true);
expect(declared.downscale).not.toHaveBeenCalled();
});
});