07863da416- WasmTool: hard cutover to startKicadCollab (gates on kicadCollabSnapshotItems; scalar reconciler no longer runs in the app) - file-seed (ysync 0005 tie-in): empty rooms are seeded from the opened file via fileToDoc/docToY (meta+layout+items — file recoverable from the Y.Doc alone); populated rooms still adopt (seed-once unchanged) - binding: gate UP applies until seed() — the provider's initial state sync otherwise streams the full doc into an editor that already holds the file (trapped eeschema's paste path in the real app) - pcbnew blobForItem: footprints Format a uuid-corrected copy directly — SaveSelection's copy regenerated mandatory-field uuids (FOOTPRINT copy ctor assigns into fresh fields), breaking wire identity (rebuild) - roundtrip.spec on the v2 items wire; new passing pcbnew footprint-containment round trip (the 0004 containment win); full fixture stays fixme on the tracked envelope-parse limit - real-app two-tab emit verified for eeschema + pcbnew (see 0008 doc) Full kicad suite: 45 passed, 3 skipped (known), 0 failed. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
379 lines
15 KiB
TypeScript
379 lines
15 KiB
TypeScript
import type { BrowserContext, Page } from "@playwright/test";
|
||
import { test, expect } from "./fixtures";
|
||
import { sexprDiff } from "../../web/standalone/src/wasm/collab/sexpr-diff";
|
||
|
||
/**
|
||
* Round-trip integration tests (feature 0004; v2 items wire since ysync 0008
|
||
* Stage D): for each collab-capable, file-bearing tool prove the Y.Doc
|
||
* representation is lossless —
|
||
*
|
||
* load a fixture file → save it (ORIG, normalized through the serializer)
|
||
* → kicadCollabSnapshotItems (per-item s-expr blobs, the Slot-model wire)
|
||
* → RELOAD the page (fresh process-global wasm; boot.ts) → open an EMPTY doc
|
||
* → kicadCollabApplyItems(snapshot) (rebuild the model purely from the blobs)
|
||
* → save (REGEN)
|
||
* → assert sexprDiff(ORIG, REGEN).equal
|
||
*
|
||
* Both ORIG and REGEN come out of the SAME tool serializer, so `sexprDiff` (which
|
||
* compares uuid-keyed items as multisets of normalized children) is false-positive
|
||
* free by construction — non-item structure (setup, layers, paper) carries no uuid
|
||
* and is intentionally not compared.
|
||
*
|
||
* The empty fixture shares the full fixture's top-level identity uuid(s) (where a
|
||
* tool has one, e.g. the schematic root) so only the synced ITEMS differ between
|
||
* ORIG and REGEN.
|
||
*/
|
||
|
||
interface ToolCfg {
|
||
tool: string;
|
||
html: string;
|
||
ext: string;
|
||
/** The per-tool save embind export (README §A). */
|
||
saveFn: "kicadSaveDrawingSheet" | "kicadSaveSchematic" | "kicadSaveBoard";
|
||
/** Full document with explicit uuid items to round-trip. */
|
||
fixture: string;
|
||
/** Valid, openable document of the same type carrying NO synced items (but the
|
||
* same top-level identity uuids as `fixture`). */
|
||
empty: string;
|
||
/** Known-volatile top-level tokens to ignore (serializer nondeterminism). */
|
||
ignoreTokens?: string[];
|
||
}
|
||
|
||
type Mod = {
|
||
kicadOpenFile(p: string): unknown;
|
||
kicadCollabSnapshotItems(): string;
|
||
kicadCollabApplyItems(j: string): unknown;
|
||
} & Record<string, (p: string) => unknown>;
|
||
type FS = {
|
||
mkdirTree(p: string): void;
|
||
writeFile(p: string, d: string): void;
|
||
readFile(p: string, o: { encoding: "utf8" }): string;
|
||
};
|
||
|
||
// Heavy tools (pcbnew ~190MB wasm) can take well over a minute to download +
|
||
// compile + boot, especially the SECOND instance of a run; keep this generous.
|
||
const BOOT_TIMEOUT = 150000;
|
||
|
||
function hasAbort(l: { consoleLogs: string[]; errors: string[] }): boolean {
|
||
return [...l.consoleLogs, ...l.errors].some((s) => s.includes("Aborted("));
|
||
}
|
||
|
||
/** Boot a fresh tool page and open `content` from MEMFS. */
|
||
async function bootOpen(page: Page, cfg: ToolCfg, content: string, name: string): Promise<void> {
|
||
await page.goto(`/kicad/${cfg.html}`);
|
||
await expect(page.locator("#canvas")).toBeVisible({ timeout: BOOT_TIMEOUT });
|
||
await page.waitForFunction(() => !!window.wxElementRegistry, null, { timeout: BOOT_TIMEOUT });
|
||
await page.waitForFunction(
|
||
(saveFn) => {
|
||
const m = (window as unknown as { Module?: Mod }).Module;
|
||
return (
|
||
typeof m?.kicadOpenFile === "function" &&
|
||
typeof m?.kicadCollabSnapshotItems === "function" &&
|
||
typeof m?.kicadCollabApplyItems === "function" &&
|
||
typeof m?.[saveFn] === "function"
|
||
);
|
||
},
|
||
cfg.saveFn,
|
||
{ timeout: BOOT_TIMEOUT },
|
||
);
|
||
await page.waitForFunction(
|
||
() =>
|
||
!!window.wxElementRegistry &&
|
||
window.wxElementRegistry
|
||
.findAll({ visible: true })
|
||
.some((e) => /Frame$/.test(e.typeName) || (e.name || "").endsWith("Frame")),
|
||
null,
|
||
{ timeout: BOOT_TIMEOUT },
|
||
);
|
||
await page.evaluate(
|
||
({ content, name, ext }) => {
|
||
const w = window as unknown as { FS: FS; Module: Mod };
|
||
try {
|
||
w.FS.mkdirTree("/home/kicad/documents");
|
||
} catch {
|
||
/* exists */
|
||
}
|
||
const p = `/home/kicad/documents/${name}.${ext}`;
|
||
w.FS.writeFile(p, content);
|
||
w.Module.kicadOpenFile(p);
|
||
},
|
||
{ content, name, ext: cfg.ext },
|
||
);
|
||
}
|
||
|
||
/** Save the current model to MEMFS via the tool's save export and read it back. */
|
||
async function saveRead(page: Page, cfg: ToolCfg, name: string): Promise<string> {
|
||
return page.evaluate(
|
||
({ saveFn, ext, name }) => {
|
||
const w = window as unknown as { FS: FS; Module: Mod };
|
||
const out = `/home/kicad/documents/${name}.${ext}`;
|
||
w.Module[saveFn](out);
|
||
return w.FS.readFile(out, { encoding: "utf8" });
|
||
},
|
||
{ saveFn: cfg.saveFn, ext: cfg.ext, name },
|
||
);
|
||
}
|
||
|
||
/**
|
||
* The full load → yjs → reload → apply → save loop. Uses TWO separate pages — the
|
||
* extract page is CLOSED before the rebuild page opens — so the process-global wasm
|
||
* heap of the first instance is freed before the second boots (otherwise the heavy
|
||
* tools, e.g. pcbnew at ~190MB, boot the second instance under memory pressure and
|
||
* stall). `snap` crosses the boundary as a plain JS string in test scope.
|
||
*/
|
||
async function roundTrip(
|
||
context: BrowserContext,
|
||
cfg: ToolCfg,
|
||
): Promise<{ orig: string; regen: string }> {
|
||
// 1–3: load the fixture, normalize via a save, extract the yjs snapshot.
|
||
// Open from a FIXED filename for both sides: some serializers embed the opened
|
||
// file name (e.g. eeschema's root "Sheetfile" property), so ORIG and REGEN must
|
||
// share it or that artifact reads as a (spurious) diff.
|
||
const extract = await context.newPage();
|
||
await bootOpen(extract, cfg, cfg.fixture, "rt");
|
||
const orig = await saveRead(extract, cfg, "orig_dump");
|
||
const snap = await extract.evaluate(() => window.Module.kicadCollabSnapshotItems());
|
||
await extract.close();
|
||
|
||
// v2 wire: { added: [{ sexpr, parent }] } — uuids live inside the blobs.
|
||
const blobs: string[] = JSON.parse(snap).added.map((w: { sexpr: string }) => w.sexpr);
|
||
const ids = [...new Set(blobs.flatMap((s) => [...s.matchAll(/\(uuid "([^"]+)"\)/g)].map((m) => m[1]!)))];
|
||
expect(ids.length, "fixture must contain uuid items").toBeGreaterThan(0);
|
||
|
||
// 4–5: fresh page (fresh wasm), open an empty doc, rebuild the model from the snapshot.
|
||
const rebuild = await context.newPage();
|
||
await bootOpen(rebuild, cfg, cfg.empty, "rt");
|
||
await rebuild.evaluate((s) => window.Module.kicadCollabApplyItems(s), snap);
|
||
|
||
// apply() runs async for eeschema/pcbnew (CallAfter + coroutine). Best-effort wait
|
||
// for the first applied item to materialize — but DON'T fail here: proceed to save
|
||
// REGEN regardless, so sexprDiff reports exactly which items failed to round-trip
|
||
// (a poll timeout would hide that signal). pl_editor settles within a tick.
|
||
const deadline = Date.now() + 15000;
|
||
for (;;) {
|
||
const probe = await saveRead(rebuild, cfg, "regen_probe");
|
||
if (probe.includes(`(uuid "${ids[0]}")`) || Date.now() >= deadline) break;
|
||
await rebuild.waitForTimeout(300);
|
||
}
|
||
|
||
const regen = await saveRead(rebuild, cfg, "regen_dump");
|
||
await rebuild.close();
|
||
return { orig, regen };
|
||
}
|
||
|
||
// ── Fixtures ────────────────────────────────────────────────────────────────
|
||
|
||
const PL: ToolCfg = {
|
||
tool: "pl_editor",
|
||
html: "pl_editor.html",
|
||
ext: "kicad_wks",
|
||
saveFn: "kicadSaveDrawingSheet",
|
||
// No root uuid in a .kicad_wks; rect + tbtext carry the uuids we compare.
|
||
fixture: `(kicad_wks (version 20220228) (generator "pl_editor") (generator_version "9.0")
|
||
(setup (textsize 1.5 1.5)(linewidth 0.15)(textlinewidth 0.15)
|
||
(left_margin 10)(right_margin 10)(top_margin 10)(bottom_margin 10))
|
||
(rect (uuid "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb") (name border) (start 0 0 ltcorner) (end 0 0 rbcorner))
|
||
(tbtext "Title" (uuid "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa") (name title) (pos 100 20 ltcorner) (font (size 2 2)))
|
||
)
|
||
`,
|
||
empty: `(kicad_wks (version 20220228) (generator "pl_editor") (generator_version "9.0")
|
||
(setup (textsize 1.5 1.5)(linewidth 0.15)(textlinewidth 0.15)
|
||
(left_margin 10)(right_margin 10)(top_margin 10)(bottom_margin 10))
|
||
)
|
||
`,
|
||
ignoreTokens: ["generator_version"],
|
||
};
|
||
|
||
const SCH: ToolCfg = {
|
||
tool: "eeschema",
|
||
html: "eeschema.html",
|
||
ext: "kicad_sch",
|
||
saveFn: "kicadSaveSchematic",
|
||
// Root (uuid …) shared with the empty doc so only the wires differ.
|
||
fixture: `(kicad_sch
|
||
(version 20250114)
|
||
(generator "eeschema")
|
||
(generator_version "9.0")
|
||
(uuid "11111111-1111-1111-1111-111111111111")
|
||
(paper "A4")
|
||
(lib_symbols)
|
||
(wire (pts (xy 50.8 50.8) (xy 101.6 50.8)) (stroke (width 0) (type default)) (uuid "22222222-0000-0000-0000-000000000001"))
|
||
(wire (pts (xy 50.8 76.2) (xy 101.6 76.2)) (stroke (width 0) (type default)) (uuid "22222222-0000-0000-0000-000000000002"))
|
||
(sheet_instances (path "/" (page "1")))
|
||
)
|
||
`,
|
||
empty: `(kicad_sch
|
||
(version 20250114)
|
||
(generator "eeschema")
|
||
(generator_version "9.0")
|
||
(uuid "11111111-1111-1111-1111-111111111111")
|
||
(paper "A4")
|
||
(lib_symbols)
|
||
(sheet_instances (path "/" (page "1")))
|
||
)
|
||
`,
|
||
ignoreTokens: ["generator_version"],
|
||
};
|
||
|
||
const PCB: ToolCfg = {
|
||
tool: "pcbnew",
|
||
// pcbnew-collab.html seeds kicad_common.json to skip the first-run setup wizard;
|
||
// plain pcbnew.html keeps the wizard, whose modal blocks boot (see pcbnew-collab.spec).
|
||
html: "pcbnew-collab.html",
|
||
ext: "kicad_pcb",
|
||
saveFn: "kicadSaveBoard",
|
||
// No root uuid in a .kicad_pcb; footprint / via / zone / gr_text / segments carry the uuids.
|
||
fixture: `(kicad_pcb
|
||
(version 20241229)
|
||
(generator "pcbnew")
|
||
(generator_version "9.0")
|
||
(general (thickness 1.6))
|
||
(paper "A4")
|
||
(layers
|
||
(0 "F.Cu" signal)
|
||
(2 "B.Cu" signal)
|
||
(37 "F.SilkS" user)
|
||
(25 "Edge.Cuts" user)
|
||
)
|
||
(setup)
|
||
(net 0 "")
|
||
(footprint "TestLib:R"
|
||
(layer "F.Cu")
|
||
(uuid "66666666-0000-0000-0000-000000000001")
|
||
(at 100 100)
|
||
(attr smd)
|
||
(property "Reference" "R1" (at 0 -4.2 0) (layer "F.SilkS") (uuid "66666666-0000-0000-0000-0000000000aa") (effects (font (size 1 1) (thickness 0.15))))
|
||
(property "Value" "R" (at 0 4.6 0) (layer "F.Fab") (uuid "66666666-0000-0000-0000-0000000000bb") (effects (font (size 1 1) (thickness 0.15))))
|
||
(fp_text user "HELLO" (at 0 0 0) (layer "F.SilkS") (uuid "66666666-0000-0000-0000-0000000000cc") (effects (font (size 1 1) (thickness 0.15))))
|
||
)
|
||
(via (at 80 80) (size 1.4) (drill 0.6) (layers "F.Cu" "B.Cu") (net 0) (uuid "77777777-0000-0000-0000-000000000001"))
|
||
(gr_text "BOARDTEXT" (at 90 95 0) (layer "F.SilkS") (uuid "77777777-0000-0000-0000-000000000003") (effects (font (size 1 1) (thickness 0.15)) (justify left bottom)))
|
||
(segment (start 50.8 50.8) (end 101.6 50.8) (width 0.2) (layer "F.Cu") (net 0) (uuid "88888888-0000-0000-0000-000000000001"))
|
||
(segment (start 50.8 76.2) (end 101.6 76.2) (width 0.2) (layer "F.Cu") (net 0) (uuid "88888888-0000-0000-0000-000000000002"))
|
||
)
|
||
`,
|
||
empty: `(kicad_pcb
|
||
(version 20241229)
|
||
(generator "pcbnew")
|
||
(generator_version "9.0")
|
||
(general (thickness 1.6))
|
||
(paper "A4")
|
||
(layers
|
||
(0 "F.Cu" signal)
|
||
(2 "B.Cu" signal)
|
||
(37 "F.SilkS" user)
|
||
(25 "Edge.Cuts" user)
|
||
)
|
||
(setup)
|
||
(net 0 "")
|
||
)
|
||
`,
|
||
ignoreTokens: ["generator_version"],
|
||
};
|
||
|
||
// Footprint-only board: the v2 items wire's PROVEN pcbnew apply path (bare
|
||
// footprint blob parse + children — the 0004 containment win). Kept separate
|
||
// from PCB so the fragile-envelope types (via/text/segment, see the fixme
|
||
// below) don't mask the passing footprint coverage.
|
||
const PCB_FP: ToolCfg = {
|
||
...PCB,
|
||
fixture: `(kicad_pcb
|
||
(version 20241229)
|
||
(generator "pcbnew")
|
||
(generator_version "9.0")
|
||
(general (thickness 1.6))
|
||
(paper "A4")
|
||
(layers
|
||
(0 "F.Cu" signal)
|
||
(2 "B.Cu" signal)
|
||
(37 "F.SilkS" user)
|
||
(25 "Edge.Cuts" user)
|
||
)
|
||
(setup)
|
||
(net 0 "")
|
||
(footprint "TestLib:R"
|
||
(layer "F.Cu")
|
||
(uuid "66666666-0000-0000-0000-000000000001")
|
||
(at 100 100)
|
||
(attr smd)
|
||
(property "Reference" "R1" (at 0 -4.2 0) (layer "F.SilkS") (uuid "66666666-0000-0000-0000-0000000000aa") (effects (font (size 1 1) (thickness 0.15))))
|
||
(property "Value" "R" (at 0 4.6 0) (layer "F.Fab") (uuid "66666666-0000-0000-0000-0000000000bb") (effects (font (size 1 1) (thickness 0.15))))
|
||
(fp_text user "HELLO" (at 0 0 0) (layer "F.SilkS") (uuid "66666666-0000-0000-0000-0000000000cc") (effects (font (size 1 1) (thickness 0.15))))
|
||
)
|
||
(footprint "TestLib:C"
|
||
(layer "F.Cu")
|
||
(uuid "99999999-0000-0000-0000-000000000009")
|
||
(at 50 50)
|
||
(attr smd)
|
||
(property "Reference" "C1" (at 0 -2 0) (layer "F.SilkS") (uuid "99999999-0000-0000-0000-0000000000aa") (effects (font (size 1 1) (thickness 0.15))))
|
||
)
|
||
)
|
||
`,
|
||
};
|
||
|
||
test.beforeAll(() => {
|
||
// No reconciler bundle needed — the round trip drives only the C++ Module.*
|
||
// exports (open / snapshot / apply / save).
|
||
});
|
||
|
||
test.describe("round trip: file → yjs → file", () => {
|
||
// Each test boots the tool TWICE (extract + rebuild); the heavy tools need well
|
||
// beyond the config's 180s per-test budget.
|
||
test.describe.configure({ timeout: 420000 });
|
||
|
||
test("pl_editor preserves items through a yjs round trip", async ({ context, testLogger }) => {
|
||
const { orig, regen } = await roundTrip(context, PL);
|
||
const diff = sexprDiff(orig, regen, { ignoreTokens: PL.ignoreTokens });
|
||
expect(
|
||
diff.equal,
|
||
`round trip lost data:\n${JSON.stringify(diff, null, 2)}`,
|
||
).toBe(true);
|
||
expect(hasAbort(testLogger), "no WASM abort").toBe(false);
|
||
});
|
||
|
||
test("eeschema preserves items through a yjs round trip", async ({ context, testLogger }) => {
|
||
const { orig, regen } = await roundTrip(context, SCH);
|
||
const diff = sexprDiff(orig, regen, { ignoreTokens: SCH.ignoreTokens });
|
||
expect(
|
||
diff.equal,
|
||
`round trip lost data:\n${JSON.stringify(diff, null, 2)}`,
|
||
).toBe(true);
|
||
expect(hasAbort(testLogger), "no WASM abort").toBe(false);
|
||
});
|
||
|
||
// THE 0004 CONTAINMENT WIN (ysync 0008 Stage C/D): footprints round-trip via the
|
||
// items wire — the bare-footprint blob parse recreates the footprint WITH its
|
||
// children (properties, fp_text) in place, which the scalar wire never could.
|
||
test("pcbnew preserves footprint containment through a yjs round trip", async ({
|
||
context,
|
||
testLogger,
|
||
}) => {
|
||
const { orig, regen } = await roundTrip(context, PCB_FP);
|
||
const diff = sexprDiff(orig, regen, { ignoreTokens: PCB_FP.ignoreTokens });
|
||
expect(
|
||
diff.equal,
|
||
`round trip lost data:\n${JSON.stringify(diff, null, 2)}`,
|
||
).toBe(true);
|
||
expect(hasAbort(testLogger), "no WASM abort").toBe(false);
|
||
});
|
||
|
||
// REMAINING KNOWN GAP (ysync 0008 status, known limit 1 — tracked, not a test
|
||
// bug): pcbnew track/via/zone/text APPLY rides the `(kicad_pcb …)` envelope
|
||
// parse, the codebase's documented asyncify-fragile path (even a verbatim
|
||
// SaveSelection envelope for a segment dies silently in the commit). The full
|
||
// fixture (via + gr_text + segments) therefore still loses those items on the
|
||
// rebuild side. Un-fixme when the envelope parse is solved. Run with
|
||
// --grep-invert skipped to see the live diff.
|
||
test.fixme(
|
||
"pcbnew preserves items through a yjs round trip",
|
||
async ({ context, testLogger }) => {
|
||
const { orig, regen } = await roundTrip(context, PCB);
|
||
const diff = sexprDiff(orig, regen, { ignoreTokens: PCB.ignoreTokens });
|
||
expect(
|
||
diff.equal,
|
||
`round trip lost data:\n${JSON.stringify(diff, null, 2)}`,
|
||
).toBe(true);
|
||
expect(hasAbort(testLogger), "no WASM abort").toBe(false);
|
||
},
|
||
);
|
||
});
|