Files
Marcos Paulo c80c6cad4c feat(diagrams): wave 3
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-13 19:45:22 -03:00

117 lines
4.7 KiB
Rust

//! Parse, layout and SVG behaviour of flowcharts, driven by the fixtures in `tests/fixtures`.
use std::fmt::Write as _;
use notescraft_diagrams::{Diagram, Error, NodeShape, Shape, escape, 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 flow(src: &str) -> notescraft_diagrams::Flowchart {
match parse(src) {
Ok(Diagram::Flowchart(f)) => f,
other => panic!("expected a flowchart, got {other:?}"),
}
}
#[test]
fn shapes_are_recognised() {
let f = flow(&fixture("shapes.mmd"));
let shapes: Vec<NodeShape> = f.nodes.iter().map(|n| n.shape).collect();
for want in [NodeShape::Rect, NodeShape::Round, NodeShape::Rhombus, NodeShape::Circle, NodeShape::Database] {
assert!(shapes.contains(&want), "missing {want:?} in {shapes:?}");
}
}
#[test]
fn chains_ampersands_labels_and_subgraphs() {
let f = flow(&fixture("chains.mmd"));
assert!(f.edges.len() >= 12, "edges: {}", f.edges.len());
assert!(f.edges.iter().any(|e| e.label.as_deref() == Some("pipe label")));
assert!(f.edges.iter().any(|e| e.label.as_deref() == Some("inline label")));
assert_eq!(f.groups.len(), 2);
assert_eq!(f.groups.iter().map(|g| g.depth).max(), Some(1));
}
#[test]
fn malformed_lines_become_diagnostics() {
let d = parse(&fixture("malformed.mmd")).unwrap_or_else(|e| panic!("{e}"));
assert_ne!(d.diagnostics(), []);
assert!(!flow(&fixture("malformed.mmd")).edges.is_empty(), "good lines after bad ones still parse");
}
#[test]
fn headers_and_source() {
assert!(matches!(parse("no header here"), Err(Error::NoHeader)));
assert!(matches!(parse(""), Err(Error::NoHeader)));
let seq = fixture("sequence.mmd");
let d = parse(&seq).unwrap_or_else(|e| panic!("{e}"));
assert!(matches!(d, Diagram::Sequence(_)));
assert_eq!(d.source(), seq);
assert!(layout(&d).is_ok(), "sequence diagrams lay out");
let src = fixture("chains.mmd");
assert_eq!(parse(&src).unwrap_or_else(|e| panic!("{e}")).source(), src);
}
#[test]
fn oversized_input_is_rejected() {
let big = format!("flowchart TD\n{}", "A --> B\n".repeat(200_000));
assert!(matches!(parse(&big), Err(Error::TooLarge { .. })));
}
#[test]
fn cyclic_graph_lays_out() {
let d = parse(&fixture("cyclic.mmd")).unwrap_or_else(|e| panic!("{e}"));
let l = layout(&d).unwrap_or_else(|e| panic!("{e}"));
assert!(l.width > 0.0 && l.height > 0.0);
}
#[test]
fn layout_is_deterministic_and_ordered_back_to_front() {
let d = parse(&fixture("chains.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);
let first_node = a.shapes.iter().position(|s| matches!(s, Shape::Box { .. } | Shape::Diamond { .. } | Shape::Circle { .. }));
let last_edge = a.shapes.iter().rposition(|s| matches!(s, Shape::Edge { .. }));
assert!(last_edge < first_node, "edges are drawn before nodes");
assert!(a.shapes.iter().any(|s| matches!(s, Shape::Group { .. })));
}
#[test]
fn directions_change_the_orientation() {
let td = layout(&parse("flowchart TD\nA --> B --> C").unwrap_or_else(|e| panic!("{e}"))).unwrap_or_else(|e| panic!("{e}"));
let lr = layout(&parse("flowchart LR\nA --> B --> C").unwrap_or_else(|e| panic!("{e}"))).unwrap_or_else(|e| panic!("{e}"));
assert!(td.height > td.width, "TD grows downwards: {}x{}", td.width, td.height);
assert!(lr.width > lr.height, "LR grows rightwards: {}x{}", lr.width, lr.height);
}
#[test]
fn svg_is_escaped() {
let d = parse(&fixture("escaping.mmd")).unwrap_or_else(|e| panic!("{e}"));
let svg = to_svg(&layout(&d).unwrap_or_else(|e| panic!("{e}")));
assert!(!svg.contains("<script"), "{svg}");
assert!(svg.starts_with("<svg") && svg.ends_with("</svg>"));
assert_eq!(escape("<a href=\"x\">&'"), "&lt;a href=&quot;x&quot;&gt;&amp;&#39;");
}
#[test]
fn self_loop_lays_out() {
let l = layout(&parse("flowchart TD\nA --> A").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)));
}
#[test]
#[ignore = "perf: run with --release -- --ignored"]
fn thousand_node_chain_lays_out_under_a_second() {
let mut src = String::from("flowchart TD\n");
for i in 0..1000 {
let _ = writeln!(src, "N{i} --> N{}", i + 1);
}
let start = std::time::Instant::now();
let l = layout(&parse(&src).unwrap_or_else(|e| panic!("{e}"))).unwrap_or_else(|e| panic!("{e}"));
let took = start.elapsed();
eprintln!("1000-node chain: {took:?}, {} shapes", l.shapes.len());
assert!(took.as_secs_f64() < 1.0, "{took:?}");
}