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