567 lines
18 KiB
JavaScript
567 lines
18 KiB
JavaScript
"use strict";
|
|
|
|
const BASE_URL = (process.env.MNOTE_UI_BASE_URL || "http://127.0.0.1:3000").replace(/\/+$/, "");
|
|
const DOCUMENT_UI_BASE_URL = (
|
|
process.env.MNOTE_TREE_SMOKE_DOCUMENT_BASE_URL ||
|
|
process.env.MNOTE_LEGACY_UI_BASE_URL ||
|
|
BASE_URL
|
|
).replace(/\/+$/, "");
|
|
const MNOTE_WEB_BASE_URL = (process.env.MNOTE_WEB_SMOKE_BASE_URL || "").replace(/\/+$/, "");
|
|
const {
|
|
DEFAULT_EMAIL,
|
|
DEFAULT_PASSWORD,
|
|
loginViaAuthForm,
|
|
loginViaAuthApi,
|
|
} = require("./lib/browser-auth-login");
|
|
|
|
const REQUEST_TIMEOUT_MS = Number(process.env.MNOTE_SMOKE_TIMEOUT_MS || 20_000);
|
|
const UI_TIMEOUT_MS = Number(process.env.MNOTE_SMOKE_UI_TIMEOUT_MS || 30_000);
|
|
// 7-76 P0：不再依赖「测试账号快速登录」按钮；UI 走标准表单，API 走 /api/auth。
|
|
const TEST_USERNAME_PREFIX = "mnote-e2e-";
|
|
const TEST_EMAIL = DEFAULT_EMAIL;
|
|
const TEST_PASSWORD = DEFAULT_PASSWORD;
|
|
|
|
function assert(condition, message) {
|
|
if (!condition) {
|
|
throw new Error(message);
|
|
}
|
|
}
|
|
|
|
function requireMnoteWebSmokeBaseUrl() {
|
|
assert(
|
|
Boolean(MNOTE_WEB_BASE_URL),
|
|
"当前 smoke 仅用于 legacy mnote-web debug/runtime，对应端口已默认退役；如需执行，请显式设置 MNOTE_WEB_SMOKE_BASE_URL。",
|
|
);
|
|
return MNOTE_WEB_BASE_URL;
|
|
}
|
|
|
|
async function requestJson(requestContext, path, init = {}) {
|
|
const response = await requestContext.fetch(`${BASE_URL}${path}`, {
|
|
...init,
|
|
headers:
|
|
init.data !== undefined
|
|
? {
|
|
"content-type": "application/json",
|
|
...(init.headers || {}),
|
|
}
|
|
: {
|
|
...(init.headers || {}),
|
|
},
|
|
timeout: REQUEST_TIMEOUT_MS,
|
|
});
|
|
|
|
const text = await response.text();
|
|
let payload = null;
|
|
try {
|
|
payload = text ? JSON.parse(text) : null;
|
|
} catch {
|
|
payload = text;
|
|
}
|
|
|
|
if (!response.ok()) {
|
|
throw new Error(
|
|
`${path} 请求失败: ${response.status()} ${response.statusText()} ${
|
|
typeof payload === "string" ? payload : JSON.stringify(payload)
|
|
}`,
|
|
);
|
|
}
|
|
|
|
const contentType = response.headers()["content-type"] || "";
|
|
if (!contentType.includes("application/json")) {
|
|
const snippet =
|
|
typeof payload === "string"
|
|
? payload.slice(0, 200)
|
|
: JSON.stringify(payload).slice(0, 200);
|
|
throw new Error(`${path} 返回了非 JSON 内容：${snippet}`);
|
|
}
|
|
|
|
return payload;
|
|
}
|
|
|
|
async function createTempDocument(requestContext, parentId = null) {
|
|
const payload = await requestJson(requestContext, "/api/tree/commands", {
|
|
method: "POST",
|
|
data: {
|
|
action: "create",
|
|
parentId,
|
|
},
|
|
});
|
|
const result = payload && typeof payload.result === "object" ? payload.result : null;
|
|
const documentId =
|
|
result && typeof result.documentId === "string"
|
|
? result.documentId
|
|
: payload && typeof payload.id === "string"
|
|
? payload.id
|
|
: "";
|
|
const workspaceId =
|
|
result && typeof result.workspaceId === "string"
|
|
? result.workspaceId
|
|
: payload && typeof payload.workspace_id === "string"
|
|
? payload.workspace_id
|
|
: payload && typeof payload.workspaceId === "string"
|
|
? payload.workspaceId
|
|
: "";
|
|
assert(documentId, "创建临时页面失败：缺少 documentId/id");
|
|
assert(workspaceId, "创建临时页面失败：缺少 workspaceId/workspace_id");
|
|
return {
|
|
documentId,
|
|
workspaceId,
|
|
};
|
|
}
|
|
|
|
async function renameDocument(requestContext, workspaceId, documentId, title) {
|
|
await requestJson(requestContext, "/api/documents/title", {
|
|
method: "POST",
|
|
data: {
|
|
workspaceId,
|
|
documentId,
|
|
title,
|
|
commandName: "page.head.updateTitle",
|
|
},
|
|
});
|
|
}
|
|
|
|
async function purgeDocument(requestContext, documentId) {
|
|
await requestJson(requestContext, "/api/documents/purge", {
|
|
method: "POST",
|
|
data: { documentId },
|
|
});
|
|
}
|
|
|
|
async function getViewerIdentity(requestContext) {
|
|
const payload = await requestJson(requestContext, "/api/auth/whoami", { method: "GET" });
|
|
assert(payload && typeof payload.userId === "string" && payload.userId, "获取当前用户失败：缺少 userId");
|
|
return payload;
|
|
}
|
|
|
|
async function tryApiQuickLogin(requestContext) {
|
|
// 名称保留兼容旧 smoke；实现为标准 password signIn（必要时 signUp）。
|
|
await loginViaAuthApi(requestContext, {
|
|
baseUrl: BASE_URL,
|
|
email: TEST_EMAIL,
|
|
password: TEST_PASSWORD,
|
|
timeoutMs: REQUEST_TIMEOUT_MS,
|
|
});
|
|
}
|
|
|
|
async function waitForAuthenticatedRedirect(page, timeout = 8_000) {
|
|
await page.waitForURL((url) => !url.toString().includes("/auth"), {
|
|
timeout,
|
|
waitUntil: "commit",
|
|
});
|
|
}
|
|
|
|
async function isVisible(locator) {
|
|
try {
|
|
return await locator.evaluateAll((elements) =>
|
|
elements.some((element) => {
|
|
if (!(element instanceof HTMLElement)) {
|
|
return false;
|
|
}
|
|
const style = window.getComputedStyle(element);
|
|
const rect = element.getBoundingClientRect();
|
|
return style.display !== "none" && style.visibility !== "hidden" && rect.width > 0 && rect.height > 0;
|
|
}),
|
|
);
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
async function clickButtonByExactText(page, text) {
|
|
await page.evaluate((label) => {
|
|
const button = Array.from(document.querySelectorAll("button")).find((candidate) => {
|
|
const content = (candidate.textContent || "").trim();
|
|
return content === label;
|
|
});
|
|
if (!(button instanceof HTMLButtonElement)) {
|
|
throw new Error(`未找到按钮：${label}`);
|
|
}
|
|
button.click();
|
|
}, text);
|
|
}
|
|
|
|
async function completeUsernameSetupIfNeeded(page) {
|
|
const saveButton = page.getByRole("button", { name: "保存并继续" });
|
|
if (!(await isVisible(saveButton))) {
|
|
return false;
|
|
}
|
|
|
|
const usernameInput = page.locator('input[name="username"]').last();
|
|
await usernameInput.waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
|
|
const currentValue = ((await usernameInput.inputValue().catch(() => "")) || "").trim();
|
|
const username = currentValue || `${TEST_USERNAME_PREFIX}${Date.now().toString().slice(-6)}`;
|
|
await usernameInput.fill(username, { timeout: UI_TIMEOUT_MS });
|
|
await saveButton.click({ timeout: UI_TIMEOUT_MS });
|
|
await waitForAuthenticatedRedirect(page, UI_TIMEOUT_MS);
|
|
return true;
|
|
}
|
|
|
|
async function registerTestAccountIfNeeded(page) {
|
|
const switchButton = page.getByRole("button", { name: "还没有账户？立即注册" });
|
|
if (!(await isVisible(switchButton))) {
|
|
return false;
|
|
}
|
|
|
|
await switchButton.click({ timeout: UI_TIMEOUT_MS });
|
|
await page.locator('input[name="account"]').fill(TEST_EMAIL, { timeout: UI_TIMEOUT_MS });
|
|
await page.locator('input[name="password"]').fill(TEST_PASSWORD, { timeout: UI_TIMEOUT_MS });
|
|
await page.getByRole("button", { name: "注册" }).click({ timeout: UI_TIMEOUT_MS });
|
|
try {
|
|
await waitForAuthenticatedRedirect(page, UI_TIMEOUT_MS);
|
|
return true;
|
|
} catch {
|
|
return completeUsernameSetupIfNeeded(page);
|
|
}
|
|
}
|
|
|
|
async function waitForViewerIdentity(requestContext, attempts = 6) {
|
|
let lastError = null;
|
|
for (let index = 0; index < attempts; index += 1) {
|
|
try {
|
|
return await getViewerIdentity(requestContext);
|
|
} catch (error) {
|
|
lastError = error;
|
|
await new Promise((resolve) => setTimeout(resolve, 1000));
|
|
}
|
|
}
|
|
throw lastError instanceof Error ? lastError : new Error("获取当前用户失败");
|
|
}
|
|
|
|
async function ensureAuthenticatedViaUi(page, requestContext) {
|
|
await page.goto(`${BASE_URL}/auth`, { waitUntil: "commit", timeout: UI_TIMEOUT_MS });
|
|
|
|
if (page.url().includes("/auth")) {
|
|
const accountField = page.locator("#account, input[name='account']").first();
|
|
const deadline = Date.now() + UI_TIMEOUT_MS;
|
|
while (page.url().includes("/auth") && Date.now() < deadline) {
|
|
if (await isVisible(accountField)) {
|
|
break;
|
|
}
|
|
await page.waitForTimeout(200);
|
|
}
|
|
if (!page.url().includes("/auth")) {
|
|
return await waitForViewerIdentity(requestContext);
|
|
}
|
|
if (!(await isVisible(accountField))) {
|
|
await page.reload({ waitUntil: "commit", timeout: UI_TIMEOUT_MS }).catch(() => undefined);
|
|
const retryDeadline = Date.now() + Math.min(8_000, UI_TIMEOUT_MS);
|
|
while (page.url().includes("/auth") && Date.now() < retryDeadline) {
|
|
if (await isVisible(accountField)) {
|
|
break;
|
|
}
|
|
await page.waitForTimeout(200);
|
|
}
|
|
}
|
|
if (!page.url().includes("/auth")) {
|
|
return await waitForViewerIdentity(requestContext);
|
|
}
|
|
if (!(await isVisible(accountField))) {
|
|
throw new Error("认证页未出现标准登录表单（#account）");
|
|
}
|
|
await loginViaAuthForm(page, {
|
|
baseUrl: BASE_URL,
|
|
email: TEST_EMAIL,
|
|
password: TEST_PASSWORD,
|
|
timeoutMs: UI_TIMEOUT_MS,
|
|
gotoAuth: false,
|
|
});
|
|
try {
|
|
await waitForAuthenticatedRedirect(page, UI_TIMEOUT_MS);
|
|
} catch {
|
|
// 账号可能尚未 seed：UI 注册或 API 兜底创建后再进站。
|
|
const completedUsername = await completeUsernameSetupIfNeeded(page);
|
|
if (!completedUsername) {
|
|
const registered = await registerTestAccountIfNeeded(page);
|
|
if (!registered) {
|
|
try {
|
|
await tryApiQuickLogin(requestContext);
|
|
await page.goto(`${BASE_URL}/`, { waitUntil: "commit", timeout: UI_TIMEOUT_MS });
|
|
} catch {
|
|
throw new Error("标准登录后仍停留在 /auth，且注册/API 兜底失败");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return await waitForViewerIdentity(requestContext);
|
|
}
|
|
|
|
async function ensureAuthenticated(page, requestContext) {
|
|
const existingViewer = await waitForViewerIdentity(requestContext, 1).catch(() => null);
|
|
if (existingViewer) {
|
|
return existingViewer;
|
|
}
|
|
|
|
const preferUiAuth = Boolean(process.env.DISPLAY);
|
|
if (preferUiAuth) {
|
|
try {
|
|
return await ensureAuthenticatedViaUi(page, requestContext);
|
|
} catch {
|
|
// 说明：有图形环境时优先走真实 UI 登录；如果异常，再回退到 API 登录。
|
|
}
|
|
}
|
|
|
|
const apiViewer = await (async () => {
|
|
try {
|
|
await tryApiQuickLogin(requestContext);
|
|
return await waitForViewerIdentity(requestContext, 3);
|
|
} catch {
|
|
return null;
|
|
}
|
|
})();
|
|
if (apiViewer) {
|
|
return apiViewer;
|
|
}
|
|
|
|
return await ensureAuthenticatedViaUi(page, requestContext);
|
|
}
|
|
|
|
async function prepareTempTreeFixture(requestContext) {
|
|
const uniqueSuffix = Date.now().toString();
|
|
const parentTitle = `task-tree-parent-${uniqueSuffix}`;
|
|
const childTitle = `task-tree-child-${uniqueSuffix}`;
|
|
|
|
const parent = await createTempDocument(requestContext, null);
|
|
const child = await createTempDocument(requestContext, parent.documentId);
|
|
|
|
await renameDocument(requestContext, parent.workspaceId, parent.documentId, parentTitle);
|
|
await renameDocument(requestContext, parent.workspaceId, child.documentId, childTitle);
|
|
|
|
return {
|
|
uniqueSuffix,
|
|
workspaceId: parent.workspaceId,
|
|
parentId: parent.documentId,
|
|
childId: child.documentId,
|
|
parentTitle,
|
|
childTitle,
|
|
createdIds: [parent.documentId, child.documentId],
|
|
};
|
|
}
|
|
|
|
async function cleanupDocuments(requestContext, createdIds) {
|
|
for (const documentId of [...createdIds].reverse()) {
|
|
await purgeDocument(requestContext, documentId);
|
|
}
|
|
}
|
|
|
|
async function openDocument(page, workspaceId, documentId) {
|
|
const url = `${DOCUMENT_UI_BASE_URL}/documents/${documentId}?workspaceId=${encodeURIComponent(workspaceId)}`;
|
|
const hasSidebarControls = async () => {
|
|
const pageTab = page.locator('[data-mnote-sidebar-tree-tab="page"]').first();
|
|
const filetreeTab = page.locator('[data-mnote-sidebar-tree-tab="filetree"]').first();
|
|
const groupButton = page.getByRole("button", { name: "分组" });
|
|
const fileButton = page.getByRole("button", { name: "文件" });
|
|
if ((await isVisible(pageTab)) || (await isVisible(filetreeTab))) {
|
|
return true;
|
|
}
|
|
if ((await isVisible(groupButton)) || (await isVisible(fileButton))) {
|
|
return true;
|
|
}
|
|
return await page.evaluate(() => {
|
|
const pageShell = document.querySelector('[data-testid="wolai-sidebar-page-tree-shell"]');
|
|
const legacyShell = document.querySelector('[data-testid="sidebar-page-tree-shell"]');
|
|
return [pageShell, legacyShell].some((node) => {
|
|
if (!(node instanceof HTMLElement)) return false;
|
|
const style = window.getComputedStyle(node);
|
|
const rect = node.getBoundingClientRect();
|
|
return !node.hidden && style.display !== "none" && style.visibility !== "hidden" && rect.width > 0 && rect.height > 0;
|
|
});
|
|
});
|
|
};
|
|
|
|
const gotoDocument = async () => {
|
|
try {
|
|
await page.goto(url, { waitUntil: "commit", timeout: UI_TIMEOUT_MS });
|
|
} catch (error) {
|
|
const message = error instanceof Error ? error.message : String(error);
|
|
if (!message.includes("ERR_ABORTED")) {
|
|
throw error;
|
|
}
|
|
await page.waitForTimeout(500);
|
|
await page.goto(url, { waitUntil: "commit", timeout: UI_TIMEOUT_MS });
|
|
}
|
|
};
|
|
|
|
await gotoDocument();
|
|
const firstDeadline = Date.now() + Math.min(UI_TIMEOUT_MS, 10_000);
|
|
while (Date.now() < firstDeadline) {
|
|
if (await hasSidebarControls()) {
|
|
return url;
|
|
}
|
|
await page.waitForTimeout(250);
|
|
}
|
|
|
|
await page.reload({ waitUntil: "commit", timeout: UI_TIMEOUT_MS }).catch(() => undefined);
|
|
const secondDeadline = Date.now() + Math.min(UI_TIMEOUT_MS, 10_000);
|
|
while (Date.now() < secondDeadline) {
|
|
if (await hasSidebarControls()) {
|
|
return url;
|
|
}
|
|
await page.waitForTimeout(250);
|
|
}
|
|
|
|
return url;
|
|
}
|
|
|
|
async function openSectionView(page) {
|
|
const waitForHost = () =>
|
|
page.waitForFunction(
|
|
() => {
|
|
const pagePanel = document.querySelector('[data-mnote-sidebar-tree-panel="page"]');
|
|
const pageRoot = document.getElementById("sidebar-tree-root");
|
|
const legacyHost = document.querySelector('[data-testid="sidebar-page-tree-shell"]');
|
|
const isVisible = (node) =>
|
|
node instanceof HTMLElement &&
|
|
!node.hidden &&
|
|
window.getComputedStyle(node).display !== "none" &&
|
|
window.getComputedStyle(node).visibility !== "hidden" &&
|
|
node.getClientRects().length > 0;
|
|
if (isVisible(legacyHost)) return true;
|
|
return isVisible(pageRoot) && (!pagePanel || isVisible(pagePanel));
|
|
},
|
|
undefined,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
|
|
try {
|
|
await waitForHost();
|
|
return;
|
|
} catch {
|
|
// 说明：未处于分组视图时才需要点击切换。
|
|
}
|
|
|
|
for (let attempt = 0; attempt < 2; attempt += 1) {
|
|
const switched = await page.evaluate(() => {
|
|
const selectors = [
|
|
'[data-mnote-sidebar-tree-tab="page"]',
|
|
'button[aria-label="分组"]',
|
|
];
|
|
for (const selector of selectors) {
|
|
const node = document.querySelector(selector);
|
|
if (node instanceof HTMLElement) {
|
|
node.click();
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
});
|
|
if (!switched) {
|
|
throw new Error("未找到页面树切换入口");
|
|
}
|
|
try {
|
|
await waitForHost();
|
|
return;
|
|
} catch (error) {
|
|
if (attempt === 1) {
|
|
throw error;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
async function openFilesystemView(page) {
|
|
const waitForHost = () =>
|
|
page.waitForFunction(
|
|
() => {
|
|
const filePanel = document.querySelector('[data-mnote-sidebar-tree-panel="filetree"]');
|
|
const fileRoot = document.getElementById("sidebar-file-tree-root");
|
|
const legacyHost = document.querySelector('[data-testid="sidebar-file-tree-shell"]');
|
|
const isVisible = (node) =>
|
|
node instanceof HTMLElement &&
|
|
!node.hidden &&
|
|
window.getComputedStyle(node).display !== "none" &&
|
|
window.getComputedStyle(node).visibility !== "hidden" &&
|
|
node.getClientRects().length > 0;
|
|
if (isVisible(legacyHost)) return true;
|
|
return isVisible(fileRoot) && (!filePanel || isVisible(filePanel));
|
|
},
|
|
undefined,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
|
|
try {
|
|
await waitForHost();
|
|
return;
|
|
} catch {
|
|
// 说明：未处于文件视图时才需要点击切换。
|
|
}
|
|
|
|
for (let attempt = 0; attempt < 2; attempt += 1) {
|
|
const switched = await page.evaluate(() => {
|
|
const selectors = [
|
|
'[data-mnote-sidebar-tree-tab="filetree"]',
|
|
'button[aria-label="文件"]',
|
|
];
|
|
for (const selector of selectors) {
|
|
const node = document.querySelector(selector);
|
|
if (node instanceof HTMLElement) {
|
|
node.click();
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
});
|
|
if (!switched) {
|
|
throw new Error("未找到文件树切换入口");
|
|
}
|
|
try {
|
|
await waitForHost();
|
|
return;
|
|
} catch (error) {
|
|
if (attempt === 1) {
|
|
throw error;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
async function ensurePageOptionsVisible(page) {
|
|
const toggle = page.getByRole("button", { name: /显示页面选项|隐藏页面选项/ });
|
|
await toggle.waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
|
|
const readLabel = async () => (await toggle.getAttribute("aria-label")) || "";
|
|
const waitUntilExpanded = async () => {
|
|
await page.waitForFunction(
|
|
() => {
|
|
const buttons = Array.from(document.querySelectorAll("button"));
|
|
return buttons.some((button) => (button.getAttribute("aria-label") || "").includes("隐藏页面选项"));
|
|
},
|
|
undefined,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
};
|
|
const label = await readLabel();
|
|
if (label.includes("显示")) {
|
|
await toggle.click({ timeout: UI_TIMEOUT_MS });
|
|
try {
|
|
await waitUntilExpanded();
|
|
} catch {
|
|
await toggle.click({ timeout: UI_TIMEOUT_MS });
|
|
await waitUntilExpanded();
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
BASE_URL,
|
|
DOCUMENT_UI_BASE_URL,
|
|
MNOTE_WEB_BASE_URL,
|
|
REQUEST_TIMEOUT_MS,
|
|
UI_TIMEOUT_MS,
|
|
assert,
|
|
requireMnoteWebSmokeBaseUrl,
|
|
cleanupDocuments,
|
|
createTempDocument,
|
|
ensureAuthenticated,
|
|
ensurePageOptionsVisible,
|
|
getViewerIdentity,
|
|
openDocument,
|
|
openFilesystemView,
|
|
openSectionView,
|
|
prepareTempTreeFixture,
|
|
purgeDocument,
|
|
renameDocument,
|
|
requestJson,
|
|
};
|