383 lines
15 KiB
Rust
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,
|
|
},
|
|
]
|
|
);
|
|
}
|