droboticflow/tests/browser/review-draft-persistence.mjs

443 lines
21 KiB
JavaScript

import { browserExecutableOptions } from "../../scripts/lib/browser-executable.mjs";
import assert from "node:assert/strict";
import fs from "node:fs";
import path from "node:path";
import { createServer } from "vite";
import { chromium } from "playwright";
const api = process.env.REVIEW_DRAFT_API;
assert.match(api, /^http:\/\/127\.0\.0\.1:\d+$/);
const cfg = await (await fetch(api + "/__fixture/info")).json();
const out = path.resolve("local-data/test-results/review-draft-persistence", cfg.role);
fs.mkdirSync(out, { recursive: true });
const report = { role: cfg.role, cases: [], errors: [], writes: [] };
const server = await createServer({
configFile: false,
cacheDir: "local-data/vite-review-draft-persistence",
server: {
host: "127.0.0.1",
port: 0,
watch: { ignored: ["**/local-data/**"] },
proxy: { "/api": api, "/__fixture": api },
},
optimizeDeps: {
noDiscovery: true,
entries: [],
include: ["react", "react-dom/client", "react-dom", "react/jsx-runtime", "react/jsx-dev-runtime"],
},
plugins: [
{
name: "draft-persistence-fixture",
configureServer(s) {
s.middlewares.use("/__draft", async (_req, res) => {
res.setHeader("Content-Type", "text/html");
res.end(
await s.transformIndexHtml(
"/__draft",
`<div id="root"></div><script type="module">
import React,{useState} from 'react';import{createRoot}from'react-dom/client';import{useReviewDraft}from'/src/hooks/useReviewDraft.ts';import{ReviewProblemPanel}from'/src/components/ReviewProblemPanel.tsx';
const cfg=await fetch('/__fixture/info').then(r=>r.json());window.cfg=cfg;window.results=[];
function Draft(){const[w,setW]=useState(true);window.setWritable=setW;const[g,setG]=useState(1);window.generation=g;window.bumpGeneration=()=>setG(v=>v+1);
const r=useReviewDraft(cfg.itemId,'synthetic-user',true,{writable:w,snapshot:{itemId:cfg.itemId,generation:g,resultVersion:cfg.resultVersion},headers:()=>cfg.headers,handleError:()=>{}});window.review=r;
r.onController({focus:()=>{},pause:()=>{},pauseAndLocate:()=>window.currentPosition||null,seekTime:t=>{window.lastSeek=t;return true},seekSlice:id=>{window.lastSlice=id;return true}});
return React.createElement('div',null,React.createElement(ReviewProblemPanel,{review:r,label:p=>(p.sourceItemId||'')+'/'+p.sliceId,onSelectProblem:p=>r.selectProblem(p,p.sourceItemId?p.sourceItemId+'/'+p.sliceId:p.sliceId)}));}
function App(){const[m,setM]=useState(true);window.unmountDraft=()=>setM(false);return m?React.createElement(Draft):React.createElement('div',null,'unmounted');}
window.positionFor=side=>window.currentPosition=cfg.role==='acceptance'?{time:1,sliceId:'same',actionId:'same-action',sourceItemId:side==='left'?'source-a':'source-b',timeBasis:'slice-seconds'}:{time:side==='left'?1:6,sliceId:side,actionId:side+'-action',timeBasis:'capture-seconds'};
createRoot(document.getElementById('root')).render(React.createElement(React.StrictMode,null,React.createElement(App)));
</script>`,
),
);
});
},
},
],
});
let browser, page, release;
let fault = "",
changeReadback = false;
try {
await server.listen();
browser = await chromium.launch({
...browserExecutableOptions(),
headless: true,
args: ["--no-proxy-server"],
});
page = await browser.newPage();
page.setDefaultTimeout(12000);
page.on("pageerror", (e) => report.errors.push(e.message));
await page.route("**/*", async (route) => {
const req = route.request(),
u = new URL(req.url());
if (u.hostname !== "127.0.0.1") return route.abort();
if (u.pathname.endsWith("/review-draft") && req.method() === "PUT") {
const payload = req.postDataJSON();
report.writes.push(payload);
const mode = fault;
fault = "";
if (mode === "reject") return route.fulfill({ status: 400, json: { error: "合成保存拒绝" } });
if (mode === "conflict")
return route.fulfill({ status: 409, json: { code: "review_draft_version_conflict", error: "合成版本冲突" } });
if (mode === "absent") return route.abort("failed");
const response = await route.fetch();
assert.equal(response.status(), 200, await response.text());
if (mode === "hold" || mode === "hold-lost") await new Promise((resolve) => (release = resolve));
if (mode === "lost" || mode === "hold-lost") return route.abort("failed");
return route.fulfill({ response });
}
if (u.pathname.endsWith("/review-draft") && req.method() === "GET" && fault === "reload-hold") {
fault = "";
const response = await route.fetch();
await new Promise((resolve) => (release = resolve));
return route.fulfill({ response });
}
if (u.pathname.endsWith("/review-draft") && req.method() === "GET" && changeReadback) {
changeReadback = false;
const response = await route.fetch(),
body = await response.json();
body.draft.resultVersion = "new-result";
return route.fulfill({ json: body });
}
if (u.pathname.includes("/review-operations/") && fault === "receipt-hold") {
fault = "";
const response = await route.fetch();
assert.equal(response.status(), 404);
await new Promise((resolve) => (release = resolve));
return route.fulfill({ response });
}
return route.continue();
});
const loaded = () => page.waitForFunction(() => window.review?.draft && !window.review.loading);
const open = async () => {
await page.goto(server.resolvedUrls.local[0] + "__draft");
await loaded();
};
const begin = async (text, slice = "left") => {
await page.evaluate(
({ text, slice }) => {
window.review.beginProblem(window.positionFor(slice), "slice");
window.review.setText(text);
},
{ text, slice },
);
await page.waitForFunction((text) => window.review.editor?.text === text, text);
};
const settled = () => page.waitForFunction(() => !window.review.saving);
await open();
await page.evaluate(() => {
window.review.setConfirmation("prior", true);
});
await page.waitForFunction(() => window.review.dirty);
assert.equal(await page.evaluate(() => window.review.canLeave()), false);
await page.evaluate(() => window.review.guardDiscard());
await page.waitForFunction(() => !window.review.dirty);
assert.equal(report.writes.length, 0);
report.cases.push("verdict-only edit blocks leaving; explicit discard restores saved verdicts");
await page.evaluate(() => window.review.setConfirmation("prior", true));
assert.equal(await page.evaluate(() => window.review.guardSave()), true);
assert.equal(await page.evaluate(() => window.review.dirty), false);
assert.deepEqual(await page.evaluate(() => window.review.currentDraft().problems), []);
await open();
assert.equal(await page.evaluate(() => window.review.confirmations[0].resolved), true);
report.cases.push("verdict-only guardSave persists with omitted empty note and reloads cleanly");
await page.evaluate(() => window.review.setConfirmation("prior", false, " still an issue "));
assert.equal(await page.evaluate(() => window.review.prepareSubmit()), true);
assert.equal(await page.evaluate(() => window.review.confirmations[0].note.trim()), "still an issue");
assert.equal(await page.evaluate(() => window.review.dirty), false);
report.cases.push("server-trimmed notes do not leave a permanent dirty state");
await begin("saved before resident focus");
assert.equal(await page.evaluate(() => window.review.save()), true);
await page.waitForFunction(() => !window.review.editor && window.review.selectedScope === "action");
const writesBeforeResidentFocus = report.writes.length;
const residentBeforeCommit = await page.evaluate(() => {
const input = window.review.inputRef.current;
if (!input?.readOnly) throw new Error("expected the resident action textarea before the next edit");
input.blur();
const resident = { scope: window.review.selectedScope, readOnly: input.readOnly };
const requestFrame = window.requestAnimationFrame;
const cancelFrame = window.cancelAnimationFrame;
const callbacks = new Map();
// Deliver the hook's real focus callback while the previous resident DOM
// is still mounted, before React commits the new slice editor.
window.requestAnimationFrame = (callback) => {
const id = requestFrame.call(window, (time) => {
callbacks.delete(id);
callback(time);
});
callbacks.set(id, callback);
return id;
};
window.cancelAnimationFrame = (id) => {
callbacks.delete(id);
cancelFrame.call(window, id);
};
try {
window.review.beginProblem(window.positionFor("left"), "slice");
window.review.setText("slice text survives resident focus");
const scheduled = [...callbacks];
if (scheduled.length !== 1) throw new Error("expected exactly one scheduled editor focus");
const [id, callback] = scheduled[0];
cancelFrame.call(window, id);
callbacks.delete(id);
callback(performance.now());
return resident;
} finally {
window.requestAnimationFrame = requestFrame;
window.cancelAnimationFrame = cancelFrame;
}
});
assert.deepEqual(residentBeforeCommit, { scope: "action", readOnly: true });
await page.waitForFunction(() => window.review.editor);
assert.deepEqual(
await page.evaluate(() => {
const { scope, text, sliceId, sourceItemId = "" } = window.review.editor;
return { scope, text, sliceId, sourceItemId };
}),
{
scope: "slice",
text: "slice text survives resident focus",
sliceId: cfg.role === "acceptance" ? "same" : "left",
sourceItemId: cfg.role === "acceptance" ? "source-a" : "",
},
"resident focus before React commit must preserve the new slice editor and source",
);
assert.equal(
await page.getByRole("textbox", { name: "审查问题说明" }).inputValue(),
"slice text survives resident focus",
);
assert.equal(report.writes.length, writesBeforeResidentFocus, "resident focus must not park a background write");
await page.evaluate(() => window.review.guardDiscard());
await page.waitForFunction(() => !window.review.dirty && !window.review.editor);
report.cases.push("resident focus before React commit preserves slice text and source without background writes");
for (const recovery of ["manual", "generation"]) {
const baseline = await page.evaluate(() => window.review.currentDraft().confirmations[0]);
await page.evaluate(() => window.review.setConfirmation("prior", true));
fault = "hold-lost";
await page.evaluate(() => {
void window.review.guardSave();
});
for (let n = 0; n < 80 && !release; n++) await page.waitForTimeout(25);
assert.ok(release);
await page.evaluate(
(baseline) => window.review.setConfirmation("prior", baseline.resolved, baseline.note || ""),
baseline,
);
release();
release = null;
await settled();
if (recovery === "manual") await page.evaluate(() => window.review.reload());
else {
const readback = page.waitForResponse(
(response) => response.url().endsWith("/review-draft") && response.request().method() === "GET",
);
await page.evaluate(() => window.bumpGeneration());
await readback;
await loaded();
}
assert.equal(await page.evaluate(() => window.review.confirmations[0].resolved), baseline.resolved);
assert.equal(await page.evaluate(() => window.review.dirty), true);
assert.equal(await page.evaluate(() => window.review.guardSave()), true);
report.cases.push(`${recovery} readback preserves a verdict reverted to its old baseline during a lost write`);
}
await begin("old submitted");
fault = "hold";
await page.evaluate(() => {
void window.review.save();
});
for (let n = 0; n < 80 && !release; n++) await page.waitForTimeout(25);
assert.ok(release);
await page.evaluate(() => window.review.setText("newer typed"));
await page.waitForFunction(() => window.review.editor.text === "newer typed");
release();
release = null;
await settled();
assert.equal(await page.evaluate(() => window.review.editor.text), "newer typed");
assert.equal(await page.evaluate(() => window.review.saveAll()), true);
report.cases.push("older successful write rebases without discarding newer text");
await begin("text before reload");
fault = "reload-hold";
await page.evaluate(() => {
void window.review.reload();
});
for (let n = 0; n < 80 && !release; n++) await page.waitForTimeout(25);
assert.ok(release);
await page.evaluate(() => {
window.review.setText("typed while reload pending");
});
assert.equal(await page.evaluate(() => window.review.editor.text), "typed while reload pending");
release();
release = null;
await loaded();
assert.equal(await page.evaluate(() => window.review.editor.text), "typed while reload pending");
assert.equal(await page.evaluate(() => window.review.saveAll()), true);
report.cases.push("reload readback preserves text entered while loading");
await page.evaluate(() => window.review.setConfirmation("prior", true));
fault = "reload-hold";
await page.evaluate(() => {
void window.review.reload();
});
for (let n = 0; n < 80 && !release; n++) await page.waitForTimeout(25);
assert.ok(release);
release();
release = null;
await loaded();
assert.equal(await page.evaluate(() => window.review.confirmations[0].resolved), true);
assert.equal(await page.evaluate(() => window.review.dirty), true);
assert.equal(await page.evaluate(() => window.review.guardSave()), true);
report.cases.push("reload preserves unsaved verdicts until explicit save");
await begin("lost response");
fault = "lost";
await page.evaluate(() => window.review.save());
await settled();
assert.equal(await page.evaluate(() => window.review.dirty), true);
const count = report.writes.length;
assert.equal(await page.evaluate(() => window.review.saveAll()), true);
assert.equal(report.writes.length, count);
report.cases.push("unknown PUT outcome is read back without a duplicate write");
await begin("not accepted");
fault = "reject";
assert.equal(await page.evaluate(() => window.review.save()), false);
assert.equal(await page.evaluate(() => window.review.editor.text), "not accepted");
await page.evaluate(() => window.review.guardDiscard());
assert.equal(await page.evaluate(() => window.review.canLeave()), true);
report.cases.push("definitive rejection keeps text and permits explicit discard");
await begin("explicit conflict retry");
fault = "conflict";
assert.equal(await page.evaluate(() => window.review.save()), false);
const before = report.writes.length;
await page.waitForTimeout(100);
assert.equal(report.writes.length, before);
assert.equal(await page.evaluate(() => window.review.save()), true);
report.cases.push("CAS conflict requires explicit retry and retains opinion text");
await begin("older failed text");
fault = "hold";
await page.evaluate(() => {
void window.review.save();
});
for (let n = 0; n < 80 && !release; n++) await page.waitForTimeout(25);
assert.ok(release);
await page.evaluate(() => {
window.review.setText("newer parked text");
window.review.beginProblem(window.positionFor("right"), "slice");
window.review.setText("other active target");
});
changeReadback = true;
release();
release = null;
await settled();
const edits = await page.evaluate(() =>
window.review.unsaved.map((e) => ({
slice: e.sourceItemId ? (e.sourceItemId === "source-a" ? "left" : "right") : e.sliceId,
text: e.text,
})),
);
assert.ok(edits.some((e) => e.slice === "left" && e.text === "newer parked text"));
assert.equal(await page.evaluate(() => window.review.editor.text), "other active target");
await page.evaluate(() => window.review.guardDiscard());
report.cases.push("failed obsolete result preserves newer parked target and active editor");
await open();
await begin("never dispatched");
fault = "absent";
await page.evaluate(() => window.review.save());
fault = "receipt-hold";
await page.evaluate(() => {
void window.review.saveAll();
});
for (let n = 0; n < 80 && !release; n++) await page.waitForTimeout(25);
assert.ok(release);
const puts = report.writes.length;
const generationRead = page.waitForResponse(
(response) => response.url().endsWith("/review-draft") && response.request().method() === "GET",
);
await page.evaluate(() => {
window.review.setConfirmation("prior", false, "new local verdict");
window.bumpGeneration();
});
await generationRead;
await loaded();
release();
release = null;
await page.waitForTimeout(150);
assert.equal(report.writes.length, puts);
assert.equal(await page.evaluate(() => window.review.saving), false);
assert.equal(await page.evaluate(() => window.review.confirmations[0].note), "new local verdict");
report.cases.push("generation change during receipt 404 stops old PUT and releases busy state");
const finalPuts = report.writes.length;
await page.evaluate(() => {
window.oldReview = window.review;
window.unmountDraft();
});
await page.getByText("unmounted", { exact: true }).waitFor();
assert.equal(await page.evaluate(() => window.oldReview.saveAll()), false);
assert.equal(await page.evaluate(() => window.oldReview.setConfirmation("prior", true)), false);
assert.equal(report.writes.length, finalPuts);
report.cases.push("unmounted hook refuses stale save and verdict callbacks");
await open();
await begin("集中列表左侧批注", "left");
assert.equal(await page.evaluate(() => window.review.saveAll()), true);
await begin("集中列表右侧批注", "right");
assert.equal(await page.evaluate(() => window.review.saveAll()), true);
for (const scope of ["action", "timestamp"]) {
await page.evaluate((scope) => {
window.review.beginProblem(window.positionFor("right"), scope);
window.review.setText(`集中列表${scope}批注`);
}, scope);
assert.equal(await page.evaluate(() => window.review.saveAll()), true);
}
const all = page.getByLabel("本次问题列表", { exact: true });
await all.getByText("集中列表左侧批注", { exact: true }).waitFor();
await all.getByText("集中列表右侧批注", { exact: true }).waitFor();
await all.getByText("集中列表action批注", { exact: true }).waitFor();
await all.getByText("集中列表timestamp批注", { exact: true }).waitFor();
const writesBeforeNavigate = report.writes.length;
await all.getByRole("button").filter({ hasText: "集中列表左侧批注" }).click();
assert.equal(await page.evaluate(() => window.review.editor.text), "集中列表左侧批注");
const expectedSlice = cfg.role === "acceptance" ? "source-a/same" : "left";
assert.equal(await page.evaluate(() => window.lastSlice), expectedSlice);
assert.equal(report.writes.length, writesBeforeNavigate);
report.cases.push(
"all current-round comments visible across slices/sources; list navigation uses source-aware target without writes",
);
await page.evaluate(() => window.setWritable(false));
await loaded();
await all.getByRole("button").filter({ hasText: "集中列表右侧批注" }).click();
assert.equal(
await page
.getByRole("textbox", { name: "审查问题说明" })
.evaluateAll((nodes) => nodes.every((node) => node.readOnly)),
true,
);
assert.equal(report.writes.length, writesBeforeNavigate);
report.cases.push("read-only all-comment navigation remains available without enabling writes");
await page.evaluate(() => window.setWritable(true));
await loaded();
await all.getByRole("button").filter({ hasText: "集中列表action批注" }).click();
await page.getByRole("button", { name: "清除意见", exact: true }).click();
await page
.getByRole("alertdialog", { name: "确认清除意见" })
.getByRole("button", { name: "确认清除", exact: true })
.click();
await all.getByText("集中列表action批注", { exact: true }).waitFor({ state: "hidden" });
await page.evaluate(() => window.review.reload());
await loaded();
assert.equal(await all.getByText("集中列表action批注", { exact: true }).count(), 0);
assert.equal(await all.getByText("集中列表左侧批注", { exact: true }).count(), 1);
report.cases.push("all scopes listed; clearing one current opinion survives reload and preserves other slices");
await page.screenshot({ path: path.join(out, "all-comments.png"), fullPage: true });
assert.deepEqual(report.errors, []);
console.log(
JSON.stringify({ role: cfg.role, cases: report.cases, errors: report.errors, puts: report.writes.length }),
);
} catch (error) {
report.failure = error.message;
if (page) {
fs.writeFileSync(path.join(out, "failure.txt"), await page.locator("body").innerText());
await page.screenshot({ path: path.join(out, "failure.png") });
}
throw error;
} finally {
release?.();
fs.writeFileSync(path.join(out, "report.json"), JSON.stringify(report, null, 2));
await browser?.close();
await server.close();
}