937 lines
32 KiB
JavaScript
937 lines
32 KiB
JavaScript
/** Run via verify-hel767.py; explicit API fake, local-only origins, no user data. */
|
|
import fs from "node:fs/promises";
|
|
import http from "node:http";
|
|
import path from "node:path";
|
|
import { pathToFileURL } from "node:url";
|
|
const { chromium } = await import(
|
|
process.env.PLAYWRIGHT_MODULE || "playwright"
|
|
);
|
|
const out = process.env.HEL767_OUT,
|
|
data = process.env.HEL767_DATA;
|
|
const fixture = JSON.parse(
|
|
await fs.readFile(path.join(data, "fixtures.json"), "utf8"),
|
|
);
|
|
let jobs = structuredClone(fixture.jobs),
|
|
apiError = false,
|
|
imageFixture;
|
|
const result = {
|
|
checks: [],
|
|
measurements: [],
|
|
errors: [],
|
|
mutations: [],
|
|
externalBlocked: [],
|
|
apiReads: [],
|
|
};
|
|
const check = (v, n) => {
|
|
result.checks.push({ name: n, pass: !!v });
|
|
if (!v) throw Error(n);
|
|
};
|
|
const server = http.createServer(async (req, res) => {
|
|
try {
|
|
const p = new URL(req.url, "http://local").pathname;
|
|
let f = path.join("calliope-web/build", decodeURIComponent(p));
|
|
if (!path.extname(f)) f = path.join("calliope-web/build", "index.html");
|
|
const bytes = await fs.readFile(f);
|
|
res.setHeader(
|
|
"Content-Type",
|
|
f.endsWith(".js")
|
|
? "text/javascript"
|
|
: f.endsWith(".css")
|
|
? "text/css"
|
|
: f.endsWith(".html")
|
|
? "text/html"
|
|
: "application/octet-stream",
|
|
);
|
|
res.end(bytes);
|
|
} catch {
|
|
res.writeHead(404);
|
|
res.end();
|
|
}
|
|
});
|
|
await new Promise((r) => server.listen(0, "127.0.0.1", r));
|
|
const base = `http://127.0.0.1:${server.address().port}`;
|
|
const browser = await chromium.launch({
|
|
headless: true,
|
|
args: ["--no-sandbox"],
|
|
});
|
|
try {
|
|
const context = await browser.newContext({
|
|
viewport: { width: 1440, height: 900 },
|
|
timezoneId: "Asia/Shanghai",
|
|
recordVideo: {
|
|
dir: path.join(out, "recordings"),
|
|
size: { width: 1440, height: 900 },
|
|
},
|
|
});
|
|
await context.addInitScript(() => {
|
|
localStorage.setItem("aigc-lang", "zh");
|
|
localStorage.setItem("aigc-reduce-motion", "1");
|
|
window.__sse = [];
|
|
window.EventSource = class {
|
|
constructor() {
|
|
window.__sse.push(this);
|
|
setTimeout(() => this.onopen?.(), 0);
|
|
}
|
|
addEventListener(t, f) {
|
|
(this.handlers ??= {})[t] = f;
|
|
}
|
|
close() {}
|
|
};
|
|
});
|
|
await context.route("**/*", async (route) => {
|
|
const req = route.request(),
|
|
u = new URL(req.url());
|
|
if (["data:", "blob:", "file:"].includes(u.protocol))
|
|
return route.continue();
|
|
if (u.origin !== base) {
|
|
result.externalBlocked.push(u.origin);
|
|
return route.abort();
|
|
}
|
|
if (!u.pathname.startsWith("/api/")) return route.continue();
|
|
const json = (body) => route.fulfill({ json: body });
|
|
if (u.pathname === "/api/file") {
|
|
if (u.searchParams.get("path")?.endsWith(".mp4")) {
|
|
const bytes = await fs.readFile(path.join(data, "video.mp4"));
|
|
const range = req.headers()["range"]?.match(/bytes=(\d+)-(\d*)/);
|
|
if (range) {
|
|
const start = +range[1],
|
|
end = range[2]
|
|
? Math.min(+range[2], bytes.length - 1)
|
|
: bytes.length - 1;
|
|
return route.fulfill({
|
|
status: 206,
|
|
body: bytes.subarray(start, end + 1),
|
|
contentType: "video/mp4",
|
|
headers: {
|
|
"Accept-Ranges": "bytes",
|
|
"Content-Range": `bytes ${start}-${end}/${bytes.length}`,
|
|
"Content-Length": String(end - start + 1),
|
|
},
|
|
});
|
|
}
|
|
return route.fulfill({
|
|
body: bytes,
|
|
contentType: "video/mp4",
|
|
headers: {
|
|
"Accept-Ranges": "bytes",
|
|
"Content-Length": String(bytes.length),
|
|
},
|
|
});
|
|
}
|
|
return route.fulfill({
|
|
body:
|
|
imageFixture ||
|
|
Buffer.from(
|
|
"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+jR1kAAAAASUVORK5CYII=",
|
|
"base64",
|
|
),
|
|
contentType: "image/png",
|
|
});
|
|
}
|
|
const session = {
|
|
id: 767,
|
|
title: "HEL767 isolated session",
|
|
project_id: null,
|
|
origin: u.searchParams.get("origin") === "scene" ? "scene" : "chat",
|
|
messages: [],
|
|
plan: null,
|
|
running: false,
|
|
};
|
|
const graph = {
|
|
canvas: {
|
|
id: 767,
|
|
title: "HEL767 isolated canvas",
|
|
project_id: null,
|
|
agent_session_id: 767,
|
|
viewport_json: null,
|
|
},
|
|
nodes: [],
|
|
edges: [],
|
|
};
|
|
if (u.pathname === "/api/agent/sessions" && req.method() === "GET")
|
|
return json([session]);
|
|
if (u.pathname === "/api/agent/sessions/767") return json(session);
|
|
if (u.pathname === "/api/canvas" && req.method() === "POST") {
|
|
result.mutations.push({
|
|
path: u.pathname,
|
|
method: "POST",
|
|
purpose: "isolated canvas ensure only",
|
|
});
|
|
return json(graph);
|
|
}
|
|
if (u.pathname === "/api/canvas/767") return json(graph);
|
|
if (u.pathname === "/api/shots/by-session/767")
|
|
return json({
|
|
id: 767,
|
|
title: "HEL767 isolated composition",
|
|
scene: { objects: [], cameraTrack: [] },
|
|
});
|
|
if (u.pathname === "/api/shots/767/captures") return json([]);
|
|
if (u.pathname === "/api/shots") return json([]);
|
|
if (
|
|
u.pathname === "/api/agent/projects" ||
|
|
u.pathname === "/api/agent/skills"
|
|
)
|
|
return json([]);
|
|
if (u.pathname === "/api/agent/sessions" && req.method() === "POST")
|
|
return json(session);
|
|
if (req.method() !== "GET") {
|
|
result.mutations.push({ path: u.pathname, method: req.method() });
|
|
const m = u.pathname.match(/^\/api\/jobs\/(\d+)\/(cancel|retry)$/);
|
|
if (m) {
|
|
const j = jobs.find((j) => j.id === +m[1]);
|
|
j.status = m[2] === "cancel" ? "failed" : "pending";
|
|
j.error = m[2] === "cancel" ? "cancelled" : null;
|
|
return json(j);
|
|
}
|
|
const d = u.pathname.match(/^\/api\/playground\/jobs\/(\d+)$/);
|
|
if (d && req.method() === "DELETE") {
|
|
jobs = jobs.filter((j) => j.id !== +d[1]);
|
|
return json({ ok: true });
|
|
}
|
|
if (u.pathname.includes("test")) return json({ ok: true });
|
|
result.errors.push(`Unexpected mutation ${req.method()} ${u.pathname}`);
|
|
return route.fulfill({
|
|
status: 503,
|
|
body: "Unlisted fixture mutation blocked",
|
|
});
|
|
}
|
|
result.apiReads.push(u.pathname);
|
|
if (u.pathname === "/api/jobs") {
|
|
if (apiError)
|
|
return route.fulfill({ status: 500, body: "HEL767 isolated error" });
|
|
return json(jobs);
|
|
}
|
|
if (u.pathname === "/api/workflows") return json(fixture.workflows);
|
|
if (u.pathname === "/api/projects")
|
|
return json([{ id: 1, title: "雾港来信" }]);
|
|
if (u.pathname === "/api/settings")
|
|
return json({
|
|
comfyui_endpoints: [],
|
|
llm_profiles: [],
|
|
queue_concurrency: 2,
|
|
queue_poll_timeout_sec: 1800,
|
|
queue_poll_interval_sec: 1,
|
|
queue_max_retries: 1,
|
|
data_dir: "HEL767-isolated-fixture",
|
|
dry_run: false,
|
|
});
|
|
if (u.pathname === "/api/comfyui/endpoints")
|
|
return json({ endpoints: [], active_id: null });
|
|
if (u.pathname.includes("/jobs")) return json([]);
|
|
if (u.pathname.includes("/sessions")) return json([]);
|
|
if (
|
|
u.pathname === "/api/library/media" ||
|
|
u.pathname === "/api/agent/agents" ||
|
|
u.pathname === "/api/agent/memories"
|
|
)
|
|
return json([]);
|
|
const wf = u.pathname.match(/^\/api\/workflows\/(\d+)$/);
|
|
if (wf)
|
|
return json({
|
|
...fixture.workflows.find((w) => w.id === +wf[1]),
|
|
workflow_json: {},
|
|
output_map: [
|
|
{
|
|
nodeId: "2",
|
|
kind: fixture.workflows.find((w) => w.id === +wf[1]).kind,
|
|
},
|
|
],
|
|
});
|
|
return json({});
|
|
});
|
|
const page = await context.newPage();
|
|
page.on("pageerror", (e) => result.errors.push(e.message));
|
|
const ref = await context.newPage();
|
|
await ref.goto(
|
|
pathToFileURL(path.resolve("../attachments/夜片场-多主题交互样本.html"))
|
|
.href,
|
|
);
|
|
await ref.evaluate(() => {
|
|
go("tasks");
|
|
document.documentElement.classList.add("capture", "reduce");
|
|
});
|
|
// Reuse the corresponding original synthetic still only inside this API fake.
|
|
// Canvas avoids capturing a parent page during its opacity entrance animation.
|
|
imageFixture = Buffer.from(
|
|
await ref.evaluate(async () => {
|
|
const img = new Image();
|
|
img.src = still(64, 96, 64);
|
|
await img.decode();
|
|
const canvas = document.createElement("canvas");
|
|
canvas.width = 48;
|
|
canvas.height = 32;
|
|
canvas.getContext("2d").drawImage(img, 0, 0, 48, 32);
|
|
return canvas.toDataURL("image/png").split(",")[1];
|
|
}),
|
|
"base64",
|
|
);
|
|
const progress = () =>
|
|
page.evaluate(() => {
|
|
for (const es of window.__sse)
|
|
for (const [id, pct] of [
|
|
[1, 62],
|
|
[2, 35],
|
|
])
|
|
es.handlers?.["job.progress"]?.({
|
|
data: JSON.stringify({
|
|
type: "job.progress",
|
|
data: { job_id: id, progress: pct, phase: "comfy_running" },
|
|
}),
|
|
});
|
|
});
|
|
const measure = (p, selectors) =>
|
|
p.evaluate(
|
|
(selectors) =>
|
|
Object.fromEntries(
|
|
Object.entries(selectors).map(([k, s]) => {
|
|
const e = document.querySelector(s);
|
|
if (!e) return [k, null];
|
|
const r = e.getBoundingClientRect(),
|
|
c = getComputedStyle(e);
|
|
return [
|
|
k,
|
|
{
|
|
x: r.x,
|
|
y: r.y,
|
|
width: r.width,
|
|
height: r.height,
|
|
font: c.fontSize,
|
|
line: c.lineHeight,
|
|
weight: c.fontWeight,
|
|
shadow: c.boxShadow,
|
|
svg: e.matches("svg") ? e.innerHTML : undefined,
|
|
radius: c.borderRadius,
|
|
color: c.color,
|
|
background: c.backgroundColor,
|
|
},
|
|
];
|
|
}),
|
|
),
|
|
selectors,
|
|
);
|
|
for (const [width, height] of process.env.HEL767_SKIP_VISUAL
|
|
? []
|
|
: [
|
|
[1440, 900],
|
|
[1366, 768],
|
|
[1280, 720],
|
|
])
|
|
for (const theme of ["night", "day", "grade", "bluehour"])
|
|
for (const [route, sample] of [
|
|
["workflows", "workflows"],
|
|
["connections", "models"],
|
|
["tasks", "tasks"],
|
|
["library", "library"],
|
|
["settings", "settings"],
|
|
]) {
|
|
await page.setViewportSize({ width, height });
|
|
await ref.setViewportSize({ width, height });
|
|
await page.goto(base + "/" + route);
|
|
await page.locator(".management-header").waitFor();
|
|
if (route === "tasks") {
|
|
await page.locator(".task-table tbody tr").first().waitFor();
|
|
await progress();
|
|
}
|
|
if (route === "settings")
|
|
await page.locator(".choices.tiles").waitFor();
|
|
await page.evaluate((theme) => {
|
|
localStorage.setItem("aigc-theme", theme);
|
|
window.dispatchEvent(
|
|
new StorageEvent("storage", { key: "aigc-theme", newValue: theme }),
|
|
);
|
|
}, theme);
|
|
await ref.evaluate(
|
|
({ sample, theme }) => {
|
|
go(sample);
|
|
setTheme(theme);
|
|
},
|
|
{ sample, theme },
|
|
);
|
|
await page.waitForTimeout(650);
|
|
const name = `${route}-${theme}-${width}`;
|
|
const actualSelectors = {
|
|
header: ".management-header",
|
|
brand: ".refract-shell > .sidebar .brand",
|
|
divider: ".refract-shell > .sidebar hr",
|
|
foot: ".sidebar-bottom",
|
|
queue: ".queue-dot",
|
|
theme: ".sidebar-bottom button",
|
|
settings: '.sidebar-bottom a[href="/settings"]',
|
|
themeCard: ".tiles .choice",
|
|
themePreview: ".tiles .preview",
|
|
themeName: ".tiles .copy strong",
|
|
themeTone: ".tiles .copy small",
|
|
};
|
|
const sampleSelectors = {
|
|
header: `#p-${sample} .ph`,
|
|
brand: ".rail .brand",
|
|
divider: ".rail hr",
|
|
foot: ".rail .foot",
|
|
queue: ".rail .queue-dot",
|
|
theme: "#themeBtn",
|
|
settings: '.rail [data-go="settings"]',
|
|
themeCard: ".ttile",
|
|
themePreview: ".ttile .tprev",
|
|
themeName: ".ttile b",
|
|
themeTone: ".ttile small",
|
|
};
|
|
for (let i = 0; i < 9; i++) {
|
|
actualSelectors[`nav${i}`] =
|
|
`.refract-shell > .sidebar nav a:nth-child(${i < 6 ? i + 1 : i - 5})`;
|
|
if (i >= 6)
|
|
actualSelectors[`nav${i}`] =
|
|
`.refract-shell > .sidebar .management a:nth-child(${i - 5})`;
|
|
sampleSelectors[`nav${i}`] = `.rail > .nav:nth-of-type(${i + 1})`;
|
|
}
|
|
if (route === "settings")
|
|
for (let i = 1; i <= 4; i++)
|
|
for (const [key, a, b] of [
|
|
["Card", ".choice", ".ttile"],
|
|
["Preview", ".preview", ".tprev"],
|
|
["Name", ".copy strong", "b"],
|
|
["Tone", ".copy small", "small"],
|
|
]) {
|
|
actualSelectors[`theme${key}${i}`] =
|
|
key === "Card"
|
|
? `.tiles .choice:nth-child(${i})`
|
|
: `.tiles .choice:nth-child(${i}) ${a}`;
|
|
sampleSelectors[`theme${key}${i}`] =
|
|
key === "Card"
|
|
? `.ttile:nth-child(${i})`
|
|
: `.ttile:nth-child(${i}) ${b}`;
|
|
}
|
|
if (route !== "settings")
|
|
for (const key of [
|
|
"themeCard",
|
|
"themePreview",
|
|
"themeName",
|
|
"themeTone",
|
|
]) {
|
|
delete actualSelectors[key];
|
|
delete sampleSelectors[key];
|
|
}
|
|
if (route === "tasks") {
|
|
Object.assign(actualSelectors, {
|
|
table: ".task-table",
|
|
head: ".task-table thead",
|
|
row: ".task-table tbody tr",
|
|
thumbnail: ".task-thumbnail",
|
|
segment: ".task-tabs",
|
|
search: ".task-search",
|
|
progress: ".task-progress",
|
|
});
|
|
Object.assign(sampleSelectors, {
|
|
table: "#p-tasks .tbl",
|
|
head: "#p-tasks thead",
|
|
row: "#taskTable tr",
|
|
thumbnail: "#taskTable td>div",
|
|
segment: "#p-tasks .seg",
|
|
search: "#p-tasks .input",
|
|
progress: "#taskTable .bar",
|
|
});
|
|
}
|
|
const railState = (p, actual) =>
|
|
p.evaluate((actual) => {
|
|
const selectors = actual
|
|
? [
|
|
".refract-shell > .sidebar nav a",
|
|
'.sidebar-bottom a[href="/settings"]',
|
|
".sidebar-bottom button:last-of-type",
|
|
]
|
|
: [
|
|
".rail > .nav",
|
|
'.rail [data-go="settings"]',
|
|
'.rail [data-go="spec"]',
|
|
];
|
|
const nodes = [
|
|
...document.querySelectorAll(selectors[0]),
|
|
...selectors.slice(1).map((x) => document.querySelector(x)),
|
|
];
|
|
const geometry = (svg) => {
|
|
const use = svg.querySelector("use");
|
|
const root = use
|
|
? document.querySelector(use.getAttribute("href"))
|
|
: svg;
|
|
return [...root.children].map((n) => [
|
|
n.tagName,
|
|
[...n.attributes].map((a) => [a.name, a.value]).sort(),
|
|
]);
|
|
};
|
|
const selected = nodes.find((n) =>
|
|
actual
|
|
? n.getAttribute("aria-current") === "page"
|
|
: n.classList.contains("on"),
|
|
);
|
|
const pseudo = selected
|
|
? getComputedStyle(selected, "::before")
|
|
: null;
|
|
return {
|
|
icons: nodes
|
|
.filter((n) => n?.querySelector("svg"))
|
|
.map((n) => {
|
|
const svg = n.querySelector("svg"),
|
|
c = getComputedStyle(svg);
|
|
return {
|
|
geometry: geometry(svg),
|
|
width: c.width,
|
|
height: c.height,
|
|
stroke: c.strokeWidth,
|
|
color: c.color,
|
|
};
|
|
}),
|
|
selected: pseudo
|
|
? Object.fromEntries(
|
|
[
|
|
"left",
|
|
"top",
|
|
"bottom",
|
|
"width",
|
|
"borderRadius",
|
|
"backgroundColor",
|
|
"boxShadow",
|
|
].map((k) => [k, pseudo[k]]),
|
|
)
|
|
: null,
|
|
};
|
|
}, actual);
|
|
const railActual = await railState(page, true),
|
|
railSample = await railState(ref, false);
|
|
result.railProbe = { railActual, railSample };
|
|
check(
|
|
JSON.stringify(railActual) === JSON.stringify(railSample),
|
|
`${name}: rail icon paths, sizes, strokes, colors and selected indicator match`,
|
|
);
|
|
const measured = {
|
|
route,
|
|
theme,
|
|
width,
|
|
height,
|
|
railActual,
|
|
railSample,
|
|
actual: await measure(page, actualSelectors),
|
|
sample: await measure(ref, sampleSelectors),
|
|
};
|
|
result.measurements.push(measured);
|
|
await page.screenshot({ path: path.join(out, name + "-actual.png") });
|
|
await ref.screenshot({ path: path.join(out, name + "-sample.png") });
|
|
for (const key of Object.keys(sampleSelectors)) {
|
|
if (key === "progress") continue; // auto columns depend on honest source text; reported separately
|
|
for (const axis of ["x", "y", "width", "height"]) {
|
|
// Table column width distribution is data-dependent, the outer table and thumbnail dimensions are fixed.
|
|
if (key === "thumbnail" && axis === "x") continue;
|
|
check(
|
|
measured.actual[key] &&
|
|
measured.sample[key] &&
|
|
Math.abs(
|
|
measured.actual[key][axis] - measured.sample[key][axis],
|
|
) < 0.1,
|
|
`${name}: ${key} ${axis} matches sample`,
|
|
);
|
|
}
|
|
}
|
|
for (const key of [
|
|
"brand",
|
|
"queue",
|
|
"theme",
|
|
"settings",
|
|
...Array.from({ length: 9 }, (_, i) => `nav${i}`),
|
|
])
|
|
check(
|
|
measured.actual[key].radius === measured.sample[key].radius,
|
|
`${name}: ${key} radius matches sample`,
|
|
);
|
|
if (route === "settings")
|
|
for (const key of [
|
|
"themeName",
|
|
"themeTone",
|
|
...Array.from({ length: 4 }, (_, i) => `themeName${i + 1}`),
|
|
...Array.from({ length: 4 }, (_, i) => `themeTone${i + 1}`),
|
|
])
|
|
check(
|
|
measured.actual[key].line === measured.sample[key].line,
|
|
`${name}: ${key} line height`,
|
|
);
|
|
check(
|
|
await page.evaluate(
|
|
() => document.documentElement.scrollWidth <= innerWidth,
|
|
),
|
|
`${name}: no overflow`,
|
|
);
|
|
}
|
|
await page.goto(base + "/tasks");
|
|
await page.locator(".task-table tbody tr").first().waitFor();
|
|
await page.setViewportSize({ width: 1440, height: 900 });
|
|
if (process.env.HEL767_SKIP_VISUAL) {
|
|
await page.goto(base + "/tasks");
|
|
await page.locator("tbody tr").first().waitFor();
|
|
}
|
|
await page.locator(".task-tabs button").nth(1).click();
|
|
check((await page.locator("tbody tr").count()) === 3, "active filter");
|
|
await page.locator(".task-tabs button").nth(2).click();
|
|
check((await page.locator("tbody tr").count()) === 1, "failed filter");
|
|
await page.locator(".task-tabs button").nth(3).click();
|
|
check((await page.locator("tbody tr").count()) === 3, "image filter");
|
|
await page.locator(".task-tabs button").nth(4).click();
|
|
check((await page.locator("tbody tr").count()) === 3, "video filter");
|
|
await page.locator(".task-tabs button").first().click();
|
|
await page.getByRole("searchbox").fill("镜头 07");
|
|
await page.waitForTimeout(100);
|
|
check((await page.locator("tbody tr").count()) === 1, "search by task title");
|
|
await page.getByRole("searchbox").fill("HEL767 absent");
|
|
await page.waitForTimeout(100);
|
|
check((await page.locator("tbody tr").count()) === 0, "search empty");
|
|
await page.screenshot({ path: path.join(out, "search-empty.png") });
|
|
await page.getByRole("searchbox").fill("");
|
|
await page.getByRole("button", { name: "查看任务 #6", exact: true }).click();
|
|
await page.getByRole("dialog").waitFor();
|
|
const video = page.locator("video");
|
|
await video.evaluate(
|
|
(v) =>
|
|
new Promise((r) =>
|
|
v.readyState >= 1
|
|
? r()
|
|
: v.addEventListener("loadedmetadata", r, { once: true }),
|
|
),
|
|
);
|
|
check(
|
|
await video.evaluate(
|
|
(v) =>
|
|
v.paused && v.controls && !v.autoplay && !v.muted && v.volume === 1,
|
|
),
|
|
"video manual playback with sound",
|
|
);
|
|
await video.hover();
|
|
const videoBox = await video.boundingBox();
|
|
await video.click({ position: { x: 26, y: videoBox.height - 28 } });
|
|
await page.waitForTimeout(250);
|
|
check(
|
|
await video.evaluate((v) => !v.paused && v.currentTime > 0),
|
|
"explicit video play",
|
|
);
|
|
await video.evaluate((v) => {
|
|
v.pause();
|
|
v.currentTime = 0.7;
|
|
v.volume = 0.4;
|
|
});
|
|
await page.waitForTimeout(300);
|
|
result.videoState = await video.evaluate((v) => ({
|
|
paused: v.paused,
|
|
time: v.currentTime,
|
|
volume: v.volume,
|
|
duration: v.duration,
|
|
seekable: v.seekable.length,
|
|
error: v.error?.message,
|
|
}));
|
|
check(
|
|
result.videoState.paused &&
|
|
result.videoState.time > 0.6 &&
|
|
Math.abs(result.videoState.volume - 0.4) < 0.001,
|
|
"pause seek volume",
|
|
);
|
|
await page.screenshot({ path: path.join(out, "video-preview.png") });
|
|
await page.keyboard.press("Tab");
|
|
check(
|
|
await page
|
|
.getByRole("dialog")
|
|
.evaluate((e) => e.contains(document.activeElement)),
|
|
"modal focus stays inside",
|
|
);
|
|
await page.getByRole("dialog").locator(".modal-close").focus();
|
|
await page.keyboard.press("Escape");
|
|
await page.getByRole("dialog").waitFor({ state: "hidden" });
|
|
check((await page.locator("video").count()) === 0, "close unmounts video");
|
|
check(
|
|
await page
|
|
.getByRole("button", { name: "查看任务 #6", exact: true })
|
|
.evaluate((e) => e === document.activeElement),
|
|
"modal restores trigger focus",
|
|
);
|
|
await page.getByRole("button", { name: "查看任务 #5", exact: true }).click();
|
|
await page.getByRole("dialog").waitFor();
|
|
check(
|
|
(await page.getByRole("dialog").locator("img").count()) === 1,
|
|
"image preview",
|
|
);
|
|
const [download] = await Promise.all([
|
|
page.waitForEvent("download"),
|
|
page.getByRole("link", { name: "下载", exact: true }).click(),
|
|
]);
|
|
check(!(await download.failure()), "native image download");
|
|
await download.saveAs(path.join(out, "downloaded-fixture.png"));
|
|
await page.getByRole("button", { name: "删除", exact: true }).click();
|
|
check(
|
|
(await page.locator("tbody tr").count()) === 5,
|
|
"delete removes row immediately",
|
|
);
|
|
await page.getByRole("button", { name: "撤销", exact: true }).click();
|
|
check((await page.locator("tbody tr").count()) === 6, "undo restores row");
|
|
check(
|
|
!result.mutations.some((m) => m.method === "DELETE"),
|
|
"undo prevents DELETE",
|
|
);
|
|
await page.getByRole("button", { name: "查看任务 #5", exact: true }).click();
|
|
await page.getByRole("button", { name: "删除", exact: true }).click();
|
|
await page.waitForTimeout(5300);
|
|
check(
|
|
result.mutations.some((m) => m.method === "DELETE"),
|
|
"delete commits after undo window",
|
|
);
|
|
await page
|
|
.locator("tbody tr")
|
|
.filter({ hasText: "参考生视频 #21" })
|
|
.getByRole("button", { name: "重试", exact: true })
|
|
.click();
|
|
await page.waitForTimeout(150);
|
|
check(
|
|
jobs.find((j) => j.id === 4).status === "pending",
|
|
"retry uses real API contract",
|
|
);
|
|
await page
|
|
.locator("tbody tr")
|
|
.filter({ hasText: "Qwen 局部重绘" })
|
|
.getByRole("button", { name: "取消", exact: true })
|
|
.click();
|
|
await page.waitForTimeout(150);
|
|
check(
|
|
jobs.find((j) => j.id === 3).error === "cancelled",
|
|
"cancel uses real API contract",
|
|
);
|
|
await page.getByRole("button", { name: "查看任务 #1", exact: true }).click();
|
|
await page.getByRole("button", { name: "创作台", exact: true }).click();
|
|
check(
|
|
(await page.locator("tbody tr").count()) === 2,
|
|
"source filter retained in details",
|
|
);
|
|
await page.getByRole("button", { name: "全部来源", exact: true }).click();
|
|
const testJob = {
|
|
...structuredClone(fixture.jobs[4]),
|
|
id: 8,
|
|
origin: "workflow_test",
|
|
payload: { source: "workflow_test", title: "HEL767 workflow test" },
|
|
output_paths: ["HEL767-fixture-4.png"],
|
|
};
|
|
jobs.push(testJob);
|
|
await page.goto(base + "/tasks");
|
|
await page.getByRole("button", { name: "查看任务 #8", exact: true }).click();
|
|
await page.getByRole("button", { name: "工作流试跑", exact: true }).click();
|
|
check(
|
|
(await page.locator("tbody tr").count()) === 1,
|
|
"workflow test source isolated",
|
|
);
|
|
await page.getByRole("button", { name: "全部来源", exact: true }).click();
|
|
// Pending/running without a numeric report must remain unknown.
|
|
await page.goto(base + "/tasks");
|
|
await page.locator("tbody tr").first().waitFor();
|
|
check(
|
|
(await page.locator(".task-progress").count()) === 0,
|
|
"no fabricated percentages after reload",
|
|
);
|
|
jobs = [];
|
|
await page.goto(base + "/tasks");
|
|
await page.waitForTimeout(400);
|
|
check((await page.locator("tbody tr").count()) === 0, "true empty data");
|
|
await page.screenshot({ path: path.join(out, "true-empty.png") });
|
|
apiError = true;
|
|
await page.goto(base + "/tasks");
|
|
await page
|
|
.getByRole("alert")
|
|
.filter({ hasText: "任务加载失败" })
|
|
.waitFor({ timeout: 15000 });
|
|
check(true, "API failure shown honestly");
|
|
apiError = false;
|
|
jobs = structuredClone(fixture.jobs);
|
|
await page.getByRole("button", { name: "重试", exact: true }).click();
|
|
await page.locator("tbody tr").first().waitFor();
|
|
check(true, "load retry restores tasks");
|
|
for (const route of [
|
|
"workflows",
|
|
"connections",
|
|
"library",
|
|
"settings",
|
|
"create?kind=image",
|
|
"create?kind=video",
|
|
]) {
|
|
await page.goto(base + "/" + route);
|
|
await page.waitForTimeout(400);
|
|
await page.screenshot({
|
|
path: path.join(out, "regression-" + route.replace(/\W/g, "-") + ".png"),
|
|
});
|
|
check(
|
|
(await page.locator(".task-table").count()) === 0,
|
|
`${route}: task table styles scoped`,
|
|
);
|
|
if (route.startsWith("create?")) {
|
|
const textarea = page.locator(".studio-form textarea").first();
|
|
await textarea.fill("HEL767 isolated creative draft");
|
|
check(
|
|
(await textarea.inputValue()) === "HEL767 isolated creative draft",
|
|
`${route}: prompt remains editable`,
|
|
);
|
|
await page.reload();
|
|
await page.locator(".studio-form textarea").first().waitFor();
|
|
check(
|
|
(await page.locator(".studio-form textarea").first().inputValue()) ===
|
|
"HEL767 isolated creative draft",
|
|
`${route}: draft survives reload`,
|
|
);
|
|
}
|
|
if (route === "workflows")
|
|
check(
|
|
(await page
|
|
.locator(".mg-side")
|
|
.evaluate((e) => e.getBoundingClientRect().width)) === 220,
|
|
"workflow sidebar retains 220px",
|
|
);
|
|
}
|
|
for (const route of [
|
|
"/",
|
|
"/workbench",
|
|
"/agents",
|
|
"/canvas",
|
|
"/build-scene",
|
|
"/models",
|
|
"/model-connections",
|
|
"/image",
|
|
"/video",
|
|
]) {
|
|
await page.goto(base + route);
|
|
await page.locator(".refract-shell > .sidebar").waitFor({ timeout: 15000 });
|
|
await page.waitForTimeout(350);
|
|
check(
|
|
(await page.locator(".refract-shell > .sidebar").count()) === 1,
|
|
`${route}: shared rail reachable`,
|
|
);
|
|
if (route === "/models")
|
|
check(
|
|
page.url().includes("/connections?tab=llm"),
|
|
"legacy models redirect",
|
|
);
|
|
if (route === "/model-connections")
|
|
check(page.url().includes("/connections"), "connections alias redirect");
|
|
}
|
|
await page.goto(base + "/create?kind=image");
|
|
await page.locator(".studio-form textarea").first().waitFor();
|
|
check(
|
|
(await page.locator(".studio-form input[type=file]").count()) === 0,
|
|
"t2i without image input keeps no padding slot",
|
|
);
|
|
await page.keyboard.press("Control+k");
|
|
await page.getByRole("dialog").waitFor();
|
|
check(true, "Ctrl+K opens global search");
|
|
await page.keyboard.press("Escape");
|
|
await page.getByRole("dialog").waitFor({ state: "hidden" });
|
|
await page.goto(base + "/tasks");
|
|
await page.locator(".task-table tbody tr").first().waitFor();
|
|
await ref.setViewportSize({ width: 1440, height: 900 });
|
|
for (const theme of ["night", "day", "grade", "bluehour"]) {
|
|
await page.evaluate((theme) => {
|
|
localStorage.setItem("aigc-theme", theme);
|
|
window.dispatchEvent(
|
|
new StorageEvent("storage", { key: "aigc-theme", newValue: theme }),
|
|
);
|
|
}, theme);
|
|
await ref.evaluate((theme) => {
|
|
go("tasks");
|
|
setTheme(theme);
|
|
}, theme);
|
|
await page.waitForTimeout(650);
|
|
await page
|
|
.locator('.refract-shell > .sidebar a[href="/workflows"]')
|
|
.hover();
|
|
await ref.locator('.rail [data-go="workflows"]').hover();
|
|
await page.waitForTimeout(250);
|
|
result.checks.push({
|
|
name: `${theme}: rail hover`,
|
|
pass: true,
|
|
actual: await measure(page, {
|
|
hover: '.refract-shell > .sidebar a[href="/workflows"]',
|
|
}),
|
|
sample: await measure(ref, { hover: '.rail [data-go="workflows"]' }),
|
|
});
|
|
const hover = result.checks.at(-1);
|
|
for (const prop of ["color", "background", "radius"])
|
|
check(
|
|
hover.actual.hover[prop] === hover.sample.hover[prop],
|
|
`${theme}: hover ${prop} matches sample`,
|
|
);
|
|
await page.screenshot({
|
|
path: path.join(out, `hover-${theme}-actual.png`),
|
|
});
|
|
await ref.screenshot({ path: path.join(out, `hover-${theme}-sample.png`) });
|
|
}
|
|
await page.locator('.sidebar-bottom button[title="主题"]').click();
|
|
await page.getByRole("dialog").waitFor();
|
|
const firstChoice = page.getByRole("dialog").locator(".choice").first();
|
|
await firstChoice.focus();
|
|
await page.keyboard.press("ArrowRight");
|
|
await page.keyboard.press("Enter");
|
|
check(
|
|
(await page.evaluate(() => document.documentElement.dataset.theme)) ===
|
|
"day",
|
|
"theme keyboard selection",
|
|
);
|
|
await page.keyboard.press("Escape");
|
|
await page.getByRole("dialog").waitFor({ state: "hidden" });
|
|
check(
|
|
await page
|
|
.locator('.sidebar-bottom button[title="主题"]')
|
|
.evaluate((e) => e === document.activeElement),
|
|
"theme dialog restores focus",
|
|
);
|
|
await page.locator('button[title="展开导航"]').click();
|
|
check(
|
|
(await page.locator(".refract-shell.expanded").count()) === 1,
|
|
"existing navigation expansion retained",
|
|
);
|
|
await page.locator('button[title="收起导航"]').click();
|
|
await page.goto(base + "/tasks");
|
|
await page.locator('.sidebar-bottom button[title="主题"]').click();
|
|
await page.getByRole("dialog").waitFor();
|
|
await page.getByRole("dialog").getByRole("switch").click();
|
|
await page.getByRole("dialog").locator(".choice").nth(3).click();
|
|
await page.waitForFunction(
|
|
() => document.documentElement.dataset.theme === "bluehour",
|
|
);
|
|
await page.waitForTimeout(50);
|
|
result.themeTransition = await page.evaluate(() => ({
|
|
theme: document.documentElement.dataset.theme,
|
|
animations: document.getAnimations().map((a) => ({
|
|
name: a.animationName,
|
|
duration: a.effect?.getTiming().duration,
|
|
})),
|
|
reduced: document.documentElement.dataset.reduce,
|
|
}));
|
|
check(
|
|
result.themeTransition.theme === "bluehour",
|
|
"full-motion theme switch applies",
|
|
);
|
|
await page.waitForTimeout(650);
|
|
check(
|
|
(await page.locator(".queue-ring").count()) === 1,
|
|
"real running jobs restore original queue ring in full motion",
|
|
);
|
|
await page.getByRole("dialog").getByRole("switch").click();
|
|
check(
|
|
(await page.locator(".queue-ring").count()) === 0,
|
|
"reduced motion removes queue ring",
|
|
);
|
|
await page.keyboard.press("Escape");
|
|
check(result.errors.length === 0, "no browser page errors");
|
|
const recordings = [await page.video().path(), await ref.video().path()];
|
|
await context.close();
|
|
result.recordings = recordings.map((p) => path.relative(out, p));
|
|
} finally {
|
|
await fs.writeFile(
|
|
path.join(
|
|
out,
|
|
process.env.HEL767_SKIP_VISUAL
|
|
? "interaction-results.json"
|
|
: "results.json",
|
|
),
|
|
JSON.stringify(result, null, 2),
|
|
);
|
|
await browser.close();
|
|
await new Promise((r) => server.close(r));
|
|
}
|