Files

383 lines
15 KiB
Rust

//! 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<u8> {
faunosteo_core::pdf::write::layout::png::base64_bytes(text).unwrap()
}
fn fixture(path: &str) -> Vec<u8> {
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<RasterRequest> {
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<_>>(),
vec!["logo:partner"]
);
assert!(branding[0].svg.starts_with("<svg"));
assert_eq!(branding[0].width_px, RASTER_WIDTH_PX);
assert_eq!(
(branding[0].width_px, branding[0].height_px),
raster_size_of(read_svg(&branding[0].svg).unwrap().root.attr("viewBox"))
);
session
.add_raster("logo:partner", &base64(TWO_BY_ONE_PNG))
.unwrap();
let document = &snapshot.document;
let main = document.views.iter().find(|v| v.is_main()).unwrap().id();
for observation in &report.observations {
let batch = requests(session.next_step().unwrap());
let mut seen = Vec::new();
for zone in &observation.zones {
if !seen.contains(&zone.view_id.as_str()) {
seen.push(&zone.view_id);
}
}
let expected_order: Vec<String> = 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::<Vec<_>>(),
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::<HashSet<_>>()
.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,
},
]
);
}