/** * Replaces char.pdfFull / pdf.roundtrip / pdf.zoneLabels: the application * export path on the core's session with the bundled sheet (drawn strings * from the document, read back from the file's content streams since R4.6, * envelope attachment, roundtrip FR/EN) and the import of the frozen v2 * archive PDFs, migrated without silent loss. */ import { describe, it, expect, vi, beforeAll, afterAll } from 'vitest' import { readFileSync } from 'node:fs' import { fileURLToPath } from 'node:url' import { dirname, resolve } from 'node:path' import type { Observation, Report } from '@faunosteo/core-wasm/types' import { exportReportToPdf } from '@/pdf/export' import { browserRasterizer } from '@/pdf/browserRasterizer' import { defaultPdfLabels } from '@/pdf/labels' import { formatDate } from '@/lib/dates' import type { Locale } from '@/i18n/types' import type { SheetIndex } from '@/services/sheetIndex' import { importReportFromPdf, ImportError } from '../helpers/pdfImport' import { PdfFile, buildPdfWithAttachment, nameOf, textOf, } from '../helpers/pdfFile' import { loadTestSheet, minimalReport } from '../helpers/sheet' import { bytesOf, readDrawing } from '../helpers/pdfRead' // The fixed 1×1 PNG for every raster; the view SVGs the session asks for are kept. const raster = vi.hoisted(() => ({ svgs: [] as string[] })) vi.mock('@/pdf/browserRasterizer', async () => { const { ONE_PX_PNG } = await import('../helpers/goldens') return { browserRasterizer: vi.fn(async (svg: string) => { raster.svgs.push(svg) return ONE_PX_PNG }), } }) /** The layered reading the application does on import (the core's reader). */ async function readBack(bytes: Uint8Array) { return (await importReportFromPdf(bytes)).read } const pageCount = (bytes: Uint8Array) => PdfFile.parse(bytes).pages().length /** The static PDF strings belong to the app's label set. */ const { fr, en } = defaultPdfLabels /** * The bytes of an app export (its warnings are not under test here); `drawn` holds the * texts of its content streams, in draw order. */ async function exportPdf(report: Report, locale: Locale): Promise { raster.svgs = [] const bytes = await bytesOf( (await exportReportToPdf(report, sheet, { locale })).pdf, ) drawn = (await readDrawing(bytes)).texts.map((t) => t.text) return bytes } const HERE = dirname(fileURLToPath(import.meta.url)) const fixture = (name: string) => new Uint8Array(readFileSync(resolve(HERE, '../fixtures', name))) let sheet: SheetIndex let drawn: string[] = [] beforeAll(async () => { sheet = await loadTestSheet() vi.spyOn(console, 'warn').mockImplementation(() => undefined) }) afterAll(() => vi.restoreAllMocks()) /** A full v3 observation: plain zone, bilateral both sides, spine with vertebrae, head zone, findings. */ function fullObservation(): Observation { return { id: 'obs-full', zones: [ { annotationId: 'c7-t1', viewId: 'main' }, { annotationId: 'hip', viewId: 'main', side: 'left' }, { annotationId: 'hip', viewId: 'main', side: 'right' }, { annotationId: 'cervical', viewId: 'main', vertebrae: [ { region: 'C', index: 3 }, { region: 'C', index: 4 }, ], }, { annotationId: 'atm', viewId: 'head' }, ], findings: [ { findingZoneId: 'c7-t1', path: ['c7-t1-dysfunctions', 'segmental', 'fixation'], labelFrSnapshot: 'Fixation de la charnière', labelEnSnapshot: 'Junction fixation', }, { findingZoneId: 'hip', path: ['hip-dysfunctions', 'articular', 'restriction-flexion'], labelFrSnapshot: 'Restriction en flexion', labelEnSnapshot: 'Flexion restriction', side: 'left', }, { findingZoneId: 'atm', path: ['atm-consultation-reasons', 'headshaking'], labelFrSnapshot: 'Headshaking (secouement de tête)', labelEnSnapshot: 'Headshaking', requiresVetReferral: true, unresolved: true, }, ], freeTextFindings: ['Sensibilité au garrot'], severity: 'moderate', comment: 'note', } } describe('export on a full v3 report (FR)', () => { it('produces one page per observation plus the conclusion, labels from the sheet', async () => { const report = minimalReport(sheet, { observations: [fullObservation()], conclusion: 'ok', }) const bytes = await exportPdf(report, 'fr') expect(pageCount(bytes)).toBe(2) const zonesIdx = drawn.indexOf(fr['pdf.section.zones']!) expect(drawn.slice(zonesIdx + 1, zonesIdx + 6)).toEqual([ 'Charnière C7-T1 (cervico-thoracique)', '•', 'Hanche (coxo-fémorale) (Gauche)', '•', 'Hanche (coxo-fémorale) (Droite)', ]) expect(drawn).toContain('Vertèbres cervicales (C3, C4)') expect(drawn).toContain('Articulation temporo-mandibulaire (ATM)') const prefix = fr['pdf.section.findings_prefix']! expect(drawn).toContain(`${prefix}CHARNIÈRE C7-T1 (CERVICO-THORACIQUE)`) expect(drawn).toContain(`${prefix}HANCHE (COXO-FÉMORALE) (GAUCHE)`) expect(drawn).toContain('(!) Headshaking (secouement de tête)') expect(drawn).toContain(fr['severity.moderate']!) expect(drawn).toContain(fr['pdf.view.general']!) expect(drawn).toContain( `${fr['pdf.view.detail_prefix']}TÊTE (VUE LATÉRALE GAUCHE)`, ) }) it('attaches the envelope and roundtrips in both locales', async () => { const report = minimalReport(sheet, { observations: [fullObservation()] }) for (const locale of ['fr', 'en'] as const) { const bytes = await exportPdf(report, locale) const out = await readBack(bytes) expect(out.migrated).toBe(false) expect(out.origin).toBe('envelope_v1') expect(out.report).toEqual(report) expect(out.archive?.locale).toBe(locale) expect(out.archive?.sheetSnapshot.ref.documentSha256).toBe( sheet.sheet.ref.documentSha256, ) } }) // The core composes only the observation's markers (the browser pipeline // hid the others with display="none"); the view facts are frozen in // pdf.goldens.test.ts "highlighted views". The SVGs are the ones the // session asked the rasteriser for: the bundled partner logo (the one SVG // logo) first, then the main view, then the head. it('highlights the observation zones of a view and omits the other markers', async () => { const report = minimalReport(sheet, { observations: [fullObservation()] }) await exportPdf(report, 'fr') expect(raster.svgs).toHaveLength(3) const [svg, head] = raster.svgs.slice(1) expect(svg).toContain('viewBox="0 0 2073.4 1629.4"') expect(svg).toContain('fill="#b85a3f"') expect(svg).toContain('url(#osteo-halo)') expect(svg).not.toContain('display="none"') expect(svg).not.toContain('data-anno-id') expect(head).toContain('viewBox="60 100 500 380"') expect(head).not.toContain('osteo-halo') }) }) /** Rebuilds wrapped values: lines are drawn one by one. */ const joined = () => drawn.join(' ').replace(/\s+/g, ' ') function fullReport() { const second: Observation = { id: 'obs-2', zones: [], findings: [ { findingZoneId: 'c7-t1', path: ['c7-t1-dysfunctions', 'segmental', 'fixation'], labelFrSnapshot: 'Fixation de la charnière', labelEnSnapshot: 'Junction fixation', }, ], freeTextFindings: ['Raideur au garrot'], comment: 'Réagit à la palpation.', } return minimalReport(sheet, { observations: [fullObservation(), second], conclusion: 'Dysfonction cervico-thoracique.', recommendations: 'Repos au pré.', nextAppointment: { kind: 'date', date: '2026-11-20' }, }) } describe('PDF content on a two-observation report', () => { it('prints the empty marker for a zoneless observation and keeps its findings', async () => { await exportPdf(fullReport(), 'fr') expect(drawn).toContain(fr['pdf.empty']) const prefix = fr['pdf.section.findings_prefix']! const occurrences = drawn.filter( (l) => l === `${prefix}CHARNIÈRE C7-T1 (CERVICO-THORACIQUE)`, ) expect(occurrences).toHaveLength(2) }) it('prints an unknown annotation id and an unknown finding zone raw', async () => { const stale: Observation = { ...fullObservation(), zones: [{ annotationId: 'point-gone', viewId: 'main' }], findings: [ { findingZoneId: 'zone-gone', path: ['x'], labelFrSnapshot: 'Snapshot FR', labelEnSnapshot: 'Snapshot EN', }, ], } const report = minimalReport(sheet, { observations: [stale] }) await exportPdf(report, 'fr') expect(drawn).toContain('point-gone') expect(drawn).toContain(`${fr['pdf.section.findings_prefix']}ZONE-GONE`) expect(drawn).toContain('Snapshot FR') }) it('draws the EN dictionary, annotation names and finding snapshots', async () => { await exportPdf(fullReport(), 'en') expect(drawn).toContain(en['pdf.section.zones']) expect(drawn.some((l) => l.includes('Hip joint'))).toBe(true) expect(drawn).toContain('Junction fixation') expect(drawn).not.toContain('Fixation de la charnière') }) it('draws free findings, comments, the conclusion page and the header on every page', async () => { const report = fullReport() const bytes = await exportPdf(report, 'fr') const pages = pageCount(bytes) expect(drawn).toContain(fr['pdf.section.free_findings']) expect(joined()).toContain('Sensibilité au garrot') expect(joined()).toContain('Raideur au garrot') expect(drawn).toContain(fr['pdf.section.comment']) expect(joined()).toContain('Réagit à la palpation.') expect(drawn).toContain(fr['pdf.section.conclusion']) expect(joined()).toContain('Dysfonction cervico-thoracique.') expect(drawn).toContain(fr['pdf.section.recommendations']) expect(joined()).toContain('Repos au pré.') expect(drawn).toContain(fr['pdf.section.next_appointment']) expect(drawn).toContain(formatDate('2026-11-20', 'fr')) const header = drawn.filter((l) => l === 'Dr. Dupont').length expect(header).toBeGreaterThanOrEqual(pages) }) it('sets the PDF metadata and the archive keyword', async () => { const bytes = await exportPdf(fullReport(), 'fr') const info = PdfFile.parse(bytes).info().dict expect(textOf(info, 'Title')).toBe(`${fr['pdf.title.suffix.bilan']}Mistral`) expect(textOf(info, 'Author')).toBe('Dr. Dupont') expect(textOf(info, 'Subject')).toBe(fr['pdf.subject']) expect(textOf(info, 'Keywords')).toContain('faunosteo-archive/1') }) it('embeds the four bundled logos without any network request', async () => { const fetchSpy = vi.fn() vi.stubGlobal('fetch', fetchSpy) try { const { pdf, warnings } = await exportReportToPdf(fullReport(), sheet, { locale: 'fr', }) expect(fetchSpy).not.toHaveBeenCalled() expect(warnings).toEqual([]) const out = await readBack(await bytesOf(pdf)) const branding = out.archive!.branding expect(branding.headerLogo?.kind).toBe('png') expect(branding.footerLogo?.kind).toBe('png') expect(branding.poweredBy?.logo?.kind).toBe('png') expect(branding.partner?.logo?.kind).toBe('svg') } finally { vi.unstubAllGlobals() } }) it('attaches osteo-report.json as a Flate EmbeddedFile, AFRelationship Data, "Faunosteo report archive v1"', async () => { const bytes = await exportPdf(fullReport(), 'fr') const objects = PdfFile.parse(bytes).all() const filespec = objects.find((o) => nameOf(o.dict, 'Type') === 'Filespec')! expect(textOf(filespec.dict, 'F')).toBe('osteo-report.json') expect(textOf(filespec.dict, 'UF')).toBe('osteo-report.json') expect(nameOf(filespec.dict, 'AFRelationship')).toBe('Data') expect(textOf(filespec.dict, 'Desc')).toBe('Faunosteo report archive v1') const embedded = objects.find( (o) => nameOf(o.dict, 'Type') === 'EmbeddedFile', )! expect(nameOf(embedded.dict, 'Filter')).toBe('FlateDecode') expect(embedded.stream).not.toBeNull() }) }) describe('a raster the browser cannot draw', () => { it('is a view_raster_failed warning; the export continues without that image', async () => { const report = minimalReport(sheet, { observations: [fullObservation()] }) const whole = await readDrawing(await exportPdf(report, 'fr')) const failing = vi.mocked(browserRasterizer) failing.mockImplementation(async (svg) => { // The head view's picture is framed on the head's own viewBox. if (svg.includes('viewBox="60 100 500 380"')) { throw new Error('canvas lost') } const { ONE_PX_PNG } = await import('../helpers/goldens') return ONE_PX_PNG }) try { const { pdf, warnings } = await exportReportToPdf(report, sheet, { locale: 'fr', }) expect(warnings).toEqual([ { kind: 'view_raster_failed', observationId: 'obs-full', viewId: 'head', }, ]) const bytes = await bytesOf(pdf) const { images, texts } = await readDrawing(bytes) // One image fewer on the observation page (the head view), the logos and // the main view drawn; the page keeps its texts and the file still // carries the whole report. expect(images.filter((i) => i.page === 0)).toHaveLength( whole.images.filter((i) => i.page === 0).length - 1, ) expect(texts.map((t) => t.text)).toContain(fr['pdf.view.general']!) expect(texts.map((t) => t.text)).not.toContain( `${fr['pdf.view.detail_prefix']}TÊTE (VUE LATÉRALE GAUCHE)`, ) expect((await readBack(bytes)).report).toEqual(report) } finally { failing.mockImplementation(async () => { const { ONE_PX_PNG } = await import('../helpers/goldens') return ONE_PX_PNG }) } }) }) describe('attachment rejection', () => { const pdfWith = (name: string, payload: unknown): Uint8Array => buildPdfWithAttachment( name, new TextEncoder().encode(JSON.stringify(payload)), ) it('reports no_attachment for a foreign JSON attachment (no version)', async () => { const bytes = pdfWith('other.json', { hello: 'world' }) await expect(importReportFromPdf(bytes)).rejects.toMatchObject({ kind: 'no_attachment', }) }) it('reports no_attachment for a v3 report failing validation', async () => { const broken: Record = { ...minimalReport(sheet) } delete broken.sheet const bytes = pdfWith('osteo-report.json', broken) await expect(importReportFromPdf(bytes)).rejects.toMatchObject({ kind: 'no_attachment', }) }) it('reads the same attachment through the core when the report is sound', async () => { const report = minimalReport(sheet) const out = await readBack(pdfWith('osteo-report.json', report)) expect(out.origin).toBe('bare_v3') expect(out.report).toEqual(report) }) }) describe('import of the frozen v2 archive PDFs', () => { it('migrates the full v2 report: ids, views, paths, severities, unresolved findings', async () => { const out = await readBack(fixture('report-v2.full.pdf')) expect(out.migrated).toBe(true) const { report } = out expect(report.version).toBe(3) expect(report.sheet).toEqual(sheet.sheet.ref) expect(report.animal.name).toBe('Mistral') const zones = report.observations.flatMap((o) => o.zones) expect( zones.map( (z) => `${z.annotationId}@${z.viewId}${z.side ? ':' + z.side : ''}`, ), ).toEqual( expect.arrayContaining([ 'c7-t1@main', 'hip@main:left', 'hip@main:right', 'cervical@main', 'atm@head', ]), ) expect(zones.every((z) => !z.unresolved)).toBe(true) const findings = report.observations.flatMap((o) => o.findings) const moved = findings.find((f) => f.path.includes('stumbling-proprioceptive'), )! expect(moved.path[0]).toBe('cervical-consultation-reasons') expect(moved.unresolved).toBeUndefined() const headshaking = findings.find((f) => f.path.includes('headshaking'))! expect(headshaking.path).toEqual([ 'atm-consultation-reasons', 'headshaking', ]) expect(findings.some((f) => f.unresolved)).toBe(false) expect(out.unresolvedFindings).toBe(0) expect(report.observations.map((o) => o.severity)).toEqual( expect.arrayContaining(['moderate', 'severe']), ) // Re-export and re-import: stable. const again = await readBack(await exportPdf(report, 'fr')) expect(again.report).toEqual(report) expect(again.migrated).toBe(false) expect(again.origin).toBe('envelope_v1') }) it('keeps a v2 finding whose node was removed and a zone whose id is unknown, both flagged', async () => { const v2 = { ...JSON.parse( readFileSync( resolve(HERE, '../fixtures/report-v2.minimal.json'), 'utf8', ), ), observations: [ { id: 'o-legacy', zones: [ { boneId: 'point-mpbyphay', detailSourceId: 'head' }, { boneId: 'point-gone' }, ], findings: [ { zoneId: 'ssb', path: ['ssb-dysfunctions', 'sutures', 'sphenozygomatic'], labelFrSnapshot: 'Suture sphéno-zygomatique', labelEnSnapshot: 'Sphenozygomatic suture', }, ], freeTextFindings: [], comment: '', severity: 'légère', }, ], } const out = await readBack( buildPdfWithAttachment( 'osteo-report.json', new TextEncoder().encode(JSON.stringify(v2)), ), ) const [obs] = out.report.observations expect(obs!.zones).toEqual([ expect.objectContaining({ annotationId: 'ssb', viewId: 'head', labelFrSnapshot: 'Synchondrose Sphéno-Basilaire (SSB)', }), expect.objectContaining({ annotationId: 'point-gone', viewId: 'main', unresolved: true, }), ]) expect(obs!.findings[0]).toMatchObject({ findingZoneId: 'ssb', path: ['ssb-dysfunctions', 'sutures', 'sphenozygomatic'], unresolved: true, labelFrSnapshot: 'Suture sphéno-zygomatique', }) expect(obs!.severity).toBe('mild') expect(out.unresolvedFindings).toBe(1) expect(out.unresolvedZones).toBe(1) // The migrated document is a valid v3 document: exporting it again keeps the flags. const again = await readBack(await exportPdf(out.report, 'en')) expect(again.report.observations[0]!.findings[0]!.unresolved).toBe(true) }) it('migrates the minimal v2 report', async () => { const out = await readBack(fixture('report-v2.minimal.pdf')) expect(out.report.version).toBe(3) expect(out.report.observations).toEqual([]) expect(out.unresolvedFindings + out.unresolvedZones).toBe(0) }) it('refuses unknown versions and unrelated PDFs with typed errors', async () => { const v7 = buildPdfWithAttachment( 'osteo-report.json', new TextEncoder().encode(JSON.stringify({ version: 7 })), ) await expect(importReportFromPdf(v7)).rejects.toMatchObject({ kind: 'incompatible_version', foundVersion: 7, }) const fake = new Uint8Array([37, 80, 68, 70, 45, 49, 46, 52, 10]) await expect(importReportFromPdf(fake)).rejects.toThrow(ImportError) }) })