forked from longtao.wu/droboticflow
611 lines
27 KiB
JavaScript
Executable File
611 lines
27 KiB
JavaScript
Executable File
import fs from "node:fs";
|
|
import path from "node:path";
|
|
import { chromium } from "playwright";
|
|
|
|
const apiURL = String(process.env.FANYU_API_URL || "http://120.48.180.80").replace(/\/+$/, "");
|
|
const statePath = process.env.FANYU_ACCEPTANCE_STATE_PATH;
|
|
const outputDir = process.env.FANYU_ACCEPTANCE_BROWSER_OUTPUT || "/tmp/fanyu-100-browser-acceptance";
|
|
if (!statePath) throw new Error("FANYU_ACCEPTANCE_STATE_PATH is required");
|
|
|
|
const state = JSON.parse(fs.readFileSync(statePath, "utf8"));
|
|
const projectId = String(state.projectId || "").trim();
|
|
const workflowId = String(state.workflowId || "").trim();
|
|
const browserFixture = state.browserFixture;
|
|
const reportPath = path.join(outputDir, "browser-acceptance.json");
|
|
fs.mkdirSync(outputDir, { recursive: true });
|
|
|
|
const checks = [];
|
|
const screenshots = [];
|
|
const diagnostics = [];
|
|
let browser;
|
|
let fatalError = "";
|
|
|
|
function requireEnv(name) {
|
|
const value = String(process.env[name] || "").trim();
|
|
if (!value) throw new Error(`${name} is required`);
|
|
return value;
|
|
}
|
|
|
|
function required(value, label) {
|
|
const normalized = String(value || "").trim();
|
|
if (!normalized) throw new Error(`state.browserFixture.${label} is required`);
|
|
return normalized;
|
|
}
|
|
|
|
function record(name, passed, evidence = {}) {
|
|
const item = { name, passed: Boolean(passed), evidence };
|
|
checks.push(item);
|
|
if (!item.passed) throw new Error(`${name} failed: ${JSON.stringify(evidence)}`);
|
|
return item;
|
|
}
|
|
|
|
async function runCheck(name, action) {
|
|
try {
|
|
const evidence = (await action()) || {};
|
|
checks.push({ name, passed: true, evidence });
|
|
return true;
|
|
} catch (error) {
|
|
checks.push({ name, passed: false, evidence: { error: error instanceof Error ? error.message : String(error) } });
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function validateFixtureContract() {
|
|
const issues = [];
|
|
if (!projectId) issues.push("projectId");
|
|
if (!workflowId) issues.push("workflowId");
|
|
if (!browserFixture || typeof browserFixture !== "object") {
|
|
issues.push("browserFixture");
|
|
} else {
|
|
for (const stage of ["annotation", "quality", "acceptance"]) {
|
|
if (!browserFixture[stage] || typeof browserFixture[stage] !== "object") issues.push(`browserFixture.${stage}`);
|
|
}
|
|
if (!browserFixture.member || typeof browserFixture.member !== "object") issues.push("browserFixture.member");
|
|
const annotation = browserFixture.annotation || {};
|
|
const quality = browserFixture.quality || {};
|
|
const acceptance = browserFixture.acceptance || {};
|
|
const member = browserFixture.member || {};
|
|
if (!annotation.captureDirectory) issues.push("browserFixture.annotation.captureDirectory");
|
|
if (!annotation.taskId) issues.push("browserFixture.annotation.taskId");
|
|
if (!quality.captureDirectory) issues.push("browserFixture.quality.captureDirectory");
|
|
if (!quality.taskId) issues.push("browserFixture.quality.taskId");
|
|
if (!acceptance.captureDirectory) issues.push("browserFixture.acceptance.captureDirectory");
|
|
if (!acceptance.humanItemId) issues.push("browserFixture.acceptance.humanItemId");
|
|
if (!member.userId) issues.push("browserFixture.member.userId");
|
|
if (!member.email) issues.push("browserFixture.member.email");
|
|
if (member.disposable !== true) issues.push("browserFixture.member.disposable=true");
|
|
}
|
|
if (issues.length) {
|
|
throw new Error(
|
|
`browser fixture is incomplete (${issues.join(", ")}); refusing to replace real interaction acceptance with a title-only smoke test`,
|
|
);
|
|
}
|
|
}
|
|
|
|
function watchPage(page, name) {
|
|
const state = { name, consoleIssues: [], pageErrors: [], requestFailures: [], serverErrors: [] };
|
|
page.on("console", (message) => {
|
|
if (["error", "warning"].includes(message.type())) {
|
|
state.consoleIssues.push(`${message.type()}: ${message.text()}`);
|
|
}
|
|
});
|
|
page.on("pageerror", (error) => state.pageErrors.push(error.message));
|
|
page.on("requestfailed", (request) => {
|
|
const failure = request.failure()?.errorText || "failed";
|
|
if (failure === "net::ERR_ABORTED") return;
|
|
if (new URL(request.url()).origin !== apiURL) return;
|
|
state.requestFailures.push(`${request.method()} ${request.url()} ${failure}`);
|
|
});
|
|
page.on("response", (response) => {
|
|
if (response.status() >= 500 && new URL(response.url()).origin === apiURL) {
|
|
state.serverErrors.push(`${response.status()} ${response.url()}`);
|
|
}
|
|
});
|
|
diagnostics.push(state);
|
|
return state;
|
|
}
|
|
|
|
function assertDiagnosticsHealthy(state, checkpoint) {
|
|
const issues = [
|
|
...state.consoleIssues,
|
|
...state.pageErrors.map((value) => `pageerror: ${value}`),
|
|
...state.requestFailures.map((value) => `requestfailed: ${value}`),
|
|
...state.serverErrors.map((value) => `server: ${value}`),
|
|
];
|
|
if (issues.length) throw new Error(`${checkpoint} emitted browser/network errors: ${issues.join(" | ")}`);
|
|
return { console: 0, pageErrors: 0, requestFailures: 0, serverErrors: 0 };
|
|
}
|
|
|
|
async function authenticatedContext(emailName, passwordName, allowedRoles, viewport = { width: 1920, height: 1080 }) {
|
|
const email = requireEnv(emailName).toLowerCase();
|
|
const context = await browser.newContext({ baseURL: apiURL, viewport });
|
|
const response = await context.request.post("/api/auth/login", {
|
|
data: { email, password: requireEnv(passwordName) },
|
|
});
|
|
if (!response.ok()) throw new Error(`${emailName} login failed: ${response.status()}`);
|
|
const meResponse = await context.request.get("/api/auth/me");
|
|
if (!meResponse.ok()) throw new Error(`${emailName} identity lookup failed: ${meResponse.status()}`);
|
|
const session = await meResponse.json();
|
|
const actualEmail = String(session?.user?.email || "").toLowerCase();
|
|
const actualRole = String(session?.user?.role || "");
|
|
record(`identity_${emailName.toLowerCase()}`, actualEmail === email && allowedRoles.includes(actualRole), {
|
|
expectedEmail: email,
|
|
actualEmail,
|
|
allowedRoles,
|
|
actualRole,
|
|
userId: session?.user?.id,
|
|
});
|
|
return { context, session };
|
|
}
|
|
|
|
async function capture(page, name, fullPage = false) {
|
|
const file = path.join(outputDir, `${name}.png`);
|
|
await page.screenshot({ path: file, fullPage });
|
|
screenshots.push(file);
|
|
return file;
|
|
}
|
|
|
|
async function unique(locator, label) {
|
|
await locator.waitFor({ state: "visible", timeout: 30_000 });
|
|
const count = await locator.count();
|
|
if (count !== 1) throw new Error(`${label} expected exactly one element, found ${count}`);
|
|
return locator;
|
|
}
|
|
|
|
function annotationURL(route, fixture) {
|
|
const params = new URLSearchParams({
|
|
projectId,
|
|
workflowId,
|
|
capture: required(fixture.captureDirectory, `${route}.captureDirectory`),
|
|
});
|
|
if (fixture.taskId) params.set("taskId", fixture.taskId);
|
|
if (fixture.runId) params.set("runId", fixture.runId);
|
|
return `/plugins/annotation-qa/workflows/${workflowId}/${route}?${params}`;
|
|
}
|
|
|
|
async function selectPool(page, pool) {
|
|
const button = page.getByTestId(`human-task-pool-${pool}`);
|
|
if ((await button.count()) !== 1) return;
|
|
if ((await button.getAttribute("aria-pressed")) === "true") return;
|
|
const responsePromise = page.waitForResponse((response) => {
|
|
const url = new URL(response.url());
|
|
return url.pathname === "/api/human-items" && url.searchParams.get("pool") === pool;
|
|
});
|
|
await button.click();
|
|
const response = await responsePromise;
|
|
if (!response.ok()) throw new Error(`task pool ${pool} failed to load: ${response.status()}`);
|
|
}
|
|
|
|
async function locateFixturePool(page, fixture, { acceptance = false } = {}) {
|
|
const selector = acceptance
|
|
? `[data-testid="acceptance-human-item"][data-human-item-id="${required(fixture.humanItemId, "acceptance.humanItemId")}"]`
|
|
: `[data-testid="annotation-task-card"][data-task-id="${required(fixture.taskId, "taskId")}"]`;
|
|
const candidates = [...new Set([fixture.pool, "mine", "available"].filter(Boolean))];
|
|
for (const pool of candidates) {
|
|
await selectPool(page, pool);
|
|
const target = page.locator(selector);
|
|
try {
|
|
await target.waitFor({ state: "visible", timeout: 10_000 });
|
|
return pool;
|
|
} catch {
|
|
// A resumable fixture can be unclaimed on the first run and already
|
|
// claimed by the same role account on a later run.
|
|
}
|
|
}
|
|
throw new Error(`fixture is not visible in task pools ${candidates.join(", ")}`);
|
|
}
|
|
|
|
async function assertHierarchy(page, fixture, { taskRequired = true } = {}) {
|
|
const projectSelect = await unique(page.getByLabel("1. 项目", { exact: true }), "project selector");
|
|
const workflowSelect = await unique(page.getByLabel("2. 工作流", { exact: true }), "workflow selector");
|
|
const captureSelect = await unique(page.getByLabel("3. Capture 子目录", { exact: true }), "Capture selector");
|
|
const captureDirectory = required(fixture.captureDirectory, "captureDirectory");
|
|
if ((await projectSelect.inputValue()) !== projectId)
|
|
throw new Error("project selector does not hold the fixture project");
|
|
if ((await workflowSelect.inputValue()) !== workflowId)
|
|
throw new Error("workflow selector does not hold the fixture workflow");
|
|
if ((await captureSelect.inputValue()) !== captureDirectory)
|
|
throw new Error("Capture selector does not hold the fixture directory");
|
|
const url = new URL(page.url());
|
|
if (url.searchParams.get("projectId") !== projectId || url.searchParams.get("workflowId") !== workflowId) {
|
|
throw new Error(`project/workflow URL scope is wrong: ${url}`);
|
|
}
|
|
if (url.searchParams.get("capture") !== captureDirectory) throw new Error(`Capture URL scope is wrong: ${url}`);
|
|
|
|
let taskEvidence = {};
|
|
if (taskRequired) {
|
|
const taskId = required(fixture.taskId, "taskId");
|
|
const card = await unique(
|
|
page.locator(`[data-testid="annotation-task-card"][data-task-id="${taskId}"]`),
|
|
"fixture task card",
|
|
);
|
|
const displayedCapture = await card.getAttribute("data-capture-directory");
|
|
const firstLine =
|
|
String(await card.innerText())
|
|
.split("\n")
|
|
.map((value) => value.trim())
|
|
.filter(Boolean)[0] || "";
|
|
if (displayedCapture !== captureDirectory || firstLine !== captureDirectory) {
|
|
throw new Error(`task card does not lead with Capture (${displayedCapture}; ${firstLine})`);
|
|
}
|
|
taskEvidence = { taskId, displayedCapture, firstLine };
|
|
}
|
|
return { projectId, workflowId, captureDirectory, url: page.url(), ...taskEvidence };
|
|
}
|
|
|
|
async function exerciseHierarchyCascade(page, fixture) {
|
|
const captureDirectory = required(fixture.captureDirectory, "annotation.captureDirectory");
|
|
const taskId = required(fixture.taskId, "annotation.taskId");
|
|
await page.goto(`/plugins/annotation-qa/workflows/all/annotate?projectId=${encodeURIComponent(projectId)}`, {
|
|
waitUntil: "domcontentloaded",
|
|
timeout: 60_000,
|
|
});
|
|
const projectSelect = await unique(page.getByLabel("1. 项目", { exact: true }), "cascade project selector");
|
|
if ((await projectSelect.inputValue()) !== projectId) await projectSelect.selectOption(projectId);
|
|
|
|
const workflowSelect = await unique(page.getByLabel("2. 工作流", { exact: true }), "cascade workflow selector");
|
|
await workflowSelect.selectOption(workflowId, { timeout: 30_000 });
|
|
await page.waitForURL((url) => url.searchParams.get("workflowId") === workflowId, { timeout: 30_000 });
|
|
|
|
const captureSelect = await unique(page.getByLabel("3. Capture 子目录", { exact: true }), "cascade Capture selector");
|
|
let captureReady = false;
|
|
for (let attempt = 0; attempt < 60; attempt += 1) {
|
|
const options = await captureSelect.locator("option").allTextContents();
|
|
if (options.includes(captureDirectory)) {
|
|
captureReady = true;
|
|
break;
|
|
}
|
|
await page.waitForTimeout(500);
|
|
}
|
|
if (!captureReady) throw new Error(`Capture option ${captureDirectory} did not load after workflow selection`);
|
|
await captureSelect.selectOption(captureDirectory, { timeout: 30_000 });
|
|
await page.waitForURL((url) => url.searchParams.get("capture") === captureDirectory, { timeout: 30_000 });
|
|
|
|
await selectPool(page, "all");
|
|
const card = await unique(
|
|
page.locator(`[data-testid="annotation-task-card"][data-task-id="${taskId}"]`),
|
|
"cascade fixture task card",
|
|
);
|
|
await card.click();
|
|
await page.waitForURL((url) => url.searchParams.get("taskId") === taskId, { timeout: 30_000 });
|
|
return assertHierarchy(page, fixture);
|
|
}
|
|
|
|
function rectanglesOverlap(left, right) {
|
|
return (
|
|
Math.max(0, Math.min(left.right, right.right) - Math.max(left.left, right.left)) > 1 &&
|
|
Math.max(0, Math.min(left.bottom, right.bottom) - Math.max(left.top, right.top)) > 1
|
|
);
|
|
}
|
|
|
|
async function assertWorkbenchLayout(page, viewport) {
|
|
await page.setViewportSize(viewport);
|
|
const editor = await unique(page.getByTestId("annotation-workbench-editor"), "annotation editor");
|
|
await editor.scrollIntoViewIfNeeded();
|
|
const toolbarLocator = await unique(page.getByTestId("sticky-annotation-toolbar"), "annotation toolbar");
|
|
await toolbarLocator.scrollIntoViewIfNeeded();
|
|
const layout = await page.evaluate(() => {
|
|
const rect = (selector) => {
|
|
const element = document.querySelector(selector);
|
|
if (!element) return null;
|
|
const value = element.getBoundingClientRect();
|
|
return {
|
|
left: value.left,
|
|
right: value.right,
|
|
top: value.top,
|
|
bottom: value.bottom,
|
|
width: value.width,
|
|
height: value.height,
|
|
};
|
|
};
|
|
const toolbarElement = document.querySelector('[data-testid="sticky-annotation-toolbar"]');
|
|
const toolbarRect = toolbarElement?.getBoundingClientRect();
|
|
const toolbarHit = toolbarRect
|
|
? document.elementFromPoint(toolbarRect.left + toolbarRect.width / 2, toolbarRect.top + toolbarRect.height / 2)
|
|
: null;
|
|
return {
|
|
viewport: { width: window.innerWidth, height: window.innerHeight },
|
|
editor: rect('[data-testid="annotation-workbench-editor"]'),
|
|
video: rect('[data-testid="annotation-workbench-editor"] video'),
|
|
timeline: rect('[data-testid="compact-annotation-timeline"]'),
|
|
toolbar: rect('[data-testid="sticky-annotation-toolbar"]'),
|
|
actions: rect('[data-testid="annotation-sticky-actions"]'),
|
|
navigator: rect('[data-testid="slice-event-navigator"]'),
|
|
toolbarUncovered: Boolean(toolbarElement && toolbarHit && toolbarElement.contains(toolbarHit)),
|
|
};
|
|
});
|
|
for (const key of ["editor", "video", "timeline", "toolbar", "actions", "navigator"]) {
|
|
if (!layout[key] || layout[key].width <= 0 || layout[key].height <= 0)
|
|
throw new Error(`${key} has no rendered box`);
|
|
}
|
|
if (rectanglesOverlap(layout.toolbar, layout.actions))
|
|
throw new Error("annotation toolbar is covered by submit actions");
|
|
if (rectanglesOverlap(layout.navigator, layout.actions))
|
|
throw new Error("slice navigator is covered by submit actions");
|
|
if (layout.toolbar.top < 0 || layout.toolbar.bottom > layout.viewport.height || !layout.toolbarUncovered) {
|
|
throw new Error("annotation toolbar is outside the viewport or covered by another layer");
|
|
}
|
|
const screenshot = await capture(page, `annotator-layout-${viewport.width}x${viewport.height}`);
|
|
return { ...layout, screenshot };
|
|
}
|
|
|
|
async function openMembers(page) {
|
|
await page.goto(`/project/${projectId}`, { waitUntil: "domcontentloaded", timeout: 60_000 });
|
|
const membersTab = await unique(page.getByTestId("project-members-tab"), "members tab");
|
|
await membersTab.click();
|
|
await unique(page.getByTestId("project-members-panel"), "project members panel");
|
|
}
|
|
|
|
function memberRow(page, userId) {
|
|
return page.locator(`[data-testid="project-member-row"][data-user-id="${userId}"]`);
|
|
}
|
|
|
|
async function searchMember(page, email, role = "all") {
|
|
await page.getByTestId("project-member-search").fill(email);
|
|
await page.getByTestId("project-member-role-filter").selectOption(role);
|
|
}
|
|
|
|
async function ensureDisposableMember(page, fixture) {
|
|
const userId = required(fixture.userId, "member.userId");
|
|
const email = required(fixture.email, "member.email");
|
|
await searchMember(page, email);
|
|
if ((await memberRow(page, userId).count()) === 1) return;
|
|
|
|
await page.getByTestId("project-member-add").click();
|
|
await unique(page.getByTestId("project-member-editor"), "member editor");
|
|
await page.getByTestId("project-member-user").selectOption(userId);
|
|
if (fixture.supplierId) await page.getByTestId("project-member-supplier").selectOption(fixture.supplierId);
|
|
const initialRoles = fixture.initialRoles || ["annotator"];
|
|
for (const role of ["annotator", "quality_reviewer", "acceptance_reviewer"]) {
|
|
await page.getByTestId(`project-member-role-${role}`).setChecked(initialRoles.includes(role));
|
|
}
|
|
const responsePromise = page.waitForResponse(
|
|
(response) =>
|
|
response.request().method() === "POST" && response.url().endsWith(`/api/projects/${projectId}/members`),
|
|
);
|
|
await page.getByTestId("project-member-save").click();
|
|
const response = await responsePromise;
|
|
if (!response.ok()) throw new Error(`member fixture creation failed: ${response.status()}`);
|
|
await searchMember(page, email);
|
|
await memberRow(page, userId).waitFor({ state: "visible", timeout: 30_000 });
|
|
}
|
|
|
|
async function exerciseMemberBulkOperations(page, fixture) {
|
|
if (fixture.disposable !== true) throw new Error("member fixture must be explicitly disposable");
|
|
const userId = required(fixture.userId, "member.userId");
|
|
const email = required(fixture.email, "member.email");
|
|
const targetRoles = fixture.bulkRoles || ["annotator", "quality_reviewer"];
|
|
await ensureDisposableMember(page, fixture);
|
|
|
|
await searchMember(page, email, "annotator");
|
|
let row = await unique(memberRow(page, userId), "disposable member row after search/filter");
|
|
const selection = row.getByLabel(`选择成员 ${email}`, { exact: true });
|
|
await selection.check();
|
|
for (const role of ["annotator", "quality_reviewer", "acceptance_reviewer"]) {
|
|
await page.getByTestId(`project-member-bulk-role-${role}`).setChecked(targetRoles.includes(role));
|
|
}
|
|
const setRolesResponse = page.waitForResponse(
|
|
(response) =>
|
|
response.request().method() === "POST" && response.url().endsWith(`/api/projects/${projectId}/members/bulk`),
|
|
);
|
|
await page.getByTestId("project-member-bulk-set-roles").click();
|
|
const updated = await setRolesResponse;
|
|
if (!updated.ok()) throw new Error(`bulk role update failed: ${updated.status()}`);
|
|
await searchMember(page, email, targetRoles[0]);
|
|
row = await unique(memberRow(page, userId), "member row after bulk role update");
|
|
const renderedRoles = await row
|
|
.locator("[data-role]")
|
|
.evaluateAll((nodes) => nodes.map((node) => node.getAttribute("data-role")));
|
|
if (targetRoles.some((role) => !renderedRoles.includes(role)) || renderedRoles.length !== targetRoles.length) {
|
|
throw new Error(`bulk roles were not rendered exactly: ${JSON.stringify(renderedRoles)}`);
|
|
}
|
|
await capture(page, "admin-project-members-bulk-roles");
|
|
|
|
await page.reload({ waitUntil: "domcontentloaded", timeout: 60_000 });
|
|
const membersTab = await unique(page.getByTestId("project-members-tab"), "members tab after reload");
|
|
await membersTab.click();
|
|
await searchMember(page, email, targetRoles[0]);
|
|
row = await unique(memberRow(page, userId), "persisted member row");
|
|
const persistedRoles = await row
|
|
.locator("[data-role]")
|
|
.evaluateAll((nodes) => nodes.map((node) => node.getAttribute("data-role")));
|
|
if (JSON.stringify([...persistedRoles].sort()) !== JSON.stringify([...targetRoles].sort())) {
|
|
throw new Error(`bulk role update did not persist: ${JSON.stringify(persistedRoles)}`);
|
|
}
|
|
|
|
await page.getByTestId("project-member-role-filter").selectOption("all");
|
|
row = await unique(memberRow(page, userId), "member row before bulk removal");
|
|
await row.getByLabel(`选择成员 ${email}`, { exact: true }).check();
|
|
const removeResponse = page.waitForResponse(
|
|
(response) =>
|
|
response.request().method() === "POST" && response.url().endsWith(`/api/projects/${projectId}/members/bulk`),
|
|
);
|
|
await page.getByTestId("project-member-bulk-remove").click();
|
|
const removed = await removeResponse;
|
|
if (!removed.ok()) throw new Error(`bulk member removal failed: ${removed.status()}`);
|
|
await memberRow(page, userId).waitFor({ state: "detached", timeout: 30_000 });
|
|
await capture(page, "admin-project-members-bulk-removed");
|
|
return { userId, email, targetRoles, persistedRoles, removed: true };
|
|
}
|
|
|
|
async function inspectRoleWorkbench({ name, emailName, passwordName, allowedRoles, route, expectedText, fixture }) {
|
|
const { context, session } = await authenticatedContext(emailName, passwordName, allowedRoles);
|
|
const page = await context.newPage();
|
|
const pageDiagnostics = watchPage(page, `${name}-workbench`);
|
|
try {
|
|
await page.goto(annotationURL(route, fixture), { waitUntil: "domcontentloaded", timeout: 60_000 });
|
|
await unique(page.getByRole("link", { name: expectedText, exact: true }), `${name} workbench navigation`);
|
|
const pool = await locateFixturePool(page, fixture, { acceptance: name === "acceptance" });
|
|
const hierarchy = await assertHierarchy(page, fixture, { taskRequired: name !== "acceptance" });
|
|
if (name === "annotator") {
|
|
const claim = page.getByText("领取标注任务", { exact: true });
|
|
if ((await claim.count()) === 1) {
|
|
await claim.click();
|
|
await unique(page.getByText("释放任务", { exact: true }), "claimed annotator task");
|
|
} else {
|
|
await unique(page.getByText("释放任务", { exact: true }), "annotator task already claimed by this user");
|
|
}
|
|
await unique(page.getByTestId("annotation-workbench-editor"), "annotator workbench editor");
|
|
} else if (name === "quality") {
|
|
const claim = page.getByText("领取标注审核", { exact: true });
|
|
if ((await claim.count()) === 1) {
|
|
await claim.click();
|
|
await unique(page.getByText("释放任务", { exact: true }), "claimed quality task");
|
|
} else {
|
|
await unique(page.getByText("释放任务", { exact: true }), "quality task already claimed by this user");
|
|
}
|
|
await unique(page.getByTestId("materialized-slice-workbench"), "quality materialized slice workbench");
|
|
} else {
|
|
const humanItemId = required(fixture.humanItemId, "acceptance.humanItemId");
|
|
const item = await unique(
|
|
page.locator(`[data-testid="acceptance-human-item"][data-human-item-id="${humanItemId}"]`),
|
|
"acceptance fixture item",
|
|
);
|
|
const claim = item.getByText("领取最终验收", { exact: true });
|
|
if ((await claim.count()) === 1) {
|
|
await claim.click();
|
|
await unique(item.getByText("释放任务", { exact: true }), "claimed final acceptance task");
|
|
} else {
|
|
await unique(item.getByText("释放任务", { exact: true }), "acceptance task already claimed by this user");
|
|
}
|
|
await unique(item.getByTestId("materialized-slice-workbench"), "acceptance materialized slice workbench");
|
|
}
|
|
await capture(page, `${name}-workbench-1920x1080`);
|
|
return {
|
|
session: { id: session.user.id, email: session.user.email, role: session.user.role },
|
|
pool,
|
|
hierarchy,
|
|
diagnostics: assertDiagnosticsHealthy(pageDiagnostics, `${name} workbench`),
|
|
};
|
|
} finally {
|
|
await context.close();
|
|
}
|
|
}
|
|
|
|
async function run() {
|
|
validateFixtureContract();
|
|
record("browser_fixture_contract", true, {
|
|
projectId,
|
|
workflowId,
|
|
annotation: {
|
|
captureDirectory: browserFixture.annotation.captureDirectory,
|
|
taskId: browserFixture.annotation.taskId,
|
|
humanItemId: browserFixture.annotation.humanItemId,
|
|
runId: browserFixture.annotation.runId,
|
|
},
|
|
quality: {
|
|
captureDirectory: browserFixture.quality.captureDirectory,
|
|
taskId: browserFixture.quality.taskId,
|
|
humanItemId: browserFixture.quality.humanItemId,
|
|
runId: browserFixture.quality.runId,
|
|
},
|
|
acceptance: {
|
|
captureDirectory: browserFixture.acceptance.captureDirectory,
|
|
humanItemId: browserFixture.acceptance.humanItemId,
|
|
runId: browserFixture.acceptance.runId,
|
|
},
|
|
member: {
|
|
userId: browserFixture.member.userId,
|
|
email: browserFixture.member.email,
|
|
supplierId: browserFixture.member.supplierId,
|
|
bulkRoles: browserFixture.member.bulkRoles,
|
|
disposable: browserFixture.member.disposable,
|
|
},
|
|
});
|
|
|
|
browser = await chromium.launch({
|
|
headless: true,
|
|
executablePath:
|
|
process.env.CHROME_EXECUTABLE_PATH || "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
|
|
});
|
|
|
|
const { context: adminContext } = await authenticatedContext(
|
|
"DROBOTICFLOW_ACCEPTANCE_EMAIL",
|
|
"DROBOTICFLOW_ACCEPTANCE_PASSWORD",
|
|
["admin", "organization_admin"],
|
|
);
|
|
const adminPage = await adminContext.newPage();
|
|
const adminDiagnostics = watchPage(adminPage, "admin");
|
|
try {
|
|
await runCheck("project_member_real_bulk_operations", async () => {
|
|
await openMembers(adminPage);
|
|
return exerciseMemberBulkOperations(adminPage, browserFixture.member);
|
|
});
|
|
|
|
await runCheck("admin_project_workflow_capture_cascade", async () => {
|
|
const hierarchy = await exerciseHierarchyCascade(adminPage, browserFixture.annotation);
|
|
await capture(adminPage, "admin-project-workflow-capture");
|
|
return hierarchy;
|
|
});
|
|
|
|
await runCheck("annotation_layout_1920_no_overlap", () =>
|
|
assertWorkbenchLayout(adminPage, { width: 1920, height: 1080 }),
|
|
);
|
|
await runCheck("annotation_layout_1366_no_overlap", () =>
|
|
assertWorkbenchLayout(adminPage, { width: 1366, height: 768 }),
|
|
);
|
|
await runCheck("admin_browser_diagnostics", () => assertDiagnosticsHealthy(adminDiagnostics, "admin interactions"));
|
|
} finally {
|
|
await adminContext.close();
|
|
}
|
|
|
|
const rolePages = [
|
|
{
|
|
name: "annotator",
|
|
emailName: "FANYU_ANNOTATOR_EMAIL",
|
|
passwordName: "FANYU_ANNOTATOR_PASSWORD",
|
|
allowedRoles: ["member", "annotator", "data_operator"],
|
|
route: "annotate",
|
|
expectedText: "切分与语义标注",
|
|
fixture: browserFixture.annotation,
|
|
},
|
|
{
|
|
name: "quality",
|
|
emailName: "FANYU_QUALITY_EMAIL",
|
|
passwordName: "FANYU_QUALITY_PASSWORD",
|
|
allowedRoles: ["member", "quality_reviewer", "qa_reviewer", "auditor"],
|
|
route: "quality",
|
|
expectedText: "切分与标注审核",
|
|
fixture: browserFixture.quality,
|
|
},
|
|
{
|
|
name: "acceptance",
|
|
emailName: "FANYU_ACCEPTANCE_EMAIL",
|
|
passwordName: "FANYU_ACCEPTANCE_PASSWORD",
|
|
allowedRoles: ["member", "acceptance_reviewer"],
|
|
route: "acceptance",
|
|
expectedText: "最终验收",
|
|
fixture: browserFixture.acceptance,
|
|
},
|
|
];
|
|
for (const rolePage of rolePages) {
|
|
await runCheck(`${rolePage.name}_real_fixture_workbench`, () => inspectRoleWorkbench(rolePage));
|
|
}
|
|
}
|
|
|
|
try {
|
|
await run();
|
|
} catch (error) {
|
|
fatalError = error instanceof Error ? error.message : String(error);
|
|
checks.push({ name: "fatal_browser_acceptance", passed: false, evidence: { error: fatalError } });
|
|
} finally {
|
|
if (browser) await browser.close();
|
|
const report = {
|
|
schemaVersion: "droboticflow.fanyu.browser-acceptance/v2",
|
|
projectId,
|
|
workflowId,
|
|
passed: !fatalError && checks.length > 0 && checks.every((item) => item.passed),
|
|
checks,
|
|
diagnostics,
|
|
screenshots,
|
|
statePath,
|
|
createdAt: new Date().toISOString(),
|
|
...(fatalError ? { error: fatalError } : {}),
|
|
};
|
|
fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
|
|
console.log(
|
|
JSON.stringify({ passed: report.passed, reportPath, screenshots, error: fatalError || undefined }, null, 2),
|
|
);
|
|
if (!report.passed) process.exitCode = 1;
|
|
}
|