//! `packages/anatomy/tests/curation.migration-leaves.test.ts` ported with its exact expectations //! (R5.7): every leaf of the legacy catalog (612) and every legacy annotation (27) travels through //! the Report v2 → v3 migration with the committed map, then is checked against the curated draft //! document itself, not against the map alone. The other 612-leaf tests (`report_rules`, the produced //! map in `curation_draft`, the application's `migration.leaves`) keep their own angles. #![allow(clippy::disallowed_methods, clippy::unwrap_used, clippy::expect_used)] mod archive_support; mod common; use archive_support::*; use faunosteo_core::domain::report::v2::ReportV2; use faunosteo_core::domain::report::{ Finding, ReportMigrationMap, finding_path_key, migrate_report_v2_to_v3, read_report_document, }; use faunosteo_core::domain::sheet::{AnatomicalSheetDocument, Annotation, LoadedSheet}; use serde_json::{Value, json}; struct Fixture { draft: LoadedSheet, map: ReportMigrationMap, leaves: Vec, findings: Vec, } fn fixture() -> Fixture { let map = draft_map(); let leaves = legacy_leaves(); let v2: ReportV2 = from(leaves_as_v2_report(&leaves)); let report = migrate_report_v2_to_v3(&v2, &map).unwrap().report; let findings = report .observations .into_iter() .flat_map(|o| o.findings) .collect(); Fixture { draft: draft_sheet(), map, leaves, findings, } } fn document(f: &Fixture) -> &AnatomicalSheetDocument { &f.draft.document } fn joined(path: &[String]) -> String { path.join("/") } /// An empty v2 report holding one observation with these zones. fn zones_report(zones: Value) -> ReportV2 { let mut v2 = leaves_as_v2_report(&[]); v2["observations"] = json!([{ "id": "zones", "zones": zones, "findings": [], "freeTextFindings": [], "comment": "" }]); from(v2) } #[test] fn migrates_the_612_leaves_442_identical_141_moved_29_removed() { let f = fixture(); assert_eq!(f.leaves.len(), 612); assert_eq!(f.findings.len(), 612); let (mut identical, mut moved, mut removed) = (0, 0, 0); for (leaf, out) in f.leaves.iter().zip(&f.findings) { let same = out.finding_zone_id == leaf.zone_id && out.path == leaf.path; if out.unresolved.is_some() { removed += 1; } else if same { identical += 1; } else { moved += 1; } } assert_eq!((identical, moved, removed), (442, 141, 29)); } #[test] fn lands_every_resolved_leaf_on_a_leaf_of_the_draft_document() { let f = fixture(); for out in f.findings.iter().filter(|o| o.unresolved.is_none()) { let where_ = format!("{}/{}", out.finding_zone_id, joined(&out.path)); let node = f.draft.indexed().node_at(&out.finding_zone_id, &out.path); assert!( node.as_ref().is_some_and(|n| n.children().is_empty()), "{where_}" ); } } #[test] fn keeps_the_legacy_snapshots_and_the_vet_flag_verbatim_on_every_finding() { let f = fixture(); for (leaf, out) in f.leaves.iter().zip(&f.findings) { let en = if leaf.en.is_empty() { &leaf.fr } else { &leaf.en }; assert_eq!(out.label_fr_snapshot, leaf.fr); assert_eq!(&out.label_en_snapshot, en); assert_eq!( out.requires_vet_referral.unwrap_or(false), leaf.vet, "{}", joined(&leaf.path) ); } } #[test] fn flags_exactly_the_leaves_the_curation_removed_with_their_legacy_path_kept() { let f = fixture(); let removed: Vec = f .leaves .iter() .map(|leaf| finding_path_key(&leaf.zone_id, &leaf.path)) .filter(|key| matches!(f.map.finding_paths.get(key), Some(None))) .collect(); assert_eq!(removed.len(), 29); let flagged: Vec<&Finding> = f .findings .iter() .filter(|o| o.unresolved.is_some()) .collect(); let keys: Vec = flagged .iter() .map(|o| format!("{}/{}", o.finding_zone_id, joined(&o.path))) .collect(); assert_eq!(keys, removed); for o in flagged { assert!( f.draft .indexed() .node_at(&o.finding_zone_id, &o.path) .is_none() ); } } #[test] fn moves_the_141_relocated_leaves_inside_their_zone_134_category_7_leaf() { let f = fixture(); let (mut category, mut leaf_renamed) = (0, 0); for (leaf, out) in f.leaves.iter().zip(&f.findings) { if out.unresolved.is_some() || out.path == leaf.path { continue; } assert_eq!(out.finding_zone_id, leaf.zone_id, "{}", joined(&leaf.path)); if out.path.last() == leaf.path.last() { category += 1; } else { leaf_renamed += 1; } } assert_eq!((category, leaf_renamed), (134, 7)); } #[test] fn reads_the_migrated_report_back_unchanged() { let f = fixture(); let v2 = leaves_as_v2_report(&f.leaves); let report = read_report_document(&v2, &f.map).unwrap().report; let again = read_report_document(&report_value(&report), &f.map).unwrap(); assert_eq!(again.report, report); assert_eq!((again.unresolved_zones, again.unresolved_findings), (0, 0)); } #[test] fn maps_the_26_observable_legacy_ids_to_annotations_of_the_right_view() { let f = fixture(); let doc = document(&f); let triggers: Vec<&str> = doc .annotations .iter() .filter_map(Annotation::trigger) .map(|a| a.id.as_str()) .collect(); let mut legacy_ids: Vec<&String> = f .map .annotations .iter() .filter(|(_, mapped)| !triggers.contains(&mapped.id.as_str())) .map(|(id, _)| id) .collect(); legacy_ids.sort(); assert_eq!(legacy_ids.len(), 26); let head: Vec<&str> = doc .annotations .iter() .filter(|a| a.view_id() == "head") .map(Annotation::id) .collect(); let zones: Vec = legacy_ids .iter() .map(|id| { if head.contains(&f.map.annotations[*id].id.as_str()) { json!({ "boneId": id, "detailSourceId": "head" }) } else { json!({ "boneId": id }) } }) .collect(); assert!(zones.iter().any(|z| z.get("detailSourceId").is_some())); let out = migrate_report_v2_to_v3(&zones_report(json!(zones)), &f.map).unwrap(); assert_eq!(out.unresolved_zones, 0); for (zone, id) in out.report.observations[0].zones.iter().zip(&legacy_ids) { let anno = doc .annotations .iter() .find(|a| a.id() == zone.annotation_id); let anno = anno.unwrap_or_else(|| panic!("{}", zone.annotation_id)); assert_eq!(anno.view_id(), zone.view_id); assert_eq!( zone.label_fr_snapshot.as_deref(), Some(f.map.annotations[*id].name.fr.as_str()) ); } } #[test] fn keeps_vertebrae_on_the_spine_zones_with_region_codes_the_draft_defines() { let f = fixture(); let doc = document(&f); let codes: Vec<&str> = doc .vertebral_config .regions .iter() .map(|r| r.code.as_str()) .collect(); let spine: Vec<&str> = doc .annotations .iter() .filter_map(Annotation::observable) .filter_map(|a| a.vertebral_region_code.as_deref()) .collect(); assert_eq!(spine.len(), 5); assert!(spine.iter().all(|code| codes.contains(code))); let legacy_id = f .map .annotations .iter() .find(|(_, m)| m.id == "cervical") .unwrap() .0; let report = zones_report(json!([ { "boneId": legacy_id, "vertebrae": [{ "region": "C", "index": 7 }] } ])); let zone = &migrate_report_v2_to_v3(&report, &f.map) .unwrap() .report .observations[0] .zones[0]; let vertebrae = zone.vertebrae.as_ref().unwrap(); assert_eq!(vertebrae.len(), 1); assert_eq!( (vertebrae[0].region.as_str(), vertebrae[0].index), ("C", 7.into()) ); assert!(codes.contains(&vertebrae[0].region.as_str())); }