Files
faunosteo/crates/core/tests/sheet_edit.rs
T
bchanot bb5efa0f00 fix(domain): V1-2.2 refuse a removal while another element names it
sheet.edit remove answers has_dependents, the document unchanged, while
dependents lists anything but descendants (owner decision 2026-10-29);
the property test checks no removal adds a referential issue.
2026-10-29 16:24:17 +01:00

957 lines
38 KiB
Rust

//! 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<ElementKey, ReviewStatus> {
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<EditCommand, _> = 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<String, usize> {
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<ElementKey> = 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::<EditCommand>(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<ElementKey, ReviewStatus>,
after: &HashMap<ElementKey, ReviewStatus>,
) {
let op = raw["op"].as_str().unwrap();
let key = || serde_json::from_value::<ElementKey>(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()
);
}