Files
Marcos Paulo 7b3ccf8f6e feat(diagrams): wave 5 diagrams-c
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-13 20:01:23 -03:00

146 lines
6.4 KiB
Rust

//! Parse, layout and SVG behaviour of class diagrams, driven by the fixtures in `tests/fixtures`.
use notescraft_diagrams::{Diagram, Error, MemberKind, RelationKind, Shape, Stereotype, Visibility, 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 class_diagram(src: &str) -> notescraft_diagrams::ClassDiagram {
let other = parse(src);
match other {
Ok(Diagram::Class(c)) => c,
Ok(d) => panic!("expected a class diagram, got kind {:?}", d.kind()),
Err(e) => panic!("parse failed: {e}"),
}
}
#[test]
fn classes_members_stereotypes_and_generics() {
let c = class_diagram(&fixture("class_basics.mmd"));
assert_eq!(c.classes.len(), 11);
let shape = c.classes.iter().find(|k| k.name == "Shape").unwrap_or_else(|| panic!("Shape missing"));
assert_eq!(shape.stereotype, Some(Stereotype::Abstract));
assert!(shape.members.iter().any(|m| m.visibility == Visibility::Protected && m.kind == MemberKind::Attribute && m.text == "area int"));
assert!(shape.members.iter().any(|m| m.visibility == Visibility::Public && m.kind == MemberKind::Method && m.text == "draw() void"));
assert!(shape.members.iter().any(|m| m.text == "name string"), "member added through `Shape : +name string`");
let circle = c.classes.iter().find(|k| k.name == "Circle").unwrap_or_else(|| panic!("Circle missing"));
assert_eq!(circle.generics.as_deref(), Some("T"));
let scale = circle.members.iter().find(|m| m.text == "scale").unwrap_or_else(|| panic!("scale missing"));
assert!(scale.is_static, "trailing `$` marks the member static");
let vertex = c.classes.iter().find(|k| k.name == "Vertex").unwrap_or_else(|| panic!("Vertex missing"));
assert_eq!(vertex.stereotype, Some(Stereotype::Interface));
}
#[test]
fn all_relation_kinds_labels_and_cardinalities() {
let c = class_diagram(&fixture("class_basics.mmd"));
assert_eq!(c.relations.len(), 7);
let kinds: Vec<RelationKind> = c.relations.iter().map(|r| r.kind).collect();
for want in [
RelationKind::Inheritance,
RelationKind::Composition,
RelationKind::Aggregation,
RelationKind::Dependency,
RelationKind::Realisation,
RelationKind::Association,
RelationKind::Link,
] {
assert!(kinds.contains(&want), "missing {want:?} in {kinds:?}");
}
let assoc = c.relations.iter().find(|r| r.kind == RelationKind::Association).unwrap_or_else(|| panic!("association missing"));
assert_eq!(assoc.label.as_deref(), Some("touches"));
assert_eq!(assoc.left_cardinality.as_deref(), Some("1"));
assert_eq!(assoc.right_cardinality.as_deref(), Some("many"));
let names_of = |i: usize| c.classes.get(i).map_or("?", |k| k.name.as_str());
let comp = c.relations.iter().find(|r| r.kind == RelationKind::Composition).unwrap_or_else(|| panic!("composition missing"));
assert_eq!((names_of(comp.left), names_of(comp.right)), ("Canvas", "Brush"));
}
#[test]
fn malformed_lines_become_diagnostics_and_parsing_continues() {
let c = class_diagram(&fixture("class_malformed.mmd"));
assert!(c.diagnostics.len() >= 5, "diagnostics: {:?}", c.diagnostics);
assert!(c.classes.iter().any(|k| k.name == "Good" && k.members.len() == 1));
assert!(c.relations.iter().any(|r| r.kind == RelationKind::Link));
assert!(!c.classes.iter().any(|k| k.name == ">"), "broken operator tails must not become classes");
}
#[test]
fn direction_line_is_parsed() {
let c = class_diagram("classDiagram\ndirection LR\nclass A");
assert_eq!(c.direction, notescraft_diagrams::Direction::LeftRight);
let bad = class_diagram("classDiagram\ndirection XY\nclass A");
assert_eq!(bad.diagnostics.len(), 1);
}
#[test]
fn five_hundred_one_classes_are_rejected() {
let mut src = String::from("classDiagram\n");
for i in 0..501 {
src.push_str("class C");
src.push_str(&i.to_string());
src.push('\n');
}
match parse(&src) {
Err(Error::LimitExceeded { what, max }) => {
assert_eq!(what, "classes");
assert_eq!(max, notescraft_diagrams::MAX_CLASSES);
}
other => panic!("expected LimitExceeded, got {:?}", other.map(|d| d.kind().to_owned())),
}
}
#[test]
fn layout_is_deterministic_parents_above_children_and_marked() {
let d = parse(&fixture("class_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");
let y_of = |prefix: &str| {
a.shapes
.iter()
.find_map(|s| match s {
Shape::Text { text } if text.content.starts_with(prefix) => Some(text.at.y),
_ => None,
})
.unwrap_or_else(|| panic!("no text starting with {prefix}"))
};
assert!(y_of("Shape") < y_of("Circle~T~"), "inheritance parent sits above the child");
let markers = a.shapes.iter().filter(|s| matches!(s, Shape::Marker { .. })).count();
assert_eq!(markers, 6, "every decoration-bearing relation has one end marker");
assert!(a.width > 0.0 && a.height > 0.0);
}
#[test]
fn svg_escapes_script_in_member_names() {
let d = parse(&fixture("class_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.contains("&lt;script&gt;"), "member name is escaped: {svg}");
}
#[test]
fn empty_class_diagram_lays_out() {
let d = parse("classDiagram\n%% nothing yet").unwrap_or_else(|e| panic!("{e}"));
let l = layout(&d).unwrap_or_else(|e| panic!("{e}"));
assert_eq!(l.shapes, []);
}
#[test]
#[ignore = "perf: run with --release -- --ignored"]
fn three_hundred_class_diagram_lays_out_under_a_second() {
let mut src = String::from("classDiagram\n");
for i in 0..300 {
let _ = std::fmt::Write::write_fmt(&mut src, format_args!("class C{i}\n"));
if i + 1 < 300 {
let _ = std::fmt::Write::write_fmt(&mut src, format_args!("C{i} <|-- C{}\n", i + 1));
}
}
let start = std::time::Instant::now();
let d = parse(&src).unwrap_or_else(|e| panic!("{e}"));
let l = layout(&d).unwrap_or_else(|e| panic!("{e}"));
let took = start.elapsed();
eprintln!("300 classes: {took:?}, {} shapes", l.shapes.len());
assert!(took.as_secs_f64() < 1.0, "{took:?}");
}