267 lines
19 KiB
JavaScript
267 lines
19 KiB
JavaScript
import assert from "node:assert/strict";
|
|
import fs from "node:fs";
|
|
import os from "node:os";
|
|
import path from "node:path";
|
|
import { spawn } from "node:child_process";
|
|
import { once } from "node:events";
|
|
|
|
const origin = process.env.FREECAD_BROWSER_ORIGIN ?? "http://127.0.0.1:5188";
|
|
const profile = fs.mkdtempSync(path.join(os.tmpdir(), "freecad-techdraw-browser-"));
|
|
const artifacts = path.resolve("docs/current/techdraw-browser");
|
|
fs.mkdirSync(artifacts, { recursive: true });
|
|
const chrome = spawn("/usr/bin/google-chrome", ["--headless=new", "--no-sandbox", "--disable-dev-shm-usage", "--remote-debugging-port=0", `--user-data-dir=${profile}`, "about:blank"], { stdio: "ignore" });
|
|
const closed = once(chrome, "exit");
|
|
let socket;
|
|
const pending = new Map();
|
|
let sequence = 0;
|
|
async function until(label, action, predicate, timeout = 30000) {
|
|
const deadline = Date.now() + timeout;
|
|
let value;
|
|
while (Date.now() < deadline) {
|
|
value = await action();
|
|
if (predicate(value)) return value;
|
|
await new Promise(resolve => setTimeout(resolve, 100));
|
|
}
|
|
throw new Error(`${label}: ${JSON.stringify(value)}`);
|
|
}
|
|
async function send(method, params = {}) {
|
|
const id = ++sequence;
|
|
const detail = method === "Runtime.evaluate" ? String(params.expression).replace(/\s+/g, " ").slice(0, 240) : params.url ?? "";
|
|
const started = performance.now();
|
|
if (process.env.FREECAD_TECHDRAW_TRACE === "1") fs.writeSync(2, `TechDraw browser start ${id} ${method}: ${detail}\n`);
|
|
return new Promise((resolve, reject) => {
|
|
const timer = setTimeout(() => { pending.delete(id); reject(new Error(`${method} timed out at ${detail}`)); }, 45000);
|
|
pending.set(id, { resolve: result => {
|
|
if (process.env.FREECAD_TECHDRAW_TRACE === "1") fs.writeSync(2, `TechDraw browser completed ${id}: ${(performance.now() - started).toFixed(1)} ms\n`);
|
|
resolve(result);
|
|
}, reject, timer });
|
|
socket.send(JSON.stringify({ id, method, params }));
|
|
});
|
|
}
|
|
async function evaluate(expression) {
|
|
const result = await send("Runtime.evaluate", { expression, awaitPromise: true, returnByValue: true });
|
|
if (result.exceptionDetails) throw new Error(JSON.stringify(result.exceptionDetails));
|
|
return result.result?.value;
|
|
}
|
|
try {
|
|
const port = await until("Chrome startup", () => {
|
|
try { return fs.readFileSync(path.join(profile, "DevToolsActivePort"), "utf8").split("\n")[0]; } catch { return null; }
|
|
}, Boolean);
|
|
const targets = await fetch(`http://127.0.0.1:${port}/json/list`).then(r => r.json());
|
|
socket = new WebSocket(targets.find(t => t.type === "page").webSocketDebuggerUrl);
|
|
socket.addEventListener("message", event => {
|
|
const message = JSON.parse(event.data);
|
|
if (process.env.FREECAD_TECHDRAW_TRACE === "1" && message.method === "Runtime.consoleAPICalled") {
|
|
fs.writeSync(2, `TechDraw browser console: ${JSON.stringify(message.params.args.map(value => value.value ?? value.description))}\n`);
|
|
}
|
|
const request = pending.get(message.id);
|
|
if (!request) return;
|
|
pending.delete(message.id); clearTimeout(request.timer);
|
|
if (message.error) request.reject(new Error(JSON.stringify(message.error)));
|
|
else request.resolve(message.result);
|
|
});
|
|
await new Promise((resolve, reject) => { socket.addEventListener("open", resolve, { once: true }); socket.addEventListener("error", reject, { once: true }); });
|
|
await send("Page.enable");
|
|
await send("Runtime.enable");
|
|
await send("Emulation.setDeviceMetricsOverride", { width: 1440, height: 900, deviceScaleFactor: 1, mobile: false });
|
|
await send("Page.navigate", { url: `${origin}/techdraw.html` });
|
|
const state = () => evaluate("({isolated:crossOriginIsolated,state:window.__freecadTechDrawState,text:document.querySelector('[role=status]')?.textContent})");
|
|
const initial = await until("Native drawing", state, value => ["success", "error"].includes(value?.state?.stage));
|
|
assert.equal(initial.state.stage, "success", JSON.stringify(initial));
|
|
assert.equal(initial.state.response.result.volume, 17280);
|
|
await evaluate(`{ const set = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value').set;
|
|
for (const [id, value] of [['length','11'],['width','6'],['height','3']]) {
|
|
const input = document.getElementById(id); set.call(input, value); input.dispatchEvent(new Event('input', {bubbles:true}));
|
|
} }`);
|
|
await evaluate("document.getElementById('run').click()");
|
|
await until("Edited drawing", state, value => Math.abs((value?.state?.response?.result?.volume ?? 0) - 198) < 1e-8);
|
|
await send("Page.setDownloadBehavior", { behavior: "allow", downloadPath: profile });
|
|
await evaluate("document.getElementById('export').click()");
|
|
const download = path.join(profile, "TechDrawDrawing.svg");
|
|
await until("SVG download", () => fs.existsSync(download), Boolean);
|
|
assert.ok(fs.readFileSync(download, "utf8").includes("<path"));
|
|
const checks = [];
|
|
for (const [width, height] of [[1440, 900], [390, 844]]) {
|
|
await send("Emulation.setDeviceMetricsOverride", { width, height, deviceScaleFactor: 1, mobile: width < 700 });
|
|
const layout = await evaluate(`(async () => {
|
|
const image = document.querySelector('img.drawing'); await image.decode();
|
|
const canvas = document.createElement('canvas'); canvas.width=320;canvas.height=240;
|
|
const context = canvas.getContext('2d');context.drawImage(image,0,0,320,240);
|
|
const pixels=context.getImageData(0,0,320,240).data;let painted=0;
|
|
for(let i=0;i<pixels.length;i+=4) if(pixels[i+3]>20) painted++;
|
|
return {painted,overflow:document.documentElement.scrollWidth>innerWidth,
|
|
bounds:[image.getBoundingClientRect().width,image.getBoundingClientRect().height]};
|
|
})()`);
|
|
assert.equal(layout.overflow, false);
|
|
assert.ok(layout.painted > 100, JSON.stringify(layout));
|
|
const screenshot = await send("Page.captureScreenshot", { format: "png", captureBeyondViewport: true });
|
|
fs.writeFileSync(path.join(artifacts, `${width}.png`), Buffer.from(screenshot.data, "base64"));
|
|
checks.push({ width, height, ...layout });
|
|
}
|
|
const routed = await evaluate(`(async()=>{
|
|
const {WebModuleRouter}=await import('/src/module-router.ts'); const router=new WebModuleRouter();
|
|
try {await router.loadManifest('/modules/manifest.json');const result=router.request('TechDraw','techdraw.createRecompute',
|
|
{schema:'freecad-web-techdraw/frontend-drawing/v1',module:'TechDraw',action:'create/recompute',documentId:'RouterDrawing',box:{length:5,width:7,height:2}});
|
|
const drawing=await result;
|
|
const saved=await router.request('TechDraw','techdraw.nativeSaveReopen',
|
|
{schema:'freecad-web-techdraw/save-reopen/v1',module:'TechDraw',action:'save/reopen',sourceEntry:'src/Mod/TechDraw/App/AppTechDraw.cpp',documentId:'RouterDrawing'});
|
|
if(saved.kind!=='result') throw new Error(JSON.stringify(saved));
|
|
return {drawing,saved:{documentId:saved.result.documentId,objectCount:saved.result.objectCount,byteLength:saved.result.bytes.byteLength,size:saved.result.size},loaded:router.listLoaded()};
|
|
}finally{router.dispose();}
|
|
})()`);
|
|
assert.equal(routed.drawing.kind, "result", JSON.stringify(routed));
|
|
assert.ok(Math.abs(routed.drawing.result.volume - 70) < 1e-8);
|
|
assert.equal(routed.saved.documentId, "RouterDrawing");
|
|
assert.equal(routed.saved.objectCount, routed.drawing.result.document.objectCount);
|
|
assert.ok(routed.saved.byteLength > 0);
|
|
assert.equal(routed.saved.byteLength, routed.saved.size);
|
|
assert.equal(routed.loaded.length, 1);
|
|
assert.equal(routed.loaded[0].worker, "techdraw-python.worker.ts");
|
|
await evaluate("document.getElementById('reset').click()");
|
|
await until("Reset drawing", state, value => value?.state?.response?.result?.volume === 17280);
|
|
await send("Emulation.setDeviceMetricsOverride", { width: 1440, height: 900, deviceScaleFactor: 1, mobile: false });
|
|
await send("Page.navigate", { url: `${origin}/workbench.html?module=TechDraw&command=techdraw.createRecompute` });
|
|
await until("Workbench ready", () => evaluate("!!document.querySelector('#payload-editor')"), Boolean);
|
|
const workbench = () => evaluate("window.__freecadWorkbenchState");
|
|
// Route an explicitly named drawing while the shell still has its initial document selected.
|
|
await evaluate(`{
|
|
const input = document.querySelector('#payload-editor');
|
|
const payload = JSON.parse(input.value);
|
|
payload.documentId = 'TechDrawDrawing';
|
|
Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, 'value').set.call(input, JSON.stringify(payload));
|
|
input.dispatchEvent(new Event('input', {bubbles:true}));
|
|
}`);
|
|
await evaluate("document.querySelector('button.run').click()");
|
|
const created = await until("Workbench drawing", workbench, value => !!value?.response);
|
|
assert.equal(created.response.kind, "result", JSON.stringify(created));
|
|
assert.equal(created.response.result.volume, 17280);
|
|
assert.equal(created.response.result.document.name, "TechDrawDrawing");
|
|
assert.equal(await evaluate("document.querySelector('figure figcaption')?.textContent"), "TechDrawDrawing / Page / View");
|
|
assert.ok(await evaluate("Array.from(document.querySelectorAll('.stat')).some(item=>item.textContent.includes('TechDrawDrawing.View'))"));
|
|
let detailRecord;
|
|
if (process.env.FREECAD_TECHDRAW_BROWSER_CASE !== "image") {
|
|
await until("Detail command available", () => evaluate("Array.from(document.querySelectorAll('.matrix-list button')).some(button=>button.querySelector('span')?.textContent==='TechDraw_DetailView')"), Boolean);
|
|
await evaluate("Array.from(document.querySelectorAll('.matrix-list button')).find(button=>button.querySelector('span')?.textContent==='TechDraw_DetailView').click()");
|
|
// Deliberately omit document and baseView: the next command must use the live selection.
|
|
const detailInput = { anchorX: 0, anchorY: 0, radius: 12, scale: 2, x: 180, y: 100, reference: "A" };
|
|
await evaluate(`{const input=document.querySelector('#payload-editor');Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype,'value').set.call(input,${JSON.stringify(JSON.stringify(detailInput))});input.dispatchEvent(new Event('input',{bubbles:true}));}`);
|
|
await evaluate("document.querySelector('button.run').click()");
|
|
const detail = await until("Workbench detail", workbench, value => !!value?.response);
|
|
assert.equal(detail.response.kind, "result", JSON.stringify(detail));
|
|
detailRecord = detail.response.result.records.find(item => item.apiId === "TechDraw:desktop:TechDraw_DetailView");
|
|
assert.ok(["partial", "exposed"].includes(detailRecord?.status), JSON.stringify(detail));
|
|
assert.equal(detailRecord.result.document, "TechDrawDrawing");
|
|
assert.equal(detailRecord.result.baseView, "View");
|
|
assert.ok(detailRecord.result.edgeCount > 0);
|
|
assert.ok(detailRecord.result.svg.includes("<path"));
|
|
assert.equal(await evaluate("document.querySelector('figure figcaption')?.textContent"), `TechDrawDrawing / Page / ${detailRecord.result.view}`);
|
|
}
|
|
await until("Image command available", () => evaluate("Array.from(document.querySelectorAll('.matrix-list button')).some(button=>button.querySelector('span')?.textContent==='TechDraw_Image')"), Boolean);
|
|
await evaluate("Array.from(document.querySelectorAll('.matrix-list button')).find(button=>button.querySelector('span')?.textContent==='TechDraw_Image').click()");
|
|
await evaluate(`{
|
|
const input=document.querySelector('#payload-editor');
|
|
Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype,'value').set.call(input,JSON.stringify({page:'Page',owner:'View'}));
|
|
input.dispatchEvent(new Event('input',{bubbles:true}));
|
|
}`);
|
|
await evaluate(`{
|
|
const bytes=new Uint8Array(58), data=new DataView(bytes.buffer);
|
|
bytes.set([66,77]);data.setUint32(2,58,true);data.setUint32(10,54,true);data.setUint32(14,40,true);
|
|
data.setInt32(18,1,true);data.setInt32(22,1,true);data.setUint16(26,1,true);data.setUint16(28,24,true);
|
|
data.setUint32(34,4,true);bytes.set([0,0,255],54);
|
|
const transfer=new DataTransfer();transfer.items.add(new File([bytes],'red.bmp',{type:'image/bmp'}));
|
|
const input=document.querySelector('input[type=file]');input.files=transfer.files;input.dispatchEvent(new Event('change',{bubbles:true}));
|
|
}`);
|
|
await until("Image upload read", () => evaluate("JSON.parse(document.querySelector('#payload-editor').value).imageBase64"), Boolean);
|
|
await evaluate("document.querySelector('button.run').click()");
|
|
const inserted = await until("Workbench image", workbench, value => !!value?.response);
|
|
assert.equal(inserted.response.kind, "result", JSON.stringify(inserted));
|
|
const imageRecord = inserted.response.result.records.find(item => item.apiId === "TechDraw:desktop:TechDraw_Image");
|
|
assert.ok(["exposed", "success"].includes(imageRecord.status), JSON.stringify(imageRecord));
|
|
assert.equal(imageRecord.code, "native_image_created");
|
|
assert.equal(imageRecord.result.document, "TechDrawDrawing");
|
|
const imagePixels = await evaluate(`(async()=>{
|
|
const image=document.querySelector('img[src^="data:image/bmp"]');await image.decode();
|
|
const canvas=document.createElement('canvas');canvas.width=canvas.height=1;
|
|
const context=canvas.getContext('2d');context.drawImage(image,0,0);
|
|
return Array.from(context.getImageData(0,0,1,1).data);
|
|
})()`);
|
|
assert.deepEqual(imagePixels, [255,0,0,255]);
|
|
const cancelImage = async () => {
|
|
await evaluate("Array.from(document.querySelectorAll('button')).find(button=>button.textContent==='取消').click()");
|
|
const cancelled = await until("Workbench image cancellation", workbench,
|
|
value => value?.response?.kind === "error"
|
|
|| value?.response?.result?.records?.some(record => record.status === "cancelled"));
|
|
assert.equal(cancelled.response.kind, "result", JSON.stringify(cancelled));
|
|
const record = cancelled.response.result.records.find(item => item.apiId === "TechDraw:desktop:TechDraw_Image");
|
|
assert.equal(record?.status, "cancelled", JSON.stringify(cancelled));
|
|
assert.equal(record.code, "image_insertion_cancelled");
|
|
const imageCount = await evaluate("document.querySelectorAll('img[src^=\"data:image/bmp\"]').length");
|
|
assert.equal(imageCount, 1);
|
|
return { record, imageCount };
|
|
};
|
|
const cancelledImage = await cancelImage();
|
|
const executeWorkbench = async (command, args, desktop = false) => {
|
|
await evaluate(`Array.from(document.querySelectorAll(${JSON.stringify(desktop ? '.matrix-list button' : 'button.command')})).find(button=>button.querySelector('span')?.textContent===${JSON.stringify(command)}).click()`);
|
|
await evaluate(`{const input=document.querySelector('#payload-editor');Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype,'value').set.call(input,${JSON.stringify(JSON.stringify(args))});input.dispatchEvent(new Event('input',{bubbles:true}));}`);
|
|
await evaluate("document.querySelector('button.run').click()");
|
|
const result = await until(`Workbench ${command}`, workbench, value => !!value?.response);
|
|
assert.equal(result.response.kind, "result", JSON.stringify(result));
|
|
return result.response.result;
|
|
};
|
|
const drawingArgs = documentId => ({schema:'freecad-web-techdraw/frontend-drawing/v1',module:'TechDraw',action:'create/recompute',documentId});
|
|
await executeWorkbench('techdraw.createRecompute', {...drawingArgs('ImageIsolation'), box:{length:9,width:7,height:5}});
|
|
const greenBytes = Buffer.from(imageRecord.result.imageBase64, 'base64');
|
|
greenBytes.set([0,255,0],54);
|
|
const green = await executeWorkbench('TechDraw_Image', {documentId:'ImageIsolation',page:'Page',owner:'View',imageBase64:greenBytes.toString('base64')}, true);
|
|
assert.equal(green.records[0].code, 'native_image_created', JSON.stringify(green));
|
|
const retainedImages = [];
|
|
for (const [documentId, expected] of [['TechDrawDrawing',[255,0,0,255]],['ImageIsolation',[0,255,0,255]]]) {
|
|
const retained = await executeWorkbench('techdraw.createRecompute', drawingArgs(documentId));
|
|
assert.ok(retained.document.objectCount >= 5);
|
|
const actual = await evaluate(`(async()=>{
|
|
const images=Array.from(document.querySelectorAll('img[src^="data:image/bmp"]'));
|
|
if(images.length!==1) return {count:images.length};
|
|
await images[0].decode();const canvas=document.createElement('canvas');canvas.width=canvas.height=1;
|
|
const context=canvas.getContext('2d');context.drawImage(images[0],0,0);
|
|
return {count:images.length,pixel:Array.from(context.getImageData(0,0,1,1).data),caption:images[0].parentElement.querySelector('figcaption').textContent};
|
|
})()`);
|
|
assert.equal(actual.count,1, `Retained image missing after returning to ${documentId}`);
|
|
assert.deepEqual(actual.pixel,expected);
|
|
assert.ok(actual.caption.startsWith(`${documentId} / Page / `));
|
|
retainedImages.push({documentId,expected,actual,objectCount:retained.document.objectCount});
|
|
}
|
|
for (const [width,height] of [[1440,900],[390,844]]) {
|
|
await send("Emulation.setDeviceMetricsOverride", {width,height,deviceScaleFactor:1,mobile:width<700});
|
|
const screenshot=await send("Page.captureScreenshot",{format:"png",captureBeyondViewport:true});
|
|
fs.writeFileSync(path.join(artifacts,`image-${width}.png`),Buffer.from(screenshot.data,"base64"));
|
|
}
|
|
console.log(JSON.stringify({ schema: "freecad-web-business-cases/v1", results: [{
|
|
capabilityId: "TechDraw:desktop:TechDraw_Image", status: "passed", cases: [{
|
|
input: { file: "red.bmp", pixel: [255,0,0,255], page: "Page", owner: "View", document: "TechDrawDrawing" },
|
|
actual: { imageRecord, imagePixels, checks, retainedImages, routed }, assertions: [
|
|
{ name: "Manifest routing retains the same native drawing for creation and FCStd save", passed: routed.loaded.length === 1 && routed.saved.byteLength > 0 },
|
|
{ name: "Switching documents and recomputing retains each native image and displays only its document pixels",
|
|
passed: retainedImages.length === 2 && retainedImages.every(({actual, expected, documentId}) =>
|
|
actual.count === 1 && actual.pixel.every((value, index) => value === expected[index])
|
|
&& actual.caption.startsWith(`${documentId} / Page / `)) },
|
|
{ name: "Uploaded image inserted through workbench Worker in current document", passed: imageRecord.result.document === "TechDrawDrawing" && imageRecord.code === "native_image_created" },
|
|
{ name: "Browser decodes uploaded native image to expected RGBA pixel", passed: imagePixels.every((value, index) => value === [255,0,0,255][index]) },
|
|
],
|
|
}, {
|
|
input: { documentId: "TechDrawDrawing", page: "Page", owner: "View", action: "cancel", imageBase64: imageRecord.result.imageBase64 },
|
|
actual: cancelledImage,
|
|
assertions: [
|
|
{ name: "Workbench cancellation reaches native image command", passed: cancelledImage.record.status === "cancelled"
|
|
&& cancelledImage.record.code === "image_insertion_cancelled" },
|
|
{ name: "Workbench cancellation preserves the displayed image", passed: cancelledImage.imageCount === 1 },
|
|
],
|
|
}],
|
|
}] }));
|
|
} finally {
|
|
for (const request of pending.values()) clearTimeout(request.timer);
|
|
socket?.close();
|
|
chrome.kill("SIGTERM");
|
|
await closed;
|
|
fs.rmSync(profile, { recursive: true, force: true });
|
|
}
|