Files
Marcos Paulo 1b03b4f139 feat(diagrams-d): wave 8
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-14 00:00:20 -03:00

150 lines
6.4 KiB
Rust

//! Parse, layout and SVG behaviour of ER diagrams, driven by `tests/fixtures`.
use notescraft_diagrams::{Diagram, Error, Glyph, Key, MarkerKind, Shape, 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 er_diagram(src: &str) -> notescraft_diagrams::ErDiagram {
match parse(src) {
Ok(Diagram::Er(e)) => e,
Err(e) => panic!("parse failed: {e}"),
Ok(d) => panic!("expected an ER diagram, got kind {:?}", d.kind()),
}
}
#[test]
fn header_kind_and_source_are_preserved() {
let e = er_diagram(&fixture("er_basics.mmd"));
assert_eq!(e.source(), fixture("er_basics.mmd"));
let d = parse(&fixture("er_basics.mmd")).unwrap_or_else(|err| panic!("{err}"));
assert_eq!(d.kind(), "erDiagram");
}
#[test]
fn entities_attributes_keys_and_comments() {
let e = er_diagram(&fixture("er_basics.mmd"));
assert_eq!(e.entities.len(), 4);
let customer = e.entities.first().unwrap_or_else(|| panic!("first entity missing"));
assert_eq!(customer.name, "CUSTOMER");
assert_eq!(customer.attributes.len(), 3);
let name = customer.attributes.first().unwrap_or_else(|| panic!("attribute missing"));
assert_eq!((name.ty.as_str(), name.name.as_str()), ("string", "name"));
assert_eq!(name.keys, vec![Key::Primary]);
assert_eq!(name.comment.as_deref(), Some("The display name"));
let points = customer.attributes.get(2).unwrap_or_else(|| panic!("third attribute missing"));
assert_eq!(points.keys.iter().map(|key| key.name()).collect::<Vec<&str>>(), vec!["FK", "PK"]);
assert!(points.written().contains("int loyalty_points"));
}
#[test]
fn all_cardinality_codes_and_identifying_connectors() {
let src = "erDiagram\nA0 ||--o{ B : a\nA0 }o..o{ B : b\nA0 }|--|| B : c\nA0 o|..|{ B : d";
let e = er_diagram(src);
assert_eq!(e.relations.len(), 4);
let codes: Vec<Vec<Glyph>> =
e.relations.iter().flat_map(|r| [r.left_cardinality.glyphs, r.right_cardinality.glyphs]).map(|glyphs| glyphs.into_iter().collect()).collect();
assert!(codes.iter().any(|c| c == &vec![Glyph::Bar, Glyph::Bar]));
assert!(codes.iter().any(|c| c == &vec![Glyph::Zero, Glyph::Many]));
let dotted: Vec<bool> = e.relations.iter().map(|r| r.non_identifying).collect();
assert_eq!(dotted, vec![false, true, false, true], "`--` identifying, `..` non-identifying");
}
#[test]
fn malformed_lines_become_diagnostics_and_parsing_continues() {
let e = er_diagram(&fixture("er_malformed.mmd"));
assert!(e.diagnostics.len() >= 3, "{:?}", e.diagnostics);
assert!(e.relations.iter().any(|r| !r.non_identifying));
assert!(
e.entities.iter().any(|x| x.name == "GOOD" && x.attributes.len() == 3),
"good lines still parse; the rejected nested block leaves `stray` in GOOD: {:?}",
e.entities.first().map(|x| x.attributes.len())
);
assert!(!e.entities.iter().any(|x| x.name == "NOT-AN-OPERATOR"), "garbage tails must not create entities");
}
#[test]
fn unknown_statement_lines_keep_the_rest_of_the_diagram() {
let e = er_diagram("erDiagram\nbanana\nA ||--o{ B : ok\n|{ nonsense tail {\nB {\n int x\n}");
assert_eq!(e.relations.len(), 1);
assert_eq!(e.diagnostics.len(), 1, "exactly the nonsense line is diagnosed: {:?}", e.diagnostics);
assert!(e.relations.iter().all(|r| r.label.as_deref() == Some("ok")), "the good relation survived");
assert!(e.entities.iter().any(|x| x.name == "B" && x.attributes.len() == 1));
}
#[test]
fn three_hundred_one_entities_are_rejected() {
let mut src = String::from("erDiagram\n");
for i in 0..301 {
let _ = std::fmt::Write::write_fmt(&mut src, format_args!("E{i}\n"));
}
match parse(&src) {
Err(Error::LimitExceeded { what, max }) => {
assert_eq!(what, "entities");
assert_eq!(max, notescraft_diagrams::MAX_ENTITIES);
}
other => panic!("expected LimitExceeded, got {:?}", other.map(|d| d.kind().to_owned())),
}
}
#[test]
fn layout_is_deterministic_and_marks_both_sides() {
let d = parse(&fixture("er_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 markers = a.shapes.iter().filter(|s| matches!(s, Shape::Marker { .. })).count();
assert_eq!(markers, 12, "two glyph markers per endpoint: {markers}");
let kinds = a
.shapes
.iter()
.filter_map(|s| match s {
Shape::Marker { kind, .. } => Some(*kind),
_ => None,
})
.collect::<Vec<MarkerKind>>();
assert!(kinds.contains(&MarkerKind::CrowFoot) && kinds.contains(&MarkerKind::Bar) && kinds.contains(&MarkerKind::Circle));
assert!(a.width > 0.0 && a.height > 0.0);
}
#[test]
fn svg_escapes_script_in_labels() {
let d = parse(&fixture("er_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;"), "{svg}");
}
#[test]
fn five_thousand_one_attributes_are_rejected() {
let mut src = String::from("erDiagram\nBIG {\n");
for i in 0..5001 {
let _ = std::fmt::Write::write_fmt(&mut src, format_args!("int f{i}\n"));
}
src.push_str("}\n");
match parse(&src) {
Err(Error::LimitExceeded { what, max }) => {
assert_eq!(what, "attributes");
assert_eq!(max, notescraft_diagrams::MAX_ATTRIBUTES);
}
other => panic!("expected LimitExceeded, got {:?}", other.map(|d| d.kind().to_owned())),
}
}
#[test]
#[ignore = "perf: run with --release -- --ignored"]
fn three_hundred_entities_lay_out_under_a_second() {
let mut src = String::from("erDiagram\n");
for i in 0..300 {
let _ = std::fmt::Write::write_fmt(&mut src, format_args!("E{i}\n"));
let _ = std::fmt::Write::write_fmt(&mut src, format_args!("E{i} ||--o{{ E{}\n", (i + 1).min(299)));
let _ = std::fmt::Write::write_fmt(&mut src, format_args!("E{i} {{\n int f{i}\n}}\n"));
}
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 entities: {took:?}, {} shapes", l.shapes.len());
assert!(took.as_secs_f64() < 1.0, "{took:?}");
}