93 lines
6.7 KiB
JavaScript
93 lines
6.7 KiB
JavaScript
import { test } from "node:test";
|
|
import assert from "node:assert/strict";
|
|
import { CanvasSync, canvasPath, canvasPayload, readLocalRecovery } from "../src/lib/canvas-sync.ts";
|
|
import { emptyCanvas, makeCanvasNode } from "../src/lib/canvas.ts";
|
|
import { loadBoardCanvas } from "../src/lib/canvas-loader.ts";
|
|
function document(text = "") { const doc = emptyCanvas(); const node = makeCanvasNode("text", { x: 0, y: 0 }); node.id = "text"; node.data.text = text; doc.nodes.push(node); return doc; }
|
|
function deferred() { let resolve, reject; const promise = new Promise((yes, no) => { resolve = yes; reject = no; }); return { promise, resolve, reject }; }
|
|
const tick = () => new Promise((resolve) => setImmediate(resolve));
|
|
|
|
test("serialized autosaves use successive versions and coalesce queued documents", async () => {
|
|
const calls = [], first = deferred();
|
|
const writer = new CanvasSync(async (path, options) => {
|
|
calls.push({ path, ...options });
|
|
if (calls.length === 1) return first.promise;
|
|
return { version: 3 };
|
|
}, canvasPath("space", "board"), { version: 1, document: emptyCanvas() }, () => {});
|
|
const a = writer.enqueue(document("A")); await tick();
|
|
writer.enqueue(document("B")); writer.enqueue(document("C"));
|
|
assert.equal(calls.length, 1);
|
|
first.resolve({ version: 2 }); await a;
|
|
assert.equal(calls.length, 2);
|
|
assert.equal(calls[0].headers["If-Match"], '"1"'); assert.equal(calls[1].headers["If-Match"], '"2"');
|
|
assert.equal(JSON.parse(calls[1].body).document.nodes[0].data.text, "C"); assert.equal(writer.version, 3);
|
|
});
|
|
|
|
test("version conflicts stop automatic writes and preserve the latest pending content", async () => {
|
|
const calls = [];
|
|
const writer = new CanvasSync(async (_path, options) => { calls.push(options); throw new Error("version_conflict"); }, "canvas", { version: 7, document: emptyCanvas() }, () => {});
|
|
await writer.enqueue(document("A")); await writer.enqueue(document("B"));
|
|
assert.equal(calls.length, 1); assert.equal(writer.error, "version_conflict"); assert.equal(writer.version, 7);
|
|
});
|
|
|
|
test("explicit retry sends the newest document after a failed write", async () => {
|
|
const calls = [];
|
|
const writer = new CanvasSync(async (_path, options) => { calls.push(options); if (calls.length === 1) throw new Error("upstream_unavailable"); return { version: 2 }; }, "canvas", { version: 1, document: emptyCanvas() }, () => {});
|
|
await writer.enqueue(document("A")); await writer.enqueue(document("B")); await writer.retry();
|
|
assert.equal(calls.length, 2); assert.equal(JSON.parse(calls[1].body).document.nodes[0].data.text, "B"); assert.equal(writer.error, "");
|
|
});
|
|
|
|
test("selection and measured dimensions do not trigger redundant writes or leak UI fields", async () => {
|
|
const initial = document("keep"); let calls = 0;
|
|
const writer = new CanvasSync(async () => { calls++; return { version: 2 }; }, "canvas", { version: 1, document: initial }, () => {});
|
|
const changed = structuredClone(initial); changed.nodes[0].selected = true; changed.nodes[0].measured = { width: 260, height: 200 };
|
|
await writer.enqueue(changed); assert.equal(calls, 0);
|
|
const payload = canvasPayload(changed);
|
|
for (const key of ["selected", "style", "measured", "dragging", "zIndex"]) assert.equal(payload.nodes[0][key], undefined);
|
|
const first = writer.enqueue(changed); const second = writer.enqueue(document("new")); await Promise.all([first, second]);
|
|
assert.equal(calls, 1);
|
|
});
|
|
|
|
test("all ID/slug combinations load the same canonical board and snapshot", async () => {
|
|
for (const workspace of ["space-id", "creative-space"]) for (const board of ["board-id", "my-board"]) {
|
|
const calls = [];
|
|
const result = await loadBoardCanvas(async (path) => { calls.push(path); return path.endsWith("/canvas") ? { version: 4, document: document("saved") } : { id: "board-id", slug: "my-board", workspace_id: "space-id", kind: "board", title: "Saved" }; }, workspace, board);
|
|
assert.equal(result.board.id, "board-id"); assert.equal(result.board.workspace_id, "space-id"); assert.equal(result.snapshot.version, 4);
|
|
assert(calls.includes(`workspaces/${workspace}/materials/${board}/canvas`));
|
|
}
|
|
});
|
|
|
|
test("failed snapshot loads and mismatched boards prevent editing rather than creating an empty replacement", async () => {
|
|
await assert.rejects(loadBoardCanvas(async (path) => { if (path.endsWith("/canvas")) throw new Error("upstream_unavailable"); return { id: "board", workspace_id: "space", kind: "board" }; }, "space", "board"), /upstream/);
|
|
await assert.rejects(loadBoardCanvas(async (path) => path.endsWith("/canvas") ? { version: 1, document: emptyCanvas() } : { id: "other", workspace_id: "space", kind: "board" }, "space", "board"), /invalid_reference/);
|
|
});
|
|
|
|
test("dirty local recovery and legacy drafts are offered for explicit migration; clean backups never replace server data", () => {
|
|
const remote = { version: 3, document: document("server") };
|
|
const local = document("local");
|
|
const storage = (values) => ({ getItem: (key) => values[key] || null });
|
|
assert.equal(readLocalRecovery(storage({ key: JSON.stringify(local) }), "key", remote).nodes[0].data.text, "local");
|
|
assert.equal(readLocalRecovery(storage({ "key:recovery": JSON.stringify({ document: local, dirty: true, baseVersion: 2 }) }), "key", remote).nodes[0].data.text, "local");
|
|
assert.equal(readLocalRecovery(storage({ "key:recovery": JSON.stringify({ document: local, dirty: false }), key: JSON.stringify(local) }), "key", remote), null);
|
|
assert.equal(readLocalRecovery(storage({ "key:recovery": JSON.stringify({ document: remote.document, dirty: true }) }), "key", remote), null);
|
|
});
|
|
|
|
test("canonical fingerprints ignore server JSON key ordering", async () => {
|
|
const remote = document("same"), local = document("same");
|
|
remote.nodes[0].data.textStyle = { bold: true, color: "#123456" };
|
|
local.nodes[0].data.textStyle = { color: "#123456", bold: true };
|
|
let calls = 0;
|
|
const writer = new CanvasSync(async () => { calls++; return { version: 2 }; }, "canvas", { version: 1, document: remote }, () => {});
|
|
await writer.enqueue(local);
|
|
assert.equal(calls, 0);
|
|
const storage = { getItem: () => JSON.stringify({ document: local, dirty: true }) };
|
|
assert.equal(readLocalRecovery(storage, "key", { version: 1, document: remote }), null);
|
|
});
|
|
|
|
|
|
test("board metadata and snapshot begin concurrently without a request waterfall", async () => {
|
|
const started = []; const releases = [];
|
|
const loading = loadBoardCanvas((path) => { started.push(path); return new Promise((resolve) => releases.push(() => resolve(path.endsWith("/canvas") ? { version: 1, document: emptyCanvas() } : { id: "board", workspace_id: "space", kind: "board" }))); }, "space", "board");
|
|
assert.equal(started.length, 2); releases.forEach((release) => release()); await loading;
|
|
});
|