Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/canvas/__tests__/server.test.ts

Raw
import { afterEach, describe, expect, it } from "vitest";
import { type CanvasServer, startCanvasServer } from "../src/server.ts";
import {
	type CanvasAction,
	type CanvasState,
	changeScene,
	emptyState,
} from "../src/store.ts";

const servers: CanvasServer[] = [];
afterEach(async () =>
	Promise.all(servers.splice(0).map((server) => server.close())),
);
function request(
	server: CanvasServer,
	path: string,
	init: RequestInit = {},
): Promise<Response> {
	return fetch(new URL(path, server.url), init);
}
function bearer(server: CanvasServer): string {
	return `Bearer ${new URL(server.url).hash.slice(1)}`;
}
function headers(server: CanvasServer): HeadersInit {
	return {
		Authorization: bearer(server),
		Origin: new URL(server.url).origin,
		"Content-Type": "application/json",
	};
}

describe("canvas server", () => {
	it("guards actions and accepts only browser scene/activity protocol", async () => {
		let state = emptyState();
		const actions: CanvasAction[] = [];
		const server = await startCanvasServer(
			() => state,
			(action) => {
				actions.push(action);
				if (action.kind === "scene")
					state = changeScene(state, action.revision, action.elements);
			},
		);
		servers.push(server);
		expect((await request(server, "/api/state")).status).toBe(401);
		expect(
			(
				await request(server, "/api/state", {
					headers: { Authorization: bearer(server) },
				})
			).status,
		).toBe(200);
		const action = await request(server, "/api/action", {
			method: "POST",
			headers: headers(server),
			body: JSON.stringify({
				kind: "activity",
				clientId: "browser",
				sequence: 1,
				activity: "active",
			}),
		});
		expect(action.status).toBe(200);
		expect(actions).toEqual([
			{
				kind: "activity",
				clientId: "browser",
				sequence: 1,
				activity: "active",
			},
		]);
		expect(
			(
				await request(server, "/api/action", {
					method: "POST",
					headers: { ...headers(server), Origin: "http://localhost" },
					body: JSON.stringify({
						kind: "scene",
						revision: 0,
						clientId: "browser",
						sequence: 1,
						activity: "active",
						elements: [],
					}),
				})
			).status,
		).toBe(403);
		for (const value of [
			{
				kind: "prepare",
				requestId: "request",
				clientId: "browser",
				elements: [],
			},
			{
				kind: "commit",
				requestId: "request",
				clientId: "browser",
				revision: 0,
				elements: [],
			},
			{ kind: "cancel", requestId: "request", clientId: "browser" },
		])
			expect(
				(
					await request(server, "/api/action", {
						method: "POST",
						headers: headers(server),
						body: JSON.stringify(value),
					})
				).status,
			).toBe(400);
	});

	it("replays contiguous revisions, resets trimmed history, and excludes same-revision updates", async () => {
		let state = emptyState();
		const server = await startCanvasServer(
			() => state,
			() => undefined,
		);
		servers.push(server);
		const changes = (after: string, authorization = bearer(server)) =>
			request(server, `/api/changes?after=${after}`, {
				headers: { Authorization: authorization },
			});
		expect((await changes("0", "Bearer bad")).status).toBe(401);
		expect(
			(
				await request(server, "/api/changes?after=-1", {
					headers: { Authorization: bearer(server) },
				})
			).status,
		).toBe(400);
		for (let revision = 1; revision <= 66; revision++) {
			state = {
				...state,
				revision,
				elements: [{ id: `r${revision}`, type: "rectangle" }],
			};
			server.publish(state);
		}
		const expired = await (await changes("0")).json();
		expect(expired).toMatchObject({
			currentRevision: 66,
			nextRevision: 66,
			reset: true,
		});
		expect(expired.changes).toHaveLength(1);
		const replay = await (await changes("64")).json();
		expect(replay).toMatchObject({
			currentRevision: 66,
			nextRevision: 66,
			reset: false,
		});
		expect(replay.changes.map((entry: CanvasState) => entry.revision)).toEqual([
			65, 66,
		]);
		state = { ...state, notice: { id: "notice", text: "same revision" } };
		server.publish(state);
		expect(
			(await (await changes("65")).json()).changes.map(
				(entry: CanvasState) => entry.revision,
			),
		).toEqual([66]);
	});

	it("bounds replay bytes and paginates large revisions without gaps", async () => {
		let state = emptyState();
		const server = await startCanvasServer(
			() => state,
			() => undefined,
		);
		servers.push(server);
		for (let revision = 1; revision <= 18; revision++) {
			state = {
				revision,
				elements: [
					{
						id: "large",
						type: "rectangle",
						x: 0,
						y: 0,
						width: 100,
						height: 100,
						customData: { payload: "x".repeat(500000) },
					},
				],
				change: { origin: "agent", id: `transaction-${revision}` },
			};
			server.publish(state);
		}
		const expired = (await (
			await request(server, "/api/changes?after=0", {
				headers: headers(server),
			})
		).json()) as { reset: boolean; nextRevision: number };
		expect(expired).toMatchObject({ reset: true, nextRevision: 18 });
		let cursor = 2;
		const revisions: number[] = [];
		for (let page = 0; page < 18 && cursor < 18; page++) {
			const text = await (
				await request(server, `/api/changes?after=${cursor}`, {
					headers: headers(server),
				})
			).text();
			expect(Buffer.byteLength(text)).toBeLessThanOrEqual(1024 * 1024);
			const result = JSON.parse(text) as {
				reset: boolean;
				nextRevision: number;
				changes: CanvasState[];
			};
			expect(result.reset).toBe(false);
			expect(result.changes.length).toBeGreaterThan(0);
			for (const snapshot of result.changes) {
				expect(snapshot.revision).toBe(++cursor);
				revisions.push(snapshot.revision);
			}
			expect(result.nextRevision).toBe(cursor);
		}
		expect(revisions).toEqual(
			Array.from({ length: 16 }, (_, index) => index + 3),
		);
	});

	it("rejects an unpageable callback snapshot instead of returning a non-advancing cursor", async () => {
		let state = emptyState();
		const server = await startCanvasServer(
			() => state,
			() => undefined,
		);
		servers.push(server);
		const frame: CanvasState = {
			revision: 1,
			elements: [
				{ id: "large", type: "rectangle", customData: { payload: "" } },
			],
		};
		const overhead = Buffer.byteLength(JSON.stringify(frame));
		// Deliberately bypass the store's smaller element limit to exercise server defense.
		frame.elements[0]!["customData"] = {
			payload: "x".repeat(1024 * 1024 - overhead),
		};
		state = frame;
		server.publish(state);
		expect(
			(
				await request(server, "/api/changes?after=0", {
					headers: headers(server),
				})
			).status,
		).toBe(413);
		for (let revision = 2; revision <= 10; revision++) {
			state = { ...frame, revision };
			server.publish(state);
		}
		expect(
			(
				await request(server, "/api/changes?after=0", {
					headers: headers(server),
				})
			).status,
		).toBe(413);
	});

	it("validates settled snapshot images without persisting them in shared state", async () => {
		const actions: CanvasAction[] = [];
		const server = await startCanvasServer(emptyState, (action) => {
			actions.push(action);
		});
		servers.push(server);
		const viewport = {
			data: "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=",
			mimeType: "image/png",
			imageWidth: 1,
			imageHeight: 1,
			left: 0,
			top: 0,
			width: 100,
			height: 100,
		};
		const post = (image: unknown) =>
			request(server, "/api/action", {
				method: "POST",
				headers: headers(server),
				body: JSON.stringify({
					kind: "activity",
					clientId: "browser",
					sequence: 1,
					activity: "settled",
					revision: 0,
					viewport: image,
				}),
			});
		expect((await post(viewport)).status).toBe(200);
		expect(actions[0]).toMatchObject({ viewport });
		for (const invalid of [
			null,
			{ ...viewport, data: "not an image" },
			{ ...viewport, data: "a".repeat(256 * 1024 + 4) },
			{ ...viewport, mimeType: "image/svg+xml" },
			{ ...viewport, imageWidth: 1025 },
			{ ...viewport, left: "10" },
			{ ...viewport, extra: true },
		])
			expect((await post(invalid)).status).toBe(400);
		expect(actions).toHaveLength(1);
		expect(
			await (
				await request(server, "/api/state", { headers: headers(server) })
			).json(),
		).not.toHaveProperty("viewport");
	});

	it("reports oversized scenes as 413 without changing state, while stale revisions remain 409", async () => {
		let state = emptyState();
		const server = await startCanvasServer(
			() => state,
			(action) => {
				if (action.kind === "scene")
					state = changeScene(state, action.revision, action.elements);
			},
		);
		servers.push(server);
		const post = (revision: number) =>
			request(server, "/api/action", {
				method: "POST",
				headers: headers(server),
				body: JSON.stringify({
					kind: "scene",
					revision,
					clientId: "browser",
					sequence: revision + 1,
					activity: "settled",
					elements: [
						{
							id: "large",
							type: "rectangle",
							customData: { data: "x".repeat(512 * 1024) },
						},
					],
				}),
			});
		expect((await post(0)).status).toBe(413);
		expect((await post(1)).status).toBe(409);
		expect(state).toEqual(emptyState());
	});

	it("preserves SSE, host, methods, and CSP", async () => {
		const server = await startCanvasServer(
			() => ({ ...emptyState(), revision: 2 }),
			() => undefined,
		);
		servers.push(server);
		const page = await request(server, "/");
		expect(page.headers.get("content-security-policy")).toContain(
			"default-src 'self'",
		);
		expect(
			(await fetch(server.url.replace("127.0.0.1", "localhost"))).status,
		).toBe(400);
		expect(
			(
				await request(server, "/api/changes?after=0", {
					method: "POST",
					headers: { Authorization: bearer(server) },
				})
			).status,
		).toBe(405);
		const response = await request(server, "/api/events", {
			headers: { Authorization: bearer(server) },
		});
		expect(response.status).toBe(200);
		const reader = response.body?.getReader();
		const chunk = await reader?.read();
		expect(new TextDecoder().decode(chunk?.value)).toContain('"revision":2');
		await reader?.cancel();
	});
});