// Actual app/API wrapper with local synthetic responses only. import assert from "node:assert/strict"; import { createServer } from "vite"; import { chromium } from "playwright"; const server = await createServer({ server: { host: "127.0.0.1", port: 5198, strictPort: true } }); await server.listen(); const base = server.resolvedUrls.local[0]; const browser = await chromium.launch({ executablePath: process.env.BROWSER_PATH || "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge", headless: true, args: ["--no-proxy-server"], }); const deferred = () => { let resolve; const promise = new Promise((r) => (resolve = r)); return { promise, resolve }; }; async function fixture(role, { holdProject = false, failLegacy = false } = {}) { const ctx = await browser.newContext({ viewport: { width: 1600, height: 1000 } }); const page = await ctx.newPage(); page.setDefaultTimeout(30000); const held = deferred(), reports = deferred(); const calls = [], errors = []; const user = { id: "reviewer", role, status: "active", organizationId: "org", name: "Test reviewer" }; const project = (id) => ({ id, name: id, status: "active", organizationId: "org" }); const item = (projectId, stage) => ({ id: `${projectId}-${stage}`, organizationId: "org", pluginId: "annotation-qa", projectId, workflowId: "workflow", runId: "run", version: 1, currentRevision: 1, createdAt: stage === "acceptance" ? "2026-09-28T00:00:00Z" : "2026-09-29T00:00:00Z", currentStageId: stage, status: stage === "acceptance" ? "claimed" : "ready", assignedUserId: stage === "acceptance" ? user.id : undefined, legacyTaskId: stage === "acceptance" ? `${projectId}-legacy` : undefined, processingProfile: "raw_human", display: { projectName: projectId, captureDirectories: [`${projectId}-${stage}`] }, subject: { payload: { captureDirectory: `${projectId}-${stage}`, items: [] } }, }); page.on("pageerror", (e) => errors.push(e.message)); await ctx.route("**/*", async (route) => { const req = route.request(), url = new URL(req.url()), path = url.pathname; if (!path.startsWith("/api/") && !path.startsWith("/worker-api/")) return route.continue(); const json = (data) => route.fulfill({ json: data }); calls.push({ path, query: Object.fromEntries(url.searchParams), method: req.method() }); assert.equal(req.method(), "GET", "queue verification must not write"); if (path === "/api/auth/me") return json({ user, organization: { id: "org", name: "Synthetic" } }); if (path === "/api/plugins") return json({ items: [{ enabled: true, manifest: { id: "annotation-qa", name: "标注", version: "1" } }] }); if (path.includes("ready") || path.includes("health")) return json({ ready: true, status: "ok", buildCommit: "test" }); if (path === "/api/projects") return json({ items: [project("project-a"), project("project-b")] }); if (path.endsWith("/members") && path.startsWith("/api/projects/")) return json({ items: [{ id: "member", projectId: path.split("/")[3], userId: user.id, roles: [role] }] }); if (path.endsWith("/workflows")) return json({ items: [{ id: "workflow", name: "Workflow", nodes: [], edges: [] }] }); if (path === "/api/human-rejects" || path.endsWith("/workload-summary")) { await reports.promise; return json({ items: [], eventCount: 0 }); } if (path === "/api/plugins/annotation-qa/tasks") { const projectId = url.searchParams.get("projectId") || "project-a"; return json({ items: [ { id: `${projectId}-legacy`, projectId, organizationId: "org", workflowId: "workflow", runId: "run", templateId: "template", templateVersion: 6, currentRevision: 1, status: "pending_acceptance", humanStageId: "acceptance", assignedUserId: user.id, clipStart: 0, clipEnd: 10, }, ], }); } if (path === "/api/human-items") { const projectId = url.searchParams.get("projectId") || "project-a"; const stage = url.searchParams.get("stageId"), pool = url.searchParams.get("pool"); if (holdProject && projectId === "project-a") await held.promise; if (failLegacy && stage === "acceptance") return route.fulfill({ status: 403, json: { error: "legacy denied" } }); const items = [item(projectId, "prepackage_acceptance"), item(projectId, "acceptance")] .filter((i) => !stage || i.currentStageId === stage) .filter((i) => pool === "all" || (pool === "mine" ? i.assignedUserId === user.id : !i.assignedUserId)); return json({ items }); } return json({ items: [], labelIds: [], sliceLabelIds: [] }); }); const close = async () => { held.resolve(); reports.resolve(); await ctx.close(); }; return { page, calls, errors, held, reports, close }; } try { for (const role of ["admin", "acceptance_reviewer"]) { const f = await fixture(role); try { await f.page.goto(base + "plugins/annotation-qa/workflows/all/acceptance?projectId=project-a", { waitUntil: "domcontentloaded", }); const available = f.page.getByTestId("human-task-pool-available"); const mine = f.page.getByTestId("human-task-pool-mine"); await available.filter({ hasText: /1/ }).waitFor(); await mine.filter({ hasText: /1/ }).waitFor(); const poolCalls = () => f.calls.filter((r) => r.path === "/api/human-items"); const initial = poolCalls().length; const expected = role === "admin" ? 2 : 4; assert.equal(new Set(poolCalls().map((r) => `${r.query.pool}:${r.query.stageId}`)).size, expected); assert.ok(initial <= expected * 2, "only the initial React development StrictMode replay may duplicate requests"); assert.ok(poolCalls().every((r) => ["acceptance", "prepackage_acceptance"].includes(r.query.stageId))); assert.ok(poolCalls().every((r) => (role === "admin" ? r.query.pool === "all" : r.query.pool !== "all"))); assert.equal( f.calls.filter((r) => r.path === "/api/human-rejects" || r.path.endsWith("/workload-summary")).length, 0, ); await mine.click(); await f.page.locator('[data-task-id="project-a-legacy"]').waitFor(); if (role === "admin") await f.page.getByTestId("human-task-pool-all").click(); await available.click(); await f.page .locator(".annotation-task-list") .getByRole("button", { name: /project-a-prepackage_acceptance/ }) .waitFor(); await f.page.waitForTimeout(200); assert.equal(poolCalls().length, initial, "switching pools must not reload the project"); if (role === "admin") { const view = f.page.getByRole("combobox", { name: "当前工作台视图" }); await view.selectOption("workload"); await f.page.getByText("正在加载工作记录…", { exact: true }).waitFor(); assert.equal(f.calls.filter((r) => r.path.endsWith("/workload-summary")).length, 1); await view.selectOption("queue"); await available.filter({ hasText: /1/ }).waitFor(); await view.selectOption("rejects"); await f.page.waitForTimeout(100); assert.equal(f.calls.filter((r) => r.path === "/api/human-rejects").length, 1); await view.selectOption("queue"); assert.equal(poolCalls().length, initial, "slow reports do not reload or block the task pool"); } assert.deepEqual(f.errors, []); console.log("PASS", role, "scoped stages, legacy task, permissions, stable pool navigation, deferred reports"); } finally { await f.close(); } } const stale = await fixture("admin", { holdProject: true }); try { await stale.page.goto(base + "plugins/annotation-qa/workflows/all/acceptance?projectId=project-a", { waitUntil: "domcontentloaded", }); await stale.page.getByRole("combobox", { name: "1. 项目", exact: true }).selectOption("project-b"); await stale.page.getByTestId("human-task-pool-available").filter({ hasText: /1/ }).waitFor(); stale.held.resolve(); await stale.page.waitForTimeout(250); assert.ok( (await stale.page.locator(".annotation-task-list").innerText()).includes("project-b-prepackage_acceptance"), ); assert.ok(!(await stale.page.locator(".annotation-task-list").innerText()).includes("project-a-")); console.log("PASS stale project responses cannot overwrite current acceptance pool"); } finally { await stale.close(); } const failed = await fixture("acceptance_reviewer", { failLegacy: true }); try { await failed.page.goto(base + "plugins/annotation-qa/workflows/all/acceptance?projectId=project-a", { waitUntil: "domcontentloaded", }); await failed.page.getByRole("alert").filter({ hasText: "任务加载失败" }).waitFor(); assert.equal(await failed.page.getByRole("button", { name: "领取任务", exact: true }).count(), 0); console.log("PASS legacy stage failure is reported, not silently accepted as an empty pool"); } finally { await failed.close(); } } finally { await browser.close(); await server.close(); }