//! R4.2e, OD-3: the value count (`json_js::prescan`, the parser's allocation proxy) of the //! legitimate archives against the hostile references, printed for RUST.md ยง10.3 and pinned //! loosely so a drift of an order of magnitude is seen. //! //! Legitimate: the R3 export of the demo with logos (its attachment located by the reader), //! the v2 full and 612-leaves exports, and envelopes built like the export does for the //! synthetic L (60 observations) and CAP (500, the collection cap) reports: the demo's //! branding with logos and labels, a snapshot of the draft sheet for that report, the //! `JSON.stringify(_, null, 2)` form. Hostile: the token-dense `values-1m.pdf` of O8. #![allow(clippy::disallowed_methods, clippy::unwrap_used, clippy::expect_used)] mod common; use common::r4::{r4_input, repo_root}; use faunosteo_core::domain::archive::{ReportArchiveEnvelope, build_sheet_snapshot}; use faunosteo_core::domain::js::parse_json; use faunosteo_core::domain::report::Report; use faunosteo_core::domain::sheet::{BundledSheetData, LoadedSheet}; use faunosteo_core::json::to_js_pretty; use faunosteo_core::pdf::import::import_pdf; use faunosteo_core::pdf::json_js::{JsonPrescan, prescan}; use faunosteo_core::pdf::read::probe::{ProbeLimits, read_attached_document}; use serde_json::{Value, json}; const SEED: &str = "supabase/seed/anatomical-sheets/equine/draft"; const FIXTURES: &str = "apps/app/tests/fixtures"; fn draft_sheet() -> LoadedSheet { let seed = repo_root().join(SEED); let read = |name: &str| std::fs::read_to_string(seed.join(name)).unwrap(); let manifest: Value = serde_json::from_str(&read("assets.json")).unwrap(); let mut assets = serde_json::Map::new(); let mut hashes = serde_json::Map::new(); for asset in manifest.as_array().unwrap() { let id = asset["svg_asset_id"].as_str().unwrap().to_owned(); let file = format!("assets/{}", asset["file"].as_str().unwrap()); assets.insert(id.clone(), Value::String(read(&file))); hashes.insert(id, asset["sha256"].clone()); } let payload = json!({ "status": "draft", "ref": parse_json(&read("sheet-ref.json")).unwrap(), "document": parse_json(&read("document.json")).unwrap(), "migrationMap": parse_json(&read("report-migration-map.json")).unwrap(), "assets": assets, "assetHashes": hashes, }); let data: BundledSheetData = serde_json::from_value(payload).unwrap(); LoadedSheet::from_bundle(data).unwrap() } fn fixture(path: &str) -> Vec { std::fs::read(repo_root().join(FIXTURES).join(path)).unwrap() } /// The attachment text of a PDF, as the reader hands it to the session. fn attachment_text(pdf: &[u8]) -> String { read_attached_document(pdf, ProbeLimits::UNBOUNDED) .unwrap() .text .into_owned() } /// An envelope like the export writes for `report`: the demo's branding (logos) and labels, /// a snapshot of the draft for that report. fn envelope_for(sheet: &LoadedSheet, demo: &ReportArchiveEnvelope, report: Report) -> String { let envelope = ReportArchiveEnvelope { sheet_snapshot: build_sheet_snapshot(sheet, &report), report, ..demo.clone() }; to_js_pretty(&envelope).unwrap() } fn report(path: &str) -> Report { let text = String::from_utf8(fixture(path)).unwrap(); serde_json::from_value(parse_json(&text).unwrap()).unwrap() } fn row(name: &str, text: &str) -> (String, usize, JsonPrescan) { (name.to_owned(), text.len(), prescan(text.as_bytes())) } #[test] fn legitimate_archives_stay_far_below_the_hostile_references() { let sheet = draft_sheet(); let demo_pdf = fixture("pdf/r3/demo.fr.logos.pdf"); let demo = import_pdf(&sheet, &demo_pdf, ProbeLimits::UNBOUNDED) .unwrap() .read .archive .unwrap(); let rows = [ row("demo fr logos (R3 export)", &attachment_text(&demo_pdf)), row( "v2full fr logos (R3 export)", &attachment_text(&fixture("pdf/r3/v2full.fr.logos.pdf")), ), row( "612 leaves (O7 read.612-leaves-exported)", &attachment_text(&r4_input("read", "read.612-leaves-exported.pdf")), ), row( "L envelope (60 observations, 120 views, logos)", &envelope_for(&sheet, &demo, report("r4/reports/L.json")), ), row( "CAP envelope (500 observations, 1,000 views, logos)", &envelope_for(&sheet, &demo, report("r4/reports/CAP.json")), ), row( "hostile: tolerance/values-1m.pdf", &attachment_text(&fixture("pdf/r4/tolerance/values-1m.pdf")), ), ]; println!("| Document | Bytes | Values | Within depth |"); println!("|---|---|---|---|"); for (name, bytes, scan) in &rows { println!( "| {name} | {bytes} | {} | {} |", scan.values, scan.within_depth ); } let cap = rows[4].2.values; assert!(cap < 200_000, "CAP envelope values: {cap}"); assert!(rows[5].2.values > 5 * cap, "values-1m is not far above CAP"); }