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.
563 lines
20 KiB
Rust
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}");
|
|
}
|
|
}
|