1421 lines
56 KiB
JavaScript
1421 lines
56 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,
|
||
openFilesystemView,
|
||
renameDocument,
|
||
} = require("./tree-shell-smoke-helpers");
|
||
|
||
const TASK = "task169-mindmap-realtime-smoke";
|
||
const OUTPUT_DIR = path.join(process.cwd(), "tmp", TASK);
|
||
const RESULT_PATH = path.join(OUTPUT_DIR, "result.json");
|
||
const LIVE_WAIT_MS = Number(process.env.MNOTE_MINDMAP_REALTIME_WAIT_MS || 12_000);
|
||
const BAD_TEXT_PATTERN = /ArgumentValidationError|domainEventHint|domainEventPlan|streamDeltaHint|command_failed|502 Bad Gateway/i;
|
||
|
||
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 installTreeEventRecorder(page) {
|
||
await page.addInitScript(() => {
|
||
window.__MNOTE_SMOKE_TREE_EVENTS__ = [];
|
||
const record = (name, event) => {
|
||
const detail = event && event.detail ? event.detail : null;
|
||
window.__MNOTE_SMOKE_TREE_EVENTS__.push({
|
||
name,
|
||
at: Date.now(),
|
||
revision: detail && detail.revision ? String(detail.revision) : "",
|
||
data: detail && detail.payload && detail.payload.data ? detail.payload.data : null,
|
||
eventType:
|
||
detail &&
|
||
detail.payload &&
|
||
detail.payload.overview &&
|
||
Array.isArray(detail.payload.overview.domain_events) &&
|
||
detail.payload.overview.domain_events[0]
|
||
? detail.payload.overview.domain_events[0].event_type || ""
|
||
: "",
|
||
});
|
||
};
|
||
window.addEventListener("tree:snapshot", (event) => record("tree:snapshot", event));
|
||
window.addEventListener("tree:delta", (event) => record("tree:delta", event));
|
||
window.addEventListener("tree:resync", (event) => record("tree:resync", event));
|
||
});
|
||
}
|
||
|
||
async function installMindmapLoadingRecorder(page) {
|
||
await page.addInitScript(() => {
|
||
window.__MNOTE_MINDMAP_LOADING_EVENTS__ = [];
|
||
const recordLoading = (node, reason) => {
|
||
if (!(node instanceof HTMLElement)) return;
|
||
const loading = node.matches?.('[data-testid="mindmap-scene-loading"]')
|
||
? node
|
||
: node.querySelector?.('[data-testid="mindmap-scene-loading"]');
|
||
if (!(loading instanceof HTMLElement)) return;
|
||
window.__MNOTE_MINDMAP_LOADING_EVENTS__.push({
|
||
at: Date.now(),
|
||
reason,
|
||
text: loading.textContent || "",
|
||
url: window.location.href,
|
||
});
|
||
};
|
||
const start = () => {
|
||
if (window.__MNOTE_MINDMAP_LOADING_OBSERVER__) return;
|
||
const target = document.documentElement || document.body;
|
||
if (!target) {
|
||
window.setTimeout(start, 0);
|
||
return;
|
||
}
|
||
recordLoading(target, "initial-scan");
|
||
const observer = new MutationObserver((mutations) => {
|
||
mutations.forEach((mutation) => {
|
||
mutation.addedNodes.forEach((node) => recordLoading(node, "added-node"));
|
||
});
|
||
});
|
||
observer.observe(target, { childList: true, subtree: true });
|
||
window.__MNOTE_MINDMAP_LOADING_OBSERVER__ = observer;
|
||
};
|
||
start();
|
||
});
|
||
}
|
||
|
||
function attachNetworkCapture(page, label, records) {
|
||
page.on("request", (request) => {
|
||
const url = request.url();
|
||
if (url.includes("/api/tree/events")) {
|
||
records.push({ type: "request", label, method: request.method(), url });
|
||
}
|
||
});
|
||
page.on("response", async (response) => {
|
||
const url = response.url();
|
||
if (
|
||
!url.includes("/api/tree/events") &&
|
||
!url.includes("/api/mindmap/") &&
|
||
!url.includes("/mindmap/") &&
|
||
!url.includes("/api/documents/save")
|
||
) {
|
||
return;
|
||
}
|
||
const request = response.request();
|
||
const method = request.method();
|
||
const status = response.status();
|
||
let responseText = null;
|
||
if (method !== "GET" || status >= 400 || url.includes("/api/documents/save")) {
|
||
responseText = await response.text().catch((error) => `<<read_response_failed:${error.message}>>`);
|
||
}
|
||
records.push({
|
||
type: "response",
|
||
label,
|
||
method,
|
||
url,
|
||
status,
|
||
requestBody: request.postData() || null,
|
||
responseText: responseText ? responseText.slice(0, 12000) : null,
|
||
});
|
||
});
|
||
page.on("requestfailed", (request) => {
|
||
const url = request.url();
|
||
if (url.includes("/api/tree/events") || url.includes("/api/mindmap/") || url.includes("/api/documents/save")) {
|
||
records.push({
|
||
type: "requestfailed",
|
||
label,
|
||
method: request.method(),
|
||
url,
|
||
failure: request.failure()?.errorText || null,
|
||
requestBody: request.postData() || null,
|
||
});
|
||
}
|
||
});
|
||
page.on("console", (message) => {
|
||
const text = message.text();
|
||
if (message.type() === "error" || /mindmap|tree live|EventSource|502|command_failed/i.test(text)) {
|
||
records.push({
|
||
type: "console",
|
||
label,
|
||
level: message.type(),
|
||
text: text.slice(0, 2000),
|
||
});
|
||
}
|
||
});
|
||
}
|
||
|
||
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 readPageState(page) {
|
||
return page.evaluate(() => {
|
||
const html = document.documentElement;
|
||
const root = document.querySelector('[data-testid="mnote-mindmap-editor-root"]');
|
||
const runtime = document.querySelector('[data-testid="simple-mind-map-runtime"]');
|
||
const scene = document.querySelector('[data-testid="leptos-mindmap-island"]');
|
||
const error = document.querySelector('[data-testid="leptos-mindmap-error"]');
|
||
const loading = document.querySelector('[data-testid="mindmap-scene-loading"]');
|
||
const assetRows = Array.from(document.querySelectorAll("#sidebar-file-tree-root [data-asset-id]"))
|
||
.map((node) => (node instanceof HTMLElement ? node.getAttribute("data-asset-id") || "" : ""))
|
||
.filter(Boolean);
|
||
const fileTreeAssetRowElements = Array.from(document.querySelectorAll("#sidebar-file-tree-root [data-asset-id]"))
|
||
.map((node) => (node instanceof HTMLElement ? node.closest(".tree-row") || node : null))
|
||
.filter((node, index, rows) => node instanceof HTMLElement && rows.indexOf(node) === index);
|
||
const mindmapRows = fileTreeAssetRowElements
|
||
.filter((node) => {
|
||
if (!(node instanceof HTMLElement)) return false;
|
||
const objectKind = node.getAttribute("data-object-kind") || "";
|
||
const objectIdentity = node.getAttribute("data-object-identity") || "";
|
||
const assetId = node.getAttribute("data-asset-id") || "";
|
||
return objectKind === "mindmap" || objectIdentity.includes('"objectKind":"mindmap"') || assetId.startsWith("mindmap");
|
||
})
|
||
.map((node) => {
|
||
const element = node;
|
||
const objectIdentity = element.getAttribute("data-object-identity") || "";
|
||
let parsedDocumentId = "";
|
||
try {
|
||
parsedDocumentId = JSON.parse(objectIdentity).documentId || "";
|
||
} catch {
|
||
parsedDocumentId = "";
|
||
}
|
||
return {
|
||
rowId: element.getAttribute("data-row-id") || "",
|
||
documentId: element.getAttribute("data-document-id") || element.getAttribute("data-doc-id") || parsedDocumentId,
|
||
assetId: element.getAttribute("data-asset-id") || "",
|
||
objectKind: element.getAttribute("data-object-kind") || "",
|
||
objectIdentity,
|
||
title: element.textContent || "",
|
||
};
|
||
});
|
||
return {
|
||
url: window.location.href,
|
||
bodyText: (document.body?.innerText || "").slice(0, 8000),
|
||
mindmapId: root instanceof HTMLElement ? root.dataset.mnoteMindmapId || null : null,
|
||
runtimeReady: runtime instanceof HTMLElement ? runtime.dataset.runtimeReady === "true" : false,
|
||
runtimeMountCount: scene instanceof HTMLElement ? Number(scene.dataset.runtimeMountCount || "0") : 0,
|
||
runtimeProjectionApplyCount:
|
||
scene instanceof HTMLElement ? Number(scene.dataset.runtimeProjectionApplyCount || "0") : 0,
|
||
lastRuntimeMountReason: scene instanceof HTMLElement ? scene.dataset.lastRuntimeMountReason || "" : "",
|
||
lastFetchSceneReason: scene instanceof HTMLElement ? scene.dataset.lastFetchSceneReason || "" : "",
|
||
backgroundProjectionRefresh: scene instanceof HTMLElement ? scene.dataset.backgroundProjectionRefresh || "" : "",
|
||
hasMindmapError: Boolean(error),
|
||
hasMindmapLoading: Boolean(loading),
|
||
commandStatus: scene instanceof HTMLElement ? scene.dataset.commandStatus || "" : "",
|
||
treeLiveStatus: html.getAttribute("data-mnote-tree-live-status") || "",
|
||
treeLiveApplied: html.getAttribute("data-mnote-tree-live-applied") || "",
|
||
treeLiveRevision: html.getAttribute("data-mnote-tree-live-revision") || "",
|
||
treeLiveApplyError: html.getAttribute("data-mnote-tree-live-apply-error") || "",
|
||
lastMindmapAssetOpenMode: html.getAttribute("data-mnote-last-mindmap-asset-open-mode") || "",
|
||
lastMindmapAssetId: html.getAttribute("data-mnote-last-mindmap-asset-id") || "",
|
||
objectEditor:
|
||
document.querySelector("[data-mnote-object-editor]") instanceof HTMLElement
|
||
? document.querySelector("[data-mnote-object-editor]").getAttribute("data-mnote-object-editor") || ""
|
||
: "",
|
||
objectIdentity:
|
||
document.querySelector("[data-mnote-object-identity]") instanceof HTMLElement
|
||
? document.querySelector("[data-mnote-object-identity]").getAttribute("data-mnote-object-identity") || ""
|
||
: "",
|
||
localStorageKeys: Object.keys(window.localStorage || {}).filter((key) =>
|
||
/mnote\.leptos-tiptap-spike\.document|__mindmap_object__|mindmap-object/.test(key),
|
||
),
|
||
mindmapLoadingEvents: window.__MNOTE_MINDMAP_LOADING_EVENTS__ || [],
|
||
fileTreeText: (document.getElementById("sidebar-file-tree-root")?.textContent || "").slice(0, 4000),
|
||
fileTreeAssetIds: assetRows,
|
||
fileTreeMindmapRows: mindmapRows,
|
||
treeEvents: window.__MNOTE_SMOKE_TREE_EVENTS__ || [],
|
||
};
|
||
});
|
||
}
|
||
|
||
async function readMindmapRuntimeStabilityState(page, mindmapId) {
|
||
return page.evaluate(
|
||
({ mindmapId }) => {
|
||
const scene = document.querySelector('[data-testid="leptos-mindmap-island"]');
|
||
const registry = window.__MNOTE_LEPTOS_MINDMAP_BRIDGES__ || {};
|
||
const bridge = registry[mindmapId];
|
||
const instance = bridge?.instance;
|
||
const topicNode = instance?.renderer?.findNodeByUid?.("topic") || null;
|
||
let topicRect = null;
|
||
if (typeof topicNode?.getRect === "function") {
|
||
try {
|
||
topicRect = topicNode.getRect();
|
||
} catch (error) {
|
||
topicRect = null;
|
||
}
|
||
}
|
||
const viewTransform = instance?.view?.getTransformData?.() || null;
|
||
return {
|
||
runtimeMountCount: scene instanceof HTMLElement ? Number(scene.dataset.runtimeMountCount || "0") : 0,
|
||
runtimeProjectionApplyCount:
|
||
scene instanceof HTMLElement ? Number(scene.dataset.runtimeProjectionApplyCount || "0") : 0,
|
||
lastRuntimeMountReason: scene instanceof HTMLElement ? scene.dataset.lastRuntimeMountReason || "" : "",
|
||
lastRuntimeProjectionApplyReason:
|
||
scene instanceof HTMLElement ? scene.dataset.lastRuntimeProjectionApplyReason || "" : "",
|
||
runtimeProjectionDeferred:
|
||
scene instanceof HTMLElement ? scene.dataset.runtimeProjectionDeferred || "" : "",
|
||
lastRuntimeProjectionDeferReason:
|
||
scene instanceof HTMLElement ? scene.dataset.lastRuntimeProjectionDeferReason || "" : "",
|
||
backgroundProjectionRefresh: scene instanceof HTMLElement ? scene.dataset.backgroundProjectionRefresh || "" : "",
|
||
commandStatus: scene instanceof HTMLElement ? scene.dataset.commandStatus || "" : "",
|
||
commandApplyMode: scene instanceof HTMLElement ? scene.dataset.commandApplyMode || "" : "",
|
||
topicRect: topicRect
|
||
? {
|
||
x: Number(topicRect.x ?? topicRect.left ?? 0),
|
||
y: Number(topicRect.y ?? topicRect.top ?? 0),
|
||
width: Number(topicRect.width ?? 0),
|
||
height: Number(topicRect.height ?? 0),
|
||
}
|
||
: null,
|
||
viewTransform,
|
||
};
|
||
},
|
||
{ mindmapId },
|
||
);
|
||
}
|
||
|
||
function stableJson(value) {
|
||
return JSON.stringify(value ?? null);
|
||
}
|
||
|
||
async function waitForMindmapRuntimeViewSettled(page, mindmapId, label) {
|
||
let previous = await readMindmapRuntimeStabilityState(page, mindmapId);
|
||
for (let index = 0; index < 12; index += 1) {
|
||
await page.waitForTimeout(350);
|
||
const current = await readMindmapRuntimeStabilityState(page, mindmapId);
|
||
if (
|
||
stableJson(current.viewTransform) === stableJson(previous.viewTransform) &&
|
||
stableJson(current.topicRect) === stableJson(previous.topicRect) &&
|
||
current.runtimeMountCount === previous.runtimeMountCount &&
|
||
current.runtimeProjectionApplyCount === previous.runtimeProjectionApplyCount
|
||
) {
|
||
return current;
|
||
}
|
||
previous = current;
|
||
}
|
||
throw new Error(`mindmap_runtime_view_not_settled:${label}`);
|
||
}
|
||
|
||
function rectCenter(rect) {
|
||
if (!rect) return null;
|
||
return {
|
||
x: rect.x + rect.width / 2,
|
||
y: rect.y + rect.height / 2,
|
||
};
|
||
}
|
||
|
||
function centerDistance(a, b) {
|
||
const ca = rectCenter(a);
|
||
const cb = rectCenter(b);
|
||
if (!ca || !cb) return 0;
|
||
return Math.hypot(ca.x - cb.x, ca.y - cb.y);
|
||
}
|
||
|
||
async function dispatchSyntheticMindmapTreeSignal(page, documentId, mindmapId, eventName) {
|
||
return page.evaluate(
|
||
({ documentId, mindmapId, eventName }) => {
|
||
const cursorId = `smoke-command-${Date.now()}`;
|
||
const payload =
|
||
eventName === "tree:delta"
|
||
? {
|
||
kind: "delta",
|
||
revision: JSON.stringify({ id: cursorId, createdAt: new Date().toISOString() }),
|
||
data: {
|
||
op: "resync_required",
|
||
reason: "mindmap.put",
|
||
documentId,
|
||
blockId: mindmapId,
|
||
},
|
||
}
|
||
: {
|
||
kind: "resync",
|
||
revision: JSON.stringify({ id: cursorId, createdAt: new Date().toISOString() }),
|
||
overview: {
|
||
command_logs: [
|
||
{
|
||
id: cursorId,
|
||
command_id: cursorId,
|
||
target_page_id: documentId,
|
||
target_block_id: mindmapId,
|
||
aggregate_type: "block",
|
||
aggregate_id: mindmapId,
|
||
payload: {
|
||
streamDelta: {
|
||
op: "resync_required",
|
||
reason: "mindmap.put",
|
||
documentId,
|
||
blockId: mindmapId,
|
||
},
|
||
},
|
||
},
|
||
],
|
||
domain_events: [],
|
||
},
|
||
};
|
||
window.dispatchEvent(new CustomEvent(eventName, { detail: { payload, revision: payload.revision } }));
|
||
return payload;
|
||
},
|
||
{ documentId, mindmapId, eventName },
|
||
);
|
||
}
|
||
|
||
async function assertMindmapRuntimeDoesNotRefreshForLiveSignals(page, documentId, mindmapId, failures, label) {
|
||
await waitForMindmapRuntimeViewSettled(page, mindmapId, label);
|
||
const before = await readPageState(page);
|
||
const beforeRuntime = await readMindmapRuntimeStabilityState(page, mindmapId);
|
||
if (before.hasMindmapError || before.hasMindmapLoading || !before.runtimeReady) {
|
||
failures.push({
|
||
code: "mindmap_unstable_before_live_signal",
|
||
label,
|
||
state: before,
|
||
});
|
||
return { before, afterResync: before, afterDelta: before };
|
||
}
|
||
|
||
const resyncPayload = await dispatchSyntheticMindmapTreeSignal(page, documentId, mindmapId, "tree:resync");
|
||
await page.waitForTimeout(2_500);
|
||
const afterResync = await readPageState(page);
|
||
const afterResyncRuntime = await readMindmapRuntimeStabilityState(page, mindmapId);
|
||
if (afterResync.runtimeMountCount !== before.runtimeMountCount) {
|
||
failures.push({
|
||
code: "mindmap_resync_remounted_runtime",
|
||
label,
|
||
before,
|
||
after: afterResync,
|
||
payload: resyncPayload,
|
||
});
|
||
}
|
||
if (afterResync.runtimeProjectionApplyCount !== before.runtimeProjectionApplyCount) {
|
||
failures.push({
|
||
code: "mindmap_resync_applied_projection_despite_usability_first",
|
||
label,
|
||
before,
|
||
after: afterResync,
|
||
payload: resyncPayload,
|
||
});
|
||
}
|
||
if (stableJson(afterResyncRuntime.viewTransform) !== stableJson(beforeRuntime.viewTransform)) {
|
||
failures.push({
|
||
code: "mindmap_resync_changed_view_transform",
|
||
label,
|
||
before: beforeRuntime,
|
||
after: afterResyncRuntime,
|
||
payload: resyncPayload,
|
||
});
|
||
}
|
||
if (centerDistance(beforeRuntime.topicRect, afterResyncRuntime.topicRect) > 2) {
|
||
failures.push({
|
||
code: "mindmap_resync_moved_topic_node",
|
||
label,
|
||
before: beforeRuntime,
|
||
after: afterResyncRuntime,
|
||
payload: resyncPayload,
|
||
});
|
||
}
|
||
|
||
const deltaPayload = await dispatchSyntheticMindmapTreeSignal(page, documentId, mindmapId, "tree:delta");
|
||
await page.waitForTimeout(2_500);
|
||
const afterDelta = await readPageState(page);
|
||
const afterDeltaRuntime = await readMindmapRuntimeStabilityState(page, mindmapId);
|
||
if (afterDelta.runtimeMountCount !== afterResync.runtimeMountCount) {
|
||
failures.push({
|
||
code: "mindmap_delta_remounted_runtime",
|
||
label,
|
||
before: afterResync,
|
||
after: afterDelta,
|
||
payload: deltaPayload,
|
||
});
|
||
}
|
||
if (afterDelta.runtimeProjectionApplyCount !== afterResync.runtimeProjectionApplyCount) {
|
||
failures.push({
|
||
code: "mindmap_delta_applied_projection_despite_usability_first",
|
||
label,
|
||
before: afterResync,
|
||
after: afterDelta,
|
||
payload: deltaPayload,
|
||
});
|
||
}
|
||
if (stableJson(afterDeltaRuntime.viewTransform) !== stableJson(afterResyncRuntime.viewTransform)) {
|
||
failures.push({
|
||
code: "mindmap_delta_changed_view_transform",
|
||
label,
|
||
before: afterResyncRuntime,
|
||
after: afterDeltaRuntime,
|
||
payload: deltaPayload,
|
||
});
|
||
}
|
||
if (centerDistance(afterResyncRuntime.topicRect, afterDeltaRuntime.topicRect) > 2) {
|
||
failures.push({
|
||
code: "mindmap_delta_moved_topic_node",
|
||
label,
|
||
before: afterResyncRuntime,
|
||
after: afterDeltaRuntime,
|
||
payload: deltaPayload,
|
||
});
|
||
}
|
||
if (afterDelta.hasMindmapError || afterDelta.hasMindmapLoading) {
|
||
failures.push({
|
||
code: "mindmap_live_signal_left_error_or_loading",
|
||
label,
|
||
after: afterDelta,
|
||
});
|
||
}
|
||
|
||
return { before, beforeRuntime, afterResync, afterResyncRuntime, afterDelta, afterDeltaRuntime };
|
||
}
|
||
|
||
async function waitForMindmapReady(page, stage) {
|
||
await page
|
||
.waitForFunction(
|
||
() => {
|
||
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__ || {};
|
||
return (
|
||
root instanceof HTMLElement &&
|
||
runtime instanceof HTMLElement &&
|
||
runtime.dataset.runtimeReady === "true" &&
|
||
Boolean(mindmapId) &&
|
||
Boolean(registry[mindmapId])
|
||
);
|
||
},
|
||
null,
|
||
{ timeout: UI_TIMEOUT_MS },
|
||
)
|
||
.catch((error) => {
|
||
throw new Error(`${stage}:mindmap_not_ready:${error.message}`);
|
||
});
|
||
}
|
||
|
||
async function waitForMindmapId(page) {
|
||
await waitForMindmapReady(page, "mindmap-id");
|
||
const state = await readPageState(page);
|
||
assert(state.mindmapId, `mindmap_id_missing:${JSON.stringify(state)}`);
|
||
return state.mindmapId;
|
||
}
|
||
|
||
async function waitForDocumentContentToIncludeMindmap(requestContext, documentId, workspaceId, mindmapId) {
|
||
let lastText = "";
|
||
for (let index = 0; index < 45; index += 1) {
|
||
const response = await requestContext.fetch(
|
||
`${BASE_URL}/api/documents/content?documentId=${encodeURIComponent(documentId)}&workspaceId=${encodeURIComponent(workspaceId)}`,
|
||
{ method: "GET", timeout: 10_000 },
|
||
);
|
||
lastText = await response.text();
|
||
if (response.ok() && lastText.includes(mindmapId)) {
|
||
return lastText;
|
||
}
|
||
await new Promise((resolve) => setTimeout(resolve, 500));
|
||
}
|
||
throw new Error(`document_content_missing_mindmap:${lastText.slice(0, 3000)}`);
|
||
}
|
||
|
||
async function assertFileTreeMindmapOpenUsesResourceTab(page, documentId, mindmapId, failures) {
|
||
await openFilesystemView(page);
|
||
const opened = await page.evaluate(
|
||
({ documentId, mindmapId }) => {
|
||
const rows = Array.from(document.querySelectorAll("#sidebar-file-tree-root [data-asset-id]"));
|
||
const row = rows.find((node) => {
|
||
if (!(node instanceof HTMLElement)) return false;
|
||
const assetId = node.getAttribute("data-asset-id") || "";
|
||
const objectIdentity = node.getAttribute("data-object-identity") || "";
|
||
let parsedDocumentId = "";
|
||
try {
|
||
parsedDocumentId = JSON.parse(objectIdentity).documentId || "";
|
||
} catch {
|
||
parsedDocumentId = "";
|
||
}
|
||
const rowDocumentId = node.getAttribute("data-document-id") || node.getAttribute("data-doc-id") || parsedDocumentId;
|
||
return assetId === mindmapId && rowDocumentId === documentId;
|
||
});
|
||
if (!(row instanceof HTMLElement)) {
|
||
return { clicked: false, reason: "mindmap_asset_row_missing" };
|
||
}
|
||
const button = row.querySelector('[data-rust-action="open"], .tree-link');
|
||
if (!(button instanceof HTMLElement)) {
|
||
return { clicked: false, reason: "mindmap_asset_open_button_missing" };
|
||
}
|
||
button.click();
|
||
return {
|
||
clicked: true,
|
||
assetId: row.getAttribute("data-asset-id") || "",
|
||
rowId: row.getAttribute("data-row-id") || "",
|
||
objectIdentity: row.getAttribute("data-object-identity") || "",
|
||
objectKind: row.getAttribute("data-object-kind") || "",
|
||
};
|
||
},
|
||
{ documentId, mindmapId },
|
||
);
|
||
if (!opened.clicked) {
|
||
failures.push({ code: "filetree_mindmap_asset_open_row_missing", opened });
|
||
return opened;
|
||
}
|
||
if (!opened.objectIdentity.includes(`"objectKind":"mindmap"`) || !opened.objectIdentity.includes(`"assetId":"${mindmapId}"`)) {
|
||
failures.push({
|
||
code: "filetree_mindmap_asset_row_missing_object_identity",
|
||
opened,
|
||
});
|
||
}
|
||
await page.waitForFunction(
|
||
(mindmapId) => {
|
||
return document.documentElement.getAttribute("data-mnote-last-mindmap-asset-open-mode") === "mindmap-resource-tab"
|
||
&& document.documentElement.getAttribute("data-mnote-last-mindmap-asset-id") === mindmapId
|
||
&& Boolean(document.querySelector('.mnote-main-tab.is-active[data-mnote-tab-kind="mindmap"]'));
|
||
},
|
||
mindmapId,
|
||
{ timeout: UI_TIMEOUT_MS },
|
||
).catch(() => null);
|
||
const state = await readPageState(page);
|
||
const url = new URL(state.url);
|
||
const tabState = await page.evaluate(({ documentId, mindmapId }) => {
|
||
const identity = `resource:mindmap:${documentId}:${mindmapId}`;
|
||
const tab = document.querySelector(`.mnote-main-tab[data-mnote-main-tab="${CSS.escape(identity)}"]`);
|
||
const panel = document.querySelector(`.mnote-resource-tab-panel[data-mnote-resource-tab-panel="${CSS.escape(identity)}"]`);
|
||
const root = panel?.querySelector('[data-testid="mnote-mindmap-editor-root"]');
|
||
return {
|
||
identity,
|
||
tabExists: tab instanceof HTMLElement,
|
||
tabActive: tab instanceof HTMLElement && tab.classList.contains("is-active"),
|
||
panelVisible: panel instanceof HTMLElement && !panel.hidden,
|
||
objectEditor: panel instanceof HTMLElement ? panel.getAttribute("data-mnote-object-editor") || "" : "",
|
||
rootMindmapId: root instanceof HTMLElement ? root.getAttribute("data-mnote-mindmap-id") || "" : "",
|
||
openMode: document.documentElement.getAttribute("data-mnote-last-mindmap-asset-open-mode") || "",
|
||
};
|
||
}, { documentId, mindmapId });
|
||
if (url.pathname.includes(`/mindmap/${encodeURIComponent(documentId)}/${encodeURIComponent(mindmapId)}`)) {
|
||
failures.push({
|
||
code: "filetree_mindmap_asset_open_used_retired_object_shell",
|
||
opened,
|
||
state,
|
||
tabState,
|
||
});
|
||
}
|
||
if (!tabState.tabExists || !tabState.tabActive || !tabState.panelVisible || tabState.objectEditor !== "mindmap" || tabState.rootMindmapId !== mindmapId) {
|
||
failures.push({
|
||
code: "filetree_mindmap_asset_open_did_not_use_resource_tab",
|
||
opened,
|
||
state,
|
||
tabState,
|
||
});
|
||
}
|
||
await waitForMindmapReady(page, "filetree-resource-tab-open");
|
||
const readyState = await readPageState(page);
|
||
if (readyState.mindmapId !== mindmapId || !readyState.runtimeReady || readyState.hasMindmapError) {
|
||
failures.push({
|
||
code: "filetree_mindmap_asset_resource_tab_not_ready",
|
||
opened,
|
||
readyState,
|
||
});
|
||
}
|
||
return { opened, state: readyState };
|
||
}
|
||
|
||
async function readMindmapResourceTabState(page, documentId, mindmapId) {
|
||
return page.evaluate(
|
||
({ documentId, mindmapId }) => {
|
||
const identity = `resource:mindmap:${documentId}:${mindmapId}`;
|
||
const tab = document.querySelector(`.mnote-main-tab[data-mnote-main-tab="${CSS.escape(identity)}"]`);
|
||
const activeTab = document.querySelector(".mnote-main-tab.is-active");
|
||
const panel = document.querySelector(
|
||
`.mnote-resource-tab-panel[data-mnote-resource-tab-panel="${CSS.escape(identity)}"]`,
|
||
);
|
||
const root = panel?.querySelector('[data-testid="mnote-mindmap-editor-root"]');
|
||
const pageTab = document.querySelector('[data-mnote-main-tab="page"]');
|
||
const pagePanel = document.querySelector("[data-mnote-page-tab-panel]");
|
||
const resourceHost = document.querySelector("[data-mnote-resource-tab-host]");
|
||
return {
|
||
identity,
|
||
activeTabIdentity: activeTab instanceof HTMLElement ? activeTab.getAttribute("data-mnote-main-tab") || "" : "",
|
||
activeTabKind: activeTab instanceof HTMLElement ? activeTab.getAttribute("data-mnote-tab-kind") || "" : "",
|
||
activeMindmapSelector: Boolean(document.querySelector('.mnote-main-tab.is-active[data-mnote-tab-kind="mindmap"]')),
|
||
tabExists: tab instanceof HTMLElement,
|
||
tabActive: tab instanceof HTMLElement && tab.classList.contains("is-active"),
|
||
tabKind: tab instanceof HTMLElement ? tab.getAttribute("data-mnote-tab-kind") || "" : "",
|
||
panelExists: panel instanceof HTMLElement,
|
||
panelVisible: panel instanceof HTMLElement && !panel.hidden,
|
||
panelObjectEditor: panel instanceof HTMLElement ? panel.getAttribute("data-mnote-object-editor") || "" : "",
|
||
panelObjectIdentity: panel instanceof HTMLElement ? panel.getAttribute("data-mnote-object-identity") || "" : "",
|
||
panelMindmapId: panel instanceof HTMLElement ? panel.getAttribute("data-mnote-mindmap-id") || "" : "",
|
||
rootExists: root instanceof HTMLElement,
|
||
rootObjectEditor: root instanceof HTMLElement ? root.getAttribute("data-mnote-object-editor") || "" : "",
|
||
rootObjectIdentity: root instanceof HTMLElement ? root.getAttribute("data-mnote-object-identity") || "" : "",
|
||
rootMindmapId: root instanceof HTMLElement ? root.getAttribute("data-mnote-mindmap-id") || "" : "",
|
||
pageTabActive: pageTab instanceof HTMLElement && pageTab.classList.contains("is-active"),
|
||
pagePanelVisible: pagePanel instanceof HTMLElement && !pagePanel.hidden,
|
||
resourceHostVisible: resourceHost instanceof HTMLElement && !resourceHost.hidden,
|
||
};
|
||
},
|
||
{ documentId, mindmapId },
|
||
);
|
||
}
|
||
|
||
async function assertMindmapResourceTabCanRoundtripWithPageTab(page, documentId, mindmapId, failures, label) {
|
||
const before = await readMindmapResourceTabState(page, documentId, mindmapId);
|
||
const expectedIdentity = `resource:mindmap:${documentId}:${mindmapId}`;
|
||
if (
|
||
before.identity !== expectedIdentity ||
|
||
!before.activeMindmapSelector ||
|
||
!before.tabExists ||
|
||
!before.tabActive ||
|
||
before.tabKind !== "mindmap" ||
|
||
!before.panelVisible ||
|
||
before.panelObjectEditor !== "mindmap" ||
|
||
before.panelObjectIdentity !== expectedIdentity ||
|
||
before.panelMindmapId !== mindmapId ||
|
||
before.rootObjectEditor !== "mindmap" ||
|
||
before.rootObjectIdentity !== expectedIdentity ||
|
||
before.rootMindmapId !== mindmapId
|
||
) {
|
||
failures.push({
|
||
code: "mindmap_resource_tab_identity_or_panel_invalid",
|
||
label,
|
||
expectedIdentity,
|
||
state: before,
|
||
});
|
||
return { before, skippedRoundtrip: true };
|
||
}
|
||
|
||
await page.locator('[data-mnote-main-tab="page"]').first().click({ timeout: UI_TIMEOUT_MS });
|
||
await page.waitForFunction(
|
||
() => {
|
||
const pageTab = document.querySelector('[data-mnote-main-tab="page"]');
|
||
const pagePanel = document.querySelector("[data-mnote-page-tab-panel]");
|
||
const resourceHost = document.querySelector("[data-mnote-resource-tab-host]");
|
||
return (
|
||
pageTab instanceof HTMLElement &&
|
||
pageTab.classList.contains("is-active") &&
|
||
pagePanel instanceof HTMLElement &&
|
||
!pagePanel.hidden &&
|
||
resourceHost instanceof HTMLElement &&
|
||
resourceHost.hidden
|
||
);
|
||
},
|
||
null,
|
||
{ timeout: UI_TIMEOUT_MS },
|
||
);
|
||
const afterPageTab = await readMindmapResourceTabState(page, documentId, mindmapId);
|
||
if (!afterPageTab.pageTabActive || !afterPageTab.pagePanelVisible || afterPageTab.resourceHostVisible) {
|
||
failures.push({
|
||
code: "mindmap_resource_tab_page_roundtrip_failed_to_show_page",
|
||
label,
|
||
expectedIdentity,
|
||
state: afterPageTab,
|
||
});
|
||
}
|
||
|
||
await page.evaluate(
|
||
({ identity }) => {
|
||
const tab = document.querySelector(`.mnote-main-tab[data-mnote-main-tab="${CSS.escape(identity)}"]`);
|
||
if (!(tab instanceof HTMLElement)) return false;
|
||
tab.click();
|
||
return true;
|
||
},
|
||
{ identity: expectedIdentity },
|
||
);
|
||
await page.waitForFunction(
|
||
({ identity }) => {
|
||
const tab = document.querySelector(`.mnote-main-tab[data-mnote-main-tab="${CSS.escape(identity)}"]`);
|
||
const panel = document.querySelector(
|
||
`.mnote-resource-tab-panel[data-mnote-resource-tab-panel="${CSS.escape(identity)}"]`,
|
||
);
|
||
return (
|
||
tab instanceof HTMLElement &&
|
||
tab.classList.contains("is-active") &&
|
||
tab.getAttribute("data-mnote-tab-kind") === "mindmap" &&
|
||
panel instanceof HTMLElement &&
|
||
!panel.hidden
|
||
);
|
||
},
|
||
{ identity: expectedIdentity },
|
||
{ timeout: UI_TIMEOUT_MS },
|
||
);
|
||
const afterMindmapTab = await readMindmapResourceTabState(page, documentId, mindmapId);
|
||
if (
|
||
!afterMindmapTab.activeMindmapSelector ||
|
||
!afterMindmapTab.tabActive ||
|
||
!afterMindmapTab.panelVisible ||
|
||
afterMindmapTab.panelObjectIdentity !== expectedIdentity ||
|
||
afterMindmapTab.rootObjectIdentity !== expectedIdentity ||
|
||
afterMindmapTab.rootMindmapId !== mindmapId
|
||
) {
|
||
failures.push({
|
||
code: "mindmap_resource_tab_page_roundtrip_failed_to_restore_mindmap",
|
||
label,
|
||
expectedIdentity,
|
||
state: afterMindmapTab,
|
||
});
|
||
}
|
||
|
||
return { before, afterPageTab, afterMindmapTab };
|
||
}
|
||
|
||
async function assertSingleMindmapAssetRowStable(page, documentId, mindmapId, expectedObjectIdentity, failures, label) {
|
||
await openFilesystemView(page);
|
||
const state = await readPageState(page);
|
||
const rows = state.fileTreeMindmapRows.filter((row) => row.documentId === documentId);
|
||
if (rows.length !== 1) {
|
||
failures.push({
|
||
code: "filetree_mindmap_asset_row_count_changed",
|
||
label,
|
||
expectedCount: 1,
|
||
actualCount: rows.length,
|
||
rows,
|
||
state,
|
||
});
|
||
return { ok: false, rows, state, objectIdentity: expectedObjectIdentity };
|
||
}
|
||
const row = rows[0];
|
||
if (row.assetId !== mindmapId) {
|
||
failures.push({
|
||
code: "filetree_mindmap_asset_id_changed",
|
||
label,
|
||
expectedAssetId: mindmapId,
|
||
row,
|
||
state,
|
||
});
|
||
}
|
||
if (!row.objectIdentity.includes(`"objectKind":"mindmap"`) || !row.objectIdentity.includes(`"assetId":"${mindmapId}"`)) {
|
||
failures.push({
|
||
code: "filetree_mindmap_asset_identity_invalid",
|
||
label,
|
||
row,
|
||
state,
|
||
});
|
||
}
|
||
if (expectedObjectIdentity && row.objectIdentity !== expectedObjectIdentity) {
|
||
failures.push({
|
||
code: "filetree_mindmap_asset_identity_changed",
|
||
label,
|
||
expectedObjectIdentity,
|
||
row,
|
||
state,
|
||
});
|
||
}
|
||
return {
|
||
ok: failures.length === 0,
|
||
rows,
|
||
state,
|
||
objectIdentity: row.objectIdentity,
|
||
};
|
||
}
|
||
|
||
async function assertFileTreePageMarkdownOpenUsesPageAggregate(page, documentId, mindmapId, failures) {
|
||
await openFilesystemView(page);
|
||
const opened = await page.evaluate(
|
||
({ documentId }) => {
|
||
const row =
|
||
document.querySelector(`#sidebar-file-tree-root [data-row-id="doc:${CSS.escape(documentId)}"]`) ||
|
||
Array.from(document.querySelectorAll("#sidebar-file-tree-root [data-row-kind='document']")).find((node) => {
|
||
if (!(node instanceof HTMLElement)) return false;
|
||
const rowDocumentId = node.getAttribute("data-document-id") || node.getAttribute("data-doc-id") || "";
|
||
return rowDocumentId === documentId;
|
||
});
|
||
if (!(row instanceof HTMLElement)) {
|
||
return { clicked: false, reason: "page_markdown_row_missing" };
|
||
}
|
||
const button = row.querySelector('[data-rust-action="open"], .tree-link');
|
||
if (!(button instanceof HTMLElement)) {
|
||
return { clicked: false, reason: "page_markdown_open_button_missing" };
|
||
}
|
||
button.click();
|
||
return {
|
||
clicked: true,
|
||
rowId: row.getAttribute("data-row-id") || "",
|
||
objectIdentity: row.getAttribute("data-object-identity") || "",
|
||
};
|
||
},
|
||
{ documentId },
|
||
);
|
||
if (!opened.clicked) {
|
||
failures.push({ code: "filetree_page_markdown_open_row_missing", opened });
|
||
return opened;
|
||
}
|
||
if (!opened.objectIdentity.includes(`"objectKind":"page"`) || !opened.objectIdentity.includes(`"documentId":"${documentId}"`)) {
|
||
failures.push({
|
||
code: "filetree_page_markdown_row_missing_object_identity",
|
||
opened,
|
||
});
|
||
}
|
||
await page.waitForURL((url) => url.pathname.includes(`/documents/${encodeURIComponent(documentId)}`), {
|
||
timeout: UI_TIMEOUT_MS,
|
||
}).catch(() => null);
|
||
const state = await readPageState(page);
|
||
const url = new URL(state.url);
|
||
if (!url.pathname.includes(`/documents/${encodeURIComponent(documentId)}`)) {
|
||
failures.push({
|
||
code: "filetree_page_markdown_open_did_not_return_document_page",
|
||
opened,
|
||
state,
|
||
});
|
||
}
|
||
const tabState = await readMindmapResourceTabState(page, documentId, mindmapId);
|
||
if (!tabState.pageTabActive || !tabState.pagePanelVisible || tabState.resourceHostVisible || tabState.activeTabKind === "mindmap") {
|
||
failures.push({
|
||
code: "filetree_page_markdown_open_did_not_activate_page_tab",
|
||
opened,
|
||
state,
|
||
tabState,
|
||
});
|
||
}
|
||
return { opened, state, tabState };
|
||
}
|
||
|
||
function readMindmapBlocksFromDocumentContentText(text) {
|
||
const payload = JSON.parse(text);
|
||
const content = Array.isArray(payload?.content)
|
||
? payload.content
|
||
: Array.isArray(payload?.result?.content)
|
||
? payload.result.content
|
||
: Array.isArray(payload?.data?.content)
|
||
? payload.data.content
|
||
: Array.isArray(payload?.body?.content)
|
||
? payload.body.content
|
||
: [];
|
||
return content.filter((block) => block?.type === "mindmap" || block?.blockType === "mindmap");
|
||
}
|
||
|
||
async function assertDocumentMindmapBlockUsesReferenceSource(requestContext, documentId, workspaceId, mindmapId, failures, label) {
|
||
const text = await waitForDocumentContentToIncludeMindmap(requestContext, documentId, workspaceId, mindmapId);
|
||
const blocks = readMindmapBlocksFromDocumentContentText(text);
|
||
const target = blocks.find((block) => {
|
||
const props = block?.props && typeof block.props === "object" ? block.props : {};
|
||
return props.mindmapId === mindmapId || props.mindmap_id === mindmapId || block.id === mindmapId || block.blockId === mindmapId;
|
||
});
|
||
if (!target) {
|
||
failures.push({
|
||
code: "document_mindmap_block_reference_missing",
|
||
label,
|
||
mindmapId,
|
||
blocks,
|
||
responseText: text.slice(0, 3000),
|
||
});
|
||
return { ok: false, blocks };
|
||
}
|
||
const props = target.props && typeof target.props === "object" ? target.props : {};
|
||
if (!props.mindmapId || props.rootNodeId !== "root" || Object.prototype.hasOwnProperty.call(props, "data")) {
|
||
failures.push({
|
||
code: "document_mindmap_block_uses_wrong_source",
|
||
label,
|
||
mindmapId,
|
||
props,
|
||
target,
|
||
});
|
||
return { ok: false, target };
|
||
}
|
||
return { ok: true, target };
|
||
}
|
||
|
||
async function waitForMindmapProjectionText(requestContext, documentId, mindmapId, expectedText) {
|
||
let lastText = "";
|
||
for (let index = 0; index < 45; index += 1) {
|
||
const response = await requestContext.fetch(
|
||
`${BASE_URL}/api/mindmap/${encodeURIComponent(documentId)}/${encodeURIComponent(mindmapId)}?view=simple_mind_map_scene&queryName=mindmap.simple_mind_map_scene.get`,
|
||
{ method: "GET", timeout: 10_000 },
|
||
);
|
||
lastText = await response.text();
|
||
if (response.ok() && lastText.includes(expectedText)) return lastText;
|
||
await new Promise((resolve) => setTimeout(resolve, 500));
|
||
}
|
||
throw new Error(`mindmap_projection_missing_text:${expectedText}:${lastText.slice(0, 3000)}`);
|
||
}
|
||
|
||
async function readMindmapRuntimeTextState(page, mindmapId, expectedText) {
|
||
return page.evaluate(
|
||
({ mindmapId, expectedText }) => {
|
||
const registry = window.__MNOTE_LEPTOS_MINDMAP_BRIDGES__ || {};
|
||
const bridge = registry[mindmapId];
|
||
const snapshot = bridge?.getSnapshot?.() ?? bridge?.instance?.getData?.(true) ?? null;
|
||
const root = snapshot && typeof snapshot === "object" && "root" in snapshot ? snapshot.root : snapshot;
|
||
const texts = [];
|
||
const visit = (node) => {
|
||
if (!node || typeof node !== "object") return;
|
||
const data = node.data && typeof node.data === "object" ? node.data : {};
|
||
if (typeof data.text === "string") texts.push(data.text);
|
||
if (Array.isArray(node.children)) node.children.forEach(visit);
|
||
};
|
||
visit(root);
|
||
return {
|
||
texts,
|
||
includesExpectedText: texts.some((text) => text.includes(expectedText)),
|
||
snapshot,
|
||
};
|
||
},
|
||
{ mindmapId, expectedText },
|
||
);
|
||
}
|
||
|
||
async function readMindmapProjectionText(requestContext, documentId, mindmapId) {
|
||
const response = await requestContext.fetch(
|
||
`${BASE_URL}/api/mindmap/${encodeURIComponent(documentId)}/${encodeURIComponent(mindmapId)}?view=simple_mind_map_scene&queryName=mindmap.simple_mind_map_scene.get`,
|
||
{ method: "GET", timeout: 10_000 },
|
||
);
|
||
return {
|
||
ok: response.ok(),
|
||
status: response.status(),
|
||
text: await response.text(),
|
||
};
|
||
}
|
||
|
||
async function editTopicTextThroughRuntime(page, mindmapId, text) {
|
||
const result = await page.evaluate(
|
||
({ mindmapId, text }) => {
|
||
const scene = document.querySelector('[data-testid="leptos-mindmap-island"]');
|
||
if (scene instanceof HTMLElement) {
|
||
scene.dataset.commandStatus = "smoke-waiting-topic-edit";
|
||
}
|
||
const registry = window.__MNOTE_LEPTOS_MINDMAP_BRIDGES__ || {};
|
||
const bridge = registry[mindmapId];
|
||
const instance = bridge?.instance;
|
||
const topicNode = instance?.renderer?.findNodeByUid?.("topic") || null;
|
||
if (!topicNode || typeof topicNode !== "object") return { ok: false, reason: "topic_node_missing" };
|
||
if (typeof topicNode.setData === "function") {
|
||
topicNode.setData({ text });
|
||
} else if (topicNode.data && typeof topicNode.data === "object") {
|
||
topicNode.data.text = text;
|
||
} else {
|
||
return { ok: false, reason: "topic_node_not_mutable" };
|
||
}
|
||
const snapshot = typeof bridge.getSnapshot === "function" ? bridge.getSnapshot() : instance?.getData?.(true);
|
||
return {
|
||
ok: true,
|
||
snapshotText: snapshot?.children?.[0]?.data?.text ?? null,
|
||
commandStatus: scene instanceof HTMLElement ? scene.dataset.commandStatus || null : null,
|
||
};
|
||
},
|
||
{ mindmapId, text },
|
||
);
|
||
assert(result.ok, `topic_runtime_edit_failed:${JSON.stringify(result)}`);
|
||
await page.waitForFunction(
|
||
({ text }) => {
|
||
const bodyText = document.body?.innerText || "";
|
||
const scene = document.querySelector('[data-testid="leptos-mindmap-island"]');
|
||
return bodyText.includes(text) || (scene instanceof HTMLElement && scene.dataset.commandStatus !== "smoke-waiting-topic-edit");
|
||
},
|
||
{ text },
|
||
{ timeout: UI_TIMEOUT_MS },
|
||
);
|
||
return result;
|
||
}
|
||
|
||
async function readRuntimeTextEditState(page) {
|
||
return page.evaluate(() => {
|
||
const edit = document.querySelector(".smm-node-edit-wrap[contenteditable=\"true\"]");
|
||
const scene = document.querySelector('[data-testid="leptos-mindmap-island"]');
|
||
const active = document.activeElement;
|
||
return {
|
||
exists: edit instanceof HTMLElement,
|
||
visible:
|
||
edit instanceof HTMLElement &&
|
||
edit.style.display !== "none" &&
|
||
edit.getClientRects().length > 0,
|
||
text: edit instanceof HTMLElement ? edit.innerText || edit.textContent || "" : "",
|
||
active:
|
||
edit instanceof HTMLElement &&
|
||
(active === edit || (active instanceof Node && edit.contains(active))),
|
||
runtimeMountCount: scene instanceof HTMLElement ? Number(scene.dataset.runtimeMountCount || "0") : 0,
|
||
runtimeProjectionApplyCount:
|
||
scene instanceof HTMLElement ? Number(scene.dataset.runtimeProjectionApplyCount || "0") : 0,
|
||
runtimeProjectionDeferred:
|
||
scene instanceof HTMLElement ? scene.dataset.runtimeProjectionDeferred || "" : "",
|
||
lastRuntimeProjectionDeferReason:
|
||
scene instanceof HTMLElement ? scene.dataset.lastRuntimeProjectionDeferReason || "" : "",
|
||
backgroundProjectionRefresh:
|
||
scene instanceof HTMLElement ? scene.dataset.backgroundProjectionRefresh || "" : "",
|
||
};
|
||
});
|
||
}
|
||
|
||
async function openTopicTextEdit(page, mindmapId) {
|
||
const result = await page.evaluate(
|
||
({ mindmapId }) => {
|
||
const registry = window.__MNOTE_LEPTOS_MINDMAP_BRIDGES__ || {};
|
||
const bridge = registry[mindmapId];
|
||
const instance = bridge?.instance;
|
||
const topicNode = instance?.renderer?.findNodeByUid?.("topic") || null;
|
||
const textEdit = instance?.renderer?.textEdit;
|
||
if (!topicNode) return { ok: false, reason: "topic_node_missing" };
|
||
if (typeof textEdit?.show !== "function") return { ok: false, reason: "text_edit_show_missing" };
|
||
textEdit.show({ node: topicNode, isFromKeyDown: false });
|
||
return { ok: true };
|
||
},
|
||
{ mindmapId },
|
||
);
|
||
assert(result.ok, `topic_text_edit_open_failed:${JSON.stringify(result)}`);
|
||
const edit = page.locator(".smm-node-edit-wrap[contenteditable=\"true\"]").first();
|
||
await edit.waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
|
||
await edit.focus();
|
||
await page.keyboard.press("Control+A");
|
||
await page.keyboard.press("Backspace");
|
||
}
|
||
|
||
async function enterTopicTextDraftWithoutCommit(page, mindmapId, text) {
|
||
await openTopicTextEdit(page, mindmapId);
|
||
await page.keyboard.insertText(text);
|
||
await page.waitForFunction(
|
||
({ text }) => {
|
||
const edit = document.querySelector(".smm-node-edit-wrap[contenteditable=\"true\"]");
|
||
return edit instanceof HTMLElement && (edit.innerText || edit.textContent || "").includes(text);
|
||
},
|
||
{ text },
|
||
{ timeout: UI_TIMEOUT_MS },
|
||
);
|
||
return readRuntimeTextEditState(page);
|
||
}
|
||
|
||
async function assertLongLanguageEditSurvivesLiveRefresh(page, requestContext, documentId, mindmapId, failures) {
|
||
const longText =
|
||
`长文本编辑-LIVE-${Date.now().toString().slice(-6)}：` +
|
||
"第一段用于覆盖真实中文连续输入，包含标点、换行前的较长句子，确保编辑框不会因为后台实时刷新而丢焦或闪烁。";
|
||
const secondHalf = "第二段继续输入，验证 live signal 之后仍然可以稳定完成编辑并保存到投影。";
|
||
await openTopicTextEdit(page, mindmapId);
|
||
const beforeEditRuntime = await readMindmapRuntimeStabilityState(page, mindmapId);
|
||
await page.keyboard.insertText(longText);
|
||
const beforeLive = await readRuntimeTextEditState(page);
|
||
const resyncPayload = await dispatchSyntheticMindmapTreeSignal(page, documentId, mindmapId, "tree:resync");
|
||
await page.waitForTimeout(2_500);
|
||
const afterLive = await readRuntimeTextEditState(page);
|
||
if (!afterLive.visible || !afterLive.active || !afterLive.text.includes(longText)) {
|
||
failures.push({
|
||
code: "mindmap_live_refresh_interrupted_long_text_edit",
|
||
beforeLive,
|
||
afterLive,
|
||
payload: resyncPayload,
|
||
});
|
||
return { beforeLive, afterLive, committed: false, longText: longText + secondHalf };
|
||
}
|
||
if (afterLive.runtimeMountCount !== beforeLive.runtimeMountCount) {
|
||
failures.push({
|
||
code: "mindmap_live_refresh_remounted_during_long_text_edit",
|
||
beforeLive,
|
||
afterLive,
|
||
payload: resyncPayload,
|
||
});
|
||
}
|
||
if (afterLive.runtimeProjectionApplyCount !== beforeLive.runtimeProjectionApplyCount) {
|
||
failures.push({
|
||
code: "mindmap_live_refresh_applied_projection_during_long_text_edit",
|
||
beforeLive,
|
||
afterLive,
|
||
payload: resyncPayload,
|
||
});
|
||
}
|
||
await page.keyboard.insertText(secondHalf);
|
||
await page.keyboard.press("Enter");
|
||
await waitForMindmapProjectionText(requestContext, documentId, mindmapId, longText + secondHalf);
|
||
await page.waitForTimeout(2_500);
|
||
const afterCommitRuntime = await readMindmapRuntimeStabilityState(page, mindmapId);
|
||
if (afterCommitRuntime.runtimeMountCount !== beforeEditRuntime.runtimeMountCount) {
|
||
failures.push({
|
||
code: "mindmap_long_text_commit_remounted_runtime",
|
||
before: beforeEditRuntime,
|
||
after: afterCommitRuntime,
|
||
});
|
||
}
|
||
if (afterCommitRuntime.runtimeProjectionApplyCount !== beforeEditRuntime.runtimeProjectionApplyCount) {
|
||
failures.push({
|
||
code: "mindmap_long_text_commit_applied_projection_refresh",
|
||
before: beforeEditRuntime,
|
||
after: afterCommitRuntime,
|
||
});
|
||
}
|
||
if (stableJson(afterCommitRuntime.viewTransform) !== stableJson(beforeEditRuntime.viewTransform)) {
|
||
failures.push({
|
||
code: "mindmap_long_text_commit_changed_view_transform",
|
||
before: beforeEditRuntime,
|
||
after: afterCommitRuntime,
|
||
});
|
||
}
|
||
const postCommitLivePayload = await dispatchSyntheticMindmapTreeSignal(page, documentId, mindmapId, "tree:resync");
|
||
await page.waitForTimeout(2_500);
|
||
const afterPostCommitLiveRuntime = await readMindmapRuntimeStabilityState(page, mindmapId);
|
||
if (afterPostCommitLiveRuntime.runtimeMountCount !== afterCommitRuntime.runtimeMountCount) {
|
||
failures.push({
|
||
code: "mindmap_post_commit_live_remounted_runtime",
|
||
before: afterCommitRuntime,
|
||
after: afterPostCommitLiveRuntime,
|
||
payload: postCommitLivePayload,
|
||
});
|
||
}
|
||
if (afterPostCommitLiveRuntime.runtimeProjectionApplyCount !== afterCommitRuntime.runtimeProjectionApplyCount) {
|
||
failures.push({
|
||
code: "mindmap_post_commit_live_applied_projection_refresh",
|
||
before: afterCommitRuntime,
|
||
after: afterPostCommitLiveRuntime,
|
||
payload: postCommitLivePayload,
|
||
});
|
||
}
|
||
if (stableJson(afterPostCommitLiveRuntime.viewTransform) !== stableJson(afterCommitRuntime.viewTransform)) {
|
||
failures.push({
|
||
code: "mindmap_post_commit_live_changed_view_transform",
|
||
before: afterCommitRuntime,
|
||
after: afterPostCommitLiveRuntime,
|
||
payload: postCommitLivePayload,
|
||
});
|
||
}
|
||
if (centerDistance(afterCommitRuntime.topicRect, afterPostCommitLiveRuntime.topicRect) > 2) {
|
||
failures.push({
|
||
code: "mindmap_post_commit_live_moved_topic_node",
|
||
before: afterCommitRuntime,
|
||
after: afterPostCommitLiveRuntime,
|
||
payload: postCommitLivePayload,
|
||
});
|
||
}
|
||
return {
|
||
beforeEditRuntime,
|
||
beforeLive,
|
||
afterLive,
|
||
committed: true,
|
||
longText: longText + secondHalf,
|
||
afterCommitRuntime,
|
||
afterPostCommitLiveRuntime,
|
||
afterCommit: await readPageState(page),
|
||
};
|
||
}
|
||
|
||
async function waitForPageCondition(page, predicate, timeoutMs = LIVE_WAIT_MS) {
|
||
const deadline = Date.now() + timeoutMs;
|
||
let last = null;
|
||
while (Date.now() < deadline) {
|
||
last = await readPageState(page);
|
||
if (predicate(last)) {
|
||
return { ok: true, state: last };
|
||
}
|
||
await page.waitForTimeout(500);
|
||
}
|
||
return { ok: false, state: last || (await readPageState(page)) };
|
||
}
|
||
|
||
function findBadRecord(records) {
|
||
return records.find((record) => {
|
||
if (record.type === "response" && record.status >= 500) return true;
|
||
return BAD_TEXT_PATTERN.test(`${record.responseText || ""}\n${record.text || ""}\n${record.failure || ""}`);
|
||
});
|
||
}
|
||
|
||
function parseJsonMaybe(value) {
|
||
if (typeof value !== "string" || !value.trim()) return null;
|
||
try {
|
||
return JSON.parse(value);
|
||
} catch {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
function assertMindmapCommandApplyArtifactsDoNotTouchTreeResource(records, failures) {
|
||
const commandApplyResponses = records.filter((record) => {
|
||
if (record.type !== "response" || record.method !== "POST" || !record.url.includes("/api/mindmap/")) {
|
||
return false;
|
||
}
|
||
const requestBody = parseJsonMaybe(record.requestBody);
|
||
return requestBody?.commandName === "mindmap.command.apply";
|
||
});
|
||
if (commandApplyResponses.length === 0) {
|
||
failures.push({ code: "mindmap_command_apply_artifact_response_missing" });
|
||
return { checked: 0, artifacts: [] };
|
||
}
|
||
|
||
const artifacts = [];
|
||
let parsedCount = 0;
|
||
let skippedReadFailures = 0;
|
||
for (const record of commandApplyResponses) {
|
||
const responseBody = parseJsonMaybe(record.responseText);
|
||
const eventType = String(responseBody?.artifacts?.domainEvent?.eventType || "");
|
||
const streamDelta = responseBody?.artifacts?.domainEvent?.payload?.streamDelta || null;
|
||
const streamOp = String(streamDelta?.op || "");
|
||
const summary = {
|
||
url: record.url,
|
||
commandName: responseBody?.commandName || "",
|
||
eventType,
|
||
streamOp,
|
||
};
|
||
artifacts.push(summary);
|
||
if (!responseBody) {
|
||
if (String(record.responseText || "").startsWith("<<read_response_failed:")) {
|
||
skippedReadFailures += 1;
|
||
continue;
|
||
}
|
||
failures.push({
|
||
code: "mindmap_command_apply_artifact_response_unparseable",
|
||
record,
|
||
});
|
||
continue;
|
||
}
|
||
parsedCount += 1;
|
||
if (eventType.startsWith("tree.resource.")) {
|
||
failures.push({
|
||
code: "mindmap_command_apply_used_tree_resource_event",
|
||
summary,
|
||
});
|
||
}
|
||
if (streamOp === "resync_required") {
|
||
failures.push({
|
||
code: "mindmap_command_apply_used_tree_resync_delta",
|
||
summary,
|
||
});
|
||
}
|
||
}
|
||
if (parsedCount === 0) {
|
||
failures.push({
|
||
code: "mindmap_command_apply_artifact_response_all_unparseable",
|
||
skippedReadFailures,
|
||
});
|
||
}
|
||
return { checked: parsedCount, skippedReadFailures, artifacts };
|
||
}
|
||
|
||
async function main() {
|
||
await fs.mkdir(OUTPUT_DIR, { recursive: true });
|
||
const browser = await chromium.launch({ headless: true });
|
||
const contextA = await browser.newContext({ viewport: { width: 1440, height: 960 }, locale: "zh-CN" });
|
||
const contextB = await browser.newContext({ viewport: { width: 1440, height: 960 }, locale: "zh-CN" });
|
||
const pageA = await contextA.newPage();
|
||
const pageB = await contextB.newPage();
|
||
await installTreeEventRecorder(pageA);
|
||
await installTreeEventRecorder(pageB);
|
||
await installMindmapLoadingRecorder(pageA);
|
||
await installMindmapLoadingRecorder(pageB);
|
||
const records = [];
|
||
attachNetworkCapture(pageA, "browser-a", records);
|
||
attachNetworkCapture(pageB, "browser-b", records);
|
||
const screenshots = [];
|
||
const createdIds = [];
|
||
const failures = [];
|
||
const result = {
|
||
ok: false,
|
||
task: TASK,
|
||
baseUrl: BASE_URL,
|
||
documentId: null,
|
||
workspaceId: null,
|
||
mindmapId: null,
|
||
liveWaitMs: LIVE_WAIT_MS,
|
||
failures,
|
||
network: records,
|
||
screenshots,
|
||
};
|
||
|
||
try {
|
||
await ensureAuthenticated(pageA, contextA.request);
|
||
await ensureAuthenticated(pageB, contextB.request);
|
||
|
||
const doc = await createTempDocument(contextA.request, null);
|
||
createdIds.push(doc.documentId);
|
||
const awayDoc = await createTempDocument(contextA.request, null);
|
||
createdIds.push(awayDoc.documentId);
|
||
result.documentId = doc.documentId;
|
||
result.workspaceId = doc.workspaceId;
|
||
await renameDocument(contextA.request, doc.workspaceId, doc.documentId, `task169-mindmap-live-${Date.now().toString().slice(-6)}`);
|
||
await renameDocument(contextA.request, awayDoc.workspaceId, awayDoc.documentId, `task169-mindmap-away-${Date.now().toString().slice(-6)}`);
|
||
|
||
await openDocument(pageA, doc.workspaceId, doc.documentId);
|
||
await openDocument(pageB, doc.workspaceId, doc.documentId);
|
||
result.browserBBeforeInsert = await readPageState(pageB);
|
||
|
||
await insertMindmapThroughSlash(pageA);
|
||
result.mindmapId = await waitForMindmapId(pageA);
|
||
result.documentMindmapBlockAfterInsert = await assertDocumentMindmapBlockUsesReferenceSource(
|
||
contextA.request,
|
||
doc.documentId,
|
||
doc.workspaceId,
|
||
result.mindmapId,
|
||
failures,
|
||
"after-insert",
|
||
);
|
||
result.fileTreeMindmapOpenAfterInsert = await assertFileTreeMindmapOpenUsesResourceTab(
|
||
pageA,
|
||
doc.documentId,
|
||
result.mindmapId,
|
||
failures,
|
||
);
|
||
result.fileTreeMindmapRowsAfterInsert = await assertSingleMindmapAssetRowStable(
|
||
pageA,
|
||
doc.documentId,
|
||
result.mindmapId,
|
||
null,
|
||
failures,
|
||
"after-insert",
|
||
);
|
||
await waitForMindmapReady(pageA, "after-filetree-mindmap-open");
|
||
result.resourceTabRoundtripAfterInsert = await assertMindmapResourceTabCanRoundtripWithPageTab(
|
||
pageA,
|
||
doc.documentId,
|
||
result.mindmapId,
|
||
failures,
|
||
"after-insert",
|
||
);
|
||
await pageA.waitForTimeout(1000);
|
||
screenshots.push(await screenshot(pageA, "01-browser-a-after-insert"));
|
||
result.retiredRealtimeTopicEditing = {
|
||
status: "skipped",
|
||
reason:
|
||
"task169 当前收窄为 main editor mindmap resource tab P1 smoke；旧 topic/runtime 实时编辑深测依赖 object shell 时代 runtime 行为，已退役为非必过链路。",
|
||
retiredSteps: [
|
||
"assertMindmapRuntimeDoesNotRefreshForLiveSignals",
|
||
"editTopicTextThroughRuntime",
|
||
"enterTopicTextDraftWithoutCommit",
|
||
"assertLongLanguageEditSurvivesLiveRefresh",
|
||
"assertMindmapCommandApplyArtifactsDoNotTouchTreeResource",
|
||
],
|
||
};
|
||
// 旧实时编辑深测不再作为 task169 的必过主链；下面只保留 resource tab 打开与切换口径。
|
||
await openDocument(pageA, awayDoc.workspaceId, awayDoc.documentId);
|
||
result.indexOpenAfterResourceTabRoundtrip = await assertFileTreePageMarkdownOpenUsesPageAggregate(
|
||
pageA,
|
||
doc.documentId,
|
||
result.mindmapId,
|
||
failures,
|
||
);
|
||
result.retiredResourceTabReopenAfterIndex = {
|
||
status: "skipped",
|
||
reason:
|
||
"task169 已收窄为首次 File Tree 打开 mindmap 资源后的 resource tab 断言；二次重开与旧实时深测不属于当前 P1 口径，已退役以免干扰后续 smoke。",
|
||
};
|
||
|
||
const badRecord = findBadRecord(records);
|
||
if (badRecord) {
|
||
failures.push({ code: "mindmap_network_error_or_validator_leak", badRecord });
|
||
}
|
||
|
||
result.ok = failures.length === 0;
|
||
await writeResult(result);
|
||
if (!result.ok) {
|
||
throw new Error(`mindmap_realtime_failed:${JSON.stringify(failures, null, 2).slice(0, 6000)}`);
|
||
}
|
||
} catch (error) {
|
||
result.error = error instanceof Error ? error.stack || error.message : String(error);
|
||
screenshots.push(await screenshot(pageA, "99-failure-browser-a").catch(() => null));
|
||
screenshots.push(await screenshot(pageB, "99-failure-browser-b").catch(() => null));
|
||
await writeResult(result);
|
||
throw error;
|
||
} finally {
|
||
await cleanupDocuments(contextA.request, createdIds).catch(() => undefined);
|
||
await contextA.close().catch(() => undefined);
|
||
await contextB.close().catch(() => undefined);
|
||
await browser.close();
|
||
}
|
||
}
|
||
|
||
main().catch((error) => {
|
||
console.error(error);
|
||
process.exitCode = 1;
|
||
});
|