//! R4.6: the incremental export session (plan §B.1.4, OD-2). Source: the TypeScript //! export's behaviours the session reproduces step by step (`packages/pdf/src/export.ts`, //! `render/observationPage.ts`, `branding.ts`, `svg/view.ts`): the raster requests (SVG //! logos, then each observation's views, main first), the warning order (a raster that //! fails before any embed, then a PNG `embedPng` refused, in view order), the state //! machine's closed refusals, and the file: driven key by key it is the one `export_pdf` //! gives (the frozen R4 digests). `rasterSizeOf` against the O4 oracle. #![allow(clippy::disallowed_methods, clippy::unwrap_used, clippy::expect_used)] mod common; use std::collections::HashSet; use common::r4::{r4_oracle, repo_root, sha256_hex}; use faunosteo_core::anatomy::compose::{asset_id_of_view, compose_highlight}; use faunosteo_core::anatomy::svg::{read_svg, serialize::serialize}; use faunosteo_core::domain::js::parse_json; use faunosteo_core::pdf::read::probe::{ProbeLimits, read_attached_document}; use faunosteo_core::pdf::write::export::export_pdf; use faunosteo_core::pdf::write::input::{ExportInput, ExportWarning, LogoSlot, Rasters}; use faunosteo_core::pdf::write::session::{ ExportSession, ExportStep, SessionError, SessionRefusal, keyed, }; use faunosteo_core::pdf::write::views::{RASTER_WIDTH_PX, RasterRequest, raster_size_of}; use serde_json::{Value, json}; const TWO_BY_ONE_PNG: &str = "iVBORw0KGgoAAAANSUhEUgAAAAIAAAABCAIAAAB7QOjdAAAAD0lEQVR4nGPYEWX///9/AA0PBE/1T7nxAAAAAElFTkSuQmCC"; fn base64(text: &str) -> Vec { faunosteo_core::pdf::write::layout::png::base64_bytes(text).unwrap() } fn fixture(path: &str) -> Vec { std::fs::read(repo_root().join("apps/app/tests/fixtures").join(path)).unwrap() } fn demo_input() -> ExportInput { let pdf = fixture("pdf/r3/demo.fr.logos.pdf"); let located = read_attached_document(&pdf, ProbeLimits::UNBOUNDED).unwrap(); let envelope: Value = parse_json(&located.text).unwrap(); serde_json::from_value(json!({ "report": envelope["report"], "sheetSnapshot": envelope["sheetSnapshot"], "branding": envelope["branding"], "labels": envelope["labels"], "locale": envelope["locale"], "exportedAt": envelope["exportedAt"], })) .unwrap() } fn stub_rasters(input: &ExportInput, png: &[u8]) -> Rasters { let mut rasters = Rasters { header_logo: Some(png.to_vec()), footer_logo: Some(png.to_vec()), powered_by: Some(png.to_vec()), partner: Some(png.to_vec()), views: Default::default(), }; for observation in &input.report.observations { for zone in &observation.zones { rasters .views .entry((observation.id.clone(), zone.view_id.clone())) .or_insert_with(|| png.to_vec()); } } rasters } fn refusal(error: SessionError) -> SessionRefusal { match error { SessionError::Refused(refusal) => refusal, SessionError::Export(error) => panic!("export error {error:?}"), } } fn requests(step: ExportStep) -> Vec { match step { ExportStep::Rasters { requests } => requests, ExportStep::Done => panic!("done too early"), } } #[test] fn raster_size_of_reproduces_the_o4_cases() { let oracle = r4_oracle("text.json"); let cases = oracle["rasterSizeOf"]["cases"].as_array().unwrap(); assert!(cases.len() > 40, "{} cases", cases.len()); for case in cases { let row = case.as_array().unwrap(); let input = row[0].as_str(); let expected = ( row[1].as_u64().unwrap() as u32, row[2].as_u64().unwrap() as u32, ); assert_eq!(raster_size_of(input), expected, "{:?}", row[0]); } assert_eq!(raster_size_of(None).0, RASTER_WIDTH_PX); } /// The branding step asks for the SVG logos only (the demo branding: the partner), each /// observation step for its views with the main view first; every request's SVG is the /// R3 composition of that view and its size the composed root's viewBox rule. #[test] fn the_requests_are_the_svg_logos_then_each_observations_views_main_first() { let input = demo_input(); let report = input.report.clone(); let snapshot: faunosteo_core::domain::archive::SheetSnapshot = serde_json::from_value(input.sheet_snapshot.clone()).unwrap(); let mut session = ExportSession::new(input).unwrap(); let branding = requests(session.next_step().unwrap()); assert_eq!( branding.iter().map(|r| r.key.as_str()).collect::>(), vec!["logo:partner"] ); assert!(branding[0].svg.starts_with(" = seen .iter() .filter(|id| **id == main) .chain(seen.iter().filter(|id| **id != main)) .map(|id| format!("view:{}:{id}", observation.id)) .collect(); assert_eq!( batch.iter().map(|r| r.key.clone()).collect::>(), expected_order, "{}", observation.id ); for request in &batch { let view_id = request.key.rsplit(':').next().unwrap(); let ids: HashSet<&str> = observation .zones .iter() .filter(|z| z.view_id == view_id) .map(|z| z.annotation_id.as_str()) .collect(); let asset_id = asset_id_of_view(document, view_id).unwrap(); let asset = snapshot .assets .iter() .find(|a| a.svg_asset_id == asset_id) .unwrap(); let root = read_svg(&asset.svg).unwrap().root; let composed = compose_highlight(document, view_id, root, &ids, view_id == main).unwrap(); assert_eq!(request.svg, serialize(&composed), "{}", request.key); assert_eq!( (request.width_px, request.height_px), raster_size_of(composed.attr("viewBox")), "{}", request.key ); session .add_raster(&request.key, &base64(TWO_BY_ONE_PNG)) .unwrap(); } } assert_eq!(session.next_step().unwrap(), ExportStep::Done); session.finish().unwrap(); let pdf = session.take_part().unwrap(); assert!(pdf.starts_with(b"%PDF-1.7")); assert!(session.warnings().is_empty()); } /// Driven key by key, the session writes the bytes `export_pdf` writes (the frozen digest), /// and the file grows as the rasters arrive (nothing waits for `finish`). #[test] fn the_session_gives_the_one_shot_bytes_and_grows_as_rasters_arrive() { let input = demo_input(); let rasters = stub_rasters(&input, &base64(TWO_BY_ONE_PNG)); let one_shot = export_pdf(input.clone(), &rasters).unwrap(); let frozen = std::fs::read_to_string( repo_root().join("apps/app/tests/fixtures/goldens/r4/pdf.demo.fr.logos.sha256"), ) .unwrap(); assert_eq!(sha256_hex(&one_shot.pdf), frozen.trim()); let map = keyed(&rasters); let mut session = ExportSession::new(input).unwrap(); let opened = session.written(); assert!(opened > 0); let mut grew_during_batches = false; while let ExportStep::Rasters { requests } = session.next_step().unwrap() { for request in requests { let before = session.written(); session.add_raster(&request.key, map[&request.key]).unwrap(); if request.key.starts_with("view:") { assert!(session.written() > before, "{}", request.key); grew_during_batches = true; } } } assert!(grew_during_batches); session.finish().unwrap(); // The parts, each under a few MiB with the stub rasters, moved out one by one. let parts = session.parts_left(); assert!(parts >= 1); let mut pdf = Vec::new(); while let Some(part) = session.take_part() { assert!(!part.is_empty()); pdf.extend_from_slice(&part); } assert_eq!(session.take_part(), None); assert_eq!(session.written(), pdf.len()); assert_eq!(pdf, one_shot.pdf); assert_eq!(session.envelope(), one_shot.envelope); assert_eq!(session.warnings(), one_shot.warnings.as_slice()); } #[test] fn the_state_machine_refuses_with_closed_kinds_and_never_traps() { let input = demo_input(); let png = base64(TWO_BY_ONE_PNG); let mut session = ExportSession::new(input).unwrap(); assert_eq!( refusal(session.add_raster("logo:partner", &png).unwrap_err()), SessionRefusal::UnknownKey, "before the first next()" ); assert_eq!( refusal(session.finish().unwrap_err()), SessionRefusal::OutOfOrder ); let branding = requests(session.next_step().unwrap()); assert_eq!( refusal(session.next_step().unwrap_err()), SessionRefusal::OutOfOrder, "next() with a key unanswered" ); assert_eq!( refusal(session.add_raster("logo:headerLogo", &png).unwrap_err()), SessionRefusal::UnknownKey ); assert_eq!( refusal(session.add_raster("view:x:y", &png).unwrap_err()), SessionRefusal::UnknownKey ); session.add_raster(&branding[0].key, &png).unwrap(); assert_eq!( refusal(session.add_raster(&branding[0].key, &png).unwrap_err()), SessionRefusal::DuplicateKey ); assert_eq!( refusal(session.raster_failed(&branding[0].key).unwrap_err()), SessionRefusal::DuplicateKey ); while let ExportStep::Rasters { requests } = session.next_step().unwrap() { for request in requests { // Garbage, an empty slice and a truncated PNG: a warning each, never a trap. let bytes: &[u8] = match request.key.len() % 3 { 0 => b"not a png", 1 => b"", _ => &png[..20], }; session.add_raster(&request.key, bytes).unwrap(); } } assert_eq!(session.next_step().unwrap(), ExportStep::Done); session.finish().unwrap(); assert!(session.take_part().unwrap().starts_with(b"%PDF-1.7")); assert_eq!( refusal(session.finish().unwrap_err()), SessionRefusal::OutOfOrder, "a second finish()" ); assert_eq!( refusal(session.next_step().unwrap_err()), SessionRefusal::OutOfOrder ); assert_eq!( refusal(session.add_raster("logo:partner", &png).unwrap_err()), SessionRefusal::OutOfOrder ); let views: usize = session .warnings() .iter() .filter(|w| matches!(w, ExportWarning::ViewRasterFailed { .. })) .count(); assert!(views > 0); } /// The warning order of the TypeScript: for an observation, the rasters that failed /// (`raster_failed`, in the order the driver reports them) come before the PNGs the /// decoder refused (in view order, as `embedPng` ran); a logo warning sits where its slot /// embeds, whatever the order its raster arrived in. #[test] fn warnings_keep_the_typescript_order() { let input = demo_input(); let png = base64(TWO_BY_ONE_PNG); let two_views = input .report .observations .iter() .find(|o| { o.zones .iter() .map(|z| &z.view_id) .collect::>() .len() >= 2 }) .map(|o| o.id.clone()) .expect("an observation with two views"); let mut session = ExportSession::new(input).unwrap(); let branding = requests(session.next_step().unwrap()); session.raster_failed(&branding[0].key).unwrap(); let mut expected = vec![ExportWarning::LogoFailed { slot: LogoSlot::Partner, }]; while let ExportStep::Rasters { requests } = session.next_step().unwrap() { let key_of = |r: &RasterRequest| r.key.clone(); let observation_id = requests[0].key.split(':').nth(1).unwrap().to_owned(); let view_of = |r: &RasterRequest| r.key.rsplit(':').next().unwrap().to_owned(); if observation_id == two_views { // The driver reports the second view's failure first (it rejected first), then // answers the batch in request order with a PNG the decoder refuses. session.raster_failed(&key_of(&requests[1])).unwrap(); expected.push(ExportWarning::ViewRasterFailed { observation_id: observation_id.clone(), view_id: view_of(&requests[1]), }); session.add_raster(&key_of(&requests[0]), b"bad").unwrap(); expected.push(ExportWarning::ViewRasterFailed { observation_id: observation_id.clone(), view_id: view_of(&requests[0]), }); for request in &requests[2..] { session.add_raster(&key_of(request), &png).unwrap(); } } else { for request in &requests { session.add_raster(&key_of(request), &png).unwrap(); } } } session.finish().unwrap(); assert_eq!(session.warnings(), expected.as_slice()); } /// `export_pdf` answers the session from its map: an absent view is `raster_failed`, an /// absent SVG logo too (its slot warns), a PNG asset logo never asks for a raster. #[test] fn the_one_shot_driver_reports_absent_rasters_as_failed() { let input = demo_input(); let png = base64(TWO_BY_ONE_PNG); let mut rasters = stub_rasters(&input, &png); rasters.partner = None; rasters.header_logo = None; let first = rasters.views.keys().min().cloned().unwrap(); rasters.views.remove(&first); let result = export_pdf(input, &rasters).unwrap(); assert_eq!( result.warnings, vec![ ExportWarning::LogoFailed { slot: LogoSlot::Partner }, ExportWarning::ViewRasterFailed { observation_id: first.0, view_id: first.1, }, ] ); }