Something went wrong. Try again.
Monorepo for Tangled
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";import { ClientResponseError } from "$lib/api/client";import { createRequestCache, httpStatusFor, parallel, toHttpError } from "$lib/api/load";
vi.mock("$app/environment", () => ({ browser: true }));
const cre = (status: number, error: string, message?: string): ClientResponseError => new ClientResponseError({ status, data: { error, message } });
describe("httpStatusFor", () => { it("passes through an in-band XRPC status", () => { expect(httpStatusFor(cre(404, "RecordNotFound"))).toBe(404); });
it("prefers an in-band status over the error-name mapping", () => { // status 503 is in [400,599] so it wins even though the name maps to 404. expect(httpStatusFor(cre(503, "RecordNotFound"))).toBe(503); });
it("maps the error name when the status is out of the 400-599 band", () => { expect(httpStatusFor(cre(200, "RecordNotFound"))).toBe(404); expect(httpStatusFor(cre(200, "InvalidRequest"))).toBe(400); expect(httpStatusFor(cre(200, "UpstreamFailed"))).toBe(502); expect(httpStatusFor(cre(200, "UpstreamGone"))).toBe(502); expect(httpStatusFor(cre(200, "InvalidRecord"))).toBe(502); expect(httpStatusFor(cre(200, "Overloaded"))).toBe(503); expect(httpStatusFor(cre(200, "SomethingElse"))).toBe(500); });
it("maps any non-XRPC cause to 500", () => { expect(httpStatusFor(new Error("boom"))).toBe(500); expect(httpStatusFor("a string")).toBe(500); expect(httpStatusFor(undefined)).toBe(500); expect(httpStatusFor({ status: 404 })).toBe(500); });});
describe("toHttpError", () => { it("throws a SvelteKit error with the mapped status and the XRPC description", () => { let thrown: unknown; try { toHttpError(cre(404, "RecordNotFound", "no such repo")); } catch (e) { thrown = e; } expect(thrown).toMatchObject({ status: 404, body: { message: "no such repo" } }); });
it("falls back to the error name when the description is absent", () => { let thrown: unknown; try { toHttpError(cre(200, "Overloaded")); } catch (e) { thrown = e; } expect(thrown).toMatchObject({ status: 503, body: { message: "Overloaded" } }); });
it("uses the fallback message + 500 for a non-XRPC cause", () => { let thrown: unknown; try { toHttpError(new Error("boom"), "could not load"); } catch (e) { thrown = e; } expect(thrown).toMatchObject({ status: 500, body: { message: "could not load" } }); });});
describe("parallel", () => { it("preserves key/value pairing regardless of settle order", async () => { // deferred across a few microtasks (no real timer) so it settles after `fast`. const slow = Promise.resolve() .then(() => Promise.resolve()) .then(() => "slow"); const result = await parallel({ fast: Promise.resolve("fast"), slow }); expect(result).toEqual({ fast: "fast", slow: "slow" }); });
it("resolves to an empty object for no tasks", async () => { await expect(parallel({})).resolves.toEqual({}); });
it("rejects if any input promise rejects", async () => { await expect( parallel({ a: Promise.resolve(1), b: Promise.reject(new Error("boom")) }) ).rejects.toThrow("boom"); });});
describe("createRequestCache", () => { it("invokes the loader once per key and shares the value", async () => { const cache = createRequestCache(); const load = vi.fn(async () => 42);
const first = await cache.run("k", load); const second = await cache.run("k", load);
expect(first).toBe(42); expect(second).toBe(42); expect(load).toHaveBeenCalledTimes(1); });
it("shares one in-flight promise for concurrent same-key calls", () => { const cache = createRequestCache(); const load = vi.fn(async () => "v");
const a = cache.run("k", load); const b = cache.run("k", load);
expect(a).toBe(b); expect(load).toHaveBeenCalledTimes(1); });
it("runs distinct keys independently", async () => { const cache = createRequestCache(); const load = vi.fn(async (key: string) => key.toUpperCase());
await cache.run("a", () => load("a")); await cache.run("b", () => load("b"));
expect(load).toHaveBeenCalledTimes(2); });});
describe("settle", () => { // the instant window lives in module state, so every case starts from a fresh module const fresh = async (): Promise<typeof import("$lib/api/load").settle> => (await import("$lib/api/load")).settle; const freshEnd = async (): Promise<typeof import("$lib/api/load").endNavigation> => (await import("$lib/api/load")).endNavigation;
beforeEach(() => vi.useFakeTimers()); afterEach(() => { vi.useRealTimers(); vi.resetModules(); });
it("hands a promise that settled over as its value, so no boundary suspends on it", async () => { const settle = await fresh(); const settled = await settle({ fast: Promise.resolve("v"), plain: 2 });
expect(settled).toEqual({ fast: "v", plain: 2 }); });
it("keeps a promise that outlasts the window, its boundary paints the skeleton", async () => { const settle = await fresh(); const slow = new Promise<string>((resolve) => setTimeout(() => resolve("late"), 400)); const page = settle({ slow, fast: Promise.resolve("v") });
await vi.advanceTimersByTimeAsync(200);
const data = await page; expect(data.fast).toBe("v"); expect(data.slow).toBe(slow);
await vi.advanceTimersByTimeAsync(400); expect(await data.slow).toBe("late"); });
it("leaves the rejection on the promise, whoever awaits it owns the failure", async () => { const settle = await fresh(); const broken = Promise.reject(new Error("boom")); const page = settle({ broken, fast: Promise.resolve("v") });
await vi.advanceTimersByTimeAsync(200);
const data = await page; expect(data.fast).toBe("v"); await expect(data.broken).rejects.toThrow("boom"); });
it("opens a fresh window for the navigation after the last one committed", async () => { const settle = await fresh(); const endNavigation = await freshEnd(); await settle({ fast: Promise.resolve("v") }); await vi.advanceTimersByTimeAsync(100);
endNavigation();
const late = new Promise<string>((resolve) => setTimeout(() => resolve("late"), 400)); const page = settle({ late });
await vi.advanceTimersByTimeAsync(200); expect((await page).late).toBe(late); });
it("opens a fresh window for the navigation after an abandoned one", async () => { const settle = await fresh(); await settle({ fast: Promise.resolve("v") }); await vi.advanceTimersByTimeAsync(500);
const late = new Promise<string>((resolve) => setTimeout(() => resolve("late"), 400)); const page = settle({ late });
await vi.advanceTimersByTimeAsync(200); expect((await page).late).toBe(late); });
it("spends one window across the loads of a navigation", async () => { const settle = await fresh(); await settle({ fast: Promise.resolve("v") }); await vi.advanceTimersByTimeAsync(150);
// 50ms of the first load's window is left const late = new Promise<string>((resolve) => setTimeout(() => resolve("late"), 400)); const page = settle({ late });
await vi.advanceTimersByTimeAsync(60); expect((await page).late).toBe(late); });});