Files
faunosteo/scripts/browser/r4-offline-import.mjs
T

201 lines
7.6 KiB
JavaScript

// Offline import of the application (R4.10, recette J1.7): one reference
// PDF picked on Home while online (the editor opens, the worker chunk is
// fetched once), then the network goes, back to Home (« Accueil »), the
// same PDF picked again through « Remplacer le bilan en cours ? ». The
// import must open the editor from the cached worker chunk and the page's
// compiled module. Two ways to lose the network, a fresh browser each:
// emulate Playwright's offline mode (context.setOffline)
// stop the server process killed (connection refused, as a LAN host
// that went away)
// The server is serve.mjs in its own process, so `stop` kills its sockets
// too; its Cache-Control lines are checked first against docker/nginx.conf
// (env.js no-store, /assets/ immutable). Headless WebKit never reuses the
// HTTP cache for a worker script offline (R4.10 finding): its rows are
// reported, not counted. Exit code 1 when a Chromium or Firefox row does
// not open the editor, or any row shows a page error or leaves the page
// without an answer (no editor, no inline line).
//
// PLAYWRIGHT_NODE_MODULES=... node scripts/browser/r4-offline-import.mjs \
// [--engines chromium,firefox,webkit] [--out <file>]
import { spawn } from 'node:child_process'
import { readdirSync, writeFileSync } from 'node:fs'
import { join } from 'node:path'
import { parseArgs } from 'node:util'
import { IMPORT_ERROR, PICK_LABEL } from './import-baseline.mjs'
import { checkBuild } from './lib/app-build.mjs'
import { tagged, timeoutAfter } from './lib/async.mjs'
import { probedPage } from './lib/page-probes.mjs'
import {
DIST_DIR,
FIXTURES_DIR,
HARNESS_DIR,
RESULTS_DIR,
} from './lib/paths.mjs'
import {
ENGINES,
closeEngine,
launchEngine,
loadPlaywright,
} from './lib/playwright.mjs'
import { resultsJson } from './lib/results-json.mjs'
import { IMMUTABLE, NO_STORE } from './serve.mjs'
const REFERENCE = join(FIXTURES_DIR, 'pdf/r3/demo.fr.logos.pdf')
const MODES = ['emulate', 'stop']
const REPLACE_LABEL = 'Remplacer' // fr.ts session.replace.confirm
const HOME_LABEL = 'Accueil' // fr.ts common.home
const CANVAS = '.svg-canvas [data-anno-id]'
// The import's two timers (10 s start, 20 s task) and a margin.
const ANSWER_TIMEOUT_MS = 40_000
const LOAD_TIMEOUT_MS = 60_000
const COUNTED = new Set(['chromium', 'firefox'])
const today = () => new Date().toISOString().slice(0, 10)
const log = (line) => console.error(`[${new Date().toISOString()}] ${line}`)
function options() {
const { values } = parseArgs({
options: {
engines: { type: 'string', default: ENGINES.join(',') },
out: {
type: 'string',
default: join(RESULTS_DIR, `${today()}-r4-offline-import.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 }
}
/** serve.mjs in a child process on a free port; resolves with its URL. */
function startChildServer() {
const child = spawn(
process.execPath,
[join(HARNESS_DIR, 'serve.mjs'), '--port', '0'],
{ stdio: ['ignore', 'pipe', 'inherit'] },
)
const url = new Promise((done, fail) => {
child.once('exit', (code) => fail(new Error(`serve.mjs exited ${code}`)))
child.stdout.on('data', (chunk) => {
const match = String(chunk).match(/serving apps\/app\/dist on (\S+)/)
if (match) done(match[1])
})
})
return { child, url }
}
/** The Cache-Control lines nginx.conf sets, read back from the server. */
async function cacheHeaders(baseUrl) {
const worker = readdirSync(join(DIST_DIR, 'assets')).find((name) =>
/^import\.worker-.*\.js$/.test(name),
)
const read = async (path) =>
(await fetch(`${baseUrl}${path}`)).headers.get('cache-control')
const envJs = await read('/env.js')
const workerChunk = await read(`/assets/${worker}`)
return {
envJs,
workerChunk,
asNginx: envJs === NO_STORE && workerChunk === IMMUTABLE,
}
}
/** One pick through the button (the replace dialog when a bilan is open). */
async function pickReference(page) {
const chooser = page.waitForEvent('filechooser', { timeout: 10_000 })
await page.getByRole('button', { name: PICK_LABEL }).click()
const replace = page.getByRole('button', { name: REPLACE_LABEL })
const replaced = await replace
.waitFor({ timeout: 2000 })
.then(() => replace.click())
.then(() => true)
.catch(() => false)
await (await chooser).setFiles(REFERENCE)
return replaced
}
/** The first answer of an import: the editor or the inline line. */
function answerOf(page) {
return Promise.race([
tagged('editor', page.waitForURL('**/editor', { timeout: 0 })),
tagged('error_text', page.locator(IMPORT_ERROR).waitFor({ timeout: 0 })),
timeoutAfter(ANSWER_TIMEOUT_MS),
])
}
/** Online import, then the network goes, then the offline import. */
async function offlineRun(page, context, server, mode) {
await page.waitForSelector(`button:has-text("${PICK_LABEL}"):enabled`)
await pickReference(page)
const online = await answerOf(page)
if (online.kind !== 'editor') return { online: online.kind }
await page.waitForSelector(CANVAS, { timeout: LOAD_TIMEOUT_MS })
if (mode === 'emulate') await context.setOffline(true)
else server.child.kill('SIGKILL')
await page.getByRole('link', { name: HOME_LABEL }).first().click()
const replaced = await pickReference(page)
const offline = await answerOf(page)
const errorText = await page
.locator(IMPORT_ERROR)
.textContent({ timeout: 300 })
.catch(() => null)
return { online: 'editor', replaced, offline: offline.kind, errorText }
}
/** One engine and mode: its own server, browser and context. */
async function runOne(pw, engine, mode) {
const server = startChildServer()
let session = null
try {
const baseUrl = await server.url
const headers = await cacheHeaders(baseUrl)
session = await launchEngine(pw, engine)
const context = await session.browser.newContext({ locale: 'fr-FR' })
const seed = { draft: null, locale: 'fr', skipDisclaimer: true }
const { page, events } = await probedPage(context, seed)
await page.goto(`${baseUrl}/`)
const run = await offlineRun(page, context, server, mode)
return { engine, mode, headers, ...run, pageErrors: events.pageErrors }
} finally {
if (session) await closeEngine(session)
server.child.kill('SIGKILL')
}
}
/** Why a row fails (header comment); empty when as expected. */
function problemsOf(row) {
const problems = []
if (!row.headers.asNginx) problems.push('cache headers differ from nginx')
if (row.online !== 'editor') problems.push(`online ${row.online}`)
if (row.pageErrors.length) problems.push('page errors')
if (row.offline === 'timeout') problems.push('no answer offline')
if (COUNTED.has(row.engine) && row.offline !== 'editor') {
problems.push(`offline ${row.offline}`)
}
return problems
}
async function main() {
const { engines, out } = options()
const build = checkBuild()
const { pw, version } = loadPlaywright()
const runs = []
for (const engine of engines) {
for (const mode of MODES) {
log(`${engine} ${mode}`)
const row = await runOne(pw, engine, mode)
runs.push({ ...row, problems: problemsOf(row) })
log(`${engine} ${mode}: offline ${row.offline} ${row.errorText ?? ''}`)
}
}
const failed = runs.filter((r) => r.problems.length > 0)
const result = { date: today(), playwright: version, build, runs }
writeFileSync(out, `${resultsJson(result)}\n`)
log(`${runs.length} runs, ${failed.length} not as expected → ${out}`)
process.exitCode = failed.length ? 1 : 0
}
await main()