150 lines
11 KiB
JavaScript
150 lines
11 KiB
JavaScript
import assert from "node:assert/strict";
|
|
import fs from "node:fs";
|
|
import os from "node:os";
|
|
import path from "node:path";
|
|
import { execFileSync } from "node:child_process";
|
|
import { fileURLToPath, pathToFileURL } from "node:url";
|
|
import { loadWasmProbe } from "./wasm-probe-runtime.mjs";
|
|
|
|
const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
|
|
const out = fs.mkdtempSync(path.join(os.tmpdir(), "freecad-draft-business-"));
|
|
const ids = JSON.parse(process.env.FREECAD_BUSINESS_IDS ?? '["Draft:draft.formatBatch"]');
|
|
const svgIds = new Set(["business-format:Draft:import:.svg", "business-format:Draft:export:.svg"]);
|
|
const dxfId = "business-format:Draft:import:.dxf";
|
|
const started = performance.now();
|
|
const timings = { operations: [] };
|
|
let exitCode = 0;
|
|
try {
|
|
let stageStarted = performance.now();
|
|
execFileSync(path.join(root, "web/node_modules/.bin/tsc"), [
|
|
"--target", "ES2022", "--module", "ESNext", "--moduleResolution", "Bundler", "--strict", "--skipLibCheck",
|
|
"--outDir", out, path.join(root, "web/src/facade-envelope.ts"), path.join(root, "web/src/draft-python-family-facade.ts"),
|
|
], { cwd: root, stdio: "pipe" });
|
|
timings.transpileSeconds = (performance.now() - stageStarted) / 1000;
|
|
const facade = await import(pathToFileURL(path.join(out, "draft-python-family-facade.js")));
|
|
const { FacadeSerialQueue } = await import(pathToFileURL(path.join(out, "facade-envelope.js")));
|
|
stageStarted = performance.now();
|
|
const { kernel } = await loadWasmProbe(process.env.FREECAD_DRAFT_BUSINESS_BUILD ?? path.join(root, "web/public/kernel"), "FreeCADWebDraftRuntimeProbe");
|
|
timings.nativeLoadSeconds = (performance.now() - stageStarted) / 1000;
|
|
const queue = new FacadeSerialQueue(); let n = 0;
|
|
const call = async records => {
|
|
const began = performance.now();
|
|
const result = await facade.dispatchDraftFormat(queue, facade.createDraftFormatRequest(`draft-${++n}`, records), kernel);
|
|
timings.operations.push({ format: records[0].format, direction: records[0].direction, seconds: (performance.now() - began) / 1000, result: result.kind });
|
|
return result;
|
|
};
|
|
const cases = [];
|
|
for (const request of [null, undefined, {}, { requestId: 17 }]) {
|
|
const rejected = await facade.dispatchDraftFormat(queue, request, kernel);
|
|
assert.equal(rejected.kind, "error", JSON.stringify(rejected));
|
|
assert.equal(rejected.requestId, "invalid");
|
|
cases.push({ input: { malformedRequest: request ?? null }, actual: rejected,
|
|
assertions: [{ name: "malformed format envelope returns a structured error", passed: true }] });
|
|
}
|
|
const lengths = [];
|
|
for (const [documentId, width, height] of [["DraftCaseA", 5, 3], ["DraftCaseB", 8, 4]]) {
|
|
const payload = `<svg xmlns="http://www.w3.org/2000/svg"><rect width="${width}" height="${height}"/></svg>`;
|
|
const imported = await call([{ format: "svg", direction: "import", documentId, payload }]);
|
|
assert.equal(imported.kind, "result", JSON.stringify(imported));
|
|
const first = imported.result.records[0];
|
|
assert.equal(first.documentId, documentId);
|
|
assert.equal(first.objectCount > 0, true);
|
|
assert.equal(first.objects.every(object => object.isNull === false && object.length > 0), true);
|
|
lengths.push(first.objects.reduce((sum, object) => sum + object.length, 0));
|
|
const appended = await call([{ format: "svg", direction: "import", documentId, payload }]);
|
|
assert.equal(appended.kind, "result", JSON.stringify(appended));
|
|
const second = appended.result.records[0];
|
|
assert.equal(second.documentId, documentId);
|
|
assert.equal(second.objectCount, first.objectCount);
|
|
assert.equal(second.objects.every(object => !first.objects.some(prior => prior.objectHandle === object.objectHandle)), true);
|
|
const exported = await call([{ format: "svg", direction: "export", documentId }]);
|
|
assert.equal(exported.kind, "result", JSON.stringify(exported));
|
|
assert.match(exported.result.records[0].payload, /<svg/i);
|
|
const exportedNames = new Set(exported.result.records[0].objects.map(object => object.objectHandle));
|
|
const retainsImports = [...first.objects, ...second.objects].every(object => exportedNames.has(object.objectHandle));
|
|
assert.equal(retainsImports, true);
|
|
const roundTrip = await call([{ format: "svg", direction: "import", documentId: `${documentId}RoundTrip`, payload: exported.result.records[0].payload }]);
|
|
assert.equal(roundTrip.kind, "result", JSON.stringify(roundTrip));
|
|
const restored = roundTrip.result.records[0];
|
|
const exportedLength = exported.result.records[0].objects.reduce((sum, object) => sum + object.length, 0);
|
|
const restoredLength = restored.objects.reduce((sum, object) => sum + object.length, 0);
|
|
assert.ok(Math.abs(restoredLength - exportedLength) < 1e-6, `SVG round trip changed native perimeter: ${exportedLength} -> ${restoredLength}`);
|
|
cases.push({ actual: { firstImport: first, repeatedImport: second, export: exported.result.records[0], roundTrip: restored }, input: { records: [
|
|
{ format: "svg", direction: "import", documentId, payload },
|
|
{ format: "svg", direction: "import", documentId, payload },
|
|
{ format: "svg", direction: "export", documentId },
|
|
] }, assertions: [
|
|
{ name: "native SVG import creates geometry in the requested new document", passed: first.documentId === documentId && first.objects.every(object => object.isNull === false && object.length > 0) },
|
|
{ name: "repeated import appends distinct objects to the existing document", passed: second.objects.every(object => !first.objects.some(prior => prior.objectHandle === object.objectHandle)) },
|
|
{ name: "export retains geometry from both imports", passed: retainsImports },
|
|
{ name: "exported SVG restores the native perimeter in another document", passed: Math.abs(restoredLength - exportedLength) < 1e-6 },
|
|
] });
|
|
}
|
|
assert.ok(Math.abs(lengths[1] / lengths[0] - 1.5) < 1e-8, `native perimeters must scale with 5x3 and 8x4 rectangles: ${lengths}`);
|
|
const observedInput = { format: "svg", direction: "import", documentId: "draft-user", payload: '<svg xmlns="http://www.w3.org/2000/svg"><rect width="5" height="3"/></svg>' };
|
|
const observed = await call([observedInput]);
|
|
assert.equal(observed.kind, "result", JSON.stringify(observed));
|
|
assert.equal(observed.result.records[0].objects.every(object => object.isNull === false && object.length > 0), true);
|
|
cases.push({ input: observedInput, actual: observed.result.records[0], assertions: [
|
|
{ name: "original runtime issue input creates real native SVG geometry", passed: true },
|
|
{ name: "different SVG dimensions produce proportional native perimeters", passed: true },
|
|
] });
|
|
const missing = await call([{ format: "svg", direction: "export", documentId: "NoSuchDraftDocument" }]);
|
|
assert.equal(missing.kind, "error");
|
|
cases.push({ input: { format: "svg", direction: "export", documentId: "NoSuchDraftDocument" }, assertions: [{ name: "missing document is rejected", passed: missing.kind === "error" }] });
|
|
const dxfCases = [];
|
|
let dxfError = null;
|
|
if (ids.includes(dxfId) || ids.includes("Draft:draft.formatBatch")) {
|
|
try {
|
|
const length = record => record.objects.reduce((sum, object) => sum + (object.length ?? 0), 0);
|
|
for (const [documentId, x, y] of [["DXFBusinessCheck", 3, 4], ["DXFBusinessOther", 6, 8]]) {
|
|
const payload = ["0", "SECTION", "2", "ENTITIES", "0", "LINE", "8", "0", "10", "0", "20", "0", "30", "0",
|
|
"11", String(x), "21", String(y), "31", "0", "0", "ENDSEC", "0", "EOF", ""].join("\n");
|
|
const input = { format: "dxf", direction: "import", documentId, payload };
|
|
const imported = await call([input]);
|
|
assert.equal(imported.kind, "result", JSON.stringify(imported));
|
|
const first = imported.result.records[0];
|
|
assert.equal(first.documentId, documentId);
|
|
assert.ok(Math.abs(length(first) - Math.hypot(x, y)) < 1e-6, JSON.stringify(first));
|
|
const exported = await call([{ format: "dxf", direction: "export", documentId }]);
|
|
assert.equal(exported.kind, "result", JSON.stringify(exported));
|
|
const saved = exported.result.records[0];
|
|
assert.match(saved.payload, /ENTITIES/);
|
|
const roundTrip = await call([{ ...input, documentId: `${documentId}Restored`, payload: saved.payload }]);
|
|
assert.equal(roundTrip.kind, "result", JSON.stringify(roundTrip));
|
|
assert.ok(Math.abs(length(roundTrip.result.records[0]) - Math.hypot(x, y)) < 1e-6);
|
|
const invalid = await call([{ ...input, payload: "not a DXF document" }]);
|
|
assert.equal(invalid.kind, "error", JSON.stringify(invalid));
|
|
const recovered = await call([{ format: "dxf", direction: "export", documentId }]);
|
|
assert.equal(recovered.kind, "result", JSON.stringify(recovered));
|
|
assert.ok(Math.abs(length(recovered.result.records[0]) - Math.hypot(x, y)) < 1e-6);
|
|
dxfCases.push({ input: { import: input, export: { format: "dxf", direction: "export", documentId },
|
|
roundTripDocument: `${documentId}Restored`, rejectedPayload: "not a DXF document" },
|
|
actual: { imported: first, exported: saved, restored: roundTrip.result.records[0], recovered: recovered.result.records[0] },
|
|
assertions: [
|
|
{ name: "supplied DXF coordinates produce the expected native line length", passed: true },
|
|
{ name: "native DXF export and reimport preserve geometry in another document", passed: true },
|
|
{ name: "invalid import is rejected and preserves existing document geometry", passed: true },
|
|
] });
|
|
}
|
|
} catch (error) { dxfError = String(error.stack ?? error); }
|
|
}
|
|
timings.totalSeconds = (performance.now() - started) / 1000;
|
|
const report = { schema: "freecad-web-business-cases/v1", timings, results: ids.map(capabilityId => {
|
|
if (svgIds.has(capabilityId)) return { capabilityId, status: "passed", scope: "native-svg-format-workflow", cases };
|
|
if (capabilityId === dxfId || capabilityId === "Draft:draft.formatBatch") return {
|
|
capabilityId, status: dxfError ? "failed" : "passed", scope: "native-svg-dxf-document-workflow", error: dxfError,
|
|
resolvedIssueIds: capabilityId === "Draft:draft.formatBatch" && !dxfError ? ["runtime:8fe11605fccfd0b61b22", "runtime:be933a588c91c63f48da"] : [],
|
|
cases: capabilityId === dxfId ? dxfCases : [...cases, ...dxfCases],
|
|
};
|
|
return { capabilityId, status: "not_implemented", cases: [] };
|
|
}) };
|
|
await new Promise((resolve, reject) => process.stdout.write(JSON.stringify(report) + "\n", error => error ? reject(error) : resolve()));
|
|
} catch (error) {
|
|
fs.writeSync(2, String(error.stack ?? error) + "\n");
|
|
if (error.stdout?.length) fs.writeSync(2, error.stdout);
|
|
if (error.stderr?.length) fs.writeSync(2, error.stderr);
|
|
exitCode = 1;
|
|
} finally { fs.rmSync(out, { recursive: true, force: true }); }
|
|
process.exit(exitCode);
|