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 { 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(); }); });