repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
extensions/canvas/__tests__/server.test.ts
Rawimport { 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();
});
});