Files
faunosteo/crates/core/tests/sheet_preview.rs
T
bchanot 5ca2b7e3ad feat(domain): per-view minimum point radius in preview state
PreviewState.min_point_radius maps a view id to the smallest point
hitbox radius that passes TooSmall on the smallest preview, so the
sheet editor can mark it on a size slider. Twin constants named in
layer.rs; frame.rs shares one first-view drawing lookup.
2026-11-17 16:33:40 +01:00

563 lines
20 KiB
Rust

//! 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::anatomy::frame::{
Frame, MIN_VISIBLE_PX, Placement, annotation_placement, min_point_radius, view_frame,
};
use faunosteo_core::anatomy::interior::Budget;
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::{Annotation, 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<u8> {
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<PreviewDrawing>) -> 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#"<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 4 4"><path d="M0 0"/></svg>"#
.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#"<svg xmlns="http://www.w3.org/2000/svg"><path d="M0 0h{i}"/></svg>"#)
.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#"<?xml-stylesheet href="https://e/x.xsl"?><svg xmlns="http://www.w3.org/2000/svg"><path d="M0 0h1"/></svg>"#.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
);
}
/// The minimum radius the formula gives on a frame, rounded up to 0.01, written apart from the
/// function under test.
fn formula_radius(frame: &Frame, main: bool) -> Option<f64> {
let (w, h) = if main { (286.0, 310.0) } else { (254.0, 191.0) };
let scale = (w / frame.width).min(h / frame.height);
let half_disc = MIN_VISIBLE_PX / 2.0 / scale;
(half_disc > 2.0).then(|| ((12.0 + half_disc) * 100.0).ceil() / 100.0)
}
/// The frames of the equine draft's views, read from the fixture's document and drawing.
fn equine_frames(sheet: &PreviewSheet) -> Vec<(String, bool, Frame)> {
let drawing = sheet.drawing(HORSE_ID).unwrap().as_ref().unwrap();
sheet
.document()
.views
.iter()
.map(|v| {
(
v.id().to_owned(),
v.is_main(),
view_frame(v, drawing).unwrap(),
)
})
.collect()
}
#[test]
fn each_view_states_the_smallest_radius_a_point_may_have() {
let sheet = published();
let radii = state(&sheet).min_point_radius;
let frames = equine_frames(&sheet);
assert_eq!(radii.len(), frames.len());
for (id, main, frame) in &frames {
assert_eq!(radii.get(id).copied(), formula_radius(frame, *main), "{id}");
}
assert!((radii["main"] - 26.50).abs() < 0.01, "{radii:?}");
assert!((radii["head"] - 15.98).abs() < 0.01, "{radii:?}");
}
#[test]
fn a_view_that_shows_every_radius_or_has_no_frame_states_none() {
let main = |w: f64, h: f64| Frame {
min_x: 0.0,
min_y: 0.0,
width: w,
height: h,
};
// Width 100: the main preview scale is 2.86, the twin's floor of 2 units shows 11 px.
assert_eq!(min_point_radius(&main(100.0, 100.0), true), None);
// Scale of exactly 1: the floor shows exactly 4 px, no radius fails.
assert_eq!(min_point_radius(&main(286.0, 310.0), true), None);
assert!(min_point_radius(&main(286.1, 310.0), true).is_some());
let mut doc = parse_json(&document_text()).unwrap();
doc["views"][1]["view_box"] = json!({"min_x": 0, "min_y": 0, "width": 0.5, "height": 0.5});
let draft = input(PreviewStatus::Draft, doc.to_string(), None);
let sheet = PreviewSheet::load(draft, vec![horse_drawing()]).unwrap();
assert_eq!(
state(&sheet).min_point_radius.keys().collect::<Vec<_>>(),
["main"]
);
}
/// A point of the draft with the radius `r`, centred in the middle of its view's frame.
fn point_with(frame: &Frame, view: &str, r: f64) -> Annotation {
let mut point = parse_json(&document_text()).unwrap()["annotations"][0].clone();
assert_eq!(point["geometry"]["type"], json!("circle"));
point["view_id"] = json!(view);
point["geometry"] = json!({
"type": "circle",
"cx": frame.min_x + frame.width / 2.0,
"cy": frame.min_y + frame.height / 2.0,
"r": r
});
serde_json::from_value(point).unwrap()
}
#[test]
fn the_stated_radius_passes_and_a_hundredth_less_is_too_small() {
let sheet = published();
let radii = state(&sheet).min_point_radius;
for (id, main, frame) in equine_frames(&sheet) {
let placement = |r: f64| {
let point = point_with(&frame, &id, r);
annotation_placement(&point, &frame, main, &mut Budget::default())
};
assert_eq!(placement(radii[&id]), Placement::InFrame, "{id}");
assert_eq!(placement(radii[&id] - 0.01), Placement::TooSmall, "{id}");
}
}