Something went wrong. Try again.
Personal fork of prime agent. Mirror of: https://mnemosyne.sigilzero.dev/sigilzero/prime-agent
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333mod common;
use std::fs;use std::path::Path;
use mmdflux::builtins::default_registry;use mmdflux::graph::GeometryLevel;use mmdflux::payload::Diagram;use mmdflux::registry::DiagramInstance;use mmdflux::{EngineAlgorithmId, OutputFormat, RenderConfig, RenderError};
fn render_class( input: &str, format: OutputFormat, config: &RenderConfig,) -> Result<String, RenderError> { mmdflux::render_diagram(input, format, config)}
fn class_instance() -> Box<dyn DiagramInstance> { default_registry() .create("class") .expect("class should be registered")}
#[test]fn class_instance_parse_simple() { let result = class_instance().parse("classDiagram\nclass User"); assert!(result.is_ok());}
#[test]fn class_instance_parse_error_on_invalid() { let result = class_instance().parse("not a class diagram"); assert!(result.is_err());}
#[test]fn class_instance_into_payload_returns_graph_payload() { let payload = class_instance() .parse("classDiagram\nclass A\nclass B\nA --> B") .unwrap() .into_payload() .unwrap(); let Diagram::Class(graph) = payload else { panic!("class should yield a class payload"); }; assert!(graph.nodes.contains_key("A")); assert!(graph.nodes.contains_key("B"));}
#[test]fn class_instance_render_ascii() { let out = render_class( "classDiagram\nA --> B", OutputFormat::Ascii, &RenderConfig::default(), ) .unwrap(); // ASCII mode should not contain Unicode box-drawing chars assert!(!out.contains('│')); assert!(!out.contains('─'));}
#[test]fn class_instance_render_svg() { let out = render_class( "classDiagram\nA --> B", OutputFormat::Svg, &RenderConfig::default(), ) .unwrap(); assert!(out.starts_with("<svg")); assert!(out.contains("<text"));}
#[test]fn class_supports_text_ascii_svg() { let registry = mmdflux::builtins::default_registry(); assert!(registry.supports_format("class", OutputFormat::Text)); assert!(registry.supports_format("class", OutputFormat::Ascii)); assert!(registry.supports_format("class", OutputFormat::Svg)); assert!(!registry.supports_format("class", OutputFormat::Mermaid));}
#[test]fn class_instance_dependency_renders_dotted() { let out = render_class( "classDiagram\nA ..> B", OutputFormat::Text, &RenderConfig::default(), ) .unwrap(); // Dotted edges use ╎ or ┊ or similar in text mode assert!(out.contains('A')); assert!(out.contains('B'));}
#[test]fn class_instance_inheritance_renders() { let out = render_class( "classDiagram\nAnimal <|-- Dog", OutputFormat::Text, &RenderConfig::default(), ) .unwrap(); assert!(out.contains("Animal")); assert!(out.contains("Dog"));}
#[test]fn lollipop_relations_render_all_participating_classes() { let input = "classDiagram\nclass Class01 {\n int amount\n draw()\n}\nClass01 --() bar\nClass02 --() bar\nfoo ()-- Class01"; let output = render_class(input, OutputFormat::Text, &RenderConfig::default()).unwrap();
assert!(output.contains("Class02")); assert!(output.contains("foo")); assert!(!output.contains("│ bar │")); assert!(!output.contains("│ foo │"));}
#[test]fn lollipop_same_name_interfaces_render_as_distinct_endpoints() { let input = "classDiagram\nService --() InterfaceA\nClient --() InterfaceA"; let output = render_class(input, OutputFormat::Text, &RenderConfig::default()).unwrap();
assert_eq!(output.matches("InterfaceA").count(), 2); assert!(!output.contains("│ InterfaceA │"));}
#[test]fn namespace_blocks_render_namespace_titles() { let input = "\classDiagramnamespace BaseShapes { class Triangle class Rectangle}Triangle --> Rectangle"; let output = render_class(input, OutputFormat::Text, &RenderConfig::default()).unwrap();
assert!(output.contains("BaseShapes")); assert!(output.contains("Triangle")); assert!(output.contains("Rectangle"));}
#[test]fn class_instance_via_registry() { let registry = default_registry(); let instance = registry.create("class").unwrap(); let payload = instance .parse("classDiagram\nclass User\nclass Order\nUser --> Order") .unwrap() .into_payload() .unwrap(); assert!(matches!(payload, Diagram::Class(_)));}
#[test]fn class_instance_unknown_engine_rejected_at_parse_boundary() { let err = EngineAlgorithmId::parse("nonexistent").unwrap_err(); assert!(err.message.contains("unknown engine"));}
#[cfg(not(feature = "engine-elk"))]#[test]fn class_instance_elk_engine_rejected_without_feature() { let result = EngineAlgorithmId::parse("elk-layered"); assert!(result.is_err()); let err = result.unwrap_err(); assert!( err.message.contains("not available"), "error should be actionable: {}", err.message );}
#[test]fn class_routed_mmds_honors_edge_routing_override() { let fixture = Path::new(env!("CARGO_MANIFEST_DIR")) .join("tests") .join("fixtures") .join("class") .join("animal_hierarchy.mmd"); let input = fs::read_to_string(&fixture).expect("class fixture should read");
let full = render_class( &input, OutputFormat::Mmds, &RenderConfig { geometry_level: GeometryLevel::Routed, layout_engine: Some(EngineAlgorithmId::parse("mermaid-layered").unwrap()), ..RenderConfig::default() }, ) .expect("mermaid-layered mmds should render"); let orthogonal = render_class( &input, OutputFormat::Mmds, &RenderConfig { geometry_level: GeometryLevel::Routed, layout_engine: Some(EngineAlgorithmId::parse("flux-layered").unwrap()), ..RenderConfig::default() }, ) .expect("flux-layered mmds should render");
assert_ne!( full, orthogonal, "class routed MMDS should differ between mermaid-layered and flux-layered engines" );}
#[test]fn class_routed_mmds_honors_edge_routing_override_on_cycle() { let input = "classDiagram\nA --> B\nB --> C\nC --> A\n"; let full = render_class( input, OutputFormat::Mmds, &RenderConfig { geometry_level: GeometryLevel::Routed, layout_engine: Some(EngineAlgorithmId::parse("mermaid-layered").unwrap()), ..RenderConfig::default() }, ) .expect("mermaid-layered mmds should render"); let orthogonal = render_class( input, OutputFormat::Mmds, &RenderConfig { geometry_level: GeometryLevel::Routed, layout_engine: Some(EngineAlgorithmId::parse("flux-layered").unwrap()), ..RenderConfig::default() }, ) .expect("flux-layered mmds should render");
assert_ne!( full, orthogonal, "class routed MMDS cycle output should differ between mermaid-layered and flux-layered" );}
#[test]fn class_svg_honors_edge_routing_override_on_cycle() { let input = "classDiagram\nA --> B\nB --> C\nC --> A\n"; let full = render_class( input, OutputFormat::Svg, &RenderConfig { layout_engine: Some(EngineAlgorithmId::parse("mermaid-layered").unwrap()), ..RenderConfig::default() }, ) .expect("mermaid-layered svg should render"); let orthogonal = render_class( input, OutputFormat::Svg, &RenderConfig { layout_engine: Some(EngineAlgorithmId::parse("flux-layered").unwrap()), ..RenderConfig::default() }, ) .expect("flux-layered svg should render");
assert!(full.starts_with("<svg")); assert!(orthogonal.starts_with("<svg")); assert_ne!( full, orthogonal, "class SVG cycle output should differ between mermaid-layered and flux-layered engines" );}
// --- Task 4.4: Class diagram solve-path enablement ---
#[test]fn class_render_text_through_solve_path() { let config = RenderConfig { layout_engine: Some(EngineAlgorithmId::parse("flux-layered").unwrap()), ..Default::default() }; let output = render_class("classDiagram\nAnimal <|-- Dog", OutputFormat::Text, &config).unwrap(); assert!(output.contains("Animal")); assert!(output.contains("Dog"));}
#[test]fn class_render_mmds_through_solve_path() { let config = RenderConfig { layout_engine: Some(EngineAlgorithmId::parse("flux-layered").unwrap()), geometry_level: GeometryLevel::Routed, ..Default::default() }; let output = render_class("classDiagram\nAnimal <|-- Dog", OutputFormat::Mmds, &config).unwrap(); let json: serde_json::Value = serde_json::from_str(&output).unwrap(); assert!(json["edges"].is_array());}
#[test]fn class_default_engine_is_flux_layered() { let default_out = render_class( "classDiagram\nA <|-- B", OutputFormat::Text, &RenderConfig::default(), ) .unwrap();
let explicit_config = RenderConfig { layout_engine: Some(EngineAlgorithmId::parse("flux-layered").unwrap()), ..Default::default() }; let explicit_out = render_class( "classDiagram\nA <|-- B", OutputFormat::Text, &explicit_config, ) .unwrap();
assert_eq!(default_out, explicit_out);}
#[test]fn class_mermaid_layered_compatibility() { let config = RenderConfig { layout_engine: Some(EngineAlgorithmId::parse("mermaid-layered").unwrap()), ..Default::default() }; let output = render_class("classDiagram\nA <|-- B", OutputFormat::Text, &config).unwrap(); assert!(output.contains('A'));}