feat(collab): selection soft-locks — remote-selected items can't be dragged locally (collab-presence 0007)
While a peer has an item selected, local users can still select it for
inspection but move/drag/rotate/delete skip it with an infobar naming the
holder (native locked-item UX; enforced via the fork's PCBJAM_REMOTE_LOCK
query — kicad 81f9cd80fd, the epic's first fork-touching phase). Overlapping
holds (both grabbed inside the awareness propagation window) tie-break
deterministically: lowest (user.id, clientID) keeps the item, every losing
client auto-releases it.
- lock-tiebreak.ts: pure policy — beats(), remoteLocks() (union of ALL other
clients' selections incl. own user's other tabs, minus own-held-and-winning
uuids so the winner isn't blocked mid-release), contestedReleases()
- presence.ts: clients() (per-client view, no user dedupe) + self(); FIX for
a pre-existing flaky stack overflow — resolveCollision re-entered itself
synchronously via its own patch's awareness 'change' and could ping-pong on
stale same-user states (~1-in-3 unit runs); re-entrancy guard defers
re-resolution to the next genuine delivery
- presence-kicad.ts: locks ride the kicadCollabSetRemote snapshot
(`locks:[{uuid,name}]`); losing overlaps call kicadCollabReleaseSelection
- wasm bindings (both TUs + merged dispatch): g_locks map + fork query
install; kicadCollabReleaseSelection (cancelInteractive only when a tool
stack is live — bare ESC would clear the whole selection — then selective
RemoveItemFromSel + infobar + forced re-emit); kicadCollabTestGetLocked
- tests: lock-tiebreak unit suite; presence-locks e2e for both editors (real
move veto — pcbnew click+M hotkey since its default left-drag is
rubber-band select, eeschema real drag — each with an unlocked control);
two-tab tests/web/locks.spec.ts (lock propagation + deterministic tiebreak
release + unlock on clear, passing vs real partykit)
Spec: docs/features/collab-presence/0007 (closed repo).
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Lg5jwWuhFH5dL8hEcBDuP2
This commit is contained in:
Gergő Törcsvári
parent
3186986a0a
commit
c30bcd4531
14 changed files with 1221 additions and 7 deletions
233
tests/kicad/presence-locks-eeschema.spec.ts
Normal file
233
tests/kicad/presence-locks-eeschema.spec.ts
Normal file
|
|
@ -0,0 +1,233 @@
|
|||
import type { Page } from "@playwright/test";
|
||||
import { test, expect } from "./fixtures";
|
||||
|
||||
/**
|
||||
* eeschema selection soft-locks — C++ veto e2e (collab-presence 0007).
|
||||
* Mirror of presence-locks-pcbnew.spec.ts: eeschema has NO native item-lock
|
||||
* plumbing (the itemPassesFilter lock branch is #if 0), so the veto rides the
|
||||
* pcbjam remote-lock check in narrowSelection's aCheckLocked path — a real
|
||||
* drag gesture on a locked wire must not move it, the same gesture moves it
|
||||
* unlocked, and ReleaseSelection strips exactly the contested uuid.
|
||||
*/
|
||||
|
||||
const WIRE1 = "22222222-0000-0000-0000-000000000001";
|
||||
const SAMPLE_SCH = `(kicad_sch
|
||||
\t(version 20250114)
|
||||
\t(generator "eeschema")
|
||||
\t(generator_version "9.0")
|
||||
\t(uuid "11111111-1111-1111-1111-111111111111")
|
||||
\t(paper "A4")
|
||||
\t(lib_symbols)
|
||||
\t(wire (pts (xy 50.8 50.8) (xy 101.6 50.8)) (stroke (width 0) (type default)) (uuid "${WIRE1}"))
|
||||
\t(wire (pts (xy 50.8 76.2) (xy 101.6 76.2)) (stroke (width 0) (type default)) (uuid "22222222-0000-0000-0000-000000000002"))
|
||||
\t(sheet_instances (path "/" (page "1")))
|
||||
)
|
||||
`;
|
||||
|
||||
type FS = { mkdirTree(p: string): void; writeFile(p: string, d: string): void };
|
||||
type Mod = {
|
||||
kicadOpenFile(p: string): unknown;
|
||||
kicadCollabPresenceStart(): void;
|
||||
kicadCollabSetRemote(j: string): void;
|
||||
kicadCollabGetViewport(): string;
|
||||
kicadCollabGetSelection(): string;
|
||||
kicadCollabGetPos(id: string): string;
|
||||
kicadCollabReleaseSelection(uuidsJson: string, holder: string): void;
|
||||
kicadCollabTestGetLocked(): string;
|
||||
kicadCollabTestSelectFirst(): string;
|
||||
};
|
||||
type LocksWindow = {
|
||||
FS: FS;
|
||||
Module: Mod;
|
||||
kicadCollab?: Record<string, unknown>;
|
||||
};
|
||||
|
||||
function hasAbort(l: { consoleLogs: string[]; errors: string[] }): boolean {
|
||||
return [...l.consoleLogs, ...l.errors].some((s) => s.includes("Aborted("));
|
||||
}
|
||||
|
||||
async function bootAndOpen(page: Page): Promise<void> {
|
||||
await page.goto("/kicad/eeschema.html");
|
||||
await expect(page.locator("#canvas")).toBeVisible({ timeout: 90000 });
|
||||
await page.waitForFunction(() => !!window.wxElementRegistry, null, { timeout: 90000 });
|
||||
await page.waitForFunction(
|
||||
() => {
|
||||
const m = (window as unknown as { Module?: Partial<Mod> }).Module;
|
||||
return (
|
||||
typeof m?.kicadOpenFile === "function" &&
|
||||
typeof m?.kicadCollabTestGetLocked === "function"
|
||||
);
|
||||
},
|
||||
null,
|
||||
{ timeout: 90000 },
|
||||
);
|
||||
await page.waitForFunction(
|
||||
() =>
|
||||
!!window.wxElementRegistry &&
|
||||
window.wxElementRegistry
|
||||
.findAll({ visible: true })
|
||||
.some((e) => /Frame$/.test(e.typeName) || (e.name || "").endsWith("Frame")),
|
||||
null,
|
||||
{ timeout: 90000 },
|
||||
);
|
||||
|
||||
await page.evaluate(
|
||||
({ content }) => {
|
||||
const w = window as unknown as LocksWindow;
|
||||
const dir = "/home/kicad/documents";
|
||||
try {
|
||||
w.FS.mkdirTree(dir);
|
||||
} catch {
|
||||
/* exists */
|
||||
}
|
||||
const p = `${dir}/locks.kicad_sch`;
|
||||
w.FS.writeFile(p, content);
|
||||
w.Module.kicadOpenFile(p);
|
||||
},
|
||||
{ content: SAMPLE_SCH },
|
||||
);
|
||||
|
||||
await expect
|
||||
.poll(() => page.title(), { timeout: 60000, intervals: [500] })
|
||||
.toMatch(/locks/i);
|
||||
|
||||
await page.evaluate(() => {
|
||||
(window as unknown as LocksWindow).Module.kicadCollabPresenceStart();
|
||||
});
|
||||
}
|
||||
|
||||
function setLock(page: Page, locked: boolean): Promise<void> {
|
||||
return page.evaluate(
|
||||
({ id, locked: isLocked }) => {
|
||||
const w = window as unknown as LocksWindow;
|
||||
w.Module.kicadCollabSetRemote(
|
||||
JSON.stringify({
|
||||
peers: [],
|
||||
locks: isLocked ? [{ uuid: id, name: "bob" }] : [],
|
||||
}),
|
||||
);
|
||||
},
|
||||
{ id: WIRE1, locked },
|
||||
);
|
||||
}
|
||||
|
||||
const wirePos = (page: Page) =>
|
||||
page.evaluate(() =>
|
||||
(window as unknown as LocksWindow).Module.kicadCollabGetPos(
|
||||
"22222222-0000-0000-0000-000000000001",
|
||||
),
|
||||
);
|
||||
|
||||
/** Screen position of the wire's stored (start) point via the GAL transform. */
|
||||
async function wireScreenPos(page: Page): Promise<{ x: number; y: number }> {
|
||||
const glId = await page.evaluate(() => {
|
||||
const visible = Array.from(document.querySelectorAll('[id^="glcanvas-"]'))
|
||||
.map((c) => c as HTMLCanvasElement)
|
||||
.find(
|
||||
(c) =>
|
||||
window.getComputedStyle(c).display !== "none" &&
|
||||
c.getBoundingClientRect().width > 0,
|
||||
);
|
||||
return visible?.id ?? null;
|
||||
});
|
||||
expect(glId).toBeTruthy();
|
||||
const box = await page.locator(`#${glId}`).boundingBox();
|
||||
expect(box).toBeTruthy();
|
||||
|
||||
const { vp, pos } = await page.evaluate(() => {
|
||||
const w = window as unknown as LocksWindow;
|
||||
return {
|
||||
vp: JSON.parse(w.Module.kicadCollabGetViewport()),
|
||||
pos: w.Module.kicadCollabGetPos("22222222-0000-0000-0000-000000000001"),
|
||||
};
|
||||
});
|
||||
const [wx, wy] = pos.split(",").map(Number);
|
||||
return {
|
||||
x: box!.x + (wx - vp.cx) * vp.scale + vp.w / 2,
|
||||
y: box!.y + (wy - vp.cy) * vp.scale + vp.h / 2,
|
||||
};
|
||||
}
|
||||
|
||||
async function dragFromWire(page: Page): Promise<void> {
|
||||
const at = await wireScreenPos(page);
|
||||
await page.mouse.move(at.x, at.y);
|
||||
await page.mouse.down();
|
||||
await page.mouse.move(at.x + 100, at.y + 60, { steps: 10 });
|
||||
await page.mouse.up();
|
||||
await page.waitForTimeout(800);
|
||||
}
|
||||
|
||||
test("a locked wire resists a real drag; the same drag moves it unlocked", async ({
|
||||
page,
|
||||
testLogger,
|
||||
}) => {
|
||||
test.setTimeout(240000);
|
||||
await bootAndOpen(page);
|
||||
|
||||
await setLock(page, true);
|
||||
await expect
|
||||
.poll(() =>
|
||||
page.evaluate(() =>
|
||||
JSON.parse((window as unknown as LocksWindow).Module.kicadCollabTestGetLocked()),
|
||||
),
|
||||
)
|
||||
.toEqual([{ uuid: WIRE1, name: "bob" }]);
|
||||
|
||||
const before = await wirePos(page);
|
||||
expect(before).toBeTruthy();
|
||||
await dragFromWire(page);
|
||||
expect(await wirePos(page)).toBe(before);
|
||||
|
||||
// Control: unlocked, the same gesture moves/bends the wire.
|
||||
await setLock(page, false);
|
||||
await dragFromWire(page);
|
||||
await expect
|
||||
.poll(() => wirePos(page), {
|
||||
timeout: 10000,
|
||||
message: "control drag never moved the unlocked wire",
|
||||
})
|
||||
.not.toBe(before);
|
||||
|
||||
expect(hasAbort(testLogger)).toBe(false);
|
||||
});
|
||||
|
||||
test("a locked wire stays selectable; ReleaseSelection strips it", async ({
|
||||
page,
|
||||
testLogger,
|
||||
}) => {
|
||||
test.setTimeout(240000);
|
||||
await bootAndOpen(page);
|
||||
await setLock(page, true);
|
||||
|
||||
// Inspection: programmatic select through the real tool still lands.
|
||||
const id = await page.evaluate(() =>
|
||||
(window as unknown as LocksWindow).Module.kicadCollabTestSelectFirst(),
|
||||
);
|
||||
expect(id).toBeTruthy();
|
||||
await expect
|
||||
.poll(() =>
|
||||
page.evaluate(() =>
|
||||
JSON.parse((window as unknown as LocksWindow).Module.kicadCollabGetSelection()),
|
||||
),
|
||||
)
|
||||
.toContain(id);
|
||||
|
||||
// Tiebreak-loser path: release exactly that uuid.
|
||||
await page.evaluate(
|
||||
({ uuid }) =>
|
||||
(window as unknown as LocksWindow).Module.kicadCollabReleaseSelection(
|
||||
JSON.stringify([uuid]),
|
||||
"bob",
|
||||
),
|
||||
{ uuid: id },
|
||||
);
|
||||
await expect
|
||||
.poll(() =>
|
||||
page.evaluate(() =>
|
||||
JSON.parse((window as unknown as LocksWindow).Module.kicadCollabGetSelection()),
|
||||
),
|
||||
)
|
||||
.toEqual([]);
|
||||
|
||||
expect(hasAbort(testLogger)).toBe(false);
|
||||
});
|
||||
316
tests/kicad/presence-locks-pcbnew.spec.ts
Normal file
316
tests/kicad/presence-locks-pcbnew.spec.ts
Normal file
|
|
@ -0,0 +1,316 @@
|
|||
import type { Page } from "@playwright/test";
|
||||
import { test, expect } from "./fixtures";
|
||||
|
||||
/**
|
||||
* pcbnew selection soft-locks — C++ veto e2e (collab-presence 0007).
|
||||
*
|
||||
* Seeds the remote lock set directly via kicadCollabSetRemote (`locks` field)
|
||||
* and drives REAL input against it:
|
||||
* - a drag-move gesture starting on a locked footprint must not move it
|
||||
* (selectPoint's aOnDrag strip + the move request filter), while the SAME
|
||||
* gesture moves it once the lock clears (the control that proves the
|
||||
* gesture itself works);
|
||||
* - plain selection of a locked item stays possible (inspection semantics);
|
||||
* - kicadCollabReleaseSelection unselects exactly the contested uuids
|
||||
* (the tiebreak-loser path), leaving the rest selected;
|
||||
* - kicadCollabTestGetLocked mirrors the seeded set.
|
||||
*
|
||||
* The awareness/tiebreak loop lives in TS (unit-tested) and in the two-tab
|
||||
* tests/web/locks.spec.ts.
|
||||
*/
|
||||
|
||||
const SEG1 = "44444444-0000-0000-0000-000000000001";
|
||||
const FP1 = "66666666-0000-0000-0000-000000000001";
|
||||
const SAMPLE_PCB = `(kicad_pcb
|
||||
\t(version 20241229)
|
||||
\t(generator "pcbnew")
|
||||
\t(generator_version "9.0")
|
||||
\t(general
|
||||
\t\t(thickness 1.6)
|
||||
\t)
|
||||
\t(paper "A4")
|
||||
\t(layers
|
||||
\t\t(0 "F.Cu" signal)
|
||||
\t\t(2 "B.Cu" signal)
|
||||
\t\t(37 "F.SilkS" user)
|
||||
\t\t(25 "Edge.Cuts" user)
|
||||
\t)
|
||||
\t(setup)
|
||||
\t(net 0 "")
|
||||
\t(footprint "TestLib:R"
|
||||
\t\t(layer "F.Cu")
|
||||
\t\t(uuid "${FP1}")
|
||||
\t\t(at 100 100)
|
||||
\t\t(attr smd)
|
||||
\t\t(fp_rect (start -2 -2) (end 2 2) (layer "F.SilkS") (stroke (width 0.3) (type solid)) (uuid "66666666-0000-0000-0000-0000000000cc"))
|
||||
\t\t(pad "1" smd rect
|
||||
\t\t\t(at 0 0)
|
||||
\t\t\t(size 3 3)
|
||||
\t\t\t(layers "F.Cu")
|
||||
\t\t\t(uuid "66666666-0000-0000-0000-0000000000dd")
|
||||
\t\t)
|
||||
\t)
|
||||
\t(segment (start 50.8 50.8) (end 101.6 50.8) (width 0.2) (layer "F.Cu") (net 0) (uuid "${SEG1}"))
|
||||
)
|
||||
`;
|
||||
|
||||
type FS = { mkdirTree(p: string): void; writeFile(p: string, d: string): void };
|
||||
type Mod = {
|
||||
kicadOpenFile(p: string): unknown;
|
||||
kicadCollabPresenceStart(): void;
|
||||
kicadCollabSetRemote(j: string): void;
|
||||
kicadCollabGetViewport(): string;
|
||||
kicadCollabGetSelection(): string;
|
||||
kicadCollabGetPos(id: string): string;
|
||||
kicadCollabReleaseSelection(uuidsJson: string, holder: string): void;
|
||||
kicadCollabTestGetLocked(): string;
|
||||
kicadCollabTestSelectComponent(): string;
|
||||
kicadCollabTestSelectFirst(): string;
|
||||
kicadCollabTestClearSelection(): boolean;
|
||||
};
|
||||
type LocksWindow = {
|
||||
FS: FS;
|
||||
Module: Mod;
|
||||
kicadCollab?: Record<string, unknown>;
|
||||
};
|
||||
|
||||
function hasAbort(l: { consoleLogs: string[]; errors: string[] }): boolean {
|
||||
return [...l.consoleLogs, ...l.errors].some((s) => s.includes("Aborted("));
|
||||
}
|
||||
|
||||
async function bootAndOpen(page: Page): Promise<void> {
|
||||
await page.goto("/kicad/pcbnew-collab.html");
|
||||
await expect(page.locator("#canvas")).toBeVisible({ timeout: 90000 });
|
||||
await page.waitForFunction(() => !!window.wxElementRegistry, null, { timeout: 90000 });
|
||||
await page.waitForFunction(
|
||||
() => {
|
||||
const m = (window as unknown as { Module?: Partial<Mod> }).Module;
|
||||
return (
|
||||
typeof m?.kicadOpenFile === "function" &&
|
||||
typeof m?.kicadCollabTestGetLocked === "function"
|
||||
);
|
||||
},
|
||||
null,
|
||||
{ timeout: 90000 },
|
||||
);
|
||||
await page.waitForFunction(
|
||||
() =>
|
||||
!!window.wxElementRegistry &&
|
||||
window.wxElementRegistry
|
||||
.findAll({ visible: true })
|
||||
.some((e) => /Frame$/.test(e.typeName) || (e.name || "").endsWith("Frame")),
|
||||
null,
|
||||
{ timeout: 90000 },
|
||||
);
|
||||
|
||||
await page.evaluate(
|
||||
({ content }) => {
|
||||
const w = window as unknown as LocksWindow;
|
||||
const dir = "/home/kicad/documents";
|
||||
try {
|
||||
w.FS.mkdirTree(dir);
|
||||
} catch {
|
||||
/* exists */
|
||||
}
|
||||
const p = `${dir}/locks.kicad_pcb`;
|
||||
w.FS.writeFile(p, content);
|
||||
w.Module.kicadOpenFile(p);
|
||||
},
|
||||
{ content: SAMPLE_PCB },
|
||||
);
|
||||
|
||||
await expect
|
||||
.poll(() => page.title(), { timeout: 60000, intervals: [500] })
|
||||
.toMatch(/locks/i);
|
||||
|
||||
await page.evaluate(() => {
|
||||
(window as unknown as LocksWindow).Module.kicadCollabPresenceStart();
|
||||
});
|
||||
}
|
||||
|
||||
/** Seed (or clear) the remote lock set for FP1. */
|
||||
function setLock(page: Page, locked: boolean): Promise<void> {
|
||||
return page.evaluate(
|
||||
({ fp, locked: isLocked }) => {
|
||||
const w = window as unknown as LocksWindow;
|
||||
w.Module.kicadCollabSetRemote(
|
||||
JSON.stringify({
|
||||
peers: [],
|
||||
locks: isLocked ? [{ uuid: fp, name: "bob" }] : [],
|
||||
}),
|
||||
);
|
||||
},
|
||||
{ fp: FP1, locked },
|
||||
);
|
||||
}
|
||||
|
||||
/** The footprint's current screen position via the exported GAL transform. */
|
||||
async function fpScreenPos(page: Page): Promise<{ x: number; y: number }> {
|
||||
const glId = await page.evaluate(() => {
|
||||
const visible = Array.from(document.querySelectorAll('[id^="glcanvas-"]'))
|
||||
.map((c) => c as HTMLCanvasElement)
|
||||
.find(
|
||||
(c) =>
|
||||
window.getComputedStyle(c).display !== "none" &&
|
||||
c.getBoundingClientRect().width > 0,
|
||||
);
|
||||
return visible?.id ?? null;
|
||||
});
|
||||
expect(glId).toBeTruthy();
|
||||
const box = await page.locator(`#${glId}`).boundingBox();
|
||||
expect(box).toBeTruthy();
|
||||
|
||||
const { vp, pos } = await page.evaluate(() => {
|
||||
const w = window as unknown as LocksWindow;
|
||||
return {
|
||||
vp: JSON.parse(w.Module.kicadCollabGetViewport()),
|
||||
pos: w.Module.kicadCollabGetPos("66666666-0000-0000-0000-000000000001"),
|
||||
};
|
||||
});
|
||||
const [wx, wy] = pos.split(",").map(Number);
|
||||
return {
|
||||
x: box!.x + (wx - vp.cx) * vp.scale + vp.w / 2,
|
||||
y: box!.y + (wy - vp.cy) * vp.scale + vp.h / 2,
|
||||
};
|
||||
}
|
||||
|
||||
const fpPos = (page: Page) =>
|
||||
page.evaluate(() =>
|
||||
(window as unknown as LocksWindow).Module.kicadCollabGetPos(
|
||||
"66666666-0000-0000-0000-000000000001",
|
||||
),
|
||||
);
|
||||
|
||||
/**
|
||||
* The real pcbnew move flow: click-select the footprint, then the `M` hotkey
|
||||
* (pcbnew's default LEFT-DRAG gesture is rubber-band select, not move — the
|
||||
* eeschema spec covers the drag-gesture path where dragging DOES move).
|
||||
* `M` routes through EDIT_TOOL::Move → RequestSelection → the locked-items
|
||||
* client filter — exactly the veto under test. The drop is a click at the
|
||||
* offset position.
|
||||
*/
|
||||
async function moveViaHotkey(page: Page): Promise<void> {
|
||||
const at = await fpScreenPos(page);
|
||||
await page.mouse.click(at.x, at.y); // select (allowed — inspection semantics)
|
||||
await page.waitForTimeout(500);
|
||||
await page.mouse.move(at.x, at.y);
|
||||
await page.keyboard.press("m");
|
||||
await page.waitForTimeout(500);
|
||||
await page.mouse.move(at.x + 120, at.y + 80, { steps: 10 });
|
||||
await page.mouse.click(at.x + 120, at.y + 80); // drop (no-op if move never started)
|
||||
await page.waitForTimeout(800);
|
||||
await page.keyboard.press("Escape"); // leave no half-open tool between phases
|
||||
await page.waitForTimeout(300);
|
||||
}
|
||||
|
||||
test("seeded locks are probeable and a locked footprint resists a real move", async ({
|
||||
page,
|
||||
testLogger,
|
||||
}) => {
|
||||
test.setTimeout(240000);
|
||||
await bootAndOpen(page);
|
||||
|
||||
await setLock(page, true);
|
||||
await expect
|
||||
.poll(() =>
|
||||
page.evaluate(() =>
|
||||
JSON.parse((window as unknown as LocksWindow).Module.kicadCollabTestGetLocked()),
|
||||
),
|
||||
)
|
||||
.toEqual([{ uuid: FP1, name: "bob" }]);
|
||||
|
||||
// Veto: select + M + drop must leave the locked footprint in place.
|
||||
const before = await fpPos(page);
|
||||
expect(before).toBeTruthy();
|
||||
await moveViaHotkey(page);
|
||||
expect(await fpPos(page)).toBe(before);
|
||||
|
||||
// Control: the SAME flow moves it once the lock clears — proving the veto
|
||||
// (not a broken gesture) kept it in place above.
|
||||
await setLock(page, false);
|
||||
await expect
|
||||
.poll(() =>
|
||||
page.evaluate(() =>
|
||||
JSON.parse((window as unknown as LocksWindow).Module.kicadCollabTestGetLocked()),
|
||||
),
|
||||
)
|
||||
.toEqual([]);
|
||||
await moveViaHotkey(page);
|
||||
await expect
|
||||
.poll(() => fpPos(page), {
|
||||
timeout: 10000,
|
||||
message: "control move never moved the unlocked footprint",
|
||||
})
|
||||
.not.toBe(before);
|
||||
|
||||
expect(hasAbort(testLogger)).toBe(false);
|
||||
});
|
||||
|
||||
test("a locked item stays selectable for inspection", async ({ page, testLogger }) => {
|
||||
test.setTimeout(240000);
|
||||
await bootAndOpen(page);
|
||||
await setLock(page, true);
|
||||
|
||||
// Programmatic select drives the real selection tool (no drag involved).
|
||||
const id = await page.evaluate(() =>
|
||||
(window as unknown as LocksWindow).Module.kicadCollabTestSelectComponent(),
|
||||
);
|
||||
expect(id).toBe(FP1);
|
||||
await expect
|
||||
.poll(() =>
|
||||
page.evaluate(() =>
|
||||
JSON.parse((window as unknown as LocksWindow).Module.kicadCollabGetSelection()),
|
||||
),
|
||||
)
|
||||
.toContain(FP1);
|
||||
|
||||
expect(hasAbort(testLogger)).toBe(false);
|
||||
});
|
||||
|
||||
test("ReleaseSelection unselects exactly the contested uuids", async ({
|
||||
page,
|
||||
testLogger,
|
||||
}) => {
|
||||
test.setTimeout(240000);
|
||||
await bootAndOpen(page);
|
||||
|
||||
// Select the footprint plus (if distinct) the first top-level item through
|
||||
// the real tool — TestSelectFirst may pick the footprint itself, so assert
|
||||
// set-minus semantics rather than counts.
|
||||
await page.evaluate(() => {
|
||||
const w = window as unknown as LocksWindow;
|
||||
w.Module.kicadCollabTestSelectComponent();
|
||||
w.Module.kicadCollabTestSelectFirst();
|
||||
});
|
||||
await expect
|
||||
.poll(() =>
|
||||
page.evaluate(() =>
|
||||
JSON.parse((window as unknown as LocksWindow).Module.kicadCollabGetSelection()),
|
||||
),
|
||||
)
|
||||
.toContain(FP1);
|
||||
const preRelease: string[] = await page.evaluate(() =>
|
||||
JSON.parse((window as unknown as LocksWindow).Module.kicadCollabGetSelection()),
|
||||
);
|
||||
|
||||
// Lose the tiebreak on the footprint only.
|
||||
await page.evaluate(
|
||||
({ fp }) =>
|
||||
(window as unknown as LocksWindow).Module.kicadCollabReleaseSelection(
|
||||
JSON.stringify([fp]),
|
||||
"bob",
|
||||
),
|
||||
{ fp: FP1 },
|
||||
);
|
||||
|
||||
// Exactly the contested uuid drops; anything else selected survives.
|
||||
await expect
|
||||
.poll(() =>
|
||||
page.evaluate(() =>
|
||||
JSON.parse((window as unknown as LocksWindow).Module.kicadCollabGetSelection()),
|
||||
),
|
||||
)
|
||||
.toEqual(preRelease.filter((u) => u !== FP1));
|
||||
|
||||
expect(hasAbort(testLogger)).toBe(false);
|
||||
});
|
||||
111
tests/web/locks.spec.ts
Normal file
111
tests/web/locks.spec.ts
Normal file
|
|
@ -0,0 +1,111 @@
|
|||
import { test, expect, type Page } from '@playwright/test';
|
||||
|
||||
/**
|
||||
* Selection soft-locks e2e (collab-presence 0007): two tabs of the real app
|
||||
* on the SAME board share the per-file room — one tab's live selection must
|
||||
* soft-lock those items for the other, and an overlapping hold (both grab the
|
||||
* same item inside the propagation window — simulated with the programmatic
|
||||
* select, which bypasses the acquisition veto exactly like a real race)
|
||||
* resolves by the deterministic (user.id, clientID) tiebreak: alice keeps,
|
||||
* bob's client releases.
|
||||
*/
|
||||
|
||||
const SCOPE = 'default';
|
||||
|
||||
type Mod = {
|
||||
kicadCollabGetSelection(): string;
|
||||
kicadCollabTestGetLocked(): string;
|
||||
kicadCollabTestSelectComponent(): string;
|
||||
kicadCollabTestClearSelection(): boolean;
|
||||
};
|
||||
type W = { Module: Mod };
|
||||
|
||||
async function bootBoard(page: Page, user: string): Promise<void> {
|
||||
await page.goto(`/${SCOPE}/projects/demo/demo.kicad_pcb?user=${user}`);
|
||||
await expect(page.locator('#canvas')).toBeVisible({ timeout: 120000 });
|
||||
await expect
|
||||
.poll(() => page.title(), {
|
||||
message: `${user}: board editor never reached the expected title`,
|
||||
timeout: 120000,
|
||||
intervals: [1000],
|
||||
})
|
||||
.toMatch(/demo — PCB Editor/i);
|
||||
await page.waitForFunction(
|
||||
() =>
|
||||
typeof (window as unknown as Partial<W>).Module?.kicadCollabTestGetLocked ===
|
||||
'function',
|
||||
null,
|
||||
{ timeout: 60000 },
|
||||
);
|
||||
}
|
||||
|
||||
const selection = (page: Page) =>
|
||||
page.evaluate(() =>
|
||||
JSON.parse((window as unknown as W).Module.kicadCollabGetSelection()),
|
||||
);
|
||||
const locked = (page: Page) =>
|
||||
page.evaluate(() =>
|
||||
JSON.parse((window as unknown as W).Module.kicadCollabTestGetLocked()),
|
||||
);
|
||||
|
||||
test('a peer selection locks the item; overlapping holds tiebreak deterministically', async ({
|
||||
page,
|
||||
context,
|
||||
}) => {
|
||||
test.setTimeout(480000); // two full board boots
|
||||
|
||||
const alice = page;
|
||||
await bootBoard(alice, 'alice');
|
||||
const bob = await context.newPage();
|
||||
await bootBoard(bob, 'bob');
|
||||
|
||||
// ── lock propagation ───────────────────────────────────────────────────────
|
||||
const fpId = await alice.evaluate(() =>
|
||||
(window as unknown as W).Module.kicadCollabTestSelectComponent(),
|
||||
);
|
||||
expect(fpId, 'demo board should contain a footprint').toBeTruthy();
|
||||
|
||||
await expect
|
||||
.poll(() => locked(bob), {
|
||||
timeout: 20000,
|
||||
message: "bob never saw alice's selection as a lock",
|
||||
})
|
||||
.toEqual([{ uuid: fpId, name: 'alice' }]);
|
||||
// The holder's own tab is NOT locked against itself.
|
||||
await expect.poll(() => locked(alice), { timeout: 20000 }).toEqual([]);
|
||||
|
||||
// ── overlapping hold → tiebreak ────────────────────────────────────────────
|
||||
// bob grabs the SAME footprint programmatically (the race-window simulation:
|
||||
// AddItemToSel bypasses the acquisition veto, like two grabs inside the
|
||||
// awareness propagation window).
|
||||
const bobPick = await bob.evaluate(() =>
|
||||
(window as unknown as W).Module.kicadCollabTestSelectComponent(),
|
||||
);
|
||||
expect(bobPick).toBe(fpId);
|
||||
|
||||
// alice ("alice" < "bob") keeps it; bob's client releases it.
|
||||
await expect
|
||||
.poll(() => selection(bob), {
|
||||
timeout: 20000,
|
||||
message: "bob's losing hold was never released",
|
||||
})
|
||||
.toEqual([]);
|
||||
expect(await selection(alice)).toContain(fpId);
|
||||
|
||||
// ── unlock on clear ────────────────────────────────────────────────────────
|
||||
await alice.evaluate(() =>
|
||||
(window as unknown as W).Module.kicadCollabTestClearSelection(),
|
||||
);
|
||||
await expect.poll(() => locked(bob), { timeout: 20000 }).toEqual([]);
|
||||
|
||||
// Now bob's grab sticks, and it locks the item for alice.
|
||||
await bob.evaluate(() =>
|
||||
(window as unknown as W).Module.kicadCollabTestSelectComponent(),
|
||||
);
|
||||
await expect
|
||||
.poll(() => selection(bob), { timeout: 20000 })
|
||||
.toContain(fpId);
|
||||
await expect
|
||||
.poll(() => locked(alice), { timeout: 20000 })
|
||||
.toEqual([{ uuid: fpId, name: 'bob' }]);
|
||||
});
|
||||
Loading…
Reference in a new issue