//! V1-2.2: the editor's commands (contract §6.6, §8.1). The status rules, case by case; the //! refusals; `dependents`; the facade; and a property test over random command sequences: //! every output reads back strictly, existing keys survive unless removed, an edited or new //! element is `to_confirm`, nothing ever becomes `inherited`, a removal leaves no new dangling //! reference and is refused only while something names its element. #![allow(clippy::disallowed_methods, clippy::unwrap_used, clippy::expect_used)] mod common; use std::collections::HashMap; use faunosteo_core::domain::js::parse_json; use faunosteo_core::domain::sheet::AnatomicalSheetDocument; use faunosteo_core::domain::sheet::edit::{ EditCommand, EditError, Relation, apply_edit, dependents, }; use faunosteo_core::domain::sheet::keys::{ElementKey, marked_elements}; use faunosteo_core::domain::sheet::schema::ReviewStatus; use faunosteo_core::facade::call; use serde_json::{Value, json}; const SEED: &str = "supabase/seed/anatomical-sheets/equine/draft/document.json"; fn name(text: &str) -> Value { json!({ "fr": text, "en": text }) } /// Two views (a detail crop of the main one), a point in each, a trigger, a zone with a /// category and a two-level node, one reference, one region; everything `reviewed`. fn small() -> AnatomicalSheetDocument { serde_json::from_value(json!({ "schema_version": 2, "species_id": "canine", "name": name("Chien"), "description": {}, "scope_disclaimer": {}, "attribution": { "authors": [], "license": null, "notes": null }, "vertebral_config": { "regions": [{ "code": "C", "name": name("Cervicales"), "count": 7 }] }, "references": [{ "id": "r1", "type": "book", "citation": "Atlas" }], "categories": [{ "id": "c", "name": name("C"), "color": null }], "views": [ { "id": "main", "kind": "main", "name": name("Vue"), "svg_asset_id": "11111111-2222-4333-8444-555555555555", "view_box": null }, { "id": "head", "kind": "detail", "name": name("Tête"), "svg_asset_id": null, "view_box": { "min_x": 0, "min_y": 0, "width": 4, "height": 4 }, "parent_view_id": "main" } ], "annotations": [ { "id": "a1", "kind": "point", "view_id": "main", "category_id": "c", "laterality": "left", "geometry": { "type": "circle", "cx": 1, "cy": 1, "r": 1 }, "review_status": "reviewed", "name": name("P1"), "finding_zone_id": "z1", "vertebral_region_code": "C" }, { "id": "a2", "kind": "point", "view_id": "head", "category_id": "c", "laterality": "unpaired", "geometry": { "type": "circle", "cx": 2, "cy": 2, "r": 1 }, "review_status": "reviewed", "name": name("P2"), "finding_zone_id": "z1", "vertebral_region_code": null }, { "id": "t1", "kind": "detail_trigger", "view_id": "main", "category_id": "c", "laterality": "unpaired", "geometry": { "type": "polygon", "points": [[0, 0], [1, 0], [1, 1]] }, "review_status": "reviewed", "name": null, "opens_view_id": "head" } ], "finding_zones": [{ "id": "z1", "name": name("Z"), "categories": [{ "id": "cat", "kind": "dysfunction", "name": name("D"), "reference_ids": ["r1"], "review_status": "reviewed", "children": [{ "id": "n1", "name": name("N1"), "review_status": "reviewed", "children": [{ "id": "n2", "name": name("N2"), "review_status": "reviewed" }] }] }] }] })) .unwrap() } fn command(value: Value) -> EditCommand { serde_json::from_value(value).unwrap() } fn edit(doc: &AnatomicalSheetDocument, value: Value) -> AnatomicalSheetDocument { apply_edit(doc, command(value)).unwrap() } fn refused(doc: &AnatomicalSheetDocument, value: Value) -> EditError { apply_edit(doc, command(value)).unwrap_err() } fn statuses(doc: &AnatomicalSheetDocument) -> HashMap { marked_elements(doc) .into_iter() .map(|m| (m.key, m.status)) .collect() } fn status(doc: &AnatomicalSheetDocument, key: Value) -> ReviewStatus { let key: ElementKey = serde_json::from_value(key).unwrap(); statuses(doc)[&key] } fn finding(path: &[&str]) -> Value { json!({ "kind": "finding", "zone_id": "z1", "path": path }) } fn annotation(id: &str) -> Value { json!({ "kind": "annotation", "id": id }) } #[test] fn inserted_elements_start_to_confirm_with_their_subtree() { let doc = small(); let point = json!({ "id": "a3", "kind": "point", "view_id": "main", "category_id": "c", "laterality": "right", "geometry": null, "review_status": "reviewed", "name": name("P3"), "finding_zone_id": null, "vertebral_region_code": null }); let next = edit( &doc, json!({ "op": "insert", "element": { "kind": "annotation", "value": point }, "position": 0 }), ); assert_eq!(next.annotations[0].id(), "a3"); assert_eq!( status(&next, annotation("a3")), ReviewStatus::ToConfirm, "a page's marking is ignored" ); let subtree = json!({ "id": "n3", "name": name("N3"), "review_status": "reviewed", "children": [{ "id": "n4", "name": name("N4"), "review_status": "inherited" }] }); let next = edit( &doc, json!({ "op": "insert", "parent": finding(&["cat"]), "element": { "kind": "finding_node", "value": subtree } }), ); assert_eq!( status(&next, finding(&["cat", "n3"])), ReviewStatus::ToConfirm ); assert_eq!( status(&next, finding(&["cat", "n3", "n4"])), ReviewStatus::ToConfirm ); let zone = json!({ "id": "z2", "name": name("Z2"), "categories": [{ "id": "k", "kind": "custom", "name": name("K"), "review_status": "reviewed", "children": [] }] }); let next = edit( &doc, json!({ "op": "insert", "element": { "kind": "zone", "value": zone } }), ); let key = json!({ "kind": "finding", "zone_id": "z2", "path": ["k"] }); assert_eq!(status(&next, key), ReviewStatus::ToConfirm); } #[test] fn a_content_change_reconfirms_an_identical_update_does_not() { let doc = small(); let mut same = serde_json::to_value(&doc.annotations[0]).unwrap(); let unchanged = edit( &doc, json!({ "op": "update", "key": annotation("a1"), "element": { "kind": "annotation", "value": same.clone() } }), ); assert_eq!(unchanged, doc); same["review_status"] = json!("to_confirm"); let ignored = edit( &doc, json!({ "op": "update", "key": annotation("a1"), "element": { "kind": "annotation", "value": same.clone() } }), ); assert_eq!( status(&ignored, annotation("a1")), ReviewStatus::Reviewed, "update never sets a marking" ); for (field, value) in [ ("name", name("Autre")), ("laterality", json!("right")), ("color", json!("#112233")), ("finding_zone_id", Value::Null), ("view_id", json!("head")), ( "geometry", json!({ "type": "circle", "cx": 1.5, "cy": 1, "r": 1 }), ), ] { let mut changed = serde_json::to_value(&doc.annotations[0]).unwrap(); changed[field] = value; let next = edit( &doc, json!({ "op": "update", "key": annotation("a1"), "element": { "kind": "annotation", "value": changed } }), ); assert_eq!( status(&next, annotation("a1")), ReviewStatus::ToConfirm, "{field}" ); assert_eq!(status(&next, annotation("a2")), ReviewStatus::Reviewed); } let node = json!({ "id": "n1", "name": name("N1 bis"), "requires_vet_referral": false, "review_status": "reviewed" }); let next = edit( &doc, json!({ "op": "update", "key": finding(&["cat", "n1"]), "element": { "kind": "finding_node", "value": node } }), ); assert_eq!( status(&next, finding(&["cat", "n1"])), ReviewStatus::ToConfirm ); assert_eq!( status(&next, finding(&["cat", "n1", "n2"])), ReviewStatus::Reviewed, "children untouched" ); assert_eq!( next.finding_zones[0].categories[0].children[0] .children .len(), 1, "children kept" ); let cited = json!({ "id": "n1", "name": name("N1"), "reference_ids": [], "review_status": "reviewed" }); let next = edit( &doc, json!({ "op": "update", "key": finding(&["cat", "n1"]), "element": { "kind": "finding_node", "value": cited } }), ); assert_eq!( status(&next, finding(&["cat", "n1"])), ReviewStatus::Reviewed, "same content" ); let flagged = json!({ "id": "n1", "name": name("N1"), "requires_vet_referral": true }); let next = edit( &doc, json!({ "op": "update", "key": finding(&["cat", "n1"]), "element": { "kind": "finding_node", "value": flagged } }), ); assert_eq!( status(&next, finding(&["cat", "n1"])), ReviewStatus::ToConfirm ); let category = json!({ "id": "cat", "kind": "anamnesis", "name": name("D"), "reference_ids": ["r1"], "children": [] }); let next = edit( &doc, json!({ "op": "update", "key": finding(&["cat"]), "element": { "kind": "finding_category", "value": category } }), ); assert_eq!(status(&next, finding(&["cat"])), ReviewStatus::ToConfirm); assert_eq!(next.finding_zones[0].categories[0].children.len(), 1); } #[test] fn shared_elements_and_reorders_keep_the_markings() { let doc = small(); let before = statuses(&doc); let texts = json!({ "name": name("Chien domestique"), "description": { "fr": "d" }, "scope_disclaimer": { "fr": "x", "en": "x" }, "attribution": { "authors": ["B"], "license": null, "notes": null } }); let reference = json!({ "id": "r1", "type": "journal", "citation": "Revue" }); let region = json!({ "code": "C", "name": name("Cou"), "count": 7, "count_range": { "min": 6, "max": 8 } }); let category = json!({ "id": "c", "name": name("Catégorie"), "color": "#aa0000" }); for command in [ json!({ "op": "update", "key": { "kind": "sheet" }, "element": { "kind": "sheet", "value": texts } }), json!({ "op": "update", "key": { "kind": "reference", "id": "r1" }, "element": { "kind": "reference", "value": reference } }), json!({ "op": "update", "key": { "kind": "region", "code": "C" }, "element": { "kind": "region", "value": region } }), json!({ "op": "update", "key": { "kind": "category", "id": "c" }, "element": { "kind": "category", "value": category } }), json!({ "op": "move", "key": annotation("t1"), "position": 0 }), json!({ "op": "move", "key": { "kind": "view", "id": "head" }, "position": 0 }), ] { assert_eq!(statuses(&edit(&doc, command.clone())), before, "{command}"); } let moved = edit( &doc, json!({ "op": "move", "key": annotation("t1"), "position": 0 }), ); assert_eq!(moved.annotations[0].id(), "t1"); } #[test] fn a_redrawn_view_reconfirms_its_annotations_and_its_crops() { let doc = small(); let mut main = serde_json::to_value(&doc.views[0]).unwrap(); main["svg_asset_id"] = json!("11111111-2222-4333-8444-000000000009"); let next = edit( &doc, json!({ "op": "update", "key": { "kind": "view", "id": "main" }, "element": { "kind": "view", "value": main } }), ); assert_eq!(status(&next, annotation("a1")), ReviewStatus::ToConfirm); assert_eq!(status(&next, annotation("t1")), ReviewStatus::ToConfirm); assert_eq!( status(&next, annotation("a2")), ReviewStatus::ToConfirm, "head crops main: its drawing changed too" ); let mut head = serde_json::to_value(&doc.views[1]).unwrap(); head["view_box"]["width"] = json!(5); let next = edit( &doc, json!({ "op": "update", "key": { "kind": "view", "id": "head" }, "element": { "kind": "view", "value": head } }), ); assert_eq!(status(&next, annotation("a2")), ReviewStatus::ToConfirm); assert_eq!(status(&next, annotation("a1")), ReviewStatus::Reviewed); let mut renamed = serde_json::to_value(&doc.views[1]).unwrap(); renamed["name"] = name("Crâne"); let next = edit( &doc, json!({ "op": "update", "key": { "kind": "view", "id": "head" }, "element": { "kind": "view", "value": renamed } }), ); assert_eq!( status(&next, annotation("a2")), ReviewStatus::Reviewed, "a rename draws nothing new" ); } #[test] fn markings_are_set_one_element_category_or_zone_at_a_time() { let doc = small(); let next = edit( &doc, json!({ "op": "set_status", "key": finding(&["cat", "n1"]), "status": "to_confirm" }), ); assert_eq!( status(&next, finding(&["cat", "n1"])), ReviewStatus::ToConfirm ); assert_eq!( status(&next, finding(&["cat", "n1", "n2"])), ReviewStatus::Reviewed ); let next = edit( &next, json!({ "op": "set_status", "key": finding(&["cat", "n1"]), "status": "reviewed" }), ); assert_eq!(statuses(&next), statuses(&doc)); let inherited: Result = serde_json::from_value( json!({ "op": "set_status", "key": annotation("a1"), "status": "inherited" }), ); assert!(inherited.is_err(), "no command assigns inherited"); let all_to_confirm = edit( &doc, json!({ "op": "set_status", "key": finding(&["cat"]), "status": "to_confirm" }), ); let all_to_confirm = edit( &all_to_confirm, json!({ "op": "set_status", "key": finding(&["cat", "n1", "n2"]), "status": "to_confirm" }), ); let marked = edit( &all_to_confirm, json!({ "op": "mark_reviewed", "key": finding(&["cat"]) }), ); assert_eq!(status(&marked, finding(&["cat"])), ReviewStatus::Reviewed); assert_eq!( status(&marked, finding(&["cat", "n1", "n2"])), ReviewStatus::Reviewed ); let zone = edit( &all_to_confirm, json!({ "op": "mark_reviewed", "key": { "kind": "zone", "id": "z1" } }), ); assert_eq!(statuses(&zone), statuses(&doc)); for key in [ finding(&["cat", "n1"]), annotation("a1"), json!({ "kind": "view", "id": "main" }), json!({ "kind": "sheet" }), ] { assert_eq!( refused(&doc, json!({ "op": "mark_reviewed", "key": key })), EditError::InvalidTarget ); } assert_eq!( refused( &doc, json!({ "op": "set_status", "key": { "kind": "view", "id": "main" }, "status": "reviewed" }) ), EditError::InvalidTarget ); } /// Owner decision 2026-10-29: a removal never leaves an orphan or a dangling reference. It /// takes the element's descendants and is refused, the document unchanged, while anything else /// names it. #[test] fn a_removal_takes_its_descendants_and_is_refused_while_named() { let doc = small(); let next = edit( &doc, json!({ "op": "remove", "key": finding(&["cat", "n1"]) }), ); assert!(next.finding_zones[0].categories[0].children.is_empty()); for key in [ json!({ "kind": "view", "id": "head" }), json!({ "kind": "view", "id": "main" }), json!({ "kind": "zone", "id": "z1" }), json!({ "kind": "category", "id": "c" }), json!({ "kind": "region", "code": "C" }), json!({ "kind": "reference", "id": "r1" }), ] { let command = json!({ "op": "remove", "key": key }); assert_eq!( refused(&doc, command.clone()), EditError::HasDependents, "{key}" ); let input = json!({ "document": doc, "command": command }).to_string(); let out: Value = serde_json::from_str(&call("sheet.edit", &input)).unwrap(); assert_eq!(out["kind"], json!("has_dependents"), "{key}"); } // Once nothing names them, the view and the zone go (the zone with its categories). let mut next = edit(&doc, json!({ "op": "remove", "key": annotation("a2") })); next = edit(&next, json!({ "op": "remove", "key": annotation("t1") })); next = edit( &next, json!({ "op": "remove", "key": { "kind": "view", "id": "head" } }), ); assert_eq!(next.views.len(), 1); let mut unlinked = serde_json::to_value(&next.annotations[0]).unwrap(); unlinked["finding_zone_id"] = Value::Null; next = edit( &next, json!({ "op": "update", "key": annotation("a1"), "element": { "kind": "annotation", "value": unlinked } }), ); next = edit( &next, json!({ "op": "remove", "key": { "kind": "zone", "id": "z1" } }), ); assert!(next.finding_zones.is_empty()); // With no citing finding left, the reference goes too; nothing dangles. next = edit( &next, json!({ "op": "remove", "key": { "kind": "reference", "id": "r1" } }), ); let issues = faunosteo_core::domain::sheet::validate_sheet_document(&next); assert!( issues .iter() .all(|i| !REFERENTIAL.contains(&i.code.as_str())), "{issues:?}" ); } /// The integrity rules that name an element that does not exist. const REFERENTIAL: [&str; 7] = [ "annotation.view.missing", "annotation.category.missing", "annotation.finding_zone.missing", "annotation.region.missing", "annotation.opens_view.invalid", "finding.reference.missing", "view.parent.missing", ]; /// How many issues of each referential rule a document has (paths shift with removals). fn referential_issues(doc: &AnatomicalSheetDocument) -> HashMap { let mut counts = HashMap::new(); for issue in faunosteo_core::domain::sheet::validate_sheet_document(doc) { if REFERENTIAL.contains(&issue.code.as_str()) { *counts.entry(issue.code).or_insert(0) += 1; } } counts } #[test] fn ambiguous_unknown_or_out_of_range_targets_are_refused() { let doc = small(); let copy = serde_json::to_value(&doc.annotations[0]).unwrap(); let cases = [ ( json!({ "op": "insert", "element": { "kind": "annotation", "value": copy.clone() } }), EditError::DuplicateKey, ), ( json!({ "op": "insert", "element": { "kind": "annotation", "value": copy.clone() }, "position": 9 }), EditError::DuplicateKey, ), ( json!({ "op": "remove", "key": annotation("zz") }), EditError::UnknownKey, ), ( json!({ "op": "remove", "key": finding(&["cat", "zz"]) }), EditError::UnknownKey, ), ( json!({ "op": "remove", "key": finding(&[]) }), EditError::UnknownKey, ), ( json!({ "op": "remove", "key": { "kind": "sheet" } }), EditError::InvalidTarget, ), ( json!({ "op": "move", "key": annotation("a1"), "position": 3 }), EditError::InvalidPosition, ), ( json!({ "op": "update", "key": annotation("a2"), "element": { "kind": "annotation", "value": copy.clone() } }), EditError::IdChanged, ), ( json!({ "op": "update", "key": annotation("a1"), "element": { "kind": "zone", "value": { "id": "a1", "name": name("x"), "categories": [] } } }), EditError::InvalidTarget, ), ( json!({ "op": "insert", "parent": { "kind": "zone", "id": "z1" }, "element": { "kind": "finding_node", "value": { "id": "x", "name": name("x") } } }), EditError::InvalidTarget, ), ( json!({ "op": "insert", "parent": finding(&["cat"]), "element": { "kind": "finding_node", "value": { "id": "n1", "name": name("x") } } }), EditError::DuplicateKey, ), ( json!({ "op": "insert", "parent": { "kind": "zone", "id": "z9" }, "element": { "kind": "finding_category", "value": { "id": "k", "kind": "custom", "name": name("x"), "children": [] } } }), EditError::UnknownKey, ), ( json!({ "op": "insert", "element": { "kind": "sheet", "value": { "name": name("x"), "description": {}, "scope_disclaimer": {}, "attribution": { "authors": [], "license": null, "notes": null } } } }), EditError::InvalidTarget, ), ]; for (command, error) in cases { assert_eq!(refused(&doc, command.clone()), error, "{command}"); } let twins = json!({ "id": "n9", "name": name("x"), "children": [{ "id": "k", "name": name("k") }, { "id": "k", "name": name("k") }] }); assert_eq!( refused( &doc, json!({ "op": "insert", "parent": finding(&["cat"]), "element": { "kind": "finding_node", "value": twins } }) ), EditError::DuplicateKey ); } #[test] fn findings_stop_at_eight_levels() { let doc = small(); // n2 sits at level 3 (category 1, n1 2, n2 3): five more levels fit, six do not. let nested = |levels: usize| { let mut node = json!({ "id": format!("d{levels}"), "name": name("d") }); for level in (1..levels).rev() { node = json!({ "id": format!("d{level}"), "name": name("d"), "children": [node] }); } node }; let under_n2 = finding(&["cat", "n1", "n2"]); edit( &doc, json!({ "op": "insert", "parent": under_n2.clone(), "element": { "kind": "finding_node", "value": nested(5) } }), ); assert_eq!( refused( &doc, json!({ "op": "insert", "parent": under_n2, "element": { "kind": "finding_node", "value": nested(6) } }) ), EditError::TooDeep ); } #[test] fn dependents_list_what_a_removal_leaves_dangling_or_takes() { let doc = small(); let of = |key: Value| -> Vec<(ElementKey, Relation)> { let key: ElementKey = serde_json::from_value(key).unwrap(); dependents(&doc, &key) .into_iter() .map(|d| (d.element, d.relation)) .collect() }; let a = |id: &str| ElementKey::Annotation { id: id.to_owned() }; let f = |path: &[&str]| ElementKey::Finding { zone_id: "z1".to_owned(), path: path.iter().map(|s| (*s).to_owned()).collect(), }; assert_eq!( of(json!({ "kind": "view", "id": "head" })), [(a("a2"), Relation::DrawnIn), (a("t1"), Relation::Opens)] ); assert_eq!( of(json!({ "kind": "view", "id": "main" }))[0], ( ElementKey::View { id: "head".to_owned() }, Relation::ChildView ) ); assert_eq!(of(json!({ "kind": "category", "id": "c" })).len(), 3); assert_eq!( of(json!({ "kind": "region", "code": "C" })), [(a("a1"), Relation::UsesRegion)] ); assert_eq!( of(json!({ "kind": "reference", "id": "r1" })), [(f(&["cat"]), Relation::Cites)] ); assert_eq!( of(json!({ "kind": "zone", "id": "z1" })), [ (a("a1"), Relation::LinksZone), (a("a2"), Relation::LinksZone), (f(&["cat"]), Relation::Descendant), (f(&["cat", "n1"]), Relation::Descendant), (f(&["cat", "n1", "n2"]), Relation::Descendant) ] ); assert_eq!( of(finding(&["cat", "n1"])), [(f(&["cat", "n1", "n2"]), Relation::Descendant)] ); assert!(of(annotation("a1")).is_empty()); } #[test] fn the_facade_runs_the_commands_with_closed_kinds() { let doc = serde_json::to_value(small()).unwrap(); let input = json!({ "document": doc, "command": { "op": "remove", "key": annotation("a1") } }); let outcome: Value = serde_json::from_str(&call("sheet.edit", &input.to_string())).unwrap(); assert_eq!(outcome["ok"], json!(true)); assert_eq!( outcome["value"]["document"]["annotations"] .as_array() .unwrap() .len(), 2 ); let bad = json!({ "document": doc, "command": { "op": "remove", "key": annotation("zz") } }); let outcome: Value = serde_json::from_str(&call("sheet.edit", &bad.to_string())).unwrap(); assert_eq!(outcome["kind"], json!("unknown_key")); let shape = json!({ "document": doc, "command": { "op": "remove" } }); assert!(call("sheet.edit", &shape.to_string()).contains(r#""kind":"invalid_shape""#)); let deps = json!({ "document": doc, "key": { "kind": "view", "id": "head" } }); let outcome: Value = serde_json::from_str(&call("sheet.dependents", &deps.to_string())).unwrap(); assert_eq!( outcome["value"]["dependents"][0], json!({ "element": annotation("a2"), "relation": "drawn_in" }) ); let huge = format!("{{\"document\":\"{}\"}}", "x".repeat(11 * 1024 * 1024)); assert!(call("sheet.edit", &huge).contains(r#""kind":"too_large""#)); } // --------------------------------------------------------------------------- // Property test struct Rng(u64); impl Rng { fn next(&mut self) -> u64 { self.0 ^= self.0 << 13; self.0 ^= self.0 >> 7; self.0 ^= self.0 << 17; self.0 } fn below(&mut self, n: usize) -> usize { if n == 0 { 0 } else { (self.next() % n as u64) as usize } } fn pick<'a, T>(&mut self, items: &'a [T]) -> Option<&'a T> { (!items.is_empty()).then(|| &items[self.below(items.len())]) } } /// A random command against the document as it stands; ids from `counter`. fn random_command(doc: &AnatomicalSheetDocument, rng: &mut Rng, counter: &mut usize) -> Value { *counter += 1; let id = format!("g{counter}"); let marked: Vec = marked_elements(doc).into_iter().map(|m| m.key).collect(); let views: Vec<&str> = doc.views.iter().map(|v| v.id()).collect(); let view = rng.pick(&views).copied().unwrap_or("main"); let findings: Vec<&ElementKey> = marked .iter() .filter(|k| matches!(k, ElementKey::Finding { path, .. } if path.len() < 8)) .collect(); match rng.below(12) { 9 => { let view = rng.pick(&doc.views).cloned(); match view { Some(view) => { let mut value = serde_json::to_value(&view).unwrap(); if value["view_box"].is_object() { value["view_box"]["width"] = json!(1 + rng.below(5)); } else { value["svg_asset_id"] = json!(format!("11111111-2222-4333-8444-{:012}", rng.below(3))); } json!({ "op": "update", "key": { "kind": "view", "id": view.id() }, "element": { "kind": "view", "value": value } }) } None => json!({ "op": "remove", "key": { "kind": "sheet" } }), } } 10 => match rng.below(3) { 0 => { json!({ "op": "insert", "element": { "kind": "reference", "value": { "id": id, "type": "web", "citation": id } } }) } 1 => { json!({ "op": "remove", "key": { "kind": "reference", "id": rng.pick(&doc.references).map(|r| r.id.clone()).unwrap_or_default() } }) } _ => { json!({ "op": "move", "key": { "kind": "zone", "id": rng.pick(&doc.finding_zones).map(|z| z.id.clone()).unwrap_or_default() }, "position": rng.below(3) }) } }, 11 => { let zone = rng .pick(&doc.finding_zones) .map(|z| z.id.clone()) .unwrap_or_default(); json!({ "op": "update", "key": { "kind": "zone", "id": zone }, "element": { "kind": "zone", "value": { "id": zone, "name": name("Zone renommée"), "categories": [] } } }) } 0 => { json!({ "op": "insert", "position": rng.below(2), "element": { "kind": "annotation", "value": { "id": id, "kind": "point", "view_id": view, "category_id": "c", "laterality": "left", "geometry": { "type": "circle", "cx": rng.below(9), "cy": 1, "r": 1 }, "review_status": "reviewed", "name": name(&id), "finding_zone_id": "z1", "vertebral_region_code": null } } }) } 1 => match rng.pick(&findings) { Some(ElementKey::Finding { zone_id, path }) => json!({ "op": "insert", "parent": { "kind": "finding", "zone_id": zone_id, "path": path }, "element": { "kind": "finding_node", "value": { "id": id, "name": name(&id), "review_status": "reviewed" } } }), _ => { json!({ "op": "insert", "element": { "kind": "zone", "value": { "id": id, "name": name(&id), "categories": [] } } }) } }, 2 => { json!({ "op": "insert", "element": { "kind": "view", "value": { "id": id, "kind": "detail", "name": name(&id), "svg_asset_id": null, "view_box": { "min_x": 0, "min_y": 0, "width": 1 + rng.below(4), "height": 2 }, "parent_view_id": view } } }) } 3 | 4 => { let key = rng.pick(&marked).cloned(); match key { Some(key) => update_command(doc, &key, rng), None => json!({ "op": "remove", "key": { "kind": "sheet" } }), } } 5 => { json!({ "op": "remove", "key": rng.pick(&marked).cloned().unwrap_or(ElementKey::Sheet) }) } 6 => { json!({ "op": "move", "key": rng.pick(&marked).cloned().unwrap_or(ElementKey::Sheet), "position": rng.below(3) }) } 7 => { json!({ "op": "set_status", "key": rng.pick(&marked).cloned().unwrap_or(ElementKey::Sheet), "status": if rng.below(2) == 0 { "reviewed" } else { "to_confirm" } }) } _ => { let zone = rng .pick(&doc.finding_zones) .map(|z| z.id.clone()) .unwrap_or_default(); json!({ "op": "mark_reviewed", "key": { "kind": "zone", "id": zone } }) } } } /// An update of `key`: its current value, renamed half the time. fn update_command(doc: &AnatomicalSheetDocument, key: &ElementKey, rng: &mut Rng) -> Value { let rename = rng.below(2) == 0; let (kind, mut value) = match key { ElementKey::Annotation { id } => ( "annotation", serde_json::to_value(doc.annotations.iter().find(|a| a.id() == id).unwrap()).unwrap(), ), ElementKey::Finding { zone_id, path } => { let zone = doc.finding_zones.iter().find(|z| &z.id == zone_id).unwrap(); let category = zone.categories.iter().find(|c| c.id == path[0]).unwrap(); if path.len() == 1 { ("finding_category", serde_json::to_value(category).unwrap()) } else { let mut nodes = &category.children; let mut node = None; for segment in &path[1..] { let found = nodes.iter().find(|n| &n.id == segment).unwrap(); nodes = &found.children; node = Some(found); } ("finding_node", serde_json::to_value(node.unwrap()).unwrap()) } } _ => unreachable!(), }; let changes = rename && value["name"] != name("renamed"); if rename { value["name"] = name("renamed"); } json!({ "op": "update", "key": key, "element": { "kind": kind, "value": value }, "changes": changes }) } #[test] fn random_command_sequences_keep_every_invariant() { let equine: AnatomicalSheetDocument = serde_json::from_value(parse_json(&common::repo_file(SEED)).unwrap()).unwrap(); for (seed, start) in [ (0x9e37_79b9_7f4a_7c15_u64, small()), (0x2545_f491_4f6c_dd1d, equine), ] { let mut rng = Rng(seed); let mut counter = 0; let mut doc = start; let (mut applied, mut refusals, mut named) = (0, 0, 0); for _ in 0..400 { let mut raw = random_command(&doc, &mut rng, &mut counter); let changes = raw.as_object_mut().unwrap().remove("changes"); let Ok(command) = serde_json::from_value::(raw.clone()) else { continue; }; let before = statuses(&doc); let inherited_before = before .values() .filter(|s| **s == ReviewStatus::Inherited) .count(); match apply_edit(&doc, command) { Err(error) => { refusals += 1; if error == EditError::HasDependents { let key: ElementKey = serde_json::from_value(raw["key"].clone()).unwrap(); assert!( dependents(&doc, &key) .iter() .any(|d| d.relation != Relation::Descendant), "refused with nothing naming it: {raw}" ); named += 1; } } Ok(next) => { applied += 1; if raw["op"] == "remove" { let (old, new) = (referential_issues(&doc), referential_issues(&next)); let grew = new .iter() .any(|(code, n)| old.get(code).is_none_or(|o| n > o)); assert!(!grew, "orphan left: {raw}"); } let text = serde_json::to_string(&next).unwrap(); let reread: AnatomicalSheetDocument = serde_json::from_value(parse_json(&text).unwrap()).unwrap(); assert_eq!(reread, next, "strictly parseable: {raw}"); let after = statuses(&next); let inherited_after = after .values() .filter(|s| **s == ReviewStatus::Inherited) .count(); assert!( inherited_after <= inherited_before, "nothing becomes inherited: {raw}" ); check_command(&raw, changes.as_ref(), &before, &after); doc = next; } } } assert!( applied > 200 && refusals > 0 && named > 0, "{applied} applied, {refusals} refused, {named} named elsewhere" ); } } /// The marking rule of the command just applied, on the keys it names. fn check_command( raw: &Value, changes: Option<&Value>, before: &HashMap, after: &HashMap, ) { let op = raw["op"].as_str().unwrap(); let key = || serde_json::from_value::(raw["key"].clone()).unwrap(); match op { "insert" => { let new: Vec<_> = after.keys().filter(|k| !before.contains_key(*k)).collect(); assert!( new.iter().all(|k| after[*k] == ReviewStatus::ToConfirm), "{raw}" ); } "update" if before.contains_key(&key()) => { let key = key(); let expected = if changes == Some(&json!(true)) { ReviewStatus::ToConfirm } else { before[&key] }; assert_eq!(after[&key], expected, "{raw}"); assert!( before .iter() .all(|(k, s)| *k == key || after.get(k) == Some(s)), "{raw}" ); } "move" => assert_eq!(before, after, "{raw}"), "set_status" => { let expected = if raw["status"] == json!("reviewed") { ReviewStatus::Reviewed } else { ReviewStatus::ToConfirm }; assert_eq!(after[&key()], expected); assert!( before .iter() .all(|(k, s)| *k == key() || after.get(k) == Some(s)), "{raw}" ); } "remove" => { let gone: Vec<_> = before.keys().filter(|k| !after.contains_key(*k)).collect(); assert!( gone.iter().all(|k| k == &&key() || is_below(k, &key())), "{raw}" ); } "mark_reviewed" => { let ElementKey::Zone { id } = key() else { unreachable!() }; for (k, status) in after { let inside = matches!(k, ElementKey::Finding { zone_id, .. } if *zone_id == id); let expected = if inside { ReviewStatus::Reviewed } else { before[k] }; assert_eq!(*status, expected, "{raw}"); } } _ => {} } if op != "remove" { assert!( before.keys().all(|k| after.contains_key(k)), "keys kept: {raw}" ); } } fn is_below(key: &ElementKey, ancestor: &ElementKey) -> bool { match (key, ancestor) { (ElementKey::Finding { zone_id, .. }, ElementKey::Zone { id }) => zone_id == id, ( ElementKey::Finding { zone_id: a, path: p, }, ElementKey::Finding { zone_id: b, path: q, }, ) => a == b && p.len() > q.len() && p.starts_with(q), _ => false, } } #[test] fn an_edit_on_a_long_chain_of_views_stays_linear() { let mut doc = serde_json::to_value(small()).unwrap(); let views = doc["views"].as_array_mut().unwrap(); for i in 0..2000 { let parent = if i == 0 { "main".to_owned() } else { format!("c{}", i - 1) }; views.push(json!({ "id": format!("c{i}"), "kind": "detail", "name": name("C"), "svg_asset_id": null, "view_box": { "min_x": 0, "min_y": 0, "width": 1, "height": 1 }, "parent_view_id": parent })); } let doc: AnatomicalSheetDocument = serde_json::from_value(doc).unwrap(); let started = std::time::Instant::now(); edit(&doc, json!({ "op": "remove", "key": annotation("a1") })); assert!( started.elapsed().as_millis() < 1000, "{:?}", started.elapsed() ); }