//! V1-2.2: `PreviewSheet` (contract §8.1, §10). The equine draft previews with the index, //! the fingerprint and the canvases of the bundled sheet; hash, fingerprint, caps and //! missing-drawing faults refuse a published version; a draft loads with them reported and //! draws with its integrity errors; a document replacement redraws without reading the //! drawings again; no report operation runs on a preview. #![allow(clippy::disallowed_methods, clippy::unwrap_used, clippy::expect_used)] mod common; use faunosteo_core::domain::js::parse_json; use faunosteo_core::domain::sheet::preview::{ PreviewDrawing, PreviewDrawingStatus, PreviewFailure, PreviewInput, PreviewSheet, PreviewState, PreviewStatus, }; use faunosteo_core::domain::sheet::{BundledSheetData, LoadedSheet, SheetIndexData}; use faunosteo_core::facade::{call_with_preview, call_with_sheet}; use serde_json::{Value, json}; const SEED: &str = "supabase/seed/anatomical-sheets/equine/draft"; const HORSE_ID: &str = "7f767f74-3b36-51a7-8465-52dd7e2ead4a"; const HORSE_SHA: &str = "0ea5202fa3b95bac167b87c12ee969ab0272e085b60c2d34dbca6202c5f08541"; const FINGERPRINT: &str = "12d788727c1e532641bd5b3a7ecf39dbdd25e70350f8a76be5ca917b262874e2"; fn document_text() -> String { common::repo_file(&format!("{SEED}/document.json")) } fn horse() -> Vec { std::fs::read(common::repo_path(&format!("{SEED}/assets/horse.svg"))).unwrap() } fn horse_drawing() -> PreviewDrawing { PreviewDrawing { asset_id: HORSE_ID.to_owned(), sha256: HORSE_SHA.to_owned(), bytes: horse(), } } fn input(status: PreviewStatus, document: String, fingerprint: Option<&str>) -> PreviewInput { PreviewInput { status, document, fingerprint: fingerprint.map(str::to_owned), } } fn published() -> PreviewSheet { let input = input(PreviewStatus::Published, document_text(), Some(FINGERPRINT)); PreviewSheet::load(input, vec![horse_drawing()]).unwrap() } fn load_err(input: PreviewInput, drawings: Vec) -> PreviewFailure { match PreviewSheet::load(input, drawings) { Ok(_) => panic!("loaded"), Err(failure) => failure, } } /// The report editor's sheet, from the same seed folder as the bundle plugin reads. fn bundled() -> LoadedSheet { let reference = parse_json(&common::repo_file(&format!("{SEED}/sheet-ref.json"))).unwrap(); let payload = json!({ "status": "draft", "ref": reference, "document": parse_json(&document_text()).unwrap(), "migrationMap": parse_json(&common::repo_file(&format!("{SEED}/report-migration-map.json"))).unwrap(), "assets": { HORSE_ID: String::from_utf8(horse()).unwrap() }, "assetHashes": { HORSE_ID: HORSE_SHA } }); let data: BundledSheetData = serde_json::from_value(payload).unwrap(); LoadedSheet::from_bundle(data).unwrap() } fn state(sheet: &PreviewSheet) -> PreviewState { sheet.state().unwrap() } fn canvas(outcome: String) -> Value { serde_json::from_str(&outcome).unwrap() } #[test] fn the_equine_draft_previews_as_the_bundled_sheet() { let preview = published(); let state = state(&preview); let bundle = bundled(); let data = SheetIndexData::of(&bundle); assert_eq!(state.fingerprint.as_deref(), Some(FINGERPRINT)); assert_eq!(bundle.reference.document_sha256, FINGERPRINT); let index = state.index.unwrap(); assert_eq!(index.main_view_id, data.main_view_id); assert_eq!(index.view_by_id, data.view_by_id); assert_eq!(index.annotation_by_id, data.annotation_by_id); assert_eq!(index.finding_zone_by_id, data.finding_zone_by_id); assert_eq!(index.names, data.names); assert_eq!(index.spine_ids, data.spine_ids); assert_eq!(index.node_keys, data.node_keys); assert_eq!(state.document, data.document); for view in ["main", "head"] { let input = json!({ "viewId": view }).to_string(); let from_preview = canvas(call_with_preview(&preview, "view.canvas", &input)); assert_eq!(from_preview["ok"], json!(true), "{view}"); assert_eq!( from_preview, canvas(call_with_sheet(&bundle, "view.canvas", &input)), "{view}" ); } assert_eq!(state.report.groups.len(), 30); assert_eq!(state.report.document_bytes, 184_105); assert_eq!(state.drawings.len(), 1); assert_eq!(state.drawings[0].state, PreviewDrawingStatus::Ok); assert_eq!(preview.drawing_reads(), 1); } #[test] fn a_hash_mismatch_is_refused_in_every_mode() { let mut bytes = horse(); bytes[200] ^= 1; for status in [ PreviewStatus::Draft, PreviewStatus::Published, PreviewStatus::Deprecated, ] { let drawing = PreviewDrawing { bytes: bytes.clone(), ..horse_drawing() }; let failure = load_err( input(status, document_text(), Some(FINGERPRINT)), vec![drawing], ); assert_eq!( failure, PreviewFailure::DrawingHashMismatch(HORSE_ID.to_owned()) ); assert_eq!(failure.kind(), "drawing_hash_mismatch"); } let not_hex = PreviewDrawing { sha256: "X".repeat(64), ..horse_drawing() }; let failure = load_err( input(PreviewStatus::Draft, document_text(), None), vec![not_hex], ); assert_eq!(failure.kind(), "drawing_hash_mismatch"); } #[test] fn a_published_version_needs_its_fingerprint_its_drawings_and_its_caps() { let wrong = "a".repeat(64); for stored in [Some(wrong.as_str()), None] { let failure = load_err( input(PreviewStatus::Published, document_text(), stored), vec![horse_drawing()], ); assert_eq!(failure, PreviewFailure::FingerprintMismatch); } let deprecated = input( PreviewStatus::Deprecated, document_text(), Some(FINGERPRINT), ); assert_eq!( load_err(deprecated, vec![]), PreviewFailure::DrawingMissing(HORSE_ID.to_owned()) ); // Over a cap: 1 025 annotations, its own fingerprint stored. let mut over = parse_json(&document_text()).unwrap(); let template = over["annotations"][0].clone(); let annotations = over["annotations"].as_array_mut().unwrap(); for i in annotations.len()..1025 { let mut copy = template.clone(); copy["id"] = json!(format!("extra-{i}")); annotations.push(copy); } let text = over.to_string(); let fingerprint = faunosteo_core::domain::sheet::fingerprint::sheet_fingerprint(&text).unwrap(); let failure = load_err( input(PreviewStatus::Published, text.clone(), Some(&fingerprint)), vec![horse_drawing()], ); assert_eq!(failure.kind(), "caps"); assert_eq!(failure.detail(), "annotations"); // The same document as a draft loads, the excess reported. let draft = PreviewSheet::load( input(PreviewStatus::Draft, text, None), vec![horse_drawing()], ) .unwrap(); let names: Vec<&str> = state(&draft) .report .caps .exceeded .iter() .map(|c| c.as_str()) .collect(); assert_eq!(names, ["annotations"]); } #[test] fn an_unreadable_document_is_refused_in_every_mode() { for status in [PreviewStatus::Draft, PreviewStatus::Published] { for text in ["{", r#"{"schema_version":2}"#, "[]"] { let failure = load_err(input(status, text.to_owned(), None), vec![]); assert_eq!(failure.kind(), "invalid_document", "{text}"); } } } #[test] fn a_draft_loads_with_its_missing_drawings_and_draws_with_its_issues() { let missing = PreviewSheet::load(input(PreviewStatus::Draft, document_text(), None), vec![]).unwrap(); assert_eq!( state(&missing).drawings[0].state, PreviewDrawingStatus::Missing ); let canvas_out = canvas(call_with_preview( &missing, "view.canvas", r#"{"viewId":"main"}"#, )); assert_eq!( (canvas_out["ok"].clone(), canvas_out["kind"].clone()), (json!(false), json!("no_asset")) ); // Integrity errors: a duplicate annotation id and a dangling category. let mut invalid = parse_json(&document_text()).unwrap(); let copy = invalid["annotations"][0].clone(); invalid["annotations"].as_array_mut().unwrap().push(copy); invalid["annotations"][1]["category_id"] = json!("nowhere"); let draft = PreviewSheet::load( input(PreviewStatus::Draft, invalid.to_string(), None), vec![horse_drawing()], ) .unwrap(); let state = state(&draft); assert!(state.fingerprint.is_none()); let codes: Vec<&str> = state .report .issues .iter() .map(|i| i.code.as_str()) .collect(); assert!( codes.contains(&"annotation.id.duplicate") && codes.contains(&"annotation.category.missing") ); let drawn = canvas(call_with_preview( &draft, "view.canvas", r#"{"viewId":"main"}"#, )); assert_eq!(drawn["ok"], json!(true)); assert!( drawn["value"]["svg"] .as_str() .unwrap() .contains("data-anno-id") ); } #[test] fn a_replaced_document_redraws_without_reading_the_drawings_again() { let mut draft = PreviewSheet::load( input(PreviewStatus::Draft, document_text(), None), vec![horse_drawing()], ) .unwrap(); let before = canvas(call_with_preview( &draft, "view.canvas", r#"{"viewId":"main"}"#, )); let mut edited = parse_json(&document_text()).unwrap(); edited["annotations"].as_array_mut().unwrap().truncate(3); for _ in 0..5 { assert_eq!( faunosteo_core::facade::replace_preview_document(&mut draft, &edited.to_string()), r#"{"ok":true,"value":null}"# ); } let after = canvas(call_with_preview( &draft, "view.canvas", r#"{"viewId":"main"}"#, )); assert_eq!(after["ok"], json!(true)); assert_ne!(after, before); assert_eq!( draft.drawing_reads(), 1, "the drawing was read once, at load" ); assert_eq!(draft.document().annotations.len(), 3); // A refused replacement keeps the previous document. let refused = faunosteo_core::facade::replace_preview_document(&mut draft, "{"); assert!(refused.contains(r#""kind":"invalid_document""#)); assert_eq!(draft.document().annotations.len(), 3); // A drawing added while open is read once, however often it is added. let svg = br#""# .to_vec(); let sha = faunosteo_core::domain::sheet::verdict::sha256_hex(&svg); for id in [ "22222222-0000-4000-8000-000000000001", "22222222-0000-4000-8000-000000000002", ] { let added = PreviewDrawing { asset_id: id.to_owned(), sha256: sha.clone(), bytes: svg.clone(), }; draft.add_drawing(added).unwrap(); } assert_eq!(draft.drawing_reads(), 2); } #[test] fn a_published_version_is_never_edited() { let mut sheet = published(); assert_eq!( sheet.replace_document(&document_text()), Err(PreviewFailure::ReadOnly) ); assert_eq!( sheet.add_drawing(horse_drawing()), Err(PreviewFailure::ReadOnly) ); } #[test] fn no_report_operation_runs_on_a_preview() { let preview = published(); for op in [ "draft.restore", "archive.import", "archive.snapshot", "zone.click", "index_data", ] { let outcome = canvas(call_with_preview(&preview, op, "{}")); assert_eq!(outcome["kind"], json!("unknown_op"), "{op}"); } let state = canvas(call_with_preview(&preview, "preview.state", "{}")); assert_eq!(state["value"]["status"], json!("published")); } #[test] fn a_preview_holds_a_bounded_number_of_bounded_drawings() { use faunosteo_core::domain::sheet::preview::MAX_HELD_DRAWINGS; let huge = vec![b' '; 2 * 1024 * 1024 + 1]; let sha = faunosteo_core::domain::sheet::verdict::sha256_hex(&huge); let oversized = PreviewDrawing { asset_id: "a".into(), sha256: sha, bytes: huge, }; let failure = load_err( input(PreviewStatus::Draft, document_text(), None), vec![oversized], ); assert_eq!( (failure.kind(), failure.detail()), ("caps", "drawing_bytes".to_owned()) ); let mut draft = PreviewSheet::load( input(PreviewStatus::Draft, document_text(), None), vec![horse_drawing()], ) .unwrap(); for i in 1..MAX_HELD_DRAWINGS { let added = PreviewDrawing { asset_id: format!("extra-{i}"), ..horse_drawing() }; draft.add_drawing(added).unwrap(); } let one_more = PreviewDrawing { asset_id: "one-more".into(), ..horse_drawing() }; assert_eq!( draft.add_drawing(one_more), Err(PreviewFailure::Caps(vec![ faunosteo_core::domain::sheet::caps::CapName::Drawings ])) ); assert_eq!(draft.drawing_reads(), 1, "the same bytes are read once"); } #[test] fn a_replaced_asset_releases_its_parse_and_a_pi_drawing_shows_rejected() { let mut draft = PreviewSheet::load( input(PreviewStatus::Draft, document_text(), None), vec![horse_drawing()], ) .unwrap(); for i in 0..40 { let svg = format!(r#""#) .into_bytes(); let sha = faunosteo_core::domain::sheet::verdict::sha256_hex(&svg); draft .add_drawing(PreviewDrawing { asset_id: "same-asset".into(), sha256: sha, bytes: svg, }) .unwrap(); } assert_eq!( draft.held_parses(), 2, "the horse and the last bytes of the re-added asset" ); let pi = br#""#.to_vec(); let sha = faunosteo_core::domain::sheet::verdict::sha256_hex(&pi); let mut doc = parse_json(&document_text()).unwrap(); doc["views"][0]["svg_asset_id"] = json!("33333333-0000-4000-8000-000000000001"); let preview = PreviewSheet::load( input(PreviewStatus::Draft, doc.to_string(), None), vec![PreviewDrawing { asset_id: "33333333-0000-4000-8000-000000000001".into(), sha256: sha, bytes: pi, }], ) .unwrap(); let state = state(&preview); assert_eq!(state.drawings[0].state, PreviewDrawingStatus::Rejected); assert_eq!( state.drawings[0].detail.as_deref(), Some("processing_instruction") ); } /// Owner decision 2026-10-29: a stored drawing outside the stored form shows rejected /// (`not_canonical`), as the verdict refuses it; the equine drawing is in that form. #[test] fn a_drawing_outside_the_stored_form_shows_rejected() { let asset = "33333333-0000-4000-8000-000000000002"; let mut doc = parse_json(&document_text()).unwrap(); doc["views"][0]["svg_asset_id"] = json!(asset); let horse_text = String::from_utf8(horse()).unwrap(); let loose = horse_text.split_once('\n').unwrap().1.as_bytes().to_vec(); let preview = PreviewSheet::load( input(PreviewStatus::Draft, doc.to_string(), None), vec![PreviewDrawing { asset_id: asset.into(), sha256: faunosteo_core::domain::sheet::verdict::sha256_hex(&loose), bytes: loose, }], ) .unwrap(); let state = state(&preview); assert_eq!(state.drawings[0].state, PreviewDrawingStatus::Rejected); assert_eq!(state.drawings[0].detail.as_deref(), Some("not_canonical")); let input = json!({ "viewId": "main" }).to_string(); let refused = canvas(call_with_preview(&preview, "view.canvas", &input)); assert_eq!(refused["detail"], json!("not_canonical")); assert_eq!( self::state(&published()).drawings[0].state, PreviewDrawingStatus::Ok ); }