@sigil-dev/grimoire 0.7.4 → 0.7.6

package/test/middleware.test.ts

@@ -1,221 +1,223 @@
-import { describe, expect, test } from "bun:test";
-import { createCookies } from "../src/server/cookie-utils";
-import type { Handle, RequestEvent } from "../src/server/hooks";
-import { createHooks, sequence } from "../src/server/hooks";
-
-function fakeEvent(overrides?: Partial<RequestEvent>): RequestEvent {
-	return {
-		request: new Request("http://localhost/"),
-		url: new URL("http://localhost/"),
-		params: {},
-		locals: {},
-		cookies: {
-			get: () => undefined,
-			set: () => {},
-			delete: () => {},
-		},
-		setHeaders: () => {},
-		...overrides,
-	};
-}
-
-describe("sequence()", () => {
-	test("chains two handlers in order", async () => {
-		const order: string[] = [];
-
-		const a: Handle = async ({ event, resolve }) => {
-			order.push("a-before");
-			const res = await resolve(event);
-			order.push("a-after");
-			return res;
-		};
-
-		const b: Handle = async ({ event, resolve }) => {
-			order.push("b-before");
-			const res = await resolve(event);
-			order.push("b-after");
-			return res;
-		};
-
-		const handler = sequence(a, b);
-		const res = await handler({
-			event: fakeEvent(),
-			resolve: async (evt) => new Response("OK"),
-		});
-
-		expect(order).toEqual(["a-before", "b-before", "b-after", "a-after"]);
-		expect(await res.text()).toBe("OK");
-	});
-
-	test("can short-circuit", async () => {
-		let reached = false;
-
-		const a: Handle = async () => {
-			return new Response("Blocked", { status: 403 });
-		};
-
-		const b: Handle = async ({ resolve, event }) => {
-			reached = true;
-			return resolve(event);
-		};
-
-		const handler = sequence(a, b);
-		const res = await handler({
-			event: fakeEvent(),
-			resolve: async () => new Response("OK"),
-		});
-
-		expect(reached).toBe(false);
-		expect(res.status).toBe(403);
-	});
-
-	test("can modify event.locals", async () => {
-		const a: Handle = async ({ event, resolve }) => {
-			event.locals.user = "alice";
-			return resolve(event);
-		};
-
-		const b: Handle = async ({ event, resolve }) => {
-			event.locals.greet = `hello ${event.locals.user}`;
-			return resolve(event);
-		};
-
-		const handler = sequence(a, b);
-		const event = fakeEvent();
-		await handler({
-			event,
-			resolve: async (evt) => {
-				return new Response(JSON.stringify(evt.locals));
-			},
-		});
-
-		expect(event.locals.user).toBe("alice");
-		expect(event.locals.greet).toBe("hello alice");
-	});
-
-	test("can modify response", async () => {
-		const a: Handle = async ({ event, resolve }) => {
-			const res = await resolve(event);
-			const headers = new Headers(res.headers);
-			headers.set("X-First", "1");
-			return new Response(res.body, { status: res.status, headers });
-		};
-
-		const b: Handle = async ({ event, resolve }) => {
-			const res = await resolve(event);
-			const headers = new Headers(res.headers);
-			headers.set("X-Second", "2");
-			return new Response(res.body, { status: res.status, headers });
-		};
-
-		const handler = sequence(a, b);
-		const res = await handler({
-			event: fakeEvent(),
-			resolve: async () => new Response("OK"),
-		});
-
-		expect(res.headers.get("X-First")).toBe("1");
-		expect(res.headers.get("X-Second")).toBe("2");
-	});
-
-	test("single handler works", async () => {
-		const handler: Handle = async ({ event, resolve }) => {
-			return resolve(event);
-		};
-
-		const res = await sequence(handler)({
-			event: fakeEvent(),
-			resolve: async () => new Response("Single"),
-		});
-
-		expect(await res.text()).toBe("Single");
-	});
-
-	test("three handlers chain correctly", async () => {
-		const order: string[] = [];
-
-		const a: Handle = async ({ event, resolve }) => {
-			order.push("a");
-			return resolve(event);
-		};
-		const b: Handle = async ({ event, resolve }) => {
-			order.push("b");
-			return resolve(event);
-		};
-		const c: Handle = async ({ event, resolve }) => {
-			order.push("c");
-			return resolve(event);
-		};
-
-		await sequence(
-			a,
-			b,
-			c,
-		)({
-			event: fakeEvent(),
-			resolve: async () => new Response("OK"),
-		});
-
-		expect(order).toEqual(["a", "b", "c"]);
-	});
-});
-
-describe("Cookies", () => {
-	function makeEvent(cookieHeader = ""): RequestEvent {
-		return fakeEvent({
-			cookies: createCookies(cookieHeader),
-		});
-	}
-
-	test("cookies.get reads from header", async () => {
-		let value: string | undefined;
-		const handler: Handle = async ({ event, resolve }) => {
-			value = event.cookies.get("session");
-			return resolve(event);
-		};
-
-		await handler({
-			event: makeEvent("session=abc123; theme=dark"),
-			resolve: async () => new Response("OK"),
-		});
-
-		expect(value).toBe("abc123");
-	});
-
-	test("cookies.set adds Set-Cookie header", async () => {
-		const event = makeEvent();
-		const handler: Handle = async ({ event: evt, resolve }) => {
-			evt.cookies.set("token", "xyz", { httpOnly: true, path: "/" });
-			return resolve(evt);
-		};
-
-		await handler({
-			event,
-			resolve: async () => new Response("OK"),
-		});
-
-		expect(event.cookies.get("token")).toBe("xyz");
-		const cookieUtils = event.cookies as ReturnType<typeof createCookies>;
-		expect(cookieUtils.toHeaders().length).toBe(1);
-		expect(cookieUtils.toHeaders()[0]).toContain("token=xyz");
-		expect(cookieUtils.toHeaders()[0]).toContain("HttpOnly");
-		expect(cookieUtils.toHeaders()[0]).toContain("Path=/");
-	});
-});
-
-describe("createHooks()", () => {
-	test("returns handle and init", async () => {
-		const handle: Handle = async ({ resolve, event }) => resolve(event);
-		const init = () => {};
-		const hooks = createHooks(handle, init);
-		expect(hooks.handle).toBe(handle);
-		expect(hooks.init).toBe(init);
-	});
-
-	test("returns handle without init", () => {
-		const handle: Handle = async ({ resolve, event }) => resolve(event);
-		const hooks = createHooks(handle);
-		expect(hooks.handle).toBe(handle);
-		expect(hooks.init).toBeUndefined();
-	});
-});
+import { describe, expect, test } from "bun:test";
+import { createCookies } from "../src/server/cookie-utils";
+import type { Handle, RequestEvent } from "../src/server/hooks";
+import { createHooks, sequence } from "../src/server/hooks";
+
+function fakeEvent(overrides?: Partial<RequestEvent>): RequestEvent {
+	return {
+		request: new Request("http://localhost/"),
+		url: new URL("http://localhost/"),
+		params: {},
+		locals: {},
+		cookies: {
+			get: () => undefined,
+			set: () => {},
+			delete: () => {},
+		},
+		route: { id: "/" },
+		fetch: globalThis.fetch,
+		setHeaders: () => {},
+		...overrides,
+	};
+}
+
+describe("sequence()", () => {
+	test("chains two handlers in order", async () => {
+		const order: string[] = [];
+
+		const a: Handle = async ({ event, resolve }) => {
+			order.push("a-before");
+			const res = await resolve(event);
+			order.push("a-after");
+			return res;
+		};
+
+		const b: Handle = async ({ event, resolve }) => {
+			order.push("b-before");
+			const res = await resolve(event);
+			order.push("b-after");
+			return res;
+		};
+
+		const handler = sequence(a, b);
+		const res = await handler({
+			event: fakeEvent(),
+			resolve: async (evt) => new Response("OK"),
+		});
+
+		expect(order).toEqual(["a-before", "b-before", "b-after", "a-after"]);
+		expect(await res.text()).toBe("OK");
+	});
+
+	test("can short-circuit", async () => {
+		let reached = false;
+
+		const a: Handle = async () => {
+			return new Response("Blocked", { status: 403 });
+		};
+
+		const b: Handle = async ({ resolve, event }) => {
+			reached = true;
+			return resolve(event);
+		};
+
+		const handler = sequence(a, b);
+		const res = await handler({
+			event: fakeEvent(),
+			resolve: async () => new Response("OK"),
+		});
+
+		expect(reached).toBe(false);
+		expect(res.status).toBe(403);
+	});
+
+	test("can modify event.locals", async () => {
+		const a: Handle = async ({ event, resolve }) => {
+			(event.locals as any).user = "alice";
+			return resolve(event);
+		};
+
+		const b: Handle = async ({ event, resolve }) => {
+			(event.locals as any).greet = `hello ${(event.locals as any).user}`;
+			return resolve(event);
+		};
+
+		const handler = sequence(a, b);
+		const event = fakeEvent();
+		await handler({
+			event,
+			resolve: async (evt) => {
+				return new Response(JSON.stringify(evt.locals));
+			},
+		});
+
+		expect((event.locals as any).user).toBe("alice");
+		expect((event.locals as any).greet).toBe("hello alice");
+	});
+
+	test("can modify response", async () => {
+		const a: Handle = async ({ event, resolve }) => {
+			const res = await resolve(event);
+			const headers = new Headers(res.headers);
+			headers.set("X-First", "1");
+			return new Response(res.body, { status: res.status, headers });
+		};
+
+		const b: Handle = async ({ event, resolve }) => {
+			const res = await resolve(event);
+			const headers = new Headers(res.headers);
+			headers.set("X-Second", "2");
+			return new Response(res.body, { status: res.status, headers });
+		};
+
+		const handler = sequence(a, b);
+		const res = await handler({
+			event: fakeEvent(),
+			resolve: async () => new Response("OK"),
+		});
+
+		expect(res.headers.get("X-First")).toBe("1");
+		expect(res.headers.get("X-Second")).toBe("2");
+	});
+
+	test("single handler works", async () => {
+		const handler: Handle = async ({ event, resolve }) => {
+			return resolve(event);
+		};
+
+		const res = await sequence(handler)({
+			event: fakeEvent(),
+			resolve: async () => new Response("Single"),
+		});
+
+		expect(await res.text()).toBe("Single");
+	});
+
+	test("three handlers chain correctly", async () => {
+		const order: string[] = [];
+
+		const a: Handle = async ({ event, resolve }) => {
+			order.push("a");
+			return resolve(event);
+		};
+		const b: Handle = async ({ event, resolve }) => {
+			order.push("b");
+			return resolve(event);
+		};
+		const c: Handle = async ({ event, resolve }) => {
+			order.push("c");
+			return resolve(event);
+		};
+
+		await sequence(
+			a,
+			b,
+			c,
+		)({
+			event: fakeEvent(),
+			resolve: async () => new Response("OK"),
+		});
+
+		expect(order).toEqual(["a", "b", "c"]);
+	});
+});
+
+describe("Cookies", () => {
+	function makeEvent(cookieHeader = ""): RequestEvent {
+		return fakeEvent({
+			cookies: createCookies(cookieHeader),
+		});
+	}
+
+	test("cookies.get reads from header", async () => {
+		let value: string | undefined;
+		const handler: Handle = async ({ event, resolve }) => {
+			value = event.cookies.get("session");
+			return resolve(event);
+		};
+
+		await handler({
+			event: makeEvent("session=abc123; theme=dark"),
+			resolve: async () => new Response("OK"),
+		});
+
+		expect(value).toBe("abc123");
+	});
+
+	test("cookies.set adds Set-Cookie header", async () => {
+		const event = makeEvent();
+		const handler: Handle = async ({ event: evt, resolve }) => {
+			evt.cookies.set("token", "xyz", { httpOnly: true, path: "/" });
+			return resolve(evt);
+		};
+
+		await handler({
+			event,
+			resolve: async () => new Response("OK"),
+		});
+
+		expect(event.cookies.get("token")).toBe("xyz");
+		const cookieUtils = event.cookies as ReturnType<typeof createCookies>;
+		expect(cookieUtils.toHeaders().length).toBe(1);
+		expect(cookieUtils.toHeaders()[0]).toContain("token=xyz");
+		expect(cookieUtils.toHeaders()[0]).toContain("HttpOnly");
+		expect(cookieUtils.toHeaders()[0]).toContain("Path=/");
+	});
+});
+
+describe("createHooks()", () => {
+	test("returns handle and init", async () => {
+		const handle: Handle = async ({ resolve, event }) => resolve(event);
+		const init = () => {};
+		const hooks = createHooks(handle, init);
+		expect(hooks.handle).toBe(handle);
+		expect(hooks.init).toBe(init);
+	});
+
+	test("returns handle without init", () => {
+		const handle: Handle = async ({ resolve, event }) => resolve(event);
+		const hooks = createHooks(handle);
+		expect(hooks.handle).toBe(handle);
+		expect(hooks.init).toBeUndefined();
+	});
+});