Codex
390 lines
24 KiB
TypeScript
390 lines
24 KiB
TypeScript
import { mkdirSync } from "node:fs";
|
|
import { connect } from "node:net";
|
|
import { join } from "node:path";
|
|
import { chromium } from "playwright";
|
|
import { runCommand } from "./command";
|
|
import { type UniDeskConfig, repoRoot, rootPath } from "./config";
|
|
|
|
type CheckStatus = "passed" | "failed";
|
|
|
|
interface E2ECheck {
|
|
name: string;
|
|
status: CheckStatus;
|
|
detail: unknown;
|
|
}
|
|
|
|
interface PublicUrls {
|
|
frontendUrl: string;
|
|
providerIngressHealthUrl: string;
|
|
providerIngressWsUrl: string;
|
|
blockedCoreUrl: string;
|
|
blockedDatabaseHost: string;
|
|
blockedDatabasePort: number;
|
|
}
|
|
|
|
function publicUrls(config: UniDeskConfig): PublicUrls {
|
|
return {
|
|
frontendUrl: `http://${config.network.publicHost}:${config.network.frontend.port}`,
|
|
providerIngressHealthUrl: `http://${config.network.publicHost}:${config.network.providerIngress.port}/health`,
|
|
providerIngressWsUrl: `ws://${config.network.publicHost}:${config.network.providerIngress.port}/ws/provider`,
|
|
blockedCoreUrl: `http://${config.network.publicHost}:${config.network.core.port}`,
|
|
blockedDatabaseHost: config.network.publicHost,
|
|
blockedDatabasePort: config.network.database.port,
|
|
};
|
|
}
|
|
|
|
async function fetchProbe(url: string, timeoutMs = 8000): Promise<unknown> {
|
|
const controller = new AbortController();
|
|
const timer = setTimeout(() => controller.abort(), timeoutMs);
|
|
try {
|
|
const response = await fetch(url, { signal: controller.signal });
|
|
const text = await response.text();
|
|
let body: unknown = text;
|
|
try { body = text.length > 0 ? JSON.parse(text) : null; } catch { /* keep text body */ }
|
|
return { reachable: true, ok: response.ok, status: response.status, body };
|
|
} catch (error) {
|
|
return { reachable: false, ok: false, error: error instanceof Error ? error.message : String(error) };
|
|
} finally {
|
|
clearTimeout(timer);
|
|
}
|
|
}
|
|
|
|
function tcpProbe(host: string, port: number, timeoutMs = 2500): Promise<unknown> {
|
|
return new Promise((resolve) => {
|
|
const socket = connect({ host, port });
|
|
let settled = false;
|
|
const finish = (detail: unknown): void => {
|
|
if (settled) return;
|
|
settled = true;
|
|
socket.destroy();
|
|
resolve(detail);
|
|
};
|
|
socket.setTimeout(timeoutMs);
|
|
socket.once("connect", () => finish({ reachable: true, ok: true, host, port }));
|
|
socket.once("timeout", () => finish({ reachable: false, ok: false, host, port, error: "timeout" }));
|
|
socket.once("error", (error) => finish({ reachable: false, ok: false, host, port, error: error.message }));
|
|
});
|
|
}
|
|
|
|
function addCheck(checks: E2ECheck[], name: string, passed: boolean, detail: unknown): void {
|
|
checks.push({ name, status: passed ? "passed" : "failed", detail });
|
|
}
|
|
|
|
function runPsql(config: UniDeskConfig, sql: string): { ok: boolean; stdout: string; stderr: string; exitCode: number | null } {
|
|
const result = runCommand([
|
|
"docker",
|
|
"exec",
|
|
"unidesk-database",
|
|
"psql",
|
|
"-U",
|
|
config.database.user,
|
|
"-d",
|
|
config.database.name,
|
|
"-v",
|
|
"ON_ERROR_STOP=1",
|
|
"-tA",
|
|
"-c",
|
|
sql,
|
|
], repoRoot);
|
|
return { ok: result.exitCode === 0, stdout: result.stdout.trim(), stderr: result.stderr.trim(), exitCode: result.exitCode };
|
|
}
|
|
|
|
function dockerCoreJson(path: string, init?: { method?: string; body?: unknown }): unknown {
|
|
const code = `
|
|
const res = await fetch(${JSON.stringify(`http://127.0.0.1:8080${path}`)}, ${JSON.stringify({
|
|
method: init?.method ?? "GET",
|
|
headers: init?.body === undefined ? undefined : { "content-type": "application/json" },
|
|
body: init?.body === undefined ? undefined : JSON.stringify(init.body),
|
|
})});
|
|
const text = await res.text();
|
|
let body = null;
|
|
try { body = text ? JSON.parse(text) : null; } catch { body = { text }; }
|
|
console.log(JSON.stringify({ ok: res.ok, status: res.status, body }));
|
|
`;
|
|
const result = runCommand(["docker", "exec", "unidesk-backend-core", "bun", "-e", code], repoRoot);
|
|
if (result.exitCode !== 0) return { ok: false, exitCode: result.exitCode, stdout: result.stdout.slice(-1200), stderr: result.stderr.slice(-1200) };
|
|
try {
|
|
return JSON.parse(result.stdout.trim()) as unknown;
|
|
} catch {
|
|
return { ok: true, stdout: result.stdout.slice(-1200), stderr: result.stderr.slice(-1200) };
|
|
}
|
|
}
|
|
|
|
async function waitForTaskStatus(taskId: string, expected: string, timeoutMs = 10_000): Promise<unknown> {
|
|
const started = Date.now();
|
|
let latest: unknown = null;
|
|
while (Date.now() - started < timeoutMs) {
|
|
latest = dockerCoreJson("/api/tasks?limit=40");
|
|
const tasks = (latest as { body?: { tasks?: Array<{ id?: string; status?: string; result?: unknown }> } }).body?.tasks ?? [];
|
|
const task = tasks.find((item) => item.id === taskId);
|
|
if (task?.status === expected) return { ok: true, task };
|
|
if (task?.status === "failed") return { ok: false, task };
|
|
await Bun.sleep(500);
|
|
}
|
|
return { ok: false, timeoutMs, latest };
|
|
}
|
|
|
|
function dockerPortSummary(): unknown {
|
|
const result = runCommand([
|
|
"docker",
|
|
"ps",
|
|
"--filter",
|
|
"label=com.docker.compose.project=unidesk",
|
|
"--format",
|
|
"{{.Names}}\t{{.Ports}}",
|
|
], repoRoot);
|
|
return {
|
|
ok: result.exitCode === 0,
|
|
exitCode: result.exitCode,
|
|
rows: result.stdout.trim().split("\n").filter(Boolean).map((line) => {
|
|
const [name, ports = ""] = line.split("\t");
|
|
return { name, ports };
|
|
}),
|
|
stderr: result.stderr.trim(),
|
|
};
|
|
}
|
|
|
|
function dockerStatusCheckDetail(dockerStatus: unknown, providerId: string): unknown {
|
|
const response = dockerStatus as { ok?: boolean; status?: number; body?: { dockerStatuses?: Array<{ providerId?: string; name?: string; nodeStatus?: string; updatedAt?: string; dockerStatus?: { ok?: boolean; socketPresent?: boolean; collectedAt?: string; counts?: unknown; daemon?: unknown; containers?: Array<{ id?: string; name?: string; image?: string; state?: string; status?: string; ports?: string }> } }> } };
|
|
const item = response.body?.dockerStatuses?.find((entry) => entry.providerId === providerId);
|
|
return {
|
|
ok: response.ok,
|
|
status: response.status,
|
|
providerId,
|
|
nodeStatus: item?.nodeStatus,
|
|
updatedAt: item?.updatedAt,
|
|
dockerStatus: item?.dockerStatus === undefined ? null : {
|
|
ok: item.dockerStatus.ok,
|
|
socketPresent: item.dockerStatus.socketPresent,
|
|
collectedAt: item.dockerStatus.collectedAt,
|
|
counts: item.dockerStatus.counts,
|
|
daemon: item.dockerStatus.daemon,
|
|
containersPreview: (item.dockerStatus.containers ?? []).slice(0, 8).map((container) => ({
|
|
id: container.id,
|
|
name: container.name,
|
|
image: container.image,
|
|
state: container.state,
|
|
status: container.status,
|
|
ports: container.ports,
|
|
})),
|
|
},
|
|
};
|
|
}
|
|
|
|
function systemStatusCheckDetail(systemStatus: unknown, providerId: string): unknown {
|
|
const response = systemStatus as { ok?: boolean; status?: number; body?: { systemStatuses?: Array<{ providerId?: string; name?: string; nodeStatus?: string; updatedAt?: string; current?: { ok?: boolean; collectedAt?: string; cpu?: unknown; memory?: unknown; disk?: unknown }; history?: unknown[] }> } };
|
|
const item = response.body?.systemStatuses?.find((entry) => entry.providerId === providerId);
|
|
return {
|
|
ok: response.ok,
|
|
status: response.status,
|
|
providerId,
|
|
nodeStatus: item?.nodeStatus,
|
|
updatedAt: item?.updatedAt,
|
|
current: item?.current === undefined ? null : {
|
|
ok: item.current.ok,
|
|
collectedAt: item.current.collectedAt,
|
|
cpu: item.current.cpu,
|
|
memory: item.current.memory,
|
|
disk: item.current.disk,
|
|
},
|
|
historyCount: item?.history?.length ?? 0,
|
|
historyPreview: (item?.history ?? []).slice(-8),
|
|
};
|
|
}
|
|
|
|
async function exposureChecks(config: UniDeskConfig, urls: PublicUrls, checks: E2ECheck[]): Promise<void> {
|
|
const portSummary = dockerPortSummary() as { rows?: Array<{ name: string; ports: string }> };
|
|
const portsText = (portSummary.rows ?? []).map((row) => `${row.name} ${row.ports}`).join("\n");
|
|
const corePublic = await fetchProbe(`${urls.blockedCoreUrl}/health`, 2500);
|
|
const databasePublic = await tcpProbe(urls.blockedDatabaseHost, urls.blockedDatabasePort);
|
|
addCheck(checks, "network:only-frontend-provider-ports", !portsText.includes(`:${config.network.core.port}->`) && !portsText.includes(`:${config.network.database.port}->`), portSummary);
|
|
addCheck(checks, "network:core-public-blocked", (corePublic as { reachable?: boolean }).reachable === false, corePublic);
|
|
addCheck(checks, "network:database-public-blocked", (databasePublic as { reachable?: boolean }).reachable === false, databasePublic);
|
|
}
|
|
|
|
async function serviceChecks(config: UniDeskConfig, urls: PublicUrls, checks: E2ECheck[]): Promise<void> {
|
|
const coreOverview = dockerCoreJson("/api/overview");
|
|
const coreNodes = dockerCoreJson("/api/nodes");
|
|
const systemStatus = dockerCoreJson("/api/nodes/system-status?limit=24");
|
|
const dockerStatus = dockerCoreJson("/api/nodes/docker-status");
|
|
const providerIngress = await fetchProbe(urls.providerIngressHealthUrl);
|
|
const overviewBody = (coreOverview as { body?: { ok?: boolean; dbReady?: boolean; onlineNodeCount?: number } }).body;
|
|
const nodeList = (coreNodes as { body?: { nodes?: Array<{ providerId?: string; status?: string }> } }).body?.nodes ?? [];
|
|
const systemStatuses = (systemStatus as { body?: { systemStatuses?: Array<{ providerId?: string; current?: { cpu?: { percent?: number }; memory?: { percent?: number; mode?: string; cacheBytes?: number }; disk?: { percent?: number } }; history?: unknown[] }> } }).body?.systemStatuses ?? [];
|
|
const mainSystem = systemStatuses.find((item) => item.providerId === config.providerGateway.id);
|
|
const dockerStatuses = (dockerStatus as { body?: { dockerStatuses?: Array<{ providerId?: string; dockerStatus?: { counts?: { containers?: number }; containers?: unknown[] } }> } }).body?.dockerStatuses ?? [];
|
|
const mainDocker = dockerStatuses.find((item) => item.providerId === config.providerGateway.id);
|
|
addCheck(checks, "core:internal-overview", (coreOverview as { ok?: boolean }).ok === true && overviewBody?.ok === true && overviewBody.dbReady === true && (overviewBody.onlineNodeCount ?? 0) >= 1, coreOverview);
|
|
addCheck(checks, "provider:self-node-online", nodeList.some((node) => node.providerId === config.providerGateway.id && node.status === "online"), coreNodes);
|
|
addCheck(checks, "provider:system-status", (systemStatus as { ok?: boolean }).ok === true && mainSystem?.current !== undefined && Number.isFinite(mainSystem.current.cpu?.percent) && Number.isFinite(mainSystem.current.memory?.percent) && mainSystem.current.memory?.mode === "actual_without_cache" && Number.isFinite(mainSystem.current.memory?.cacheBytes) && Number.isFinite(mainSystem.current.disk?.percent) && (mainSystem.history?.length ?? 0) > 0, systemStatusCheckDetail(systemStatus, config.providerGateway.id));
|
|
addCheck(checks, "provider:docker-status", (dockerStatus as { ok?: boolean }).ok === true && mainDocker?.dockerStatus !== undefined && ((mainDocker.dockerStatus.counts?.containers ?? 0) > 0 || (mainDocker.dockerStatus.containers?.length ?? 0) > 0), dockerStatusCheckDetail(dockerStatus, config.providerGateway.id));
|
|
const upgradeDispatch = dockerCoreJson("/api/dispatch", {
|
|
method: "POST",
|
|
body: { providerId: config.providerGateway.id, command: "provider.upgrade", payload: { source: "cli-e2e", mode: "plan" } },
|
|
});
|
|
const upgradeTaskId = (upgradeDispatch as { body?: { taskId?: string } }).body?.taskId ?? "";
|
|
const upgradeTask = upgradeTaskId ? await waitForTaskStatus(upgradeTaskId, "succeeded") : { ok: false, error: "missing taskId", upgradeDispatch };
|
|
const taskResult = (upgradeTask as { task?: { result?: { plan?: unknown; mode?: string } }; ok?: boolean }).task?.result;
|
|
addCheck(checks, "provider:upgrade-plan", (upgradeDispatch as { ok?: boolean }).ok === true && (upgradeTask as { ok?: boolean }).ok === true && taskResult?.mode === "plan" && taskResult.plan !== undefined, { upgradeDispatch, upgradeTask });
|
|
addCheck(checks, "provider-ingress:public-health", (providerIngress as { ok?: boolean; body?: { ok?: boolean } }).ok === true && (providerIngress as { body?: { ok?: boolean } }).body?.ok === true, providerIngress);
|
|
}
|
|
|
|
function databaseChecks(config: UniDeskConfig, checks: E2ECheck[]): string {
|
|
const markerId = `e2e_${Date.now()}_${Math.random().toString(16).slice(2, 8)}`;
|
|
const failedTaskId = `task_${markerId}_failed_diagnostic`;
|
|
const markerSql = `
|
|
CREATE TABLE IF NOT EXISTS unidesk_e2e_markers (
|
|
id TEXT PRIMARY KEY,
|
|
source TEXT NOT NULL,
|
|
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
|
);
|
|
INSERT INTO unidesk_e2e_markers (id, source) VALUES ('${markerId}', 'cli-e2e');
|
|
INSERT INTO unidesk_tasks (id, provider_id, command, status, payload, result, created_at, updated_at)
|
|
VALUES (
|
|
'${failedTaskId}',
|
|
'${config.providerGateway.id}',
|
|
'echo',
|
|
'failed',
|
|
'{"source":"cli-e2e","case":"history-diagnostics"}'::jsonb,
|
|
'{"error":"e2e forced failure for diagnostics","exitCode":23,"stderr":"simulated provider failure"}'::jsonb,
|
|
now() - interval '83 seconds',
|
|
now()
|
|
);
|
|
SELECT 'marker=' || id FROM unidesk_e2e_markers WHERE id = '${markerId}';
|
|
SELECT 'marker_count=' || count(*) FROM unidesk_e2e_markers;
|
|
SELECT 'failed_task=' || id FROM unidesk_tasks WHERE id = '${failedTaskId}' AND status = 'failed';
|
|
SELECT 'online_main_server=' || count(*) FROM unidesk_nodes WHERE provider_id = '${config.providerGateway.id}' AND status = 'online';
|
|
`;
|
|
const marker = runPsql(config, markerSql);
|
|
addCheck(checks, "database:named-volume-write", marker.ok && marker.stdout.includes(`marker=${markerId}`), marker);
|
|
addCheck(checks, "database:provider-state", marker.ok && marker.stdout.includes("online_main_server=1"), marker);
|
|
return markerId;
|
|
}
|
|
|
|
async function frontendCheck(config: UniDeskConfig, urls: PublicUrls, checks: E2ECheck[]): Promise<{ screenshotPath: string; bodyText: string; consoleErrors: string[] }> {
|
|
const e2eDir = rootPath(".state", "e2e");
|
|
mkdirSync(e2eDir, { recursive: true });
|
|
const screenshotPath = join(e2eDir, `${new Date().toISOString().replace(/[-:.TZ]/g, "")}_frontend.png`);
|
|
const consoleErrors: string[] = [];
|
|
const browser = await chromium.launch({ headless: true });
|
|
try {
|
|
const page = await browser.newPage({ viewport: { width: 1440, height: 920 } });
|
|
page.on("console", (message) => {
|
|
if (message.type() === "error") consoleErrors.push(message.text());
|
|
});
|
|
page.on("pageerror", (error) => consoleErrors.push(error.message));
|
|
await page.goto(urls.frontendUrl, { waitUntil: "domcontentloaded", timeout: 15000 });
|
|
await page.waitForSelector('[data-testid="login-screen"]', { timeout: 10000 });
|
|
await page.fill('input[name="username"]', config.auth.username);
|
|
await page.fill('input[name="password"]', config.auth.password);
|
|
await page.click('button[type="submit"]');
|
|
await page.waitForSelector('[data-testid="app-shell"]', { timeout: 10000 });
|
|
await page.waitForFunction(() => document.querySelector('[data-testid="conn-text"]')?.textContent?.includes("核心在线"), undefined, { timeout: 15000 });
|
|
const landedUrl = page.url();
|
|
const publicOrigin = new URL(urls.frontendUrl).origin;
|
|
const landed = new URL(landedUrl);
|
|
const publicFrontendReached = landed.origin === publicOrigin && !["127.0.0.1", "localhost", "::1"].includes(landed.hostname);
|
|
await page.waitForSelector(`text=${config.providerGateway.id}`, { timeout: 10000 });
|
|
await page.waitForSelector(`text=${config.providerGateway.name}`, { timeout: 10000 });
|
|
await page.setViewportSize({ width: 390, height: 860 });
|
|
const mobileRailHeights: number[] = [];
|
|
for (const moduleLabel of ["运行总览", "资源节点", "任务调度", "系统配置"]) {
|
|
await page.getByRole("button", { name: new RegExp(moduleLabel) }).click();
|
|
await page.waitForTimeout(80);
|
|
const height = await page.locator(".rail").evaluate((element) => Math.round(element.getBoundingClientRect().height));
|
|
mobileRailHeights.push(height);
|
|
}
|
|
const mobileRailMax = Math.max(...mobileRailHeights);
|
|
const mobileRailMin = Math.min(...mobileRailHeights);
|
|
await page.getByRole("button", { name: /任务调度/ }).click();
|
|
await page.getByRole("button", { name: /待处理任务/ }).click();
|
|
await page.waitForSelector('[data-testid="pending-task-page"]', { timeout: 5000 });
|
|
const mobileContentMetrics = await page.locator('[data-testid="pending-task-page"]').evaluate((element) => {
|
|
const pageTop = element.getBoundingClientRect().top;
|
|
const empty = element.querySelector(".empty-state");
|
|
const emptyBox = empty?.getBoundingClientRect();
|
|
const emptyStrong = empty?.querySelector("strong")?.getBoundingClientRect();
|
|
return {
|
|
pageTop: Math.round(pageTop),
|
|
emptyTextOffset: emptyBox && emptyStrong ? Math.round(emptyStrong.top - emptyBox.top) : 0,
|
|
};
|
|
});
|
|
await page.setViewportSize({ width: 1440, height: 920 });
|
|
await page.getByRole("button", { name: /运行总览/ }).click();
|
|
await page.getByRole("button", { name: /态势总览/ }).click();
|
|
const bodyText = await page.locator("body").innerText({ timeout: 5000 });
|
|
const rawBlocksBefore = await page.locator("pre.raw-json").count();
|
|
const nakedJsonText = bodyText.includes('{"') || bodyText.includes('"providerId"') || bodyText.includes('"labels"');
|
|
await page.getByTestId("pending-task-card").click();
|
|
await page.waitForSelector('[data-testid="pending-task-page"]', { timeout: 5000 });
|
|
const pendingTaskText = await page.locator('[data-testid="pending-task-page"]').innerText({ timeout: 5000 });
|
|
await page.getByRole("button", { name: /任务历史/ }).click();
|
|
await page.waitForSelector('[data-testid="task-history-page"]', { timeout: 5000 });
|
|
const taskHistoryText = await page.locator('[data-testid="task-history-page"]').innerText({ timeout: 5000 });
|
|
await page.getByRole("button", { name: /运行总览/ }).click();
|
|
await page.getByRole("button", { name: /态势总览/ }).click();
|
|
await page.screenshot({ path: screenshotPath, fullPage: true });
|
|
await page.getByTestId(`raw-node-${config.providerGateway.id.replace(/[^a-zA-Z0-9_-]/g, "_")}`).click();
|
|
await page.waitForSelector('[data-testid="raw-json"]', { timeout: 5000 });
|
|
const rawText = await page.locator('[data-testid="raw-json"]').innerText({ timeout: 5000 });
|
|
await page.getByRole("button", { name: "关闭" }).click();
|
|
await page.getByRole("button", { name: /资源节点/ }).click();
|
|
await page.getByRole("button", { name: /资源监控/ }).click();
|
|
await page.waitForSelector('[data-testid="node-monitor-page"]', { timeout: 10000 });
|
|
await page.locator('[data-testid="node-monitor-page"]').getByRole("button", { name: new RegExp(config.providerGateway.id) }).click();
|
|
await page.waitForSelector('[data-testid="metric-chart-cpu"]', { timeout: 10000 });
|
|
await page.waitForSelector('[data-testid="metric-chart-memory"]', { timeout: 10000 });
|
|
await page.waitForSelector('[data-testid="metric-chart-disk"]', { timeout: 10000 });
|
|
await page.waitForFunction(() => {
|
|
const text = document.body.innerText.toLowerCase();
|
|
return text.includes("任务管理器视图") && text.includes("cpu") && text.includes("memory") && text.includes("disk") && text.includes("不含缓存");
|
|
}, undefined, { timeout: 10000 });
|
|
const monitorText = await page.locator('[data-testid="node-monitor-page"]').innerText({ timeout: 5000 });
|
|
await page.getByTestId("upgrade-plan-button").click();
|
|
await page.waitForFunction(() => document.body.innerText.includes("预检升级 已下发"), undefined, { timeout: 10000 });
|
|
const upgradeControlText = await page.locator('[data-testid="provider-upgrade-control"]').innerText({ timeout: 5000 });
|
|
await page.getByRole("button", { name: /Docker 状态/ }).click();
|
|
await page.waitForSelector('[data-testid="docker-status-page"]', { timeout: 10000 });
|
|
await page.locator('[data-testid="docker-status-page"]').getByRole("button", { name: new RegExp(config.providerGateway.id) }).click();
|
|
await page.waitForSelector('[data-testid="docker-container-table"]', { timeout: 10000 });
|
|
await page.waitForSelector('[data-testid="database-volume-card"]', { timeout: 10000 });
|
|
await page.waitForFunction(() => {
|
|
const text = document.body.innerText.toLowerCase();
|
|
return text.includes("docker desktop 视图") && text.includes("containers") && text.includes("unidesk_pgdata_10gb");
|
|
}, undefined, { timeout: 10000 });
|
|
const dockerText = await page.locator('[data-testid="docker-status-page"]').innerText({ timeout: 5000 });
|
|
addCheck(checks, "frontend:login-provider-visible", bodyText.includes(config.providerGateway.id) && bodyText.includes(config.providerGateway.name) && bodyText.includes("核心在线"), { screenshotPath });
|
|
addCheck(checks, "frontend:public-provider-info-visible", publicFrontendReached && bodyText.includes(config.providerGateway.id) && bodyText.includes(config.providerGateway.name) && rawText.includes('"status": "online"') && rawText.includes(`"providerId": "${config.providerGateway.id}"`), { frontendUrl: urls.frontendUrl, landedUrl, providerId: config.providerGateway.id, rawTextPreview: rawText.slice(0, 400) });
|
|
addCheck(checks, "frontend:mobile-nav-fixed-height", mobileRailMax - mobileRailMin <= 1 && mobileRailMax <= 44, { mobileRailHeights });
|
|
addCheck(checks, "frontend:mobile-content-top-aligned", mobileContentMetrics.pageTop <= 190 && mobileContentMetrics.emptyTextOffset <= 14, { mobileContentMetrics });
|
|
addCheck(checks, "frontend:pending-task-drilldown", pendingTaskText.includes("待处理任务") && (pendingTaskText.includes("当前无待处理任务") || (pendingTaskText.includes("Provider") && pendingTaskText.includes("已等待"))), { pendingTaskPreview: pendingTaskText.slice(0, 600) });
|
|
addCheck(checks, "frontend:task-history-diagnostics", taskHistoryText.includes("任务耗时") && taskHistoryText.includes("诊断信息") && taskHistoryText.includes("失败原因") && taskHistoryText.includes("e2e forced failure for diagnostics"), { taskHistoryPreview: taskHistoryText.slice(0, 900) });
|
|
addCheck(checks, "frontend:no-naked-json-before-click", rawBlocksBefore === 0 && !nakedJsonText, { rawBlocksBefore, nakedJsonText });
|
|
addCheck(checks, "frontend:raw-json-explicit-button", rawText.includes('"providerId"') && rawText.includes(config.providerGateway.id), { rawTextPreview: rawText.slice(0, 400) });
|
|
addCheck(checks, "frontend:system-monitor-visible", monitorText.includes("任务管理器视图") && monitorText.includes("CPU") && monitorText.includes("Memory") && monitorText.includes("Disk") && monitorText.includes("不含缓存"), { monitorTextPreview: monitorText.slice(0, 800) });
|
|
addCheck(checks, "frontend:upgrade-plan-dispatch", upgradeControlText.includes("预检升级 已下发"), { providerId: config.providerGateway.id, upgradeControlPreview: upgradeControlText.slice(0, 500) });
|
|
addCheck(checks, "frontend:docker-status-visible", dockerText.toLowerCase().includes("docker desktop 视图") && dockerText.toLowerCase().includes("containers") && dockerText.includes("unidesk_pgdata_10gb") && (dockerText.includes("unidesk-frontend") || dockerText.includes("unidesk-backend-core")), { dockerTextPreview: dockerText.slice(0, 800) });
|
|
addCheck(checks, "frontend:no-console-errors", consoleErrors.length === 0, { consoleErrors });
|
|
return { screenshotPath, bodyText, consoleErrors };
|
|
} finally {
|
|
await browser.close();
|
|
}
|
|
}
|
|
|
|
export async function runE2E(config: UniDeskConfig): Promise<unknown> {
|
|
const checks: E2ECheck[] = [];
|
|
const urls = publicUrls(config);
|
|
await exposureChecks(config, urls, checks);
|
|
await serviceChecks(config, urls, checks);
|
|
const markerId = databaseChecks(config, checks);
|
|
const frontend = await frontendCheck(config, urls, checks);
|
|
const ok = checks.every((check) => check.status === "passed");
|
|
return {
|
|
ok,
|
|
urls,
|
|
markerId,
|
|
screenshotPath: frontend.screenshotPath,
|
|
checks,
|
|
};
|
|
}
|