1043 lines
50 KiB
JavaScript
1043 lines
50 KiB
JavaScript
#!/usr/bin/env node
|
|
"use strict";
|
|
|
|
const fs = require("node:fs/promises");
|
|
const path = require("node:path");
|
|
const { chromium } = require("playwright");
|
|
const {
|
|
BASE_URL,
|
|
UI_TIMEOUT_MS,
|
|
assert,
|
|
cleanupDocuments,
|
|
createTempDocument,
|
|
ensureAuthenticated,
|
|
openDocument,
|
|
renameDocument,
|
|
} = require("./tree-shell-smoke-helpers");
|
|
|
|
const TASK = "task167-mindmap-kmind-parity-smoke";
|
|
const OUTPUT_DIR = path.join(process.cwd(), "tmp", TASK);
|
|
const RESULT_PATH = path.join(OUTPUT_DIR, "result.json");
|
|
const STAGE = process.argv.includes("--stage") ? process.argv[process.argv.indexOf("--stage") + 1] : "all";
|
|
|
|
async function writeResult(payload) {
|
|
await fs.mkdir(OUTPUT_DIR, { recursive: true });
|
|
await fs.writeFile(RESULT_PATH, `${JSON.stringify({ ...payload, resultPath: RESULT_PATH }, null, 2)}\n`, "utf8");
|
|
}
|
|
|
|
async function screenshot(page, name) {
|
|
const file = path.join(OUTPUT_DIR, `${name}.png`);
|
|
await page.screenshot({ path: file, fullPage: true });
|
|
return file;
|
|
}
|
|
|
|
async function insertMindmapThroughSlash(page) {
|
|
const editor = page
|
|
.locator('[data-testid="mnote-leptos-tiptap-island-editor-root"] .editor-surface .ProseMirror[contenteditable="true"]')
|
|
.first();
|
|
await editor.waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
|
|
await editor.click({ timeout: UI_TIMEOUT_MS });
|
|
await page.keyboard.type("/");
|
|
const item = page.getByTestId("slash-item-mindmap").first();
|
|
await item.waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
|
|
await item.click({ timeout: UI_TIMEOUT_MS });
|
|
}
|
|
|
|
async function assertMindmapReady(page, stage) {
|
|
await page.locator('[data-testid="mnote-mindmap-editor-root"]').waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
|
|
await page.locator('[data-testid="simple-mind-map-runtime"]').waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
|
|
await page.waitForFunction(
|
|
() => {
|
|
const root = document.querySelector('[data-testid="mnote-mindmap-editor-root"]');
|
|
const runtime = document.querySelector('[data-testid="simple-mind-map-runtime"]');
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
const mindmapId = root instanceof HTMLElement ? root.dataset.mnoteMindmapId || null : null;
|
|
const registry = window.__MNOTE_LEPTOS_MINDMAP_BRIDGES__ || {};
|
|
const bridge = mindmapId ? registry[mindmapId] : null;
|
|
return (
|
|
runtime instanceof HTMLElement &&
|
|
runtime.dataset.runtimeEngine === "simple-mind-map" &&
|
|
runtime.dataset.runtimeReady === "true" &&
|
|
shell instanceof HTMLElement &&
|
|
shell.dataset.uiShellSource === "leptos-rust-shell" &&
|
|
Boolean(bridge)
|
|
);
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
).catch((error) => {
|
|
throw new Error(`mindmap_not_ready:${stage}:${error.message}`);
|
|
});
|
|
}
|
|
|
|
async function readMindmapIdentity(page) {
|
|
return page.evaluate(() => {
|
|
const root = document.querySelector('[data-testid="mnote-mindmap-editor-root"]');
|
|
return {
|
|
mindmapId: root instanceof HTMLElement ? root.dataset.mnoteMindmapId || null : null,
|
|
};
|
|
});
|
|
}
|
|
|
|
async function readToolbarMetrics(page) {
|
|
return page.evaluate(() => {
|
|
const toolbar = document.querySelector('[data-testid="mindmap-schema-toolbar"]');
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
const mainCluster = document.querySelector('[data-testid="mindmap-schema-toolbar-cluster-main"]');
|
|
const fileCluster = document.querySelector('[data-testid="mindmap-schema-toolbar-cluster-file"]');
|
|
const moreButton = document.querySelector('[data-testid="mindmap-schema-toolbar-action-more"]');
|
|
const moreMenu = document.querySelector('[data-testid="mindmap-schema-toolbar-more-menu"]');
|
|
const buttons = Array.from(document.querySelectorAll('[data-testid^="mindmap-schema-toolbar-action-"]')).filter(
|
|
(node) => node instanceof HTMLElement && node.getBoundingClientRect().width > 0,
|
|
);
|
|
const rect = toolbar instanceof HTMLElement ? toolbar.getBoundingClientRect() : null;
|
|
const topValues = buttons.map((node) => Math.round(node.getBoundingClientRect().top));
|
|
return {
|
|
toolbarExists: toolbar instanceof HTMLElement,
|
|
shellExists: shell instanceof HTMLElement,
|
|
height: rect ? rect.height : 0,
|
|
width: rect ? rect.width : 0,
|
|
toolbarRows: new Set(topValues).size,
|
|
visibleActions:
|
|
shell instanceof HTMLElement && shell.dataset.toolbarVisibleActions
|
|
? shell.dataset.toolbarVisibleActions.split(",").filter(Boolean)
|
|
: [],
|
|
overflowActions:
|
|
shell instanceof HTMLElement && shell.dataset.toolbarOverflowActions
|
|
? shell.dataset.toolbarOverflowActions.split(",").filter(Boolean)
|
|
: [],
|
|
moreOpen: shell instanceof HTMLElement ? shell.dataset.toolbarMoreOpen === "true" : false,
|
|
mainCluster: mainCluster instanceof HTMLElement,
|
|
fileCluster: fileCluster instanceof HTMLElement,
|
|
moreButton: moreButton instanceof HTMLButtonElement,
|
|
moreMenu: moreMenu instanceof HTMLElement,
|
|
labels: buttons.map((node) => (node.textContent || "").trim()),
|
|
iconKeys: buttons.map((node) => (node instanceof HTMLElement ? node.dataset.iconKey || null : null)),
|
|
};
|
|
});
|
|
}
|
|
|
|
async function verifyToolbarStage(page) {
|
|
await page.setViewportSize({ width: 1440, height: 960 });
|
|
const desktopMetrics = await readToolbarMetrics(page);
|
|
assert(desktopMetrics.toolbarExists, "toolbar_missing");
|
|
assert(desktopMetrics.shellExists, "rust_shell_missing");
|
|
assert(desktopMetrics.mainCluster, "toolbar_main_cluster_missing");
|
|
assert(desktopMetrics.fileCluster, "toolbar_file_cluster_missing");
|
|
assert(desktopMetrics.height <= 72, `toolbar_height_too_large:${desktopMetrics.height}`);
|
|
assert(desktopMetrics.toolbarRows <= 1, `toolbar_not_single_row:${desktopMetrics.toolbarRows}`);
|
|
assert(
|
|
desktopMetrics.visibleActions.join(",").startsWith("undo,redo,editNode,insertSiblingAfter,deleteNode,insertChild"),
|
|
"toolbar_order_unexpected",
|
|
);
|
|
assert(desktopMetrics.labels.every((label) => !/(palette|sliders|layout)/i.test(label)), "toolbar_internal_icon_key_visible");
|
|
|
|
await page.setViewportSize({ width: 900, height: 760 });
|
|
await page.waitForTimeout(500);
|
|
const narrowMetrics = await readToolbarMetrics(page);
|
|
assert(narrowMetrics.height <= 72, `narrow_toolbar_height_too_large:${narrowMetrics.height}`);
|
|
assert(narrowMetrics.toolbarRows <= 1, `narrow_toolbar_not_single_row:${narrowMetrics.toolbarRows}`);
|
|
assert(narrowMetrics.overflowActions.length > 0, "narrow_toolbar_overflow_missing");
|
|
assert(narrowMetrics.moreButton, "toolbar_more_button_missing");
|
|
await page.getByTestId("mindmap-schema-toolbar-action-more").click({ timeout: UI_TIMEOUT_MS });
|
|
await page.waitForFunction(
|
|
() => {
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
const menu = document.querySelector('[data-testid="mindmap-schema-toolbar-more-menu"]');
|
|
return shell instanceof HTMLElement && shell.dataset.toolbarMoreOpen === "true" && menu instanceof HTMLElement;
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
const menuMetrics = await readToolbarMetrics(page);
|
|
assert(menuMetrics.moreOpen, "toolbar_more_not_open");
|
|
assert(menuMetrics.moreMenu, "toolbar_more_menu_missing");
|
|
await page.keyboard.press("Escape");
|
|
await page.waitForFunction(
|
|
() => {
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
const menu = document.querySelector('[data-testid="mindmap-schema-toolbar-more-menu"]');
|
|
return shell instanceof HTMLElement && shell.dataset.toolbarMoreOpen === "false" && !(menu instanceof HTMLElement);
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
const closedMetrics = await readToolbarMetrics(page);
|
|
assert(!closedMetrics.moreOpen, "toolbar_more_escape_not_closed");
|
|
return {
|
|
desktop: desktopMetrics,
|
|
narrow: narrowMetrics,
|
|
menu: menuMetrics,
|
|
closed: closedMetrics,
|
|
};
|
|
}
|
|
|
|
async function verifyFullscreenStage(page) {
|
|
await page.setViewportSize({ width: 1440, height: 960 });
|
|
await page.waitForTimeout(200);
|
|
const before = await readToolbarMetrics(page);
|
|
assert(before.toolbarExists, "toolbar_missing_before_fullscreen");
|
|
const root = page.getByTestId("mnote-mindmap-editor-root");
|
|
const rootBox = await root.boundingBox();
|
|
assert(rootBox && rootBox.width > 0 && rootBox.height > 0, "fullscreen_root_box_missing");
|
|
const fullscreenButton = page.getByTestId("mindmap-schema-navigator-action-fullscreenCanvas");
|
|
await fullscreenButton.waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
|
|
await fullscreenButton.click({ timeout: UI_TIMEOUT_MS });
|
|
await page.waitForFunction(
|
|
() => {
|
|
const root = document.querySelector('[data-testid="mnote-mindmap-editor-root"]');
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
const scene = document.querySelector('[data-testid="leptos-mindmap-island"]');
|
|
return (
|
|
root instanceof HTMLElement &&
|
|
shell instanceof HTMLElement &&
|
|
scene instanceof HTMLElement &&
|
|
(document.fullscreenElement === root || root.contains(document.fullscreenElement)) &&
|
|
shell.dataset.fullscreenActive === "true" &&
|
|
scene.dataset.fullscreenActive === "true"
|
|
);
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
await page.waitForFunction(
|
|
() => {
|
|
const scene = document.querySelector('[data-testid="leptos-mindmap-island"]');
|
|
return scene instanceof HTMLElement && scene.dataset.fullscreenResizeStatus === "success";
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
const active = await page.evaluate(() => {
|
|
const root = document.querySelector('[data-testid="mnote-mindmap-editor-root"]');
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
const toolbar = document.querySelector('[data-testid="mindmap-schema-toolbar"]');
|
|
const sidebar = document.querySelector('[data-testid="mindmap-schema-sidebar"]');
|
|
const navigator = document.querySelector('[data-testid="mindmap-schema-navigator"]');
|
|
return {
|
|
fullscreenElementIsRoot: root instanceof HTMLElement && document.fullscreenElement === root,
|
|
fullscreenElementInsideRoot:
|
|
root instanceof HTMLElement && Boolean(document.fullscreenElement) && root.contains(document.fullscreenElement),
|
|
shellFullscreenActive: shell instanceof HTMLElement ? shell.dataset.fullscreenActive === "true" : false,
|
|
toolbarVisible: toolbar instanceof HTMLElement && toolbar.getBoundingClientRect().height > 0,
|
|
sidebarVisible: sidebar instanceof HTMLElement && sidebar.getBoundingClientRect().height > 0,
|
|
navigatorVisible: navigator instanceof HTMLElement && navigator.getBoundingClientRect().height > 0,
|
|
};
|
|
});
|
|
assert(active.fullscreenElementIsRoot || active.fullscreenElementInsideRoot, "fullscreen_element_unexpected");
|
|
assert(active.shellFullscreenActive, "fullscreen_shell_state_missing");
|
|
assert(active.toolbarVisible && active.sidebarVisible && active.navigatorVisible, "fullscreen_chrome_not_visible");
|
|
await page.keyboard.press("Escape");
|
|
await page.waitForFunction(() => document.fullscreenElement === null, null, { timeout: UI_TIMEOUT_MS });
|
|
await page.waitForFunction(
|
|
() => {
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
return shell instanceof HTMLElement && shell.dataset.fullscreenActive === "false";
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
const after = await page.evaluate(() => {
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
return {
|
|
fullscreenElement: document.fullscreenElement === null,
|
|
shellFullscreenActive: shell instanceof HTMLElement ? shell.dataset.fullscreenActive === "true" : null,
|
|
chromeVisibility: shell instanceof HTMLElement ? shell.dataset.chromeVisibility || null : null,
|
|
};
|
|
});
|
|
assert(after.fullscreenElement, "fullscreen_escape_exit_failed");
|
|
assert(after.shellFullscreenActive === false, "fullscreen_shell_state_not_restored");
|
|
assert(after.chromeVisibility === "visible", `fullscreen_visible_state_not_restored:${after.chromeVisibility}`);
|
|
|
|
await page.mouse.move(rootBox.x + rootBox.width / 2, rootBox.y + rootBox.height / 2);
|
|
await page.mouse.move(Math.max(4, rootBox.x - 24), Math.max(4, rootBox.y - 24));
|
|
await page.waitForFunction(
|
|
() => {
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
return shell instanceof HTMLElement && shell.dataset.chromeVisibility === "hiddenByPointerLeave";
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
await page.evaluate(async () => {
|
|
const root = document.querySelector('[data-testid="mnote-mindmap-editor-root"]');
|
|
if (root instanceof HTMLElement && typeof root.requestFullscreen === "function") {
|
|
await root.requestFullscreen();
|
|
}
|
|
});
|
|
await page.waitForFunction(
|
|
() => {
|
|
const root = document.querySelector('[data-testid="mnote-mindmap-editor-root"]');
|
|
return root instanceof HTMLElement && document.fullscreenElement === root;
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
await page.evaluate(async () => {
|
|
if (document.fullscreenElement) {
|
|
await document.exitFullscreen();
|
|
}
|
|
});
|
|
await page.waitForFunction(() => document.fullscreenElement === null, null, { timeout: UI_TIMEOUT_MS });
|
|
await page.waitForFunction(
|
|
() => {
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
return shell instanceof HTMLElement && shell.dataset.fullscreenActive === "false";
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
const hiddenAfterExit = await page.evaluate(() => {
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
return {
|
|
chromeVisibility: shell instanceof HTMLElement ? shell.dataset.chromeVisibility || null : null,
|
|
shellFullscreenActive: shell instanceof HTMLElement ? shell.dataset.fullscreenActive === "true" : null,
|
|
};
|
|
});
|
|
assert(hiddenAfterExit.shellFullscreenActive === false, "fullscreen_hidden_shell_state_not_restored");
|
|
assert(
|
|
hiddenAfterExit.chromeVisibility === "hiddenByPointerLeave",
|
|
`fullscreen_hidden_state_unexpected:${hiddenAfterExit.chromeVisibility}`,
|
|
);
|
|
return { before, active, after, hiddenAfterExit };
|
|
}
|
|
|
|
async function readChromeVisibilityMetrics(page) {
|
|
return page.evaluate(() => {
|
|
const root = document.querySelector('[data-testid="mnote-mindmap-editor-root"]');
|
|
const scene = document.querySelector('[data-testid="leptos-mindmap-island"]');
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
const toolbar = document.querySelector('[data-testid="mindmap-schema-toolbar"]');
|
|
const sidebar = document.querySelector('[data-testid="mindmap-schema-sidebar"]');
|
|
const navigator = document.querySelector('[data-testid="mindmap-schema-navigator"]');
|
|
const minimap = document.querySelector('[data-testid="mindmap-schema-minimap"]');
|
|
return {
|
|
rootBox: root instanceof HTMLElement ? root.getBoundingClientRect().toJSON?.() ?? null : null,
|
|
sceneChromeVisibility: scene instanceof HTMLElement ? scene.dataset.chromeVisibility || null : null,
|
|
shellChromeVisibility: shell instanceof HTMLElement ? shell.dataset.chromeVisibility || null : null,
|
|
toolbarVisible: toolbar instanceof HTMLElement && toolbar.getBoundingClientRect().height > 0,
|
|
sidebarVisible: sidebar instanceof HTMLElement && sidebar.getBoundingClientRect().height > 0,
|
|
navigatorVisible: navigator instanceof HTMLElement && navigator.getBoundingClientRect().height > 0,
|
|
minimapVisible: minimap instanceof HTMLElement && minimap.getBoundingClientRect().height > 0,
|
|
};
|
|
});
|
|
}
|
|
|
|
async function verifyChromeHideStage(page) {
|
|
const root = page.getByTestId("mnote-mindmap-editor-root");
|
|
await root.waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
|
|
const box = await root.boundingBox();
|
|
assert(box && box.width > 0 && box.height > 0, "mindmap_root_box_missing");
|
|
|
|
await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
|
|
await page.waitForFunction(
|
|
() => {
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
return shell instanceof HTMLElement && shell.dataset.chromeVisibility === "visible";
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
const before = await readChromeVisibilityMetrics(page);
|
|
assert(before.toolbarVisible && before.sidebarVisible && before.navigatorVisible, "chrome_not_visible_before_leave");
|
|
|
|
await page.mouse.move(Math.max(4, box.x - 24), Math.max(4, box.y - 24));
|
|
await page.waitForFunction(
|
|
() => {
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
return shell instanceof HTMLElement && shell.dataset.chromeVisibility === "hiddenByPointerLeave";
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
const hidden = await readChromeVisibilityMetrics(page);
|
|
assert(!hidden.toolbarVisible && !hidden.sidebarVisible && !hidden.navigatorVisible, "chrome_not_hidden_after_leave");
|
|
|
|
await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
|
|
await page.waitForTimeout(300);
|
|
const afterEnter = await readChromeVisibilityMetrics(page);
|
|
assert(afterEnter.shellChromeVisibility === "hiddenByPointerLeave", "chrome_restored_by_pointer_enter");
|
|
|
|
await page.mouse.click(box.x + box.width / 2, box.y + box.height / 2);
|
|
await page.waitForFunction(
|
|
() => {
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
return shell instanceof HTMLElement && shell.dataset.chromeVisibility === "visible";
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
const restored = await readChromeVisibilityMetrics(page);
|
|
assert(restored.toolbarVisible && restored.sidebarVisible && restored.navigatorVisible, "chrome_not_restored_after_click");
|
|
return { before, hidden, afterEnter, restored };
|
|
}
|
|
|
|
async function readContextMenuMetrics(page) {
|
|
return page.evaluate(() => {
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
const scene = document.querySelector('[data-testid="leptos-mindmap-island"]');
|
|
const menu = document.querySelector('[data-testid="mindmap-schema-context-menu"]');
|
|
const buttons = Array.from(
|
|
document.querySelectorAll('[data-testid^="mindmap-schema-context-menu-action-"]'),
|
|
).filter((node) => node instanceof HTMLButtonElement);
|
|
return {
|
|
chromeVisibility: shell instanceof HTMLElement ? shell.dataset.chromeVisibility || null : null,
|
|
contextMenuKind: scene instanceof HTMLElement ? scene.dataset.contextMenuKind || null : null,
|
|
menuVisible: menu instanceof HTMLElement && menu.getBoundingClientRect().width > 0,
|
|
itemIds: buttons.map((button) => button.dataset.mindmapContextActionId || null),
|
|
disabledIds: buttons
|
|
.filter((button) => button.disabled || button.dataset.disabled === "true")
|
|
.map((button) => button.dataset.mindmapContextActionId || null),
|
|
};
|
|
});
|
|
}
|
|
|
|
async function findCanvasEmptyPoint(page) {
|
|
const point = await page.evaluate(() => {
|
|
const root = document.querySelector('[data-testid="mnote-mindmap-editor-root"]');
|
|
if (!(root instanceof HTMLElement)) return null;
|
|
const rootRect = root.getBoundingClientRect();
|
|
const blockers = Array.from(
|
|
document.querySelectorAll(
|
|
'.smm-node,[data-testid="mindmap-schema-toolbar"],[data-testid="mindmap-schema-sidebar"],[data-testid="mindmap-schema-navigator"],[data-testid="mindmap-schema-context-menu"]',
|
|
),
|
|
)
|
|
.filter((node) => node instanceof HTMLElement)
|
|
.map((node) => node.getBoundingClientRect())
|
|
.filter((rect) => rect.width > 0 && rect.height > 0);
|
|
const padding = 36;
|
|
for (let y = rootRect.top + padding; y < rootRect.bottom - padding; y += 24) {
|
|
for (let x = rootRect.left + padding; x < rootRect.right - padding; x += 24) {
|
|
const blocked = blockers.some((rect) => x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom);
|
|
if (!blocked) return { x, y };
|
|
}
|
|
}
|
|
return {
|
|
x: rootRect.left + rootRect.width * 0.5,
|
|
y: rootRect.top + rootRect.height * 0.75,
|
|
};
|
|
});
|
|
assert(point && typeof point.x === "number" && typeof point.y === "number", "context_menu_canvas_point_missing");
|
|
return point;
|
|
}
|
|
|
|
async function verifyContextMenuStage(page) {
|
|
const rootNode = page.locator(".smm-node").first();
|
|
await rootNode.waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
|
|
await rootNode.click({ button: "right", timeout: UI_TIMEOUT_MS });
|
|
await page.waitForFunction(
|
|
() => {
|
|
const menu = document.querySelector('[data-testid="mindmap-schema-context-menu"]');
|
|
const scene = document.querySelector('[data-testid="leptos-mindmap-island"]');
|
|
return (
|
|
menu instanceof HTMLElement &&
|
|
scene instanceof HTMLElement &&
|
|
scene.dataset.contextMenuKind === "node"
|
|
);
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
const nodeMenu = await readContextMenuMetrics(page);
|
|
assert(nodeMenu.menuVisible, "node_context_menu_not_visible");
|
|
assert(nodeMenu.contextMenuKind === "node", `node_context_menu_kind_unexpected:${nodeMenu.contextMenuKind}`);
|
|
assert(
|
|
nodeMenu.itemIds.join(",") === "insertChild,insertSiblingAfter,deleteNode,summary,associativeLine,expandCollapse,copyNodeText",
|
|
`node_context_menu_items_unexpected:${nodeMenu.itemIds.join(",")}`,
|
|
);
|
|
assert(nodeMenu.disabledIds.includes("deleteNode"), `root_delete_not_disabled:${nodeMenu.disabledIds.join(",")}`);
|
|
|
|
const rootBox = await page.getByTestId("mnote-mindmap-editor-root").boundingBox();
|
|
assert(rootBox && rootBox.width > 0 && rootBox.height > 0, "context_menu_root_box_missing");
|
|
await page.mouse.move(Math.max(4, rootBox.x - 24), Math.max(4, rootBox.y - 24));
|
|
await page.waitForTimeout(250);
|
|
const afterLeave = await readContextMenuMetrics(page);
|
|
assert(afterLeave.menuVisible, "context_menu_closed_after_pointerleave");
|
|
assert(afterLeave.chromeVisibility === "visible", `chrome_hidden_while_context_menu_open:${afterLeave.chromeVisibility}`);
|
|
|
|
await page.keyboard.press("Escape");
|
|
await page.waitForFunction(
|
|
() => !(document.querySelector('[data-testid="mindmap-schema-context-menu"]') instanceof HTMLElement),
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
const afterEscape = await readContextMenuMetrics(page);
|
|
assert(!afterEscape.menuVisible, "context_menu_escape_not_closed");
|
|
|
|
const point = await findCanvasEmptyPoint(page);
|
|
await page.mouse.click(point.x, point.y, { button: "right" });
|
|
await page.waitForFunction(
|
|
() => {
|
|
const menu = document.querySelector('[data-testid="mindmap-schema-context-menu"]');
|
|
const scene = document.querySelector('[data-testid="leptos-mindmap-island"]');
|
|
return (
|
|
menu instanceof HTMLElement &&
|
|
scene instanceof HTMLElement &&
|
|
scene.dataset.contextMenuKind === "canvas"
|
|
);
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
const canvasMenu = await readContextMenuMetrics(page);
|
|
assert(canvasMenu.contextMenuKind === "canvas", `canvas_context_menu_kind_unexpected:${canvasMenu.contextMenuKind}`);
|
|
assert(
|
|
canvasMenu.itemIds.join(",") === "centerRoot,fitView,search,readonly,showMenu",
|
|
`canvas_context_menu_items_unexpected:${canvasMenu.itemIds.join(",")}`,
|
|
);
|
|
assert(!canvasMenu.itemIds.includes("insertChild"), "canvas_context_menu_contains_insert_child");
|
|
assert(!canvasMenu.itemIds.includes("deleteNode"), "canvas_context_menu_contains_delete_node");
|
|
|
|
return { nodeMenu, afterLeave, afterEscape, canvasMenu };
|
|
}
|
|
|
|
async function readThemeMetrics(page) {
|
|
return page.evaluate(() => {
|
|
const root = document.querySelector('[data-testid="mnote-mindmap-editor-root"]');
|
|
const runtime = document.querySelector('[data-testid="simple-mind-map-runtime"]');
|
|
const mindmapId = root instanceof HTMLElement ? root.dataset.mnoteMindmapId || null : null;
|
|
const registry = window.__MNOTE_LEPTOS_MINDMAP_BRIDGES__ || {};
|
|
const bridge = mindmapId ? registry[mindmapId] : null;
|
|
const instance = bridge?.instance || null;
|
|
const themeConfig = typeof instance?.getThemeConfig === "function" ? instance.getThemeConfig() : null;
|
|
const nodeRects = Array.from(document.querySelectorAll(".smm-node"))
|
|
.filter((node) => node instanceof Element)
|
|
.map((node) => node.getBoundingClientRect())
|
|
.filter((rect) => rect.width > 0 && rect.height > 0)
|
|
.map((rect) => ({
|
|
left: rect.left,
|
|
top: rect.top,
|
|
right: rect.right,
|
|
bottom: rect.bottom,
|
|
width: rect.width,
|
|
height: rect.height,
|
|
}));
|
|
const paths = Array.from(runtime?.querySelectorAll?.("svg path") || []).filter(
|
|
(node) => node instanceof SVGPathElement && node.getBoundingClientRect().width + node.getBoundingClientRect().height > 0,
|
|
);
|
|
let overlaps = 0;
|
|
for (let i = 0; i < nodeRects.length; i += 1) {
|
|
for (let j = i + 1; j < nodeRects.length; j += 1) {
|
|
const a = nodeRects[i];
|
|
const b = nodeRects[j];
|
|
const width = Math.max(0, Math.min(a.right, b.right) - Math.max(a.left, b.left));
|
|
const height = Math.max(0, Math.min(a.bottom, b.bottom) - Math.max(a.top, b.top));
|
|
if (width * height > 4) overlaps += 1;
|
|
}
|
|
}
|
|
return {
|
|
layout: typeof instance?.getLayout === "function" ? instance.getLayout() : null,
|
|
theme: typeof instance?.getTheme === "function" ? instance.getTheme() : null,
|
|
themeConfig,
|
|
nodeCount: nodeRects.length,
|
|
pathCount: paths.length,
|
|
overlaps,
|
|
};
|
|
});
|
|
}
|
|
|
|
async function verifyThemeStage(page) {
|
|
const initial = await readThemeMetrics(page);
|
|
assert(initial.layout === "logicalStructure", `theme_layout_unexpected:${initial.layout}`);
|
|
assert(initial.theme === "default", `theme_template_unexpected:${initial.theme}`);
|
|
assert(initial.themeConfig?.root?.fillColor === "#e25563", `theme_root_fill_unexpected:${initial.themeConfig?.root?.fillColor}`);
|
|
assert(initial.themeConfig?.root?.color === "#ffffff", `theme_root_color_unexpected:${initial.themeConfig?.root?.color}`);
|
|
assert(initial.themeConfig?.second?.fillColor === "#4f7df3", `theme_second_fill_unexpected:${initial.themeConfig?.second?.fillColor}`);
|
|
assert(initial.themeConfig?.second?.color === "#ffffff", `theme_second_color_unexpected:${initial.themeConfig?.second?.color}`);
|
|
assert(initial.themeConfig?.node?.color === "#315aa9", `theme_node_color_unexpected:${initial.themeConfig?.node?.color}`);
|
|
assert(
|
|
initial.themeConfig?.generalizationLineColor === "#ef6a5b",
|
|
`theme_generalization_line_unexpected:${initial.themeConfig?.generalizationLineColor}`,
|
|
);
|
|
assert(initial.themeConfig?.lineStyle === "curve", `theme_line_style_unexpected:${initial.themeConfig?.lineStyle}`);
|
|
assert(initial.nodeCount >= 2, `theme_node_count_too_small:${initial.nodeCount}`);
|
|
assert(initial.pathCount > 0, `theme_path_count_empty:${initial.pathCount}`);
|
|
assert(initial.overlaps === 0, `theme_nodes_overlap:${initial.overlaps}`);
|
|
|
|
return { initial };
|
|
}
|
|
|
|
async function readSidebarMetrics(page) {
|
|
return page.evaluate(() => {
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
const rail = document.querySelector('[data-testid="mindmap-schema-sidebar-rail"]');
|
|
const drawer = document.querySelector('[data-testid="mindmap-schema-sidebar-drawer"]');
|
|
const title = document.querySelector('[data-testid="mindmap-schema-sidebar-title"]');
|
|
const closeButton = document.querySelector('[data-testid="mindmap-schema-sidebar-close"]');
|
|
const hideHandle = document.querySelector('[data-testid="mindmap-schema-sidebar-hide-handle"]');
|
|
const restoreHandle = document.querySelector('[data-testid="mindmap-schema-sidebar-restore-handle"]');
|
|
const structureCards = Array.from(
|
|
document.querySelectorAll('[data-testid^="mindmap-schema-sidebar-option-layout-"][data-control-type="layoutCard"]'),
|
|
);
|
|
return {
|
|
triggerVisible: shell instanceof HTMLElement ? shell.dataset.sidebarTriggerVisible === "true" : null,
|
|
panelOpen: shell instanceof HTMLElement ? shell.dataset.sidebarPanelOpen === "true" : null,
|
|
railVisible: rail instanceof HTMLElement && rail.getBoundingClientRect().height > 0,
|
|
drawerVisible: drawer instanceof HTMLElement && drawer.getBoundingClientRect().width > 0,
|
|
drawerWidth: drawer instanceof HTMLElement ? Math.round(drawer.getBoundingClientRect().width) : 0,
|
|
title: title instanceof HTMLElement ? (title.textContent || "").trim() : "",
|
|
closeButton: closeButton instanceof HTMLButtonElement,
|
|
hideHandle: hideHandle instanceof HTMLButtonElement,
|
|
restoreHandle: restoreHandle instanceof HTMLButtonElement,
|
|
structureCardCount: structureCards.length,
|
|
};
|
|
});
|
|
}
|
|
|
|
async function verifySidebarStage(page) {
|
|
const structureTab = page.getByTestId("mindmap-schema-sidebar-tab-structure");
|
|
await structureTab.waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
|
|
await structureTab.click({ timeout: UI_TIMEOUT_MS });
|
|
await page.waitForFunction(
|
|
() => {
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
const title = document.querySelector('[data-testid="mindmap-schema-sidebar-title"]');
|
|
return (
|
|
shell instanceof HTMLElement &&
|
|
shell.dataset.sidebarPanelOpen === "true" &&
|
|
shell.dataset.sidebarActivePanel === "structure" &&
|
|
title instanceof HTMLElement &&
|
|
(title.textContent || "").trim() === "结构"
|
|
);
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
const opened = await readSidebarMetrics(page);
|
|
assert(opened.railVisible, "sidebar_rail_missing");
|
|
assert(opened.drawerVisible, "sidebar_drawer_not_visible");
|
|
assert(opened.drawerWidth >= 280, `sidebar_drawer_width_too_small:${opened.drawerWidth}`);
|
|
assert(opened.title === "结构", `sidebar_title_unexpected:${opened.title}`);
|
|
assert(opened.structureCardCount >= 6, `sidebar_structure_cards_missing:${opened.structureCardCount}`);
|
|
assert(opened.closeButton, "sidebar_close_button_missing");
|
|
assert(opened.hideHandle, "sidebar_hide_handle_missing");
|
|
|
|
await page.getByTestId("mindmap-schema-sidebar-close").click({ timeout: UI_TIMEOUT_MS });
|
|
await page.waitForFunction(
|
|
() => {
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
const drawer = document.querySelector('[data-testid="mindmap-schema-sidebar-drawer"]');
|
|
return shell instanceof HTMLElement && shell.dataset.sidebarPanelOpen === "false" && !(drawer instanceof HTMLElement);
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
const closed = await readSidebarMetrics(page);
|
|
assert(closed.panelOpen === false, "sidebar_close_not_applied");
|
|
|
|
await structureTab.click({ timeout: UI_TIMEOUT_MS });
|
|
await page.waitForFunction(
|
|
() => {
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
return shell instanceof HTMLElement && shell.dataset.sidebarPanelOpen === "true";
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
await page.getByTestId("mindmap-schema-sidebar-hide-handle").click({ timeout: UI_TIMEOUT_MS });
|
|
await page.waitForFunction(
|
|
() => {
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
const restoreHandle = document.querySelector('[data-testid="mindmap-schema-sidebar-restore-handle"]');
|
|
return (
|
|
shell instanceof HTMLElement &&
|
|
shell.dataset.sidebarTriggerVisible === "false" &&
|
|
shell.dataset.sidebarPanelOpen === "false" &&
|
|
restoreHandle instanceof HTMLButtonElement
|
|
);
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
const hidden = await readSidebarMetrics(page);
|
|
assert(hidden.restoreHandle, "sidebar_restore_handle_missing");
|
|
assert(hidden.triggerVisible === false, "sidebar_trigger_not_hidden");
|
|
|
|
await page.getByTestId("mindmap-schema-sidebar-restore-handle").click({ timeout: UI_TIMEOUT_MS });
|
|
await page.waitForFunction(
|
|
() => {
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
const title = document.querySelector('[data-testid="mindmap-schema-sidebar-title"]');
|
|
return (
|
|
shell instanceof HTMLElement &&
|
|
shell.dataset.sidebarTriggerVisible === "true" &&
|
|
shell.dataset.sidebarPanelOpen === "true" &&
|
|
title instanceof HTMLElement &&
|
|
(title.textContent || "").trim() === "结构"
|
|
);
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
const restored = await readSidebarMetrics(page);
|
|
assert(restored.drawerVisible, "sidebar_drawer_not_restored");
|
|
return { opened, closed, hidden, restored };
|
|
}
|
|
|
|
async function readRuntimeMindmapState(page) {
|
|
return page.evaluate(() => {
|
|
const root = document.querySelector('[data-testid="mnote-mindmap-editor-root"]');
|
|
const mindmapId = root instanceof HTMLElement ? root.dataset.mnoteMindmapId || null : null;
|
|
const registry = window.__MNOTE_LEPTOS_MINDMAP_BRIDGES__ || {};
|
|
const bridge = mindmapId ? registry[mindmapId] : null;
|
|
const instance = bridge?.instance || null;
|
|
const snapshot = bridge?.getSnapshot?.() || null;
|
|
const data = snapshot && typeof snapshot === "object" && !Array.isArray(snapshot) ? snapshot.data || null : null;
|
|
return {
|
|
mindmapId,
|
|
layout: typeof instance?.getLayout === "function" ? instance.getLayout() : null,
|
|
theme: typeof instance?.getTheme === "function" ? instance.getTheme() : null,
|
|
rootFillColor: data && typeof data === "object" ? data.fillColor || null : null,
|
|
commandStatus:
|
|
document.querySelector('[data-testid="leptos-mindmap-island"]') instanceof HTMLElement
|
|
? document.querySelector('[data-testid="leptos-mindmap-island"]').dataset.commandStatus || null
|
|
: null,
|
|
};
|
|
});
|
|
}
|
|
|
|
async function readPersistedMindmapState(page) {
|
|
return page.evaluate(async () => {
|
|
const root = document.querySelector('[data-testid="mnote-mindmap-editor-root"]');
|
|
const mindmapId = root instanceof HTMLElement ? root.dataset.mnoteMindmapId || null : null;
|
|
const match = window.location.pathname.match(/\/documents\/([^/?#]+)/);
|
|
const documentId = match?.[1] ? decodeURIComponent(match[1]) : null;
|
|
if (!documentId || !mindmapId) {
|
|
return {
|
|
documentId,
|
|
mindmapId,
|
|
status: null,
|
|
layout: null,
|
|
theme: null,
|
|
rootFillColor: null,
|
|
};
|
|
}
|
|
const response = await fetch(
|
|
`/api/mindmap/${encodeURIComponent(documentId)}/${encodeURIComponent(mindmapId)}?view=simple_mind_map_scene&queryName=mindmap.simple_mind_map_scene.get`,
|
|
{ headers: { Accept: "application/json" } },
|
|
);
|
|
const payload = await response.json().catch(() => null);
|
|
const rootData =
|
|
payload && typeof payload === "object" && payload.root && typeof payload.root === "object" && !Array.isArray(payload.root)
|
|
? payload.root.data || null
|
|
: null;
|
|
return {
|
|
documentId,
|
|
mindmapId,
|
|
status: response.status,
|
|
layout: payload && typeof payload === "object" ? payload.layout || null : null,
|
|
theme: payload && typeof payload === "object" ? payload.theme || null : null,
|
|
rootFillColor: rootData && typeof rootData === "object" ? rootData.fillColor || null : null,
|
|
};
|
|
});
|
|
}
|
|
|
|
async function waitForMindmapCommandSuccess(page, actionId, predicate) {
|
|
try {
|
|
await page.waitForFunction(
|
|
({ actionId }) => {
|
|
const scene = document.querySelector('[data-testid="leptos-mindmap-island"]');
|
|
return (
|
|
scene instanceof HTMLElement &&
|
|
scene.dataset.lastSchemaAction === actionId &&
|
|
scene.dataset.commandStatus === "success"
|
|
);
|
|
},
|
|
{ actionId },
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
} catch (error) {
|
|
const debug = await page.evaluate(() => {
|
|
const scene = document.querySelector('[data-testid="leptos-mindmap-island"]');
|
|
const errorNode = document.querySelector('[data-testid="leptos-mindmap-error"]');
|
|
return {
|
|
commandStatus: scene instanceof HTMLElement ? scene.dataset.commandStatus || null : null,
|
|
lastSchemaAction: scene instanceof HTMLElement ? scene.dataset.lastSchemaAction || null : null,
|
|
commandFailedAction: scene instanceof HTMLElement ? scene.dataset.commandFailedAction || null : null,
|
|
commandFailedMessage: scene instanceof HTMLElement ? scene.dataset.commandFailedMessage || null : null,
|
|
errorText: errorNode instanceof HTMLElement ? (errorNode.textContent || "").trim() : null,
|
|
};
|
|
});
|
|
throw new Error(
|
|
`mindmap_command_not_success:${actionId}:${JSON.stringify(debug)}:${error instanceof Error ? error.message : String(error)}`,
|
|
);
|
|
}
|
|
if (predicate) {
|
|
await page.waitForFunction(predicate, null, { timeout: UI_TIMEOUT_MS });
|
|
}
|
|
}
|
|
|
|
async function verifySidebarActionsStage(page) {
|
|
await page.getByTestId("mindmap-schema-sidebar-tab-structure").click({ timeout: UI_TIMEOUT_MS });
|
|
await page.getByTestId("mindmap-schema-sidebar-option-layout-mind-map").click({ timeout: UI_TIMEOUT_MS });
|
|
await waitForMindmapCommandSuccess(
|
|
page,
|
|
"setLayout",
|
|
() => {
|
|
const root = document.querySelector('[data-testid="mnote-mindmap-editor-root"]');
|
|
const mindmapId = root instanceof HTMLElement ? root.dataset.mnoteMindmapId || null : null;
|
|
const registry = window.__MNOTE_LEPTOS_MINDMAP_BRIDGES__ || {};
|
|
const bridge = mindmapId ? registry[mindmapId] : null;
|
|
return bridge?.instance?.getLayout?.() === "mindMap";
|
|
},
|
|
);
|
|
|
|
await page.getByTestId("mindmap-schema-sidebar-tab-theme").click({ timeout: UI_TIMEOUT_MS });
|
|
await page.getByTestId("mindmap-schema-sidebar-option-theme-dark").click({ timeout: UI_TIMEOUT_MS });
|
|
await waitForMindmapCommandSuccess(page, "setTheme");
|
|
|
|
await page.getByTestId("mindmap-schema-sidebar-tab-nodeStyle").click({ timeout: UI_TIMEOUT_MS });
|
|
await page.getByTestId("mindmap-schema-sidebar-option-node-fill-blue").click({ timeout: UI_TIMEOUT_MS });
|
|
await waitForMindmapCommandSuccess(page, "painter");
|
|
|
|
const beforeReload = await readPersistedMindmapState(page);
|
|
assert(beforeReload.layout === "mindMap", `sidebar_actions_layout_before_reload:${beforeReload.layout}`);
|
|
assert(beforeReload.theme === "dark", `sidebar_actions_theme_before_reload:${beforeReload.theme}`);
|
|
assert(beforeReload.rootFillColor === "#dbeafe", `sidebar_actions_fill_before_reload:${beforeReload.rootFillColor}`);
|
|
|
|
await page.reload({ waitUntil: "domcontentloaded" });
|
|
await assertMindmapReady(page, "sidebar-actions-reload");
|
|
const afterReload = await readPersistedMindmapState(page);
|
|
assert(afterReload.layout === "mindMap", `sidebar_actions_layout_after_reload:${afterReload.layout}`);
|
|
assert(afterReload.theme === "dark", `sidebar_actions_theme_after_reload:${afterReload.theme}`);
|
|
assert(afterReload.rootFillColor === "#dbeafe", `sidebar_actions_fill_after_reload:${afterReload.rootFillColor}`);
|
|
|
|
return { beforeReload, afterReload };
|
|
}
|
|
|
|
async function readNavigatorMetrics(page) {
|
|
return page.evaluate(() => {
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
const navigator = document.querySelector('[data-testid="mindmap-schema-navigator"]');
|
|
const searchInput = document.querySelector('[data-testid="mindmap-schema-navigator-search"]');
|
|
const minimap = document.querySelector('[data-testid="mindmap-schema-minimap"]');
|
|
const readonlyButton = document.querySelector('[data-testid="mindmap-schema-navigator-action-readonly"]');
|
|
const zoomInput = document.querySelector('[data-testid="mindmap-schema-navigator-zoom-input"]');
|
|
return {
|
|
navigatorVisible: navigator instanceof HTMLElement && navigator.getBoundingClientRect().height > 0,
|
|
searchOpen: shell instanceof HTMLElement ? shell.dataset.navigatorSearchOpen === "true" : false,
|
|
minimapOpen: shell instanceof HTMLElement ? shell.dataset.navigatorMinimapOpen === "true" : false,
|
|
readonly: shell instanceof HTMLElement ? shell.dataset.navigatorReadonly === "true" : false,
|
|
searchInputVisible: searchInput instanceof HTMLInputElement && searchInput.getBoundingClientRect().width > 0,
|
|
minimapVisible: minimap instanceof HTMLElement && minimap.getBoundingClientRect().height > 0,
|
|
readonlyActive: readonlyButton instanceof HTMLButtonElement ? readonlyButton.dataset.active === "true" : false,
|
|
zoomValue: zoomInput instanceof HTMLInputElement ? zoomInput.value : null,
|
|
};
|
|
});
|
|
}
|
|
|
|
async function verifyNavigatorStage(page, screenshots) {
|
|
const initial = await readNavigatorMetrics(page);
|
|
assert(initial.navigatorVisible, "navigator_missing");
|
|
assert(!initial.searchInputVisible, "navigator_search_should_be_collapsed");
|
|
screenshots.push(await screenshot(page, "07-navigator-icons"));
|
|
|
|
await page.getByTestId("mindmap-schema-navigator-action-search").click({ timeout: UI_TIMEOUT_MS });
|
|
await page.waitForFunction(
|
|
() => {
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
const input = document.querySelector('[data-testid="mindmap-schema-navigator-search"]');
|
|
return shell instanceof HTMLElement && shell.dataset.navigatorSearchOpen === "true" && input instanceof HTMLInputElement;
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
const searchInput = page.getByTestId("mindmap-schema-navigator-search");
|
|
await searchInput.fill("主题", { timeout: UI_TIMEOUT_MS });
|
|
screenshots.push(await screenshot(page, "08-search-expanded"));
|
|
await searchInput.press("Escape");
|
|
await page.waitForFunction(
|
|
() => {
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
const input = document.querySelector('[data-testid="mindmap-schema-navigator-search"]');
|
|
return shell instanceof HTMLElement && shell.dataset.navigatorSearchOpen === "false" && !(input instanceof HTMLInputElement);
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
|
|
await page.getByTestId("mindmap-schema-navigator-action-minimap").click({ timeout: UI_TIMEOUT_MS });
|
|
await page.waitForFunction(
|
|
() => {
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
const minimap = document.querySelector('[data-testid="mindmap-schema-minimap"]');
|
|
return shell instanceof HTMLElement && shell.dataset.navigatorMinimapOpen === "true" && minimap instanceof HTMLElement;
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
|
|
await page.getByTestId("mindmap-schema-navigator-action-readonly").click({ timeout: UI_TIMEOUT_MS });
|
|
await page.waitForFunction(
|
|
() => {
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
return shell instanceof HTMLElement && shell.dataset.navigatorReadonly === "true";
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
|
|
const zoomInputField = page.getByTestId("mindmap-schema-navigator-zoom-input");
|
|
const previousZoom = await zoomInputField.inputValue();
|
|
await zoomInputField.fill("abc", { timeout: UI_TIMEOUT_MS });
|
|
await zoomInputField.press("Enter");
|
|
await page.waitForTimeout(200);
|
|
const afterInvalidZoom = await zoomInputField.inputValue();
|
|
assert(afterInvalidZoom === previousZoom, `navigator_zoom_invalid_not_restored:${afterInvalidZoom}`);
|
|
|
|
const final = await readNavigatorMetrics(page);
|
|
assert(final.minimapVisible, "navigator_minimap_not_visible");
|
|
assert(final.readonlyActive, "navigator_readonly_not_active");
|
|
return { initial, final };
|
|
}
|
|
|
|
async function restoreNavigatorDefaultState(page) {
|
|
const current = await readNavigatorMetrics(page);
|
|
if (current.minimapOpen) {
|
|
await page.getByTestId("mindmap-schema-navigator-action-minimap").click({ timeout: UI_TIMEOUT_MS });
|
|
await page.waitForFunction(
|
|
() => {
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
return shell instanceof HTMLElement && shell.dataset.navigatorMinimapOpen === "false";
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
}
|
|
if (current.readonly) {
|
|
await page.getByTestId("mindmap-schema-navigator-action-readonly").click({ timeout: UI_TIMEOUT_MS });
|
|
await page.waitForFunction(
|
|
() => {
|
|
const shell = document.querySelector('[data-testid="mindmap-rust-shell"]');
|
|
return shell instanceof HTMLElement && shell.dataset.navigatorReadonly === "false";
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
}
|
|
}
|
|
|
|
async function restoreCanvasIdleState(page) {
|
|
await page.keyboard.press("Escape").catch(() => undefined);
|
|
const root = page.getByTestId("mnote-mindmap-editor-root");
|
|
const box = await root.boundingBox();
|
|
if (box && box.width > 0 && box.height > 0) {
|
|
await page.mouse.click(box.x + box.width / 2, box.y + box.height / 2);
|
|
}
|
|
await page.waitForTimeout(200);
|
|
}
|
|
|
|
async function main() {
|
|
if (!["all", "toolbar", "fullscreen", "chrome-hide", "sidebar", "sidebar-actions", "navigator", "context-menu", "theme"].includes(STAGE)) {
|
|
throw new Error(`当前 smoke 只实现 --stage all/toolbar/fullscreen/chrome-hide/sidebar/sidebar-actions/navigator/context-menu/theme，收到：${STAGE}`);
|
|
}
|
|
await fs.mkdir(OUTPUT_DIR, { recursive: true });
|
|
|
|
const browser = await chromium.launch({ headless: true });
|
|
const context = await browser.newContext({ viewport: { width: 1440, height: 960 }, locale: "zh-CN" });
|
|
const page = await context.newPage();
|
|
const screenshots = [];
|
|
const createdIds = [];
|
|
const result = {
|
|
ok: false,
|
|
task: TASK,
|
|
stage: STAGE,
|
|
baseUrl: BASE_URL,
|
|
documentId: null,
|
|
mindmapId: null,
|
|
toolbar: null,
|
|
screenshots,
|
|
};
|
|
|
|
try {
|
|
await ensureAuthenticated(page, context.request);
|
|
const doc = await createTempDocument(context.request, null);
|
|
createdIds.push(doc.documentId);
|
|
const title = `task167-mindmap-${Date.now().toString().slice(-6)}`;
|
|
await renameDocument(context.request, doc.workspaceId, doc.documentId, title);
|
|
result.documentId = doc.documentId;
|
|
|
|
await openDocument(page, doc.workspaceId, doc.documentId);
|
|
await insertMindmapThroughSlash(page);
|
|
await assertMindmapReady(page, STAGE);
|
|
result.mindmapId = (await readMindmapIdentity(page)).mindmapId;
|
|
if (STAGE === "all") {
|
|
result.toolbar = await verifyToolbarStage(page);
|
|
screenshots.push(await screenshot(page, "01-toolbar-single-row"));
|
|
result.fullscreen = await verifyFullscreenStage(page);
|
|
screenshots.push(await screenshot(page, "02-fullscreen-canvas"));
|
|
await restoreCanvasIdleState(page);
|
|
result.chromeHide = await verifyChromeHideStage(page);
|
|
screenshots.push(await screenshot(page, "03-chrome-hidden-after-leave"));
|
|
screenshots.push(await screenshot(page, "04-chrome-restored-after-click"));
|
|
result.sidebar = await verifySidebarStage(page);
|
|
screenshots.push(await screenshot(page, "05-sidebar-structure-drawer"));
|
|
await page.getByTestId("mindmap-schema-sidebar-hide-handle").click({ timeout: UI_TIMEOUT_MS }).catch(() => undefined);
|
|
await page.waitForTimeout(200);
|
|
screenshots.push(await screenshot(page, "06-sidebar-hidden-handle"));
|
|
await page.getByTestId("mindmap-schema-sidebar-restore-handle").click({ timeout: UI_TIMEOUT_MS }).catch(() => undefined);
|
|
await page.waitForTimeout(200);
|
|
await page.getByTestId("mindmap-schema-sidebar-close").click({ timeout: UI_TIMEOUT_MS }).catch(() => undefined);
|
|
await page.waitForTimeout(200);
|
|
result.navigator = await verifyNavigatorStage(page, screenshots);
|
|
await restoreNavigatorDefaultState(page);
|
|
result.contextMenu = await verifyContextMenuStage(page);
|
|
screenshots.push(await screenshot(page, "09-node-context-menu"));
|
|
await restoreCanvasIdleState(page);
|
|
result.theme = await verifyThemeStage(page);
|
|
screenshots.push(await screenshot(page, "10-kmind-theme-baseline"));
|
|
result.sidebarActions = await verifySidebarActionsStage(page);
|
|
result.toolbarRows = result.toolbar?.desktop?.toolbarRows ?? null;
|
|
result.fullscreenOk = Boolean(result.fullscreen);
|
|
result.chromeHideOk = Boolean(result.chromeHide);
|
|
result.sidebarDrawerOk = Boolean(result.sidebar);
|
|
result.navigatorOk = Boolean(result.navigator);
|
|
result.contextMenuOk = Boolean(result.contextMenu);
|
|
result.themeOk = Boolean(result.theme);
|
|
result.reloadOk = Boolean(result.sidebarActions);
|
|
} else if (STAGE === "toolbar") {
|
|
result.toolbar = await verifyToolbarStage(page);
|
|
screenshots.push(await screenshot(page, "01-toolbar-single-row"));
|
|
} else if (STAGE === "fullscreen") {
|
|
result.fullscreen = await verifyFullscreenStage(page);
|
|
screenshots.push(await screenshot(page, "02-fullscreen-canvas"));
|
|
} else if (STAGE === "chrome-hide") {
|
|
result.chromeHide = await verifyChromeHideStage(page);
|
|
screenshots.push(await screenshot(page, "03-chrome-hidden-after-leave"));
|
|
screenshots.push(await screenshot(page, "04-chrome-restored-after-click"));
|
|
} else if (STAGE === "sidebar") {
|
|
result.sidebar = await verifySidebarStage(page);
|
|
screenshots.push(await screenshot(page, "05-sidebar-structure-drawer"));
|
|
await page.getByTestId("mindmap-schema-sidebar-hide-handle").click({ timeout: UI_TIMEOUT_MS }).catch(() => undefined);
|
|
await page.waitForTimeout(200);
|
|
screenshots.push(await screenshot(page, "06-sidebar-hidden-handle"));
|
|
} else if (STAGE === "sidebar-actions") {
|
|
result.sidebarActions = await verifySidebarActionsStage(page);
|
|
} else if (STAGE === "navigator") {
|
|
result.navigator = await verifyNavigatorStage(page, screenshots);
|
|
} else if (STAGE === "context-menu") {
|
|
result.contextMenu = await verifyContextMenuStage(page);
|
|
screenshots.push(await screenshot(page, "09-node-context-menu"));
|
|
} else if (STAGE === "theme") {
|
|
result.theme = await verifyThemeStage(page);
|
|
screenshots.push(await screenshot(page, "10-kmind-theme-baseline"));
|
|
}
|
|
|
|
result.ok = true;
|
|
await writeResult(result);
|
|
} catch (error) {
|
|
result.error = error instanceof Error ? error.stack || error.message : String(error);
|
|
screenshots.push(await screenshot(page, "99-failure").catch(() => null));
|
|
await writeResult(result);
|
|
throw error;
|
|
} finally {
|
|
await cleanupDocuments(context.request, createdIds).catch(() => undefined);
|
|
await browser.close();
|
|
}
|
|
}
|
|
|
|
main().catch((error) => {
|
|
console.error(error);
|
|
process.exitCode = 1;
|
|
});
|