Files
faunosteo/apps/app/tests/unit/r4.writer-oracles.test.ts
T

367 lines
13 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/**
* R4.1 freeze, writer oracles O1 to O3 (plan 2026-10-17 §B.5.1), recorded on
* the application export path with the Step 6 golden inputs (three reports,
* fr / en, nologos / logos, fixed 1×1 / 2×1 rasters) at FIXED_EXPORTED_AT:
* - O1, the complete draw log of every run, which the Step 6 text, images
* and links goldens must equal once rounded;
* - O2, the PDFs of those runs, one real-raster PDF (resvg, v2full's first
* observation) with every PNG it embedded, one PDF exported through the
* store path (D-R11 case);
* - O3, the frozen pre-R2 envelopes attached byte for byte by pdf-lib.
* `MAKE_R4_ORACLES=1` writes them; never again without an owner decision.
*/
import { readFileSync } from 'node:fs'
import { resolve } from 'node:path'
import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest'
import { AFRelationship, PageSizes, PDFDocument, StandardFonts } from 'pdf-lib'
import type { Branding, Practitioner, Report } from '@faunosteo/core-wasm/types'
import {
exportReportArchive,
readAttachedDocument,
readAttachmentBytes,
type ExportInput,
type Rasterizer,
} from '@faunosteo/pdf'
import { loadBranding } from '@/pdf/branding'
import { defaultPdfLabels } from '@/pdf/labels'
import { importAttachment } from '@/pdf/import'
import type { SheetIndex } from '@/services/sheetIndex'
import type { Locale } from '@/i18n/types'
import { useReportStore } from '@/state/reportStore'
import { resvgRasterizer } from '../../../../packages/pdf/tests/helpers/resvg'
import { loadTestSheet, sheetSnapshot } from '../helpers/sheet'
import {
buildGoldenReports,
GOLDEN_REPORTS,
type GoldenReportName,
} from '../helpers/goldenReports'
import {
brandingOf,
FIXTURES_DIR,
ONE_PX_PNG,
readGolden,
TWO_BY_ONE_PNG,
viewIdsOf,
type LogoMode,
} from '../helpers/goldens'
import {
checkBytesOracle,
checkJsonOracle,
drawLogOf,
FIXED_EXPORTED_AT,
R3_PDF_DIR,
R4_GOLDEN_DIR,
readPdfFacts,
recordFullDrawing,
sha256,
step6Images,
step6Links,
step6Texts,
STEP6_PDF_DIR,
type DrawLog,
} from '../helpers/r4-draw'
const raster = vi.hoisted(() => ({ rasterize: null as Rasterizer | null }))
vi.mock('@/pdf/browserRasterizer', () => ({
browserRasterizer: vi.fn<Rasterizer>((svg, size) =>
raster.rasterize!(svg, size),
),
}))
const logoMode = vi.hoisted(() => ({ current: 'nologos' as LogoMode }))
vi.mock('@/pdf/branding', async () => {
const { brandingOf } = await import('../helpers/goldens')
return { loadBranding: vi.fn(() => brandingOf(logoMode.current)) }
})
const MODES: readonly LogoMode[] = ['nologos', 'logos']
const LOCALES: readonly Locale[] = ['fr', 'en']
const REAL_DIR = resolve(R3_PDF_DIR, 'real')
const R2_DIR = resolve(FIXTURES_DIR, 'goldens/r2')
const R2_ENVELOPES = ['demo', 'v2full', 'v2unresolved'].map(
(name) => `${name}.fr.nologos`,
)
const REAL_RASTER_TIMEOUT = 120_000
let sheet: SheetIndex
let reports: Record<GoldenReportName, Report>
beforeAll(async () => {
sheet = await loadTestSheet()
reports = buildGoldenReports(sheet).reports
vi.spyOn(console, 'warn').mockImplementation(() => undefined)
vi.useFakeTimers({ toFake: ['Date'] })
vi.setSystemTime(FIXED_EXPORTED_AT)
})
afterAll(() => {
useReportStore.getState().reset()
sessionStorage.clear()
vi.useRealTimers()
vi.restoreAllMocks()
})
interface Run {
report: Report
mode: LogoMode
locale: Locale
rasterize: Rasterizer
}
interface Exported {
pdf: Uint8Array
log: DrawLog
}
const fixedRaster =
(mode: LogoMode): Rasterizer =>
async () =>
mode === 'logos' ? TWO_BY_ONE_PNG : ONE_PX_PNG
/**
* One export through the TypeScript engine with the application's inputs (the snapshot
* the core builds, the bundled branding of the mode, the app's labels, the fixed export
* time), drawn under the full recorder. R4.6 moved `@/pdf/export` onto the core's
* session: the oracles stay those of the R3 build, so the engine is called directly, as
* the app export called it until then (same inputs, same order).
*/
async function exportRun(run: Run): Promise<Exported> {
raster.rasterize = run.rasterize
logoMode.current = run.mode
const recorder = recordFullDrawing()
try {
const { pdf, warnings } = await exportReportArchive({
report: run.report as ExportInput['report'],
sheet: sheetSnapshot(sheet, run.report) as ExportInput['sheet'],
branding: await loadBranding(),
labels: defaultPdfLabels,
locale: run.locale,
rasterizer: run.rasterize,
exportedAt: new Date(),
})
expect(warnings).toEqual([])
expect(recorder.unexpectedCalls()).toEqual([])
expect(recorder.state.documents.size).toBe(1)
return { pdf, log: drawLogOf(recorder, await readPdfFacts(pdf)) }
} finally {
recorder.stop()
}
}
describe.each(GOLDEN_REPORTS)('writer oracles of %s', (name) => {
describe.each(MODES)('%s', (mode) => {
it.each(LOCALES)(
'%s: O1 draw log, O2 PDF, rounded = step6',
async (locale) => {
const run = { report: reports[name], mode, locale }
const out = await exportRun({ ...run, rasterize: fixedRaster(mode) })
const id = `${name}.${locale}.${mode}`
checkJsonOracle(resolve(R4_GOLDEN_DIR, `draw.${id}.json`), out.log)
checkBytesOracle(resolve(R3_PDF_DIR, `${id}.pdf`), out.pdf)
expect(step6Texts(out.log)).toEqual(readGolden(`text.${id}.json`))
expect(step6Images(out.log)).toEqual(readGolden(`images.${id}.json`))
expect(step6Links(out.log)).toEqual(readGolden(`links.${id}.json`))
},
)
})
})
type RasterSubject =
| { kind: 'logo'; slot: string }
| { kind: 'view'; observationId: string; viewId: string }
interface RasterCall {
index: number
svgSha256: string
widthPx: number
heightPx: number
png: Uint8Array | null
}
const LOGO_SLOTS = ['headerLogo', 'footerLogo', 'poweredBy', 'partner'] as const
function logoOf(branding: Branding, slot: (typeof LOGO_SLOTS)[number]) {
const value = branding[slot]
return value && 'kind' in value ? value : (value?.logo ?? null)
}
/**
* The engine's rasteriser calls in order: the SVG logos while embedding the
* branding (header, footer, powered-by, partner), then each observation's
* views, main first (packages/pdf export and observationPage).
*/
function rasterSubjects(branding: Branding, report: Report): RasterSubject[] {
const logos = LOGO_SLOTS.filter(
(slot) => logoOf(branding, slot)?.kind === 'svg',
).map((slot): RasterSubject => ({ kind: 'logo', slot }))
const snapshot = sheetSnapshot(sheet, report)
const views = report.observations.flatMap((o) =>
viewIdsOf(snapshot, o).map(
(viewId): RasterSubject => ({
kind: 'view',
observationId: o.id,
viewId,
}),
),
)
return [...logos, ...views]
}
/** resvg wrapped: each call is numbered when it is made, its PNG kept. */
function capturingResvg(calls: RasterCall[]): Rasterizer {
const resvg = resvgRasterizer()
return async (svg, size) => {
const call: RasterCall = {
index: calls.length,
svgSha256: sha256(svg),
widthPx: size.widthPx,
heightPx: size.heightPx,
png: null,
}
calls.push(call)
call.png = await resvg(svg, size)
return call.png
}
}
const REAL_NOTE =
'v2full reduced to its first observation (obs-1, main view), every other ' +
'field unchanged: the full report weighed 3 MB in real rasters.'
/** v2full with its first observation only: one view keeps the set small. */
function firstObservationOf(report: Report): Report {
return { ...report, observations: report.observations.slice(0, 1) }
}
describe('O2 real raster: v2full first observation, fr, logos, resvg', () => {
it(
'freezes the PDF, every PNG returned and the call manifest',
async () => {
const calls: RasterCall[] = []
const report = firstObservationOf(reports.v2full)
const { pdf } = await exportRun({
report,
mode: 'logos',
locale: 'fr',
rasterize: capturingResvg(calls),
})
const subjects = rasterSubjects(await brandingOf('logos'), report)
expect(subjects).toEqual([
{ kind: 'logo', slot: 'partner' },
{ kind: 'view', observationId: 'obs-1', viewId: 'main' },
])
expect(calls).toHaveLength(subjects.length)
checkBytesOracle(resolve(REAL_DIR, 'v2full-obs1.fr.logos.pdf'), pdf)
const manifest = calls.map(({ png, ...call }) => {
const file = `raster-${call.index}.png`
checkBytesOracle(resolve(REAL_DIR, file), png!)
const pngSha256 = sha256(png!)
return { ...call, png: file, pngSha256, subject: subjects[call.index] }
})
const manifestFile = resolve(REAL_DIR, 'manifest.json')
checkJsonOracle(manifestFile, { note: REAL_NOTE, calls: manifest })
},
REAL_RASTER_TIMEOUT,
)
})
type KeyOrder = { path: string; keys: string[] }
function keyOrders(value: unknown, path = 'report'): KeyOrder[] {
if (!value || typeof value !== 'object') return []
const entries = Object.entries(value)
const own = Array.isArray(value)
? []
: [{ path, keys: entries.map(([k]) => k) }]
return [...own, ...entries.flatMap(([k, v]) => keyOrders(v, `${path}.${k}`))]
}
/** Objects whose key sequence differs between two equal values. */
function keyOrderDifferences(a: unknown, b: unknown) {
const other = new Map(keyOrders(b).map((o) => [o.path, o.keys]))
return keyOrders(a)
.map((o) => ({ path: o.path, attachment: o.keys, core: other.get(o.path) }))
.filter((d) => JSON.stringify(d.attachment) !== JSON.stringify(d.core))
}
/** A partial practitioner, keys out of the contract order (name, cabinet, contact, siret). */
const EDITED_PRACTITIONER: Practitioner = {
contact: 'secretariat@example.test',
name: 'Dr. Claire Dupont-Martin',
}
describe('O2 store path: demo, next appointment set, practitioner edited', () => {
it('freezes the PDF and the store report; attachment order is D-R11', async () => {
sessionStorage.clear()
const store = useReportStore.getState()
expect(
store.hydrateImport({ report: reports.demo, archive: null }, sheet),
).toEqual({ ok: true })
store.setNextAppointment({ kind: 'date', date: '2026-11-20' })
store.setPractitioner(EDITED_PRACTITIONER)
const report = useReportStore.getState().report!
const { pdf } = await exportRun({
report,
mode: 'nologos',
locale: 'fr',
rasterize: fixedRaster('nologos'),
})
checkBytesOracle(resolve(R3_PDF_DIR, 'store-path.fr.nologos.pdf'), pdf)
checkJsonOracle(resolve(R3_PDF_DIR, 'store-path.report.json'), report)
const attached = (await readAttachedDocument(pdf)) as { report: unknown }
expect(keyOrders(attached.report)).toEqual(keyOrders(report))
const reread = importAttachment(attached, sheet).read.report
expect(reread).toEqual(attached.report)
const differences = keyOrderDifferences(attached.report, reread)
console.info('D-R11 key order, attachment vs core:', differences)
expect(differences.length).toBeGreaterThan(0)
})
})
interface EnvelopeMeta {
locale: 'fr' | 'en'
labels: Record<string, Record<string, string>>
report: { animal: { name: string }; practitioner: { name: string } }
}
/** The engine's file structure around a given attachment (export.ts, attachment/write.ts). */
async function envelopePdf(attachment: Uint8Array): Promise<Uint8Array> {
const envelope = JSON.parse(
new TextDecoder().decode(attachment),
) as EnvelopeMeta
const labels = envelope.labels[envelope.locale]
const title = `${labels['pdf.title.suffix.bilan']}${envelope.report.animal.name}`
const doc = await PDFDocument.create()
doc.setTitle(title)
doc.setAuthor(envelope.report.practitioner.name)
doc.setSubject(labels['pdf.subject'])
doc.setKeywords(['faunosteo-archive/1'])
doc.setCreationDate(FIXED_EXPORTED_AT)
doc.setModificationDate(FIXED_EXPORTED_AT)
const font = await doc.embedFont(StandardFonts.Helvetica)
doc.addPage(PageSizes.A4).drawText(title, { x: 40, y: 790, size: 12, font })
await doc.attach(attachment, 'osteo-report.json', {
mimeType: 'application/json',
description: 'Faunosteo report archive v1',
creationDate: FIXED_EXPORTED_AT,
modificationDate: FIXED_EXPORTED_AT,
afRelationship: AFRelationship.Data,
})
return doc.save({ useObjectStreams: false })
}
describe.each(R2_ENVELOPES)('O3 pre-R2 envelope PDF %s', (name) => {
// The R2 freeze wrote the decoded attachment text as is, and UTF-8
// round-trips JSON.stringify output: the file bytes are the attachment.
it('carries the frozen bytes, read back as is', async () => {
const golden = new Uint8Array(
readFileSync(resolve(R2_DIR, `envelope.${name}.json`)),
)
const pdf = await envelopePdf(golden)
checkBytesOracle(resolve(STEP6_PDF_DIR, `envelope.${name}.pdf`), pdf)
const read = await readAttachmentBytes(pdf)
expect(Buffer.from(read).equals(Buffer.from(golden))).toBe(true)
expect(await readAttachedDocument(pdf)).toEqual(
JSON.parse(new TextDecoder().decode(golden)),
)
})
})