fix(anatomy): V1-2.2 refuse a root visibility that hides the markers

Both composers append the marker layer as the root's last child, so a
root visibility="hidden" whose children set visible back drew the
drawing without a marker (0 marker pixels in Chromium and Firefox, PDF
and canvas). The reader refuses any root visibility but visible
(root_visibility); cleaning, verdict, preview, PDF gate and both
composers answer it.
This commit is contained in:
bchanot committed 2026-10-30 18:56:48 +01:00
1 parent 81f7639c75
commit d8562f60f5
14 files changed
+509 -169

No files matched your search

+16 -155
View File
@@ -12,135 +12,30 @@ mod common;
use std::collections::HashSet;
use common::sheet_readers::{
OPEN, assert_refused_everywhere, canvas_outcome, holders, preview, sheet, svg, verdict_detail,
};
use faunosteo_core::anatomy::compose::{ComposeError, compose_canvas, compose_highlight};
use faunosteo_core::anatomy::svg::clean::{CleaningOutcome, clean_svg};
use faunosteo_core::anatomy::svg::refs::{RESERVED_IDS, is_reserved_id};
use faunosteo_core::anatomy::svg::tree::parse_svg;
use faunosteo_core::anatomy::svg::{Element, SvgRejection, read_svg};
use faunosteo_core::domain::sheet::AnatomicalSheetDocument;
use faunosteo_core::domain::sheet::preview::{
PreviewDrawing, PreviewDrawingStatus, PreviewInput, PreviewSheet, PreviewStatus,
};
use faunosteo_core::domain::sheet::verdict::{
DrawingResult, VerdictBinding, VerdictDrawing, VerdictInput, codes, compute_verdict, sha256_hex,
};
use faunosteo_core::facade::call_with_preview;
use faunosteo_core::domain::sheet::verdict::{DrawingResult, sha256_hex};
use serde::Deserialize;
use serde_json::{Value, json};
use serde_json::json;
const HORSE: &str = "supabase/seed/anatomical-sheets/equine/draft/assets/horse.svg";
/// The DEV equine object (contract §9.3): its bytes are the committed draft drawing.
const HORSE_SHA256: &str = "0ea5202fa3b95bac167b87c12ee969ab0272e085b60c2d34dbca6202c5f08541";
const MAIN_ASSET: &str = "11111111-2222-4333-8444-555555555555";
const DETAIL_ASSET: &str = "66666666-7777-4888-9999-aaaaaaaaaaaa";
const OPEN: &str = concat!(
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n",
r#"<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 10 10">"#
);
/// The filter a hostile drawing put in the engine's place: every pixel transparent.
const ERASER: &str = "<filter id=\"osteo-halo\"><feColorMatrix type=\"matrix\" \
values=\"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\"/></filter>";
fn svg(body: &str) -> String {
format!("{OPEN}{body}</svg>")
}
fn name(text: &str) -> Value {
json!({ "fr": text, "en": text })
}
/// A sheet with a main view (one point marker) and a detail view.
fn document() -> String {
json!({
"schema_version": 2, "species_id": "canine", "name": name("Chien"),
"description": {}, "scope_disclaimer": { "fr": "Outil", "en": "Tool" },
"attribution": { "authors": ["A"], "license": null, "notes": null },
"vertebral_config": { "regions": [] }, "references": [],
"categories": [{ "id": "c", "name": name("C"), "color": null }],
"views": [
{ "id": "main", "kind": "main", "name": name("Vue"), "svg_asset_id": MAIN_ASSET, "view_box": null },
{ "id": "detail", "kind": "detail", "name": name("Tête"), "svg_asset_id": DETAIL_ASSET,
"view_box": null, "parent_view_id": "main" }
],
"annotations": [{
"id": "hock", "kind": "point", "view_id": "main", "category_id": "c",
"laterality": "unpaired", "geometry": { "type": "circle", "cx": 5, "cy": 5, "r": 1 },
"review_status": "reviewed", "name": name("Jarret"), "finding_zone_id": null,
"vertebral_region_code": null
}],
"finding_zones": []
})
.to_string()
}
fn sheet() -> AnatomicalSheetDocument {
serde_json::from_str(&document()).unwrap()
}
fn drawing(asset_id: &str, text: &str) -> PreviewDrawing {
PreviewDrawing {
asset_id: asset_id.to_owned(),
sha256: sha256_hex(text.as_bytes()),
bytes: text.as_bytes().to_vec(),
}
}
fn preview(detail: &str) -> PreviewSheet {
let input = PreviewInput {
status: PreviewStatus::Draft,
document: document(),
fingerprint: None,
};
let main = svg("<path d=\"M0 0h1\"/>");
let drawings = vec![drawing(MAIN_ASSET, &main), drawing(DETAIL_ASSET, detail)];
PreviewSheet::load(input, drawings).unwrap()
}
fn canvas_outcome(preview: &PreviewSheet, view: &str) -> Value {
let input = json!({ "viewId": view }).to_string();
serde_json::from_str(&call_with_preview(preview, "view.canvas", &input)).unwrap()
}
fn verdict_detail(detail: &str) -> (bool, DrawingResult, Option<String>) {
let main = svg("<path d=\"M0 0h1\"/>");
let document = document();
let row = |asset_id: &'static str, text: &str| VerdictDrawing {
asset_id,
sha256: Box::leak(sha256_hex(text.as_bytes()).into_boxed_str()),
byte_size: text.len() as u64,
bytes: Some(Box::leak(text.as_bytes().to_vec().into_boxed_slice())),
};
let verdict = compute_verdict(&VerdictInput {
binding: VerdictBinding {
sheet_id: "s".to_owned(),
version_id: "v".to_owned(),
revision: 1,
review_id: "r".to_owned(),
},
document: &document,
base_document: None,
drawings: vec![row(MAIN_ASSET, &main), row(DETAIL_ASSET, detail)],
});
let checked = verdict
.drawings
.iter()
.find(|d| d.asset_id == DETAIL_ASSET)
.unwrap();
(
verdict.failures.iter().any(|f| f == codes::SVG_REJECTED),
checked.result,
checked.detail.clone(),
)
}
/// Every element holding `id`, in document order.
fn holders<'a>(element: &'a Element, id: &str, out: &mut Vec<&'a Element>) {
if element.attr("id") == Some(id) {
out.push(element);
}
for child in element.element_children() {
holders(child, id, out);
}
/// The drawing is refused `reserved_id` by every reader of the product.
fn assert_refused_everywhere_id(text: &str) {
assert_refused_everywhere(text, "reserved_id");
}
/// No element of the tree holds a reserved id, in any case.
@@ -149,40 +44,6 @@ fn free_of_reserved(element: &Element) -> bool {
&& element.element_children().all(free_of_reserved)
}
/// The drawing is refused `reserved_id` by every reader of the product.
fn assert_refused_everywhere(text: &str) {
assert_eq!(
read_svg(text).err(),
Some(SvgRejection::ReservedId),
"{text}"
);
let cleaning = clean_svg(text.as_bytes());
assert_eq!(cleaning.outcome, CleaningOutcome::Rejected, "{text}");
assert_eq!(cleaning.reason.as_deref(), Some("reserved_id"), "{text}");
assert!(cleaning.preview.is_none() && cleaning.stored.is_none() && cleaning.sha256.is_none());
let preview = preview(text);
let state = preview.state().unwrap();
let detail = state
.drawings
.iter()
.find(|d| d.asset_id == DETAIL_ASSET)
.unwrap();
assert_eq!(detail.state, PreviewDrawingStatus::Rejected, "{text}");
assert_eq!(detail.detail.as_deref(), Some("reserved_id"), "{text}");
let refused = canvas_outcome(&preview, "detail");
assert_eq!(
(refused["kind"].as_str(), refused["detail"].as_str()),
(Some("svg_rejected"), Some("reserved_id")),
"{text}"
);
let (failed, result, reason) = verdict_detail(text);
assert!(failed, "{text}");
assert_eq!(result, DrawingResult::SvgRejected, "{text}");
assert_eq!(reason.as_deref(), Some("reserved_id"), "{text}");
}
#[test]
fn the_reserved_set_is_the_halo_filter_alone() {
assert_eq!(RESERVED_IDS, ["osteo-halo"]);
@@ -249,11 +110,11 @@ fn a_drawing_without_a_reserved_id_is_accepted_and_gets_the_engine_halo() {
/// 2. A filter of its own named `osteo-halo`, referenced or not, eraser or harmless.
#[test]
fn a_filter_named_osteo_halo_is_refused() {
assert_refused_everywhere(&svg(ERASER));
assert_refused_everywhere(&svg(&format!(
assert_refused_everywhere_id(&svg(ERASER));
assert_refused_everywhere_id(&svg(&format!(
"<defs>{ERASER}</defs><path filter=\"url(#osteo-halo)\" d=\"M0 0h1\"/>"
)));
assert_refused_everywhere(&svg(
assert_refused_everywhere_id(&svg(
"<filter id=\"osteo-halo\"><feGaussianBlur stdDeviation=\"18\"/></filter>",
));
}
@@ -287,10 +148,10 @@ fn the_reserved_id_on_any_kept_element_is_refused() {
"<g><g><g><path id=\"osteo-halo\" d=\"M0 0h1\"/></g></g></g>",
];
for body in elements {
assert_refused_everywhere(&svg(body));
assert_refused_everywhere_id(&svg(body));
}
let root = OPEN.replace("viewBox", "id=\"osteo-halo\" viewBox");
assert_refused_everywhere(&format!("{root}<path d=\"M0 0h1\"/></svg>"));
assert_refused_everywhere_id(&format!("{root}<path d=\"M0 0h1\"/></svg>"));
}
/// 4. References to the reserved id: dangling when the drawing does not define it (already
@@ -322,7 +183,7 @@ fn references_to_the_reserved_id_are_refused() {
Some("dangling_reference"),
"{reference}"
);
assert_refused_everywhere(&svg(&format!(
assert_refused_everywhere_id(&svg(&format!(
"<defs><filter id=\"osteo-halo\"/><g id=\"OSTEO-HALO\"/></defs>{reference}"
)));
}
@@ -344,7 +205,7 @@ fn adversarial_spellings_never_reach_the_composition() {
"oSTEO-hALO",
];
for id in decoded_to_reserved {
assert_refused_everywhere(&svg(&format!("<g id=\"{id}\"/>")));
assert_refused_everywhere_id(&svg(&format!("<g id=\"{id}\"/>")));
}
let removed = [