141 lines
5.0 KiB
Rust
141 lines
5.0 KiB
Rust
//! R3 O2: the Rust annotation layer equals the TypeScript layer tree frozen by
|
|
//! `packages/anatomy/tests/r3.layer-oracles.test.ts`, attribute order included (the review
|
|
//! drawings are byte goldens of that order until R5).
|
|
#![allow(clippy::disallowed_methods, clippy::unwrap_used, clippy::expect_used)]
|
|
|
|
mod common;
|
|
|
|
use std::collections::HashSet;
|
|
|
|
use common::svg_tree::{view_names, with_trigger_names_per_language};
|
|
use faunosteo_core::anatomy::layer::render_layer;
|
|
use faunosteo_core::anatomy::svg::{Element, Node};
|
|
use faunosteo_core::domain::sheet::AnatomicalSheetDocument;
|
|
use serde::Deserialize;
|
|
use serde_json::{Map, Value, json};
|
|
|
|
/// `LayerElement` as the TypeScript writes it: tag, ordered attributes, children, text.
|
|
fn layer_value(element: &Element) -> Value {
|
|
let attrs: Map<String, Value> = element
|
|
.attrs
|
|
.iter()
|
|
.map(|a| (a.qname.clone(), Value::String(a.value.clone())))
|
|
.collect();
|
|
let mut text = None;
|
|
let mut children = Vec::new();
|
|
for child in &element.children {
|
|
match child {
|
|
Node::Element(e) => children.push(layer_value(e)),
|
|
Node::Text(t) => text = Some(t.clone()),
|
|
}
|
|
}
|
|
let mut out = json!({ "tag": element.qname, "attrs": attrs, "children": children });
|
|
if let Some(t) = text {
|
|
out["text"] = Value::String(t);
|
|
}
|
|
out
|
|
}
|
|
|
|
/// Attribute names in order, at every level: what `==` on maps would not check.
|
|
fn orders(value: &Value, out: &mut Vec<Vec<String>>) {
|
|
out.push(
|
|
value["attrs"]
|
|
.as_object()
|
|
.unwrap()
|
|
.keys()
|
|
.cloned()
|
|
.collect(),
|
|
);
|
|
for child in value["children"].as_array().unwrap() {
|
|
orders(child, out);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn every_frozen_layer_is_reproduced_with_its_attribute_order() {
|
|
let (_, oracle) = common::oracle_file("r3/layer.json");
|
|
let (_, draft) = common::oracle_file("sheet.draft.json");
|
|
let draft = AnatomicalSheetDocument::deserialize(&draft["output"]).unwrap();
|
|
let edge = AnatomicalSheetDocument::deserialize(&oracle["edge"]).unwrap();
|
|
let cases = oracle["cases"].as_array().unwrap();
|
|
assert_eq!(cases.len(), 8);
|
|
for case in cases {
|
|
let document = if case["doc"] == "draft" {
|
|
&draft
|
|
} else {
|
|
&edge
|
|
};
|
|
let view = case["viewId"].as_str().unwrap();
|
|
let states: HashSet<&str> = case["states"]
|
|
.as_array()
|
|
.unwrap()
|
|
.iter()
|
|
.map(|s| s.as_str().unwrap())
|
|
.collect();
|
|
let layer = layer_value(&render_layer(document, view, &states).unwrap());
|
|
let label = format!("{} {} {:?}", case["doc"], view, states.len());
|
|
let mut frozen = case["layer"].clone();
|
|
with_trigger_names_per_language(&mut frozen, &view_names(document));
|
|
assert_eq!(layer, frozen, "{label}");
|
|
let (mut ours, mut theirs) = (Vec::new(), Vec::new());
|
|
orders(&layer, &mut ours);
|
|
orders(&frozen, &mut theirs);
|
|
assert_eq!(ours, theirs, "{label}: attribute order");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn an_unknown_view_is_refused() {
|
|
let (_, oracle) = common::oracle_file("r3/layer.json");
|
|
let edge = AnatomicalSheetDocument::deserialize(&oracle["edge"]).unwrap();
|
|
assert!(render_layer(&edge, "nope", &HashSet::new()).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn an_unnamed_trigger_names_the_opened_view_in_each_language_and_a_named_one_keeps_its_names() {
|
|
let (_, draft) = common::oracle_file("sheet.draft.json");
|
|
let draft = AnatomicalSheetDocument::deserialize(&draft["output"]).unwrap();
|
|
let layer = render_layer(&draft, "main", &HashSet::new()).unwrap();
|
|
let trigger = layer
|
|
.element_children()
|
|
.find(|e| e.attr("data-anno-id") == Some("head-trigger"))
|
|
.unwrap();
|
|
assert_eq!(
|
|
trigger.attr("data-anno-name-fr"),
|
|
Some("Tête (vue latérale gauche)")
|
|
);
|
|
assert_eq!(
|
|
trigger.attr("data-anno-name-en"),
|
|
Some("Head (left lateral view)")
|
|
);
|
|
let title = trigger.element_children().next().unwrap();
|
|
assert_eq!(
|
|
title.children,
|
|
[Node::Text(
|
|
"Tête (vue latérale gauche) / Head (left lateral view)".to_owned()
|
|
)]
|
|
);
|
|
// The edge document: an unnamed trigger on a view named Tête / Head, a named one.
|
|
let (_, oracle) = common::oracle_file("r3/layer.json");
|
|
let edge = AnatomicalSheetDocument::deserialize(&oracle["edge"]).unwrap();
|
|
let layer = render_layer(&edge, "main", &HashSet::new()).unwrap();
|
|
let names = |id: &str| {
|
|
let e = layer
|
|
.element_children()
|
|
.find(|e| e.attr("data-anno-id") == Some(id))
|
|
.unwrap();
|
|
(
|
|
e.attr("data-anno-name-fr").unwrap().to_owned(),
|
|
e.attr("data-anno-name-en").unwrap().to_owned(),
|
|
)
|
|
};
|
|
assert_eq!(
|
|
names("trigger-circle"),
|
|
("Tête".to_owned(), "Head".to_owned())
|
|
);
|
|
assert_eq!(
|
|
names("trigger-named"),
|
|
("Ouvrir".to_owned(), "Open".to_owned())
|
|
);
|
|
}
|