test(tests): R4.3d browser proofs on the production build: app import baseline on the Rust path, CSP with and without the keyword, leak series, WebKit repetition

Same perimeter as the TS baseline (226 files, 3 engines, real Home page): 666/678 outcome
and message agreements, the 12 others the 4 declared files; W5 0 long tasks (TS 91 and
173 ms); 50 MiB file in WebKit 145/126 MiB against 324 with the worker read and 76 for the
TS. CSP: editor opens with the keyword, the engine message without, in 3 engines, the
worker's wasm-eval refusal reported by Chromium and Firefox. Leak series on the app:
Chromium ≤ 2 MiB per import after init, Firefox GC sawtooth reclaimed, WebKit grows with
same-tab navigations (control too) and levels off on one page; 20/20 WebKit workers closed.
This commit is contained in:
bchanot committed 2026-10-18 19:48:31 +02:00
1 parent 8ddf185aa6
commit 08f01ef363
17 files changed
+26759 -28

No files matched your search

+375
View File
@@ -0,0 +1,375 @@
// CSP proof of the application's import worker (R4.3d, plan §B.1.5, DEPLOY.md
// OD-1): the server's two policies, the three engines, one reference PDF
// picked on Home, a fresh browser per engine and policy.
// with DEPLOY.md's policy, 'wasm-unsafe-eval' in script-src: the
// import opens the editor; no violation for scripts, workers or
// wasm (the footer's external image is the one known violation).
// without the keyword removed: the inline line « Le moteur de lecture n'a
// pas pu être chargé. Réessayez l'import. », the button enabled
// again, no page error, and a second pick of the same file shows
// the same line (the page stays usable).
// Violations: the document's `securitypolicyviolation` events (the
// init-script probe) and every console message of the page and its
// workers. A worker's own `securitypolicyviolation` event fires in the
// worker's scope, out of the harness's reach without changing the
// application's worker, so both policies run a second time with
// `report-uri` appended (the enforced directives unchanged): the reports
// the browser POSTs name what was blocked and where, workers included. Each
// browser runs under the 4 GiB RSS watchdog (not a guaranteed memory
// limit). Exit code 1 when a run is not as expected.
//
// PLAYWRIGHT_NODE_MODULES=... node scripts/browser/r4-app-csp.mjs \
// [--engines chromium,firefox,webkit] [--out <file>]
import { readFileSync, writeFileSync } from 'node:fs'
import { join } from 'node:path'
import { pathToFileURL } from 'node:url'
import { parseArgs } from 'node:util'
import {
IMPORT_ERROR,
PICK_LABEL,
finalState,
firstEnd,
resultOf,
settle,
} from './import-baseline.mjs'
import { checkBuild } from './lib/app-build.mjs'
import { delay, firstLine, isStop, untilStopped } from './lib/async.mjs'
import { hostFacts, memAvailableBytes } from './lib/host.mjs'
import { sha256 } from './lib/inputs.mjs'
import { countErrorLines, probedPage } from './lib/page-probes.mjs'
import {
FIXTURES_DIR,
REPO_ROOT,
RESULTS_DIR,
relativeToRepo,
} from './lib/paths.mjs'
import {
ENGINES,
closeEngine,
launchEngine,
loadPlaywright,
} from './lib/playwright.mjs'
import { resultsJson } from './lib/results-json.mjs'
import { watchdogFacts } from './lib/watchdog.mjs'
import { startServer } from './serve.mjs'
const REFERENCE = join(FIXTURES_DIR, 'pdf/r3/demo.fr.logos.pdf')
const FR_DICT = join(REPO_ROOT, 'apps/app/src/i18n/fr.ts')
// The two policies as served, then the same with `report-uri` appended:
// the browser POSTs each violation report to the server, workers included.
const PASSES = [
{ variant: 'with', reporting: false },
{ variant: 'without', reporting: false },
{ variant: 'with', reporting: true },
{ variant: 'without', reporting: true },
]
const KNOWN_IMAGE_HOST = 'zenquality.fr'
const CSP_TEXT = /content.security.policy|refused to|unsafe-eval|\bCSP\b/i
const LATE_VIOLATIONS_MS = 2000
const RETRY_TIMEOUT_MS = 30_000
const MAX_CONSOLE = 40
const today = () => new Date().toISOString().slice(0, 10)
const log = (line) => console.error(`[${new Date().toISOString()}] ${line}`)
const pathOf = (url) => {
try {
return new URL(url).pathname
} catch {
return url
}
}
function options() {
const { values } = parseArgs({
options: {
engines: { type: 'string', default: ENGINES.join(',') },
out: {
type: 'string',
default: join(RESULTS_DIR, `${today()}-r4-csp.json`),
},
},
})
const engines = values.engines.split(',').filter(Boolean)
const unknown = engines.filter((e) => !ENGINES.includes(e))
if (unknown.length) throw new Error(`unknown engines: ${unknown.join(', ')}`)
return { engines, out: values.out }
}
const pickButton = (page) => page.getByRole('button', { name: PICK_LABEL })
/** Home in a fresh context, every console message and worker recorded. */
async function cspTab(session, baseUrl) {
const context = await session.browser.newContext({ locale: 'fr-FR' })
const seed = { draft: null, locale: 'fr', skipDisclaimer: false }
const { page, events } = await probedPage(context, seed)
const seen = { console: [], workers: [], crashed: false }
page.on('console', (m) => {
const worker = m.worker()
const text = m.text().slice(0, 400)
seen.console.push({
type: m.type(),
worker: worker && pathOf(worker.url()),
text,
})
})
page.on('worker', (w) => {
const row = { path: pathOf(w.url()), closed: false }
seen.workers.push(row)
w.on('close', () => (row.closed = true))
})
page.on('crash', () => (seen.crashed = true))
await page.goto(`${baseUrl}/`)
await pickButton(page).and(page.locator(':enabled')).waitFor()
return { context, page, events, seen }
}
async function buttonEnabled(page) {
return pickButton(page)
.and(page.locator(':enabled'))
.waitFor({ timeout: 5000 })
.then(() => true)
.catch(() => false)
}
/** One pick, as import-baseline.mjs measures it, then 2 s for late events. */
async function firstImport(session, tab) {
const since = await tab.page.evaluate(() => performance.now())
const start = performance.now()
const first = await untilStopped(session, firstEnd(tab, REFERENCE))
const durationMs = first.at - start
if (isStop(first) || first.kind === 'timeout' || first.kind === 'error') {
return { outcome: first.kind, error: first.error ?? null, durationMs }
}
await settle(tab, first)
await delay(LATE_VIOLATIONS_MS)
const final = await finalState(tab, since)
return { outcome: resultOf(final), durationMs, ...final }
}
/** A second pick of the same file: the inline line must come back. */
async function retryImport(tab) {
const { page } = tab
await page.evaluate(countErrorLines)
await page.setInputFiles('input[type="file"]', REFERENCE)
const shown = await page
.waitForFunction(() => window.__errorLines > 0, null, {
timeout: RETRY_TIMEOUT_MS,
})
.then(() => true)
.catch(() => false)
const errorText = shown
? await page.locator(IMPORT_ERROR).textContent({ timeout: 1000 })
: null
return { shown, errorText, buttonEnabledAfter: await buttonEnabled(page) }
}
/** The violations and console messages that name the policy. */
function violationsOf(row, seen) {
const documentViolations = row.cspViolations ?? []
const consoleCsp = seen.console.filter((m) => CSP_TEXT.test(m.text))
const known = (text) => text.includes(KNOWN_IMAGE_HOST)
return {
documentViolations,
unexpectedDocumentViolations: documentViolations.filter((v) => !known(v)),
consoleCsp,
unexpectedConsoleCsp: consoleCsp.filter((m) => !known(m.text)),
}
}
/** One `report-uri` report, the fields that name what was blocked where. */
function reportFacts(report) {
const r = report['csp-report'] ?? report
return {
documentPath: r['document-uri'] && pathOf(r['document-uri']),
effectiveDirective: r['effective-directive'],
violatedDirective: r['violated-directive'],
blockedUri: r['blocked-uri'],
sourceFile: r['source-file'] && pathOf(r['source-file']),
disposition: r.disposition,
unparsed: r.unparsed,
}
}
/** What each policy must show (header comment); empty when as expected. */
function problemsOf(variant, row, coreUnavailable) {
const problems = []
if (row.pageErrors?.length) problems.push('page errors')
if (row.crashed) problems.push('page crashed')
if (variant === 'with') {
const known = (r) => String(r.blockedUri).includes(KNOWN_IMAGE_HOST)
if (row.outcome !== 'editor') problems.push(`outcome ${row.outcome}`)
if (row.unexpectedDocumentViolations.length) problems.push('violations')
if (row.unexpectedConsoleCsp.length) problems.push('CSP console messages')
if (row.reports?.some((r) => !known(r))) problems.push('reports')
return problems
}
if (row.errorText !== coreUnavailable) problems.push('inline line')
if (!row.buttonEnabledAfter) problems.push('button not enabled again')
if (row.retry?.errorText !== coreUnavailable) problems.push('retry line')
if (!row.retry?.buttonEnabledAfter) problems.push('retry: button')
return problems
}
async function cspRun(session, baseUrl, variant, coreUnavailable) {
const tab = await cspTab(session, baseUrl)
try {
const row = await firstImport(session, tab)
if (variant === 'without' && row.outcome === 'error') {
row.buttonEnabledAfter = await buttonEnabled(tab.page)
row.retry = await retryImport(tab)
}
const { seen } = tab
const full = { ...row, ...violationsOf(row, seen), crashed: seen.crashed }
full.workers = seen.workers
full.console = seen.console.slice(0, MAX_CONSOLE)
full.consoleCount = seen.console.length
delete full.cspViolations
return full
} finally {
await tab.context.close().catch(() => undefined)
}
}
/** One engine's run; the reports are read once its browser is closed. */
async function engineRun(pw, engine, { server, pass, coreUnavailable }) {
const session = await launchEngine(pw, engine)
const head = { ...pass, engine, engineVersion: session.version }
let row
try {
row = await cspRun(session, server.url, pass.variant, coreUnavailable)
} catch (error) {
row = { outcome: 'error', error: firstLine(error) }
} finally {
await closeEngine(session)
}
if (pass.reporting) row.reports = server.reports.splice(0).map(reportFacts)
if (!row.error) row.problems = problemsOf(pass.variant, row, coreUnavailable)
return { ...head, ...row }
}
async function passRuns(pw, pass, engines, coreUnavailable) {
const server = await startServer({
csp: pass.variant,
reportViolations: pass.reporting,
})
const runs = []
try {
for (const engine of engines) {
const run = await engineRun(pw, engine, { server, pass, coreUnavailable })
runs.push(run)
log(
`${policyName(pass)} ${engine}: ${run.outcome} ` +
`${run.problems ?? run.error}`,
)
}
} finally {
server.close()
}
return { csp: server.csp, runs }
}
const policyName = (pass) =>
pass.reporting ? `${pass.variant} + report-uri` : pass.variant
const asExpected = (r) => Array.isArray(r.problems) && r.problems.length === 0
function summary(result) {
const line = (cells) => `| ${cells.join(' | ')} |`
const header = [
'Policy',
'Engine',
'Outcome',
'Inline line',
'Button enabled',
'Retry line',
'Document violations',
'CSP console messages',
'report-uri reports',
'Workers created / closed',
'Page errors',
'Verdict',
]
const reportCell = (r) =>
r.reporting
? (r.reports ?? [])
.map(
(x) =>
`[${x.documentPath}] ${x.effectiveDirective} ${x.blockedUri}`,
)
.join('; ') || 'none'
: '–'
const rows = result.runs.map((r) =>
line([
policyName(r),
r.engine,
r.outcome,
r.errorText ?? '–',
String(r.buttonEnabledAfter ?? '–'),
r.retry?.errorText ?? '–',
(r.documentViolations ?? []).join('; ') || 'none',
(r.consoleCsp ?? [])
.map((m) => `[${m.worker ?? 'page'}] ${m.text}`)
.join('; ') || 'none',
reportCell(r),
r.workers
? `${r.workers.length} / ${r.workers.filter((w) => w.closed).length}`
: '–',
String(r.pageErrors?.length ?? '–'),
asExpected(r)
? 'as expected'
: `NOT AS EXPECTED: ${r.problems ?? r.error}`,
]),
)
return [line(header), line(header.map(() => '---')), ...rows].join('\n')
}
async function main() {
const opts = options()
const build = checkBuild()
const { pw, version } = loadPlaywright()
const { fr } = await import(pathToFileURL(FR_DICT).href)
const coreUnavailable = fr['home.import.error_core_unavailable']
const result = {
harness: 'scripts/browser/r4-app-csp.mjs',
startedAt: new Date().toISOString(),
watchdog: watchdogFacts(),
host: hostFacts(),
build,
playwrightCore: version,
reference: {
file: relativeToRepo(REFERENCE),
bytes: readFileSync(REFERENCE).length,
sha256: sha256(readFileSync(REFERENCE)),
},
expected: { without: coreUnavailable, knownImageHost: KNOWN_IMAGE_HOST },
observation:
"document: the init-script probe's securitypolicyviolation events; " +
'console: every message of the page and its workers; reporting ' +
'passes: the same enforced directives plus report-uri, the reports ' +
"the browser POSTs (a worker's own violation events fire in its " +
"scope, out of the harness's reach otherwise)",
policies: {},
runs: [],
}
for (const pass of PASSES) {
const { csp, runs } = await passRuns(
pw,
pass,
opts.engines,
coreUnavailable,
)
result.policies[policyName(pass)] = csp
result.runs.push(...runs)
}
result.endedAt = new Date().toISOString()
result.host.memAvailableBytesAtEnd = memAvailableBytes()
result.engines = Object.fromEntries(
result.runs.map((r) => [r.engine, r.engineVersion]),
)
writeFileSync(opts.out, `${resultsJson(result)}\n`)
log(`results written to ${opts.out}`)
console.log(summary(result))
if (!result.runs.every(asExpected)) process.exitCode = 1
}
await main()