test(tests): R4.1e browser harness and TS baselines (Chromium, Firefox, WebKit)
Playwright harness under scripts/browser: 127.0.0.1 server with the DEPLOY CSP, export and import baselines of the TypeScript engine under a 4 GiB RSS watchdog (not a guaranteed memory limit), O9 browser columns in inflate.browsers.json (26 rows agree with Node in all three engines). Results of 2026-10-18 committed; the O9 Node test no longer expects browser columns in inflate.json.
This commit is contained in:
1 parent
4bdfda59ba
commit
4439fd2420
23 files changed
+20903
-18
No files matched your search
@@ -0,0 +1,259 @@
|
||||
// Export baseline of the TypeScript PDF engine (R4.1e, plan O12, §B.4):
|
||||
// each run launches a fresh browser, seeds the tab's draft with a reference
|
||||
// report, opens /editor, clicks « Exporter en PDF » and waits for the
|
||||
// download. Records time, PDF size, every PNG the browser rasteriser
|
||||
// encoded, the browser's summed RSS (before, peak, after), the Chromium JS
|
||||
// heap, the dialogs, and stopped_by_ceiling when the watchdog killed it.
|
||||
//
|
||||
// PLAYWRIGHT_NODE_MODULES=... node scripts/browser/export-baseline.mjs \
|
||||
// [--engines chromium,firefox,webkit] [--out <file>]
|
||||
import { readFileSync } from 'node:fs'
|
||||
import { join } from 'node:path'
|
||||
import { pathToFileURL } from 'node:url'
|
||||
import {
|
||||
delay,
|
||||
firstLine,
|
||||
tagged,
|
||||
timeoutAfter,
|
||||
untilStopped,
|
||||
} from './lib/async.mjs'
|
||||
import { runHarnessCli } from './lib/harness.mjs'
|
||||
import { FIXTURES_DIR } from './lib/paths.mjs'
|
||||
import { probedPage, readProbe } from './lib/page-probes.mjs'
|
||||
import { closeEngine, launchEngine } from './lib/playwright.mjs'
|
||||
import { sum } from './lib/stats.mjs'
|
||||
|
||||
const MINUTE = 60_000
|
||||
export const EXPORT_REPORTS = [
|
||||
{ id: 'demo', file: 'report-v3.demo.json', runs: 3, timeoutMs: 5 * MINUTE },
|
||||
{ id: 'L', file: 'r4/reports/L.json', runs: 3, timeoutMs: 30 * MINUTE },
|
||||
{ id: 'CAP', file: 'r4/reports/CAP.json', runs: 1, timeoutMs: 45 * MINUTE },
|
||||
]
|
||||
const EXPORT_LABEL = 'Exporter en PDF' // fr.ts editor.export
|
||||
const CANVAS = '.svg-canvas [data-anno-id]'
|
||||
const LOAD_TIMEOUT_MS = 2 * MINUTE
|
||||
const GC_SETTLE_MS = 1000
|
||||
const IDLE_SETTLE_MS = 5000
|
||||
const PROGRESS_POLL_MS = 2000
|
||||
|
||||
/** The draft exactly as persistence.ts writes it: JSON.stringify(report). */
|
||||
function draftOf(report) {
|
||||
const text = readFileSync(join(FIXTURES_DIR, report.file), 'utf8')
|
||||
return JSON.stringify(JSON.parse(text))
|
||||
}
|
||||
|
||||
async function chromiumCdp(session, context, page) {
|
||||
if (session.engine !== 'chromium') return null
|
||||
const cdp = await context.newCDPSession(page)
|
||||
await cdp.send('Performance.enable')
|
||||
return cdp
|
||||
}
|
||||
|
||||
async function openEditor(session, baseUrl, report) {
|
||||
const context = await session.browser.newContext({
|
||||
acceptDownloads: true,
|
||||
locale: 'fr-FR',
|
||||
})
|
||||
const seed = { draft: draftOf(report), locale: 'fr', skipDisclaimer: true }
|
||||
const { page, events } = await probedPage(context, seed)
|
||||
const cdp = await chromiumCdp(session, context, page)
|
||||
await page.goto(`${baseUrl}/editor`)
|
||||
await page.waitForSelector(CANVAS, { timeout: LOAD_TIMEOUT_MS })
|
||||
const button = page.getByRole('button', { name: EXPORT_LABEL })
|
||||
await button.and(page.locator(':enabled')).waitFor()
|
||||
return { context, page, events, cdp, button }
|
||||
}
|
||||
|
||||
async function jsHeap(cdp) {
|
||||
const { metrics } = await cdp.send('Performance.getMetrics')
|
||||
const value = (name) => metrics.find((m) => m.name === name)?.value ?? null
|
||||
return { used: value('JSHeapUsedSize'), total: value('JSHeapTotalSize') }
|
||||
}
|
||||
|
||||
/** Settled memory: forced GC in Chromium (CDP), 5 s idle elsewhere. */
|
||||
async function settledMemory(session, cdp) {
|
||||
if (cdp) await cdp.send('HeapProfiler.collectGarbage')
|
||||
await delay(cdp ? GC_SETTLE_MS : IDLE_SETTLE_MS)
|
||||
const rss = session.watchdog.snapshot()
|
||||
const heap = cdp ? await jsHeap(cdp) : null
|
||||
return {
|
||||
rssBytes: rss.currentBytes,
|
||||
rssContentBytes: rss.currentContentBytes,
|
||||
rssMaxProcessBytes: rss.currentMaxProcessBytes,
|
||||
jsHeapUsedBytes: heap?.used ?? null,
|
||||
jsHeapTotalBytes: heap?.total ?? null,
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Polls how many PNG blobs the page has encoded, so a run the watchdog kills
|
||||
* still says how far the export got. One read at a time (the page's main
|
||||
* thread may be busy for seconds); stops at the first failed read.
|
||||
*/
|
||||
function trackRasters(tab) {
|
||||
let reading = false
|
||||
const read = () => {
|
||||
if (reading) return
|
||||
reading = true
|
||||
tab.page
|
||||
.evaluate(() => window.__harness.png.length)
|
||||
.then((count) => (tab.rastersSoFar = count))
|
||||
.catch(() => clearInterval(timer))
|
||||
.finally(() => (reading = false))
|
||||
}
|
||||
const timer = setInterval(read, PROGRESS_POLL_MS)
|
||||
return () => clearInterval(timer)
|
||||
}
|
||||
|
||||
async function clickAndDownload(tab, timeoutMs) {
|
||||
const download = tab.page.waitForEvent('download', { timeout: 0 })
|
||||
download.catch(() => undefined)
|
||||
const clicked = tab.button.click().then(() => download)
|
||||
const stopTracking = trackRasters(tab)
|
||||
const end = Promise.race([
|
||||
tagged('downloaded', clicked),
|
||||
timeoutAfter(timeoutMs),
|
||||
])
|
||||
end.finally(stopTracking)
|
||||
return end
|
||||
}
|
||||
|
||||
async function downloadBytes(download) {
|
||||
const stream = await download.createReadStream()
|
||||
let bytes = 0
|
||||
for await (const chunk of stream) bytes += chunk.length
|
||||
return bytes
|
||||
}
|
||||
|
||||
/** PNG blobs; the first is the partner SVG logo (branding precedes pages). */
|
||||
function rastersOf(probe) {
|
||||
const sizes = probe.png.map((p) => p.bytes ?? 0)
|
||||
const views = sizes.slice(1)
|
||||
return {
|
||||
count: sizes.length,
|
||||
totalBytes: sum(sizes),
|
||||
logoBytes: sizes[0] ?? null,
|
||||
views: {
|
||||
count: views.length,
|
||||
totalBytes: sum(views),
|
||||
minBytes: views.length ? Math.min(...views) : null,
|
||||
maxBytes: views.length ? Math.max(...views) : null,
|
||||
},
|
||||
nullBlobs: probe.png.filter((p) => p.bytes === null).length,
|
||||
dataUrlFallbacks: probe.dataUrls,
|
||||
dimensions: [...new Set(probe.png.map((p) => `${p.width}x${p.height}`))],
|
||||
}
|
||||
}
|
||||
|
||||
const elapsed = (from, to) => (from === null || to === null ? null : to - from)
|
||||
|
||||
function peakOf(snapshot) {
|
||||
return {
|
||||
rssPeakBytes: snapshot.peakBytes,
|
||||
rssPeakContentBytes: snapshot.peakContentBytes,
|
||||
rssPeakMaxProcessBytes: snapshot.peakMaxProcessBytes,
|
||||
}
|
||||
}
|
||||
|
||||
function eventsOf(tab) {
|
||||
const { dialogs, pageErrors, consoleErrors } = tab.events
|
||||
return { dialogs: dialogs.map((d) => d.message), pageErrors, consoleErrors }
|
||||
}
|
||||
|
||||
/** The part after the download: size, alerts, settled memory, probes. */
|
||||
async function afterDownload(session, tab, end) {
|
||||
const pdfBytes = await downloadBytes(end.value)
|
||||
await tab.button.and(tab.page.locator(':enabled')).waitFor()
|
||||
await delay(500)
|
||||
const peak = peakOf(session.watchdog.snapshot())
|
||||
const after = await settledMemory(session, tab.cdp)
|
||||
const probe = await tab.page.evaluate(readProbe)
|
||||
return {
|
||||
pdfBytes,
|
||||
suggestedFilename: end.value.suggestedFilename(),
|
||||
exportMs: elapsed(probe.clickAt, probe.pdfBlobAt),
|
||||
rasters: rastersOf(probe),
|
||||
cspViolations: probe.csp,
|
||||
...peak,
|
||||
after,
|
||||
}
|
||||
}
|
||||
|
||||
/** A run that did not download: how far it got and what it held. */
|
||||
function unfinished(session, tab, end, base) {
|
||||
const snapshot = session.watchdog.snapshot()
|
||||
return {
|
||||
outcome: end.kind,
|
||||
error: end.error ?? null,
|
||||
...base,
|
||||
...peakOf(snapshot),
|
||||
stoppedAtBytes: snapshot.stopped ? snapshot.stoppedAtBytes : null,
|
||||
rastersBeforeEnd: tab.rastersSoFar ?? null,
|
||||
...eventsOf(tab),
|
||||
}
|
||||
}
|
||||
|
||||
async function measureExport(session, baseUrl, report) {
|
||||
const tab = await openEditor(session, baseUrl, report)
|
||||
const before = await settledMemory(session, tab.cdp)
|
||||
await session.watchdog.resetPeak()
|
||||
const start = performance.now()
|
||||
const end = await untilStopped(
|
||||
session,
|
||||
clickAndDownload(tab, report.timeoutMs),
|
||||
)
|
||||
const base = { before, clickToEndMs: end.at - start }
|
||||
if (end.kind !== 'downloaded') return unfinished(session, tab, end, base)
|
||||
const rest = await afterDownload(session, tab, end)
|
||||
return { outcome: 'downloaded', ...base, ...rest, ...eventsOf(tab) }
|
||||
}
|
||||
|
||||
async function exportRun(pw, { engine, baseUrl, report, index }) {
|
||||
const session = await launchEngine(pw, engine)
|
||||
const head = { engine, engineVersion: session.version, report: report.id }
|
||||
try {
|
||||
const measured = await measureExport(session, baseUrl, report)
|
||||
return { ...head, run: index + 1, ...measured }
|
||||
} catch (error) {
|
||||
const stopped = session.watchdog.snapshot().stopped
|
||||
const outcome = stopped ? 'stopped_by_ceiling' : 'error'
|
||||
return { ...head, run: index + 1, outcome, error: firstLine(error) }
|
||||
} finally {
|
||||
await closeEngine(session)
|
||||
}
|
||||
}
|
||||
|
||||
function runPlan(engines, baseUrl, wanted) {
|
||||
const reports = EXPORT_REPORTS.filter((r) => !wanted || wanted.includes(r.id))
|
||||
return engines.flatMap((engine) =>
|
||||
reports.flatMap((report) =>
|
||||
Array.from({ length: report.runs }, (_, index) => ({
|
||||
engine,
|
||||
baseUrl,
|
||||
report,
|
||||
index,
|
||||
})),
|
||||
),
|
||||
)
|
||||
}
|
||||
|
||||
export async function runExportBaseline(context) {
|
||||
const { pw, baseUrl, engines, filters, log } = context
|
||||
const runs = []
|
||||
for (const plan of runPlan(engines, baseUrl, filters.reports)) {
|
||||
const run = await exportRun(pw, plan)
|
||||
log(`export ${run.engine} ${run.report} #${run.run}: ${run.outcome}`)
|
||||
if (run.outcome === 'watchdog_failed') throw new Error('watchdog failed')
|
||||
runs.push(run)
|
||||
}
|
||||
const reports = EXPORT_REPORTS.map(({ id, file, runs: n }) => ({
|
||||
id,
|
||||
file: `apps/app/tests/fixtures/${file}`,
|
||||
runs: n,
|
||||
}))
|
||||
return { locale: 'fr', reports, runs }
|
||||
}
|
||||
|
||||
if (import.meta.url === pathToFileURL(process.argv[1]).href) {
|
||||
await runHarnessCli({ export: runExportBaseline })
|
||||
}
|
||||
Reference in new issue
Block a user