Files
faunosteo/crates/core/tests/editor_rules.rs
T
bchanot 3639c8778e feat(domain): R2.3 editor rules in Rust — zone click chain, reducers, finding toggle, vertebra selection, report operations
zoneInteraction (decision + reducers, collectVertebrae concatenated-key
dedup, syncVertebrae Map order), FindingsTreePicker.toggleLeaf (clicked
leaf by position, parents first-wins), VertebraPicker toggle/all/none and
the store's newReport/add/remove/move, checked against 49 cases frozen
from the TypeScript (41 byte-equal, 8 equal up to key order: contract
order replaces insertion order, D-R11) and the 13-case service suite.
Typed error kinds where the TypeScript would throw or corrupt a list.
2026-10-14 00:17:22 +02:00

476 lines
17 KiB
Rust

//! The editor rules against the TypeScript they replace: every case of
//! `tests/oracles/editor.json` (frozen from `zoneInteraction.ts`, the findings picker, the
//! vertebra picker and the store by `apps/app/tests/unit/r2.editor-characterisation.test.ts`)
//! runs through the Rust functions, and the `services.zoneInteraction.test.ts` suite is ported
//! with its exact expectations.
#![allow(clippy::disallowed_methods, clippy::unwrap_used, clippy::expect_used)]
mod common;
use faunosteo_core::domain::editor::{
self, EditorError, LeafClick, MoveDirection, NewReportDraft, NewReportStamp, VertebraAction,
ZoneClickKind,
};
use faunosteo_core::domain::js::parse_json;
use faunosteo_core::domain::report::{LateralSide, Observation, Report, SheetRef, Vertebra};
use faunosteo_core::domain::sheet::{BundledSheetData, IndexedDocument, LoadedSheet};
use faunosteo_core::json::to_js_pretty;
use serde::Serialize;
use serde::de::DeserializeOwned;
use serde_json::{Map, Value, json};
/// Cases whose TypeScript output only differs from the Rust one by key order (D-R11: the core
/// prints every object in the contract's field order). `newZone` writes `side` after the
/// label snapshots, `syncVertebrae` appends `vertebrae` to a spawned zone, the store's
/// `newReport` spreads the draft before stamping version, id and dates. Every other case is
/// byte-equal; these are equal once keys are sorted.
const ORDER_ONLY: [&str; 8] = [
"add left side",
"add both sides to left",
"add an existing side changes nothing",
"sync spawns zones for new regions and prunes the emptied one",
"sync falls back to the main view spine annotation",
"sync spawns zones in first-seen region order",
"new report starts with one empty observation",
"new report keeps the draft observations",
];
fn draft_sheet() -> LoadedSheet {
let seed = "supabase/seed/anatomical-sheets/equine/draft";
let payload = json!({
"status": "draft",
"ref": {
"sheet_id": "s", "version_id": null, "document_sha256": "0".repeat(64),
"schema_version": 2, "species_id": "equine"
},
"document": parse_json(&common::repo_file(&format!("{seed}/document.json"))).unwrap(),
"migrationMap": parse_json(&common::repo_file(&format!("{seed}/report-migration-map.json"))).unwrap(),
"assets": {}, "assetHashes": {}
});
let data: BundledSheetData = serde_json::from_value(payload).unwrap();
LoadedSheet::from_bundle(data).unwrap()
}
fn field<T: DeserializeOwned>(input: &Value, name: &str) -> T {
serde_json::from_value(input[name].clone()).unwrap_or_else(|e| panic!("{name}: {e}"))
}
fn text<T: Serialize>(value: &T) -> String {
to_js_pretty(value).unwrap()
}
fn run_zone(sheet: &IndexedDocument<'_>, function: &str, input: &Value) -> Option<String> {
let observation = || field::<Observation>(input, "observation");
Some(match function {
"zone_click" => {
let active: Option<Observation> = field(input, "observation");
let id: String = field(input, "annotationId");
text(&editor::zone_click(sheet, active.as_ref(), &id))
}
"add_sides" => {
let sides: Vec<LateralSide> = field(input, "sides");
let id: String = field(input, "annotationId");
text(&editor::add_sides(sheet, &observation(), &id, &sides).unwrap())
}
"remove_zone_at" => text(&editor::remove_zone_at(
&observation(),
field(input, "index"),
)),
"vertebra_initial" => text(&editor::vertebra_initial(
sheet,
&observation(),
field(input, "zoneIndex"),
)),
"sync_vertebrae" => {
let selection: Vec<Vertebra> = field(input, "selection");
let view: String = field(input, "viewId");
text(&editor::sync_vertebrae(
sheet,
&observation(),
&selection,
&view,
))
}
_ => return None,
})
}
fn run_finding(sheet: &IndexedDocument<'_>, input: &Value) -> String {
let path: Vec<String> = field(input, "path");
let zone: String = field(input, "findingZoneId");
let side: Option<LateralSide> = field(input, "side");
let click = LeafClick {
finding_zone_id: &zone,
path: &path,
leaf_position: field(input, "leafPosition"),
side,
};
let observation: Observation = field(input, "observation");
text(&editor::toggle_finding(sheet, &observation, &click).unwrap())
}
fn run_report(function: &str, input: &Value) -> String {
let report = || field::<Report>(input, "report");
match function {
"vertebra_select" => {
let selection: Vec<Vertebra> = field(input, "selection");
let action: VertebraAction = field(input, "action");
text(&editor::select_vertebrae(&selection, &action).unwrap())
}
"new_report" => {
let (id, at, obs): (String, String, String) = (
field(input, "id"),
field(input, "createdAt"),
field(input, "observationId"),
);
let stamp = NewReportStamp {
id: &id,
created_at: &at,
observation_id: &obs,
};
let draft: NewReportDraft = field(input, "draft");
let sheet: SheetRef = field(input, "sheet");
text(&editor::new_report(draft, sheet, &stamp))
}
"add_observation" => {
let id: String = field(input, "id");
text(&editor::add_observation(&report(), &id))
}
"remove_observation" => text(&editor::remove_observation(
&report(),
field(input, "index"),
)),
"move_observation" => {
let direction: MoveDirection = field(input, "direction");
text(&editor::move_observation(&report(), field(input, "index"), direction).unwrap())
}
other => panic!("unknown function {other}"),
}
}
/// Objects with their keys sorted, recursively: equality up to key order.
fn canonical(value: &Value) -> Value {
match value {
Value::Object(map) => {
let mut keys: Vec<&String> = map.keys().collect();
keys.sort();
let sorted: Map<String, Value> = keys
.into_iter()
.map(|k| (k.clone(), canonical(&map[k])))
.collect();
Value::Object(sorted)
}
Value::Array(items) => Value::Array(items.iter().map(canonical).collect()),
other => other.clone(),
}
}
#[test]
fn every_frozen_typescript_case_gives_the_same_output_in_rust() {
let sheet = draft_sheet();
let indexed = sheet.indexed();
let oracle = parse_json(&common::repo_file("crates/core/tests/oracles/editor.json")).unwrap();
let cases = oracle["cases"].as_array().unwrap();
assert_eq!(cases.len(), 49);
let mut order_only = Vec::new();
for case in cases {
let name = case["name"].as_str().unwrap();
let function = case["fn"].as_str().unwrap();
let input = &case["input"];
let actual = match function {
"toggle_finding" => run_finding(&indexed, input),
_ => run_zone(&indexed, function, input).unwrap_or_else(|| run_report(function, input)),
};
let expected = text(&case["output"]);
if actual == expected {
continue;
}
let same = canonical(&serde_json::from_str(&actual).unwrap())
== canonical(&serde_json::from_str(&expected).unwrap());
assert!(same, "{name}\nrust: {actual}\nts: {expected}");
order_only.push(name);
}
assert_eq!(order_only, ORDER_ONLY);
}
// --- services.zoneInteraction.test.ts, ported one to one ---------------------------------
fn empty() -> Observation {
serde_json::from_value(json!({
"id": "obs-1", "zones": [], "findings": [], "freeTextFindings": [], "comment": ""
}))
.unwrap()
}
fn click(sheet: &IndexedDocument<'_>, obs: Option<&Observation>, id: &str) -> ZoneClickKind {
editor::zone_click(sheet, obs, id).kind
}
fn after(sheet: &IndexedDocument<'_>, obs: &Observation, id: &str) -> Observation {
editor::zone_click(sheet, Some(obs), id)
.observation
.unwrap()
}
#[test]
fn opens_the_detail_view_for_the_trigger_even_without_an_active_observation() {
let sheet = draft_sheet();
let s = sheet.indexed();
for obs in [None, Some(&empty())] {
let out = editor::zone_click(&s, obs, "head-trigger");
assert_eq!(out.kind, ZoneClickKind::OpenView);
assert_eq!(out.view_id.as_deref(), Some("head"));
}
}
#[test]
fn only_activates_a_fallback_observation_when_none_is_active() {
let sheet = draft_sheet();
let s = sheet.indexed();
assert_eq!(click(&s, None, "c7-t1"), ZoneClickKind::ActivateFallback);
assert_eq!(click(&s, Some(&empty()), "nope"), ZoneClickKind::Ignore);
}
#[test]
fn always_opens_the_vertebra_picker_on_a_spine_zone() {
let sheet = draft_sheet();
let s = sheet.indexed();
let obs = editor::zone_click(&s, Some(&empty()), "cervical")
.observation
.unwrap();
assert_eq!(
click(&s, Some(&empty()), "cervical"),
ZoneClickKind::OpenVertebraPicker
);
assert_eq!(
click(&s, Some(&obs), "cervical"),
ZoneClickKind::OpenVertebraPicker
);
}
#[test]
fn routes_bilateral_zones_through_the_side_picker_or_clears_both_sides() {
let sheet = draft_sheet();
let s = sheet.indexed();
assert_eq!(
click(&s, Some(&empty()), "hip"),
ZoneClickKind::OpenLateralityPicker
);
let left = editor::add_sides(&s, &empty(), "hip", &[LateralSide::Left]).unwrap();
assert_eq!(
click(&s, Some(&left), "hip"),
ZoneClickKind::OpenLateralityPicker
);
let both = editor::add_sides(&s, &left, "hip", &[LateralSide::Right]).unwrap();
assert_eq!(
click(&s, Some(&both), "hip"),
ZoneClickKind::RemoveBothSides
);
}
#[test]
fn toggles_plain_zones_and_splits_the_observable_annotations_as_the_sheet_says() {
let sheet = draft_sheet();
let s = sheet.indexed();
assert_eq!(click(&s, Some(&empty()), "c7-t1"), ZoneClickKind::Toggle);
let kinds: Vec<ZoneClickKind> = s
.document
.annotations
.iter()
.filter_map(|a| a.observable())
.map(|a| click(&s, Some(&empty()), &a.id))
.collect();
let count = |k: ZoneClickKind| kinds.iter().filter(|x| **x == k).count();
assert_eq!(count(ZoneClickKind::OpenLateralityPicker), 10);
assert_eq!(count(ZoneClickKind::OpenVertebraPicker), 5);
assert_eq!(count(ZoneClickKind::Toggle), 12);
}
#[test]
fn toggle_zone_adds_a_zone_with_snapshots_then_removes_it() {
let sheet = draft_sheet();
let s = sheet.indexed();
let added = after(&s, &empty(), "c7-t1");
assert_eq!(
serde_json::to_value(&added.zones).unwrap(),
json!([{
"annotationId": "c7-t1",
"viewId": "main",
"labelFrSnapshot": "Charnière C7-T1 (cervico-thoracique)",
"labelEnSnapshot": "C7-T1 junction (cervicothoracic)"
}])
);
assert!(after(&s, &added, "c7-t1").zones.is_empty());
}
#[test]
fn ensure_zone_keeps_an_existing_zone_and_reports_its_index() {
let sheet = draft_sheet();
let s = sheet.indexed();
let base = after(&s, &empty(), "c7-t1");
let base = editor::zone_click(&s, Some(&base), "cervical")
.observation
.unwrap();
let again = editor::zone_click(&s, Some(&base), "cervical");
assert_eq!(again.zone_index, Some(1));
assert!(again.observation.is_none());
let fresh = editor::zone_click(&s, Some(&empty()), "cervical");
assert_eq!(fresh.zone_index, Some(0));
assert_eq!(
fresh.observation.unwrap().zones[0].annotation_id,
"cervical"
);
}
#[test]
fn add_sides_appends_only_the_missing_sides_and_never_removes_one() {
let sheet = draft_sheet();
let s = sheet.indexed();
let left = editor::add_sides(&s, &empty(), "hip", &[LateralSide::Left]).unwrap();
let opened = editor::zone_click(&s, Some(&left), "hip");
assert_eq!(opened.sides_present, Some(vec![LateralSide::Left]));
let same = editor::add_sides(&s, &left, "hip", &[LateralSide::Left]).unwrap();
assert_eq!(same, left);
let both = editor::add_sides(&s, &left, "hip", &[LateralSide::Left, LateralSide::Right]);
let both = both.unwrap();
let sides: Vec<Option<LateralSide>> = both.zones.iter().map(|z| z.side).collect();
assert_eq!(sides, [Some(LateralSide::Left), Some(LateralSide::Right)]);
assert!(after(&s, &both, "hip").zones.is_empty());
}
#[test]
fn remove_zone_at_removes_one_zone_by_index_and_keeps_findings() {
let sheet = draft_sheet();
let s = sheet.indexed();
let mut obs = after(&s, &empty(), "c7-t1");
obs.findings = serde_json::from_value(json!([{
"findingZoneId": "c7-t1",
"path": ["c7-t1-dysfunctions", "segmental", "fixation"],
"labelFrSnapshot": "F",
"labelEnSnapshot": "F"
}]))
.unwrap();
let out = editor::remove_zone_at(&obs, 0);
assert!(out.zones.is_empty());
assert_eq!(out.findings.len(), 1);
}
#[test]
fn detail_view_zones_are_distinct_from_main_view_zones_with_the_same_id() {
let sheet = draft_sheet();
let s = sheet.indexed();
let obs = after(&s, &empty(), "atm");
assert_eq!(obs.zones[0].annotation_id, "atm");
assert_eq!(obs.zones[0].view_id, "head");
assert_eq!(click(&s, Some(&obs), "atm"), ZoneClickKind::Toggle);
}
fn vertebrae(list: Value) -> Vec<Vertebra> {
serde_json::from_value(list).unwrap()
}
#[test]
fn collects_vertebrae_across_spine_zones_the_priority_zone_first() {
let sheet = draft_sheet();
let s = sheet.indexed();
let mut obs = empty();
obs.zones = serde_json::from_value(json!([
{ "annotationId": "thoracic", "viewId": "main", "vertebrae": [{ "region": "T", "index": 2 }] },
{ "annotationId": "cervical", "viewId": "main",
"vertebrae": [{ "region": "C", "index": 3 }, { "region": "C", "index": 4 }] },
{ "annotationId": "c7-t1", "viewId": "main" }
]))
.unwrap();
assert_eq!(
editor::collect_vertebrae(&s, &obs, 1),
vertebrae(json!([
{ "region": "C", "index": 3 }, { "region": "C", "index": 4 }, { "region": "T", "index": 2 }
]))
);
}
#[test]
fn replaces_per_region_prunes_emptied_zones_and_spawns_zones_for_new_regions() {
let sheet = draft_sheet();
let s = sheet.indexed();
let base = editor::zone_click(&s, Some(&empty()), "cervical")
.observation
.unwrap();
let selection = vertebrae(json!([
{ "region": "L", "index": 3 }, { "region": "L", "index": 4 }, { "region": "Cd", "index": 20 }
]));
let out = editor::sync_vertebrae(&s, &base, &selection, "main");
let ids: Vec<&str> = out.zones.iter().map(|z| z.annotation_id.as_str()).collect();
assert_eq!(ids, ["lumbar", "caudal"]);
assert_eq!(out.zones[0].vertebrae.as_deref(), Some(&selection[..2]));
assert_eq!(
out.zones[0].label_fr_snapshot.as_deref(),
Some("Vertèbres lombaires")
);
assert!(
editor::sync_vertebrae(&s, &out, &[], "main")
.zones
.is_empty()
);
}
#[test]
fn keeps_non_spine_zones_untouched_and_ignores_unknown_regions() {
let sheet = draft_sheet();
let s = sheet.indexed();
let base = after(&s, &empty(), "c7-t1");
let selection = vertebrae(json!([{ "region": "XX", "index": 1 }]));
assert_eq!(
editor::sync_vertebrae(&s, &base, &selection, "main").zones,
base.zones
);
}
// --- closed failure kinds (inputs the TypeScript UI never produced) -------------------
#[test]
fn inputs_the_typescript_never_produced_are_closed_failures() {
let sheet = draft_sheet();
let s = sheet.indexed();
let missing = editor::add_sides(&s, &empty(), "nope", &[LateralSide::Left]);
assert_eq!(missing.unwrap_err().kind(), "unknown_annotation");
let path = vec![
"c7-t1-dysfunctions".to_owned(),
"segmental".to_owned(),
"nope".to_owned(),
];
let leaf = |zone: &'static str, position| LeafClick {
finding_zone_id: zone,
path: &path,
leaf_position: position,
side: None,
};
let unknown_zone = editor::toggle_finding(&s, &empty(), &leaf("nope", 0));
assert_eq!(unknown_zone.unwrap_err(), EditorError::UnknownZone);
let wrong_id = editor::toggle_finding(&s, &empty(), &leaf("c7-t1", 0));
assert_eq!(wrong_id.unwrap_err(), EditorError::UnknownNode);
let out_of_list = editor::toggle_finding(&s, &empty(), &leaf("c7-t1", 999));
assert_eq!(out_of_list.unwrap_err().kind(), "unknown_node");
let huge: VertebraAction =
serde_json::from_value(json!({ "kind": "all", "region": "C", "count": 1e9 })).unwrap();
assert_eq!(
editor::select_vertebrae(&[], &huge).unwrap_err().kind(),
"invalid_count"
);
let none: VertebraAction =
serde_json::from_value(json!({ "kind": "all", "region": "C", "count": -2 })).unwrap();
assert!(editor::select_vertebrae(&[], &none).unwrap().is_empty());
let report: Report = serde_json::from_value(
parse_json(&common::repo_file(
"apps/app/tests/fixtures/report-v3.demo.json",
))
.unwrap(),
)
.unwrap();
let past_end = report.observations.len();
let moved = editor::move_observation(&report, past_end, MoveDirection::Up);
assert_eq!(moved.unwrap_err(), EditorError::InvalidIndex);
let down = editor::move_observation(&report, usize::MAX, MoveDirection::Down).unwrap();
assert_eq!(down, report);
}