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.
This commit is contained in:
1 parent
0c47d0f837
commit
3639c8778e
9 files changed
+4465
No files matched your search
@@ -0,0 +1,475 @@
|
||||
//! 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);
|
||||
}
|
||||
Reference in new issue
Block a user