feat(domain): R4.6 ExportSession (incremental export, OD-2): rasters decoded and written on arrival, chunked file handed out in parts, views composed by the core, raster_size_of (O4); wasm ExportSession and CoreExportSession; R4 digests re-frozen (catalog and page tree written last, B2)
This commit is contained in:
1 parent
8d16be577c
commit
9e688b6801
38 files changed
+2421
-354
No files matched your search
@@ -0,0 +1,382 @@
|
||||
//! 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,
|
||||
},
|
||||
]
|
||||
);
|
||||
}
|
||||
Reference in new issue
Block a user