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.
476 lines
17 KiB
Rust
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);
|
|
}
|