7b3ccf8f6e
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
126 lines
6.0 KiB
Rust
126 lines
6.0 KiB
Rust
//! Parse, layout and SVG behaviour of state diagrams, driven by the fixtures in `tests/fixtures`.
|
|
|
|
use std::fmt::Write as _;
|
|
|
|
use notescraft_diagrams::{Diagram, Error, Shape, StateKind, layout, parse, to_svg};
|
|
|
|
fn fixture(name: &str) -> String {
|
|
std::fs::read_to_string(format!("{}/tests/fixtures/{name}", env!("CARGO_MANIFEST_DIR"))).unwrap_or_default()
|
|
}
|
|
|
|
fn state_diagram(src: &str) -> notescraft_diagrams::StateDiagram {
|
|
match parse(src) {
|
|
Ok(Diagram::State(s)) => s,
|
|
Ok(d) => panic!("expected a state diagram, got kind {:?}", d.kind()),
|
|
Err(e) => panic!("parse failed: {e}"),
|
|
}
|
|
}
|
|
|
|
fn idx_of(s: ¬escraft_diagrams::StateDiagram, id: &str) -> usize {
|
|
s.states.iter().position(|st| st.id == id).unwrap_or_else(|| panic!("state {id} missing"))
|
|
}
|
|
|
|
#[test]
|
|
fn states_transitions_aliases_and_kinds() {
|
|
let s = state_diagram(&fixture("state_basics.mmd"));
|
|
assert_eq!(s.states.len(), 13);
|
|
assert_eq!(s.transitions.len(), 11);
|
|
let load = idx_of(&s, "load");
|
|
let active = idx_of(&s, "Active");
|
|
let t = s.transitions.get(1).unwrap_or_else(|| panic!("second transition missing"));
|
|
assert_eq!((t.from, t.to), (load, active), "load --> Active");
|
|
assert_eq!(t.event.as_deref(), Some("done"));
|
|
let load_state = s.states.get(load).unwrap_or_else(|| panic!("load state missing"));
|
|
assert_eq!(load_state.label, "Loading data", "`state \"Loading data\" as load` aliases the display text");
|
|
assert!(s.states.iter().any(|st| st.kind == StateKind::Start));
|
|
assert!(s.states.iter().any(|st| st.kind == StateKind::End));
|
|
assert_eq!(s.states.get(idx_of(&s, "c")).map(|st| st.kind), Some(StateKind::Choice));
|
|
assert!(s.states.iter().any(|st| st.kind == StateKind::Fork));
|
|
let inner = s.states.iter().find(|st| st.id == "Inner").unwrap_or_else(|| panic!("Inner missing"));
|
|
assert_eq!(inner.group.as_deref(), Some("Active"), "composite members carry the group id");
|
|
assert!(
|
|
s.states.iter().any(|st| st.id == "Done"
|
|
&& s.transitions.iter().any(|t| t.from == idx_of(&s, "Done") && t.to == idx_of(&s, "Done") && t.event.as_deref() == Some("retry"))),
|
|
"self transition with event"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn notes_and_concurrency_become_diagnostics_and_comments_are_skipped() {
|
|
let s = state_diagram(&fixture("state_basics.mmd"));
|
|
assert_eq!(s.diagnostics.len(), 2, "diagnostics: {:?}", s.diagnostics);
|
|
assert!(s.diagnostics.iter().any(|d| d.message.contains("notes")));
|
|
assert!(s.diagnostics.iter().any(|d| d.message.contains("concurrent")));
|
|
assert_eq!(s.direction, notescraft_diagrams::Direction::LeftRight);
|
|
}
|
|
|
|
#[test]
|
|
fn kind_reflects_the_written_header() {
|
|
assert_eq!(parse(&fixture("state_basics.mmd")).map_or(String::new(), |d| d.kind().to_owned()), "stateDiagram-v2");
|
|
assert_eq!(parse(&fixture("state_malformed.mmd")).map_or(String::new(), |d| d.kind().to_owned()), "stateDiagram");
|
|
}
|
|
|
|
#[test]
|
|
fn malformed_lines_become_diagnostics_and_parsing_continues() {
|
|
let s = state_diagram(&fixture("state_malformed.mmd"));
|
|
assert!(s.diagnostics.len() >= 5, "diagnostics: {:?}", s.diagnostics);
|
|
let (good, better) = (idx_of(&s, "Good"), idx_of(&s, "Better"));
|
|
assert!(s.transitions.iter().any(|t| t.from == good && t.to == better), "Good --> Better still parsed");
|
|
assert!(!s.states.iter().any(|st| st.id == ">"), "broken operator tails must not become states");
|
|
assert!(s.states.iter().any(|st| st.id == "A"), "transitions before the bad lines register their states");
|
|
}
|
|
|
|
#[test]
|
|
fn layout_reuses_flowchart_boxes_groups_and_is_deterministic() {
|
|
let d = parse(&fixture("state_basics.mmd")).unwrap_or_else(|e| panic!("{e}"));
|
|
let (a, b) = (layout(&d).unwrap_or_else(|e| panic!("{e}")), layout(&d).unwrap_or_else(|e| panic!("{e}")));
|
|
assert_eq!(a, b, "layout must be deterministic");
|
|
assert!(a.shapes.iter().any(|s| matches!(s, Shape::Group { .. })), "composites become groups");
|
|
assert!(a.shapes.iter().any(|s| matches!(s, Shape::Circle { .. })), "`[*]` becomes a circle");
|
|
assert!(a.shapes.iter().any(|s| matches!(s, Shape::Diamond { .. })), "`<<choice>>` becomes a rhombus");
|
|
assert_eq!(a.shapes.iter().filter(|s| matches!(s, Shape::Box { .. })).count(), 8, "7 normal states + the fork bar");
|
|
assert!(a.width > 0.0 && a.height > 0.0);
|
|
let svg = to_svg(&a);
|
|
assert!(svg.starts_with("<svg") && svg.ends_with("</svg>"));
|
|
assert!(!svg.contains("<script"));
|
|
}
|
|
|
|
#[test]
|
|
fn circular_and_self_transitions_lay_out() {
|
|
let src = "stateDiagram-v2\nA --> B\nB --> A : back\nA --> A : tick";
|
|
let sd = state_diagram(src);
|
|
assert_eq!(sd.transitions.len(), 3);
|
|
let l = layout(&parse(src).unwrap_or_else(|e| panic!("{e}"))).unwrap_or_else(|e| panic!("{e}"));
|
|
assert!(l.shapes.iter().any(|s| matches!(s, Shape::Edge { points, .. } if points.len() > 2)), "self transitions loop");
|
|
assert!(l.shapes.iter().any(|s| matches!(s, Shape::Edge { label: Some(t), .. } if t.content == "back")), "events become labels");
|
|
}
|
|
|
|
#[test]
|
|
fn composite_nesting_past_the_cap_is_flattened_with_a_diagnostic() {
|
|
let mut src = String::from("stateDiagram-v2\nS0 --> S1\n");
|
|
for i in 0..=8 {
|
|
let _ = writeln!(src, "state C{i} {{");
|
|
let _ = writeln!(src, "state N{i}");
|
|
}
|
|
let sd = state_diagram(&src);
|
|
assert!(sd.diagnostics.iter().any(|d| d.message.contains("nest at most 8")), "diagnostics: {:?}", sd.diagnostics);
|
|
assert!(sd.states.iter().any(|st| st.group.as_deref() == Some("C7")), "the 8th level nests");
|
|
assert!(!sd.states.iter().any(|st| st.group.as_deref() == Some("C8")), "the 9th composite is flattened");
|
|
}
|
|
|
|
#[test]
|
|
fn five_hundred_one_states_are_rejected() {
|
|
let mut src = String::from("stateDiagram-v2\n");
|
|
for i in 0..501 {
|
|
let _ = writeln!(src, "S{i} --> S{}", i + 1);
|
|
}
|
|
match parse(&src) {
|
|
Err(Error::LimitExceeded { what, max }) => {
|
|
assert_eq!(what, "states");
|
|
assert_eq!(max, notescraft_diagrams::MAX_STATES);
|
|
}
|
|
Ok(_) => panic!("expected LimitExceeded"),
|
|
Err(e) => panic!("wrong error: {e}"),
|
|
}
|
|
}
|