forked from longtao.wu/droboticflow
443 lines
21 KiB
JavaScript
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();
|
|
}
|