7b3ccf8f6e
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
146 lines
6.4 KiB
Rust
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("<script>"), "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:?}");
|
|
}
|