domainforge 0.13.0

package/domainforge-core/tests/cli_import_tests.rs

@@ -0,0 +1,291 @@
+#[cfg(feature = "cli")]
+use assert_cmd::Command;
+#[cfg(feature = "shacl")]
+use domainforge_core::ImportError;
+#[cfg(feature = "cli")]
+use predicates::prelude::*;
+#[cfg(feature = "cli")]
+use std::fs::write;
+#[cfg(feature = "cli")]
+use std::path::PathBuf;
+#[cfg(feature = "cli")]
+use tempfile::tempdir;
+
+#[cfg(feature = "cli")]
+fn get_sea_binary() -> String {
+    std::env::var("CARGO_BIN_EXE_sea").unwrap_or_else(|_| {
+        let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+        path.push("../target");
+        if cfg!(debug_assertions) {
+            path.push("debug");
+        } else {
+            path.push("release");
+        }
+        let binary_name = if cfg!(windows) {
+            "domainforge.exe"
+        } else {
+            "domainforge"
+        };
+        path.push(binary_name);
+        path.to_string_lossy().to_string()
+    })
+}
+
+#[cfg(feature = "cli")]
+#[test]
+fn test_cli_import_sbvr_minimal() {
+    // Create a minimal graph and export to SBVR via API, then import with CLI
+    let mut graph = domainforge_core::Graph::new();
+    let e1 = domainforge_core::primitives::Entity::new_with_namespace("Warehouse", "default");
+    let e2 = domainforge_core::primitives::Entity::new_with_namespace("Factory", "default");
+    let r = domainforge_core::primitives::Resource::new_with_namespace(
+        "Cameras",
+        domainforge_core::units::unit_from_string("units"),
+        "default",
+    );
+    let e1_id = e1.id().clone();
+    let e2_id = e2.id().clone();
+    let r_id = r.id().clone();
+    graph.add_entity(e1).unwrap();
+    graph.add_entity(e2).unwrap();
+    graph.add_resource(r).unwrap();
+    let flow = domainforge_core::primitives::Flow::new(
+        r_id,
+        e1_id,
+        e2_id,
+        rust_decimal::Decimal::new(100, 0),
+    );
+    graph.add_flow(flow).unwrap();
+
+    let sbvr = graph.export_sbvr().unwrap();
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("test.sbvr");
+    write(&file, sbvr).unwrap();
+
+    let bin = get_sea_binary();
+    let mut cmd = Command::new(&bin);
+    cmd.arg("import")
+        .arg("--format")
+        .arg("sbvr")
+        .arg(file.to_str().unwrap());
+    cmd.assert()
+        .success()
+        .stdout(predicate::str::contains("Imported SBVR to Graph"));
+}
+
+#[cfg(feature = "cli")]
+#[test]
+fn test_cli_import_kg_turtle_minimal() {
+    let mut graph = domainforge_core::Graph::new();
+    let e1 = domainforge_core::primitives::Entity::new_with_namespace("Warehouse", "default");
+    let e2 = domainforge_core::primitives::Entity::new_with_namespace("Factory", "default");
+    let r = domainforge_core::primitives::Resource::new_with_namespace(
+        "Cameras",
+        domainforge_core::units::unit_from_string("units"),
+        "default",
+    );
+    let e1_id = e1.id().clone();
+    let e2_id = e2.id().clone();
+    let r_id = r.id().clone();
+    graph.add_entity(e1).unwrap();
+    graph.add_entity(e2).unwrap();
+    graph.add_resource(r).unwrap();
+    let flow = domainforge_core::primitives::Flow::new(
+        r_id,
+        e1_id,
+        e2_id,
+        rust_decimal::Decimal::new(100, 0),
+    );
+    graph.add_flow(flow).unwrap();
+
+    let kg = domainforge_core::kg::KnowledgeGraph::from_graph(&graph).unwrap();
+    let turtle = kg.to_turtle();
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("test.ttl");
+    write(&file, turtle).unwrap();
+
+    let bin = get_sea_binary();
+    let mut cmd = Command::new(&bin);
+    cmd.arg("import")
+        .arg("--format")
+        .arg("kg")
+        .arg(file.to_str().unwrap());
+    cmd.assert()
+        .success()
+        .stdout(predicate::str::contains("Imported KG (Turtle) to Graph"));
+}
+
+#[cfg(not(feature = "cli"))]
+#[test]
+fn cli_import_tests_skipped_without_feature() {
+    assert!(true);
+}
+
+#[cfg(feature = "shacl")]
+#[test]
+fn test_cli_import_kg_rdfxml_minimal() {
+    let mut graph = domainforge_core::Graph::new();
+    let e1 = domainforge_core::primitives::Entity::new_with_namespace("Warehouse", "default");
+    let e2 = domainforge_core::primitives::Entity::new_with_namespace("Factory", "default");
+    let r = domainforge_core::primitives::Resource::new_with_namespace(
+        "Cameras",
+        domainforge_core::units::unit_from_string("units"),
+        "default",
+    );
+    let e1_id = e1.id().clone();
+    let e2_id = e2.id().clone();
+    let r_id = r.id().clone();
+    graph.add_entity(e1).unwrap();
+    graph.add_entity(e2).unwrap();
+    graph.add_resource(r).unwrap();
+    let flow = domainforge_core::primitives::Flow::new(
+        r_id,
+        e1_id,
+        e2_id,
+        rust_decimal::Decimal::new(100, 0),
+    );
+    graph.add_flow(flow).unwrap();
+
+    let kg = domainforge_core::kg::KnowledgeGraph::from_graph(&graph).unwrap();
+    let rdf_xml = kg.to_rdf_xml();
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("test.rdf");
+    write(&file, rdf_xml).unwrap();
+
+    let bin = get_sea_binary();
+    let mut cmd = Command::new(&bin);
+    cmd.arg("import")
+        .arg("--format")
+        .arg("kg")
+        .arg(file.to_str().unwrap());
+    cmd.assert()
+        .success()
+        .stdout(predicate::str::contains("Imported KG (RDF/XML) to Graph"));
+}
+
+#[cfg(feature = "shacl")]
+#[test]
+fn test_cli_import_kg_rdfxml_validation_fails() {
+    // Create graph with a flow that violates minExclusive (quantity == 0)
+    let mut graph = domainforge_core::Graph::new();
+    let e1 = domainforge_core::primitives::Entity::new_with_namespace("Warehouse", "default");
+    let e2 = domainforge_core::primitives::Entity::new_with_namespace("Factory", "default");
+    let r = domainforge_core::primitives::Resource::new_with_namespace(
+        "Cameras",
+        domainforge_core::units::unit_from_string("units"),
+        "default",
+    );
+    let e1_id = e1.id().clone();
+    let e2_id = e2.id().clone();
+    let r_id = r.id().clone();
+    graph.add_entity(e1).unwrap();
+    graph.add_entity(e2).unwrap();
+    graph.add_resource(r).unwrap();
+    let flow = domainforge_core::primitives::Flow::new(
+        r_id,
+        e1_id,
+        e2_id,
+        rust_decimal::Decimal::new(0, 0),
+    );
+    graph.add_flow(flow).unwrap();
+
+    let kg = domainforge_core::kg::KnowledgeGraph::from_graph(&graph).unwrap();
+    let rdf_xml = kg.to_rdf_xml();
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("test_bad.rdf");
+    write(&file, rdf_xml).unwrap();
+
+    let bin = get_sea_binary();
+    let mut cmd = Command::new(&bin);
+    cmd.arg("import")
+        .arg("--format")
+        .arg("kg")
+        .arg(file.to_str().unwrap());
+    cmd.assert()
+        .failure()
+        .stderr(predicate::str::contains("SHACL validation failed"));
+}
+
+#[cfg(feature = "shacl")]
+#[test]
+fn test_import_kg_rdfxml_direct() {
+    let mut graph = domainforge_core::Graph::new();
+    let e1 = domainforge_core::primitives::Entity::new_with_namespace("Warehouse", "default");
+    let e2 = domainforge_core::primitives::Entity::new_with_namespace("Factory", "default");
+    let r = domainforge_core::primitives::Resource::new_with_namespace(
+        "Cameras",
+        domainforge_core::units::unit_from_string("units"),
+        "default",
+    );
+    let e1_id = e1.id().clone();
+    let e2_id = e2.id().clone();
+    let r_id = r.id().clone();
+    graph.add_entity(e1).unwrap();
+    graph.add_entity(e2).unwrap();
+    graph.add_resource(r).unwrap();
+    let flow = domainforge_core::primitives::Flow::new(
+        r_id,
+        e1_id,
+        e2_id,
+        rust_decimal::Decimal::new(100, 0),
+    );
+    graph.add_flow(flow).unwrap();
+
+    let kg = domainforge_core::kg::KnowledgeGraph::from_graph(&graph).unwrap();
+    let rdf_xml = kg.to_rdf_xml();
+
+    // Import using the direct function
+    let imported = domainforge_core::import_kg_rdfxml(&rdf_xml);
+    assert!(imported.is_ok(), "RDF/XML import failed: {:?}", imported);
+    let imported_graph = imported.unwrap();
+    assert_eq!(imported_graph.entity_count(), 2);
+    assert_eq!(imported_graph.resource_count(), 1);
+    assert_eq!(imported_graph.flow_count(), 1);
+}
+
+#[cfg(feature = "shacl")]
+#[test]
+fn test_import_kg_rdfxml_direct_validation_fails() {
+    // Create graph with a flow that violates minExclusive (quantity == 0)
+    let mut graph = domainforge_core::Graph::new();
+    let e1 = domainforge_core::primitives::Entity::new_with_namespace("Warehouse", "default");
+    let e2 = domainforge_core::primitives::Entity::new_with_namespace("Factory", "default");
+    let r = domainforge_core::primitives::Resource::new_with_namespace(
+        "Cameras",
+        domainforge_core::units::unit_from_string("units"),
+        "default",
+    );
+    let e1_id = e1.id().clone();
+    let e2_id = e2.id().clone();
+    let r_id = r.id().clone();
+    graph.add_entity(e1).unwrap();
+    graph.add_entity(e2).unwrap();
+    graph.add_resource(r).unwrap();
+    let flow = domainforge_core::primitives::Flow::new(
+        r_id,
+        e1_id,
+        e2_id,
+        rust_decimal::Decimal::new(0, 0),
+    );
+    graph.add_flow(flow).unwrap();
+
+    let kg = domainforge_core::kg::KnowledgeGraph::from_graph(&graph).unwrap();
+    let rdf_xml = kg.to_rdf_xml();
+
+    let imported = domainforge_core::import_kg_rdfxml(&rdf_xml);
+    assert!(
+        imported.is_err(),
+        "Expected SHACL validation error, got {:?}",
+        imported
+    );
+    match imported.err().unwrap() {
+        ImportError::ShaclValidation(msg) => {
+            assert!(
+                msg.contains("SHACL validation failed"),
+                "Expected SHACL validation failure, got: {}",
+                msg
+            );
+        }
+        other => panic!("Expected SHACL validation error, got {:?}", other),
+    }
+}

package/domainforge-core/tests/cli_path_traversal_tests.rs

@@ -0,0 +1,124 @@
+#![cfg(feature = "cli")]
+
+use domainforge_core::projection::protobuf::validate_proto_package_namespace;
+use std::fs;
+use std::path::PathBuf;
+use tempfile::{tempdir, TempDir};
+
+fn write_input(dir: &TempDir, content: &str) -> PathBuf {
+    let path = dir.path().join("input.sea");
+    fs::write(&path, content).unwrap();
+    path
+}
+
+fn run_project(input: &PathBuf, output: &PathBuf, extra_args: &[&str]) -> Result<(), String> {
+    let mut cmd = assert_cmd::Command::new(assert_cmd::cargo::cargo_bin!("domainforge"));
+    cmd.arg("project")
+        .arg("--format")
+        .arg("protobuf")
+        .arg("--multi-file")
+        .arg("--package")
+        .arg("sea.generated")
+        .args(extra_args)
+        .arg(input)
+        .arg(output);
+    let output = cmd.output().unwrap();
+    if output.status.success() {
+        Ok(())
+    } else {
+        Err(String::from_utf8_lossy(&output.stderr).to_string())
+    }
+}
+
+#[test]
+fn test_namespace_rejects_absolute_path() {
+    let result = validate_proto_package_namespace("/tmp/escape");
+    assert!(result.is_err(), "Expected rejection for '/tmp/escape'");
+    assert!(result.unwrap_err().contains("path separators"));
+}
+
+#[test]
+fn test_namespace_rejects_traversal() {
+    let result = validate_proto_package_namespace("../escape");
+    assert!(result.is_err(), "Expected rejection for '../escape'");
+    assert!(result.unwrap_err().contains("traversal"));
+}
+
+#[test]
+fn test_namespace_rejects_slash() {
+    let result = validate_proto_package_namespace("a/b");
+    assert!(result.is_err(), "Expected rejection for 'a/b'");
+    assert!(result.unwrap_err().contains("path separators"));
+}
+
+#[test]
+fn test_namespace_rejects_backslash() {
+    let result = validate_proto_package_namespace("a\\b");
+    assert!(result.is_err(), "Expected rejection for 'a\\b'");
+    assert!(result.unwrap_err().contains("path separators"));
+}
+
+#[test]
+fn test_namespace_rejects_leading_dot() {
+    let result = validate_proto_package_namespace(".hidden");
+    assert!(result.is_err(), "Expected rejection for '.hidden'");
+}
+
+#[test]
+fn test_namespace_rejects_double_dot() {
+    let result = validate_proto_package_namespace("foo..bar");
+    assert!(result.is_err(), "Expected rejection for 'foo..bar'");
+}
+
+#[test]
+fn test_namespace_accepts_simple() {
+    assert!(validate_proto_package_namespace("logistics").is_ok());
+}
+
+#[test]
+fn test_namespace_accepts_dotted() {
+    assert!(validate_proto_package_namespace("com.example.api").is_ok());
+}
+
+#[test]
+fn test_namespace_accepts_underscore() {
+    assert!(validate_proto_package_namespace("my_pkg").is_ok());
+}
+
+#[test]
+fn test_namespace_accepts_dotted_with_underscore() {
+    assert!(validate_proto_package_namespace("com.example_my.api").is_ok());
+}
+
+#[test]
+fn test_namespace_accepts_empty() {
+    assert!(validate_proto_package_namespace("").is_ok());
+}
+
+#[test]
+fn test_namespace_rejects_digit_start() {
+    let result = validate_proto_package_namespace("9invalid");
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_namespace_rejects_special_chars() {
+    let result = validate_proto_package_namespace("ns!@#");
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_multi_file_writes_inside_output_dir() {
+    let dir = tempdir().unwrap();
+    let input = write_input(&dir, "Entity \"TestEntity\" in domain");
+    let output = dir.path().join("out_proto");
+    fs::create_dir_all(&output).unwrap();
+
+    let result = run_project(&input, &output, &[]);
+    assert!(
+        result.is_ok(),
+        "Multi-file projection should succeed: {:?}",
+        result
+    );
+    assert!(fs::read_dir(&output).unwrap().count() > 0);
+}

package/domainforge-core/tests/cli_tests.rs

@@ -0,0 +1,63 @@
+#![cfg(feature = "cli")]
+
+use assert_cmd::Command;
+use predicates::prelude::*;
+use std::io::Write;
+use tempfile::NamedTempFile;
+
+/// Helper function to test help output for a command
+fn run_help_test(args: &[&str], expected: &str) {
+    let mut cmd = Command::new(assert_cmd::cargo::cargo_bin!("domainforge"));
+    cmd.args(args)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains(expected));
+}
+
+#[test]
+fn test_help() {
+    run_help_test(&["--help"], "SEA DSL CLI");
+}
+
+#[test]
+fn test_validate_help() {
+    run_help_test(&["validate", "--help"], "Validate");
+}
+
+#[test]
+fn test_import_help() {
+    run_help_test(&["import", "--help"], "Import");
+}
+
+#[test]
+fn test_project_help() {
+    run_help_test(&["project", "--help"], "Project");
+}
+
+#[test]
+fn test_validate_basic() {
+    let mut file = NamedTempFile::new().unwrap();
+    writeln!(file, "Entity \"Test\" in domain").unwrap();
+    file.flush().unwrap();
+
+    let mut cmd = Command::new(assert_cmd::cargo::cargo_bin!("domainforge"));
+    cmd.arg("validate")
+        .arg(file.path())
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("Validation succeeded"));
+}
+
+#[test]
+fn test_format_check() {
+    let mut file = NamedTempFile::new().unwrap();
+    writeln!(file, "Entity \"Test\" in domain").unwrap();
+    file.flush().unwrap();
+
+    let mut cmd = Command::new(assert_cmd::cargo::cargo_bin!("domainforge"));
+    cmd.arg("format")
+        .arg(file.path())
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("Entity \"Test\" in domain"));
+}

package/domainforge-core/tests/diagnostics_tests.rs

@@ -0,0 +1,203 @@
+// Tests for enhanced error diagnostics with fuzzy matching
+use domainforge_core::{ErrorCode, ValidationError};
+
+#[test]
+fn test_error_code_assignment() {
+    let syntax_err = ValidationError::syntax_error("test", 1, 1);
+    assert_eq!(syntax_err.error_code(), ErrorCode::E005_SyntaxError);
+
+    let entity_err = ValidationError::undefined_entity("Warehouse", "line 10");
+    assert_eq!(entity_err.error_code(), ErrorCode::E001_UndefinedEntity);
+
+    let resource_err = ValidationError::undefined_resource("Steel", "line 15");
+    assert_eq!(resource_err.error_code(), ErrorCode::E002_UndefinedResource);
+}
+
+#[test]
+fn test_source_range_from_syntax_error() {
+    let err = ValidationError::syntax_error_with_range("test", 10, 5, 10, 15);
+    let range = err.range().expect("Should have range");
+
+    assert_eq!(range.start.line, 10);
+    assert_eq!(range.start.column, 5);
+    assert_eq!(range.end.line, 10);
+    assert_eq!(range.end.column, 15);
+}
+
+#[test]
+fn test_location_string() {
+    let err = ValidationError::syntax_error("test", 10, 5);
+    assert_eq!(err.location_string(), Some("10:5".to_string()));
+
+    let err2 = ValidationError::undefined_entity("Warehouse", "line 20");
+    assert_eq!(err2.location_string(), Some("line 20".to_string()));
+}
+
+#[test]
+fn test_fuzzy_matching_undefined_entity() {
+    let candidates = vec![
+        "Warehouse".to_string(),
+        "Factory".to_string(),
+        "Supplier".to_string(),
+    ];
+
+    let err = ValidationError::undefined_entity_with_candidates("Warehous", "line 10", &candidates);
+
+    let suggestion = match err {
+        ValidationError::UndefinedReference { suggestion, .. } => suggestion,
+        _ => panic!("Expected UndefinedReference"),
+    };
+
+    assert!(suggestion.is_some());
+    assert!(suggestion.unwrap().contains("Warehouse"));
+}
+
+#[test]
+fn test_fuzzy_matching_undefined_resource() {
+    let candidates = vec![
+        "Steel".to_string(),
+        "Iron".to_string(),
+        "Copper".to_string(),
+    ];
+
+    let err = ValidationError::undefined_resource_with_candidates("Stel", "line 15", &candidates);
+
+    let suggestion = match err {
+        ValidationError::UndefinedReference { suggestion, .. } => suggestion,
+        _ => panic!("Expected UndefinedReference"),
+    };
+
+    assert!(suggestion.is_some());
+    assert!(suggestion.unwrap().contains("Steel"));
+}
+
+#[test]
+fn test_fuzzy_matching_no_candidates() {
+    let candidates = vec!["Warehouse".to_string(), "Factory".to_string()];
+
+    let err = ValidationError::undefined_entity_with_candidates("XYZ", "line 10", &candidates);
+
+    let suggestion = match err {
+        ValidationError::UndefinedReference { suggestion, .. } => suggestion,
+        _ => panic!("Expected UndefinedReference"),
+    };
+
+    // Should fall back to generic suggestion
+    assert!(suggestion.is_some());
+    assert!(suggestion.unwrap().contains("Entity \"XYZ\""));
+}
+
+#[test]
+fn test_error_code_display() {
+    assert_eq!(ErrorCode::E001_UndefinedEntity.as_str(), "E001");
+    assert_eq!(ErrorCode::E005_SyntaxError.as_str(), "E005");
+    assert_eq!(ErrorCode::E300_VariableNotInScope.as_str(), "E300");
+}
+
+#[test]
+fn test_error_code_description() {
+    assert_eq!(
+        ErrorCode::E001_UndefinedEntity.description(),
+        "Undefined entity"
+    );
+    assert_eq!(ErrorCode::E003_UnitMismatch.description(), "Unit mismatch");
+    assert_eq!(
+        ErrorCode::E402_DeterminismViolation.description(),
+        "Determinism violation"
+    );
+}
+
+// Formatter tests
+use domainforge_core::error::{DiagnosticFormatter, HumanFormatter, JsonFormatter, LspFormatter};
+
+#[test]
+fn test_json_formatter_output() {
+    let error = ValidationError::syntax_error_with_range("unexpected token", 10, 5, 10, 15);
+    let formatter = JsonFormatter;
+    let output = formatter.format(&error, None);
+
+    // Verify it's valid JSON
+    let parsed: serde_json::Value = serde_json::from_str(&output).expect("Valid JSON");
+    assert_eq!(parsed["code"], "E005");
+    assert_eq!(parsed["severity"], "error");
+    assert_eq!(parsed["range"]["start"]["line"], 10);
+    assert_eq!(parsed["range"]["start"]["column"], 5);
+}
+
+#[test]
+fn test_json_formatter_with_fuzzy_suggestion() {
+    let candidates = vec!["Warehouse".to_string(), "Factory".to_string()];
+    let error =
+        ValidationError::undefined_entity_with_candidates("Warehous", "line 10", &candidates);
+    let formatter = JsonFormatter;
+    let output = formatter.format(&error, None);
+
+    let parsed: serde_json::Value = serde_json::from_str(&output).expect("Valid JSON");
+    assert_eq!(parsed["code"], "E001");
+    assert!(parsed["hint"].as_str().unwrap().contains("Warehouse"));
+}
+
+#[test]
+fn test_human_formatter_basic() {
+    let error = ValidationError::undefined_entity("TestEntity", "line 5");
+    let formatter = HumanFormatter::new(false, false);
+    let output = formatter.format(&error, None);
+
+    assert!(output.contains("error[E001]"));
+    assert!(output.contains("TestEntity"));
+}
+
+#[test]
+fn test_human_formatter_with_source() {
+    let source = r#"Entity "Warehouse" in logistics
+Entity "Factory" in manufacturing
+Flow "Steel" from "Warehous" to "Factory" quantity 100
+"#;
+
+    let error = ValidationError::syntax_error_with_range("typo in entity name", 3, 19, 3, 28);
+    let formatter = HumanFormatter::new(false, true);
+    let output = formatter.format(&error, Some(source));
+
+    // Should include source snippet
+    assert!(output.contains("Warehous"));
+    assert!(output.contains("^^^"));
+}
+
+#[test]
+fn test_lsp_formatter_output() {
+    let error = ValidationError::syntax_error_with_range("test", 10, 5, 10, 15);
+    let formatter = LspFormatter;
+    let output = formatter.format(&error, None);
+
+    // Verify it's valid JSON
+    let parsed: serde_json::Value = serde_json::from_str(&output).expect("Valid JSON");
+    assert_eq!(parsed["severity"], 1); // Error
+    assert_eq!(parsed["code"], "E005");
+    assert_eq!(parsed["source"], "domainforge");
+    // LSP uses 0-indexed lines
+    assert_eq!(parsed["range"]["start"]["line"], 9);
+}
+
+#[test]
+fn test_format_multiple_errors_json() {
+    use domainforge_core::error::diagnostics::format_errors_json;
+
+    let errors = vec![
+        ValidationError::syntax_error("error 1", 1, 1),
+        ValidationError::undefined_entity("Test", "line 5"),
+        ValidationError::unit_mismatch(
+            domainforge_core::units::Dimension::Mass,
+            domainforge_core::units::Dimension::Currency,
+            "line 10",
+        ),
+    ];
+
+    let output = format_errors_json(&errors);
+    let parsed: serde_json::Value = serde_json::from_str(&output).expect("Valid JSON");
+
+    assert!(parsed.is_array());
+    assert_eq!(parsed.as_array().unwrap().len(), 3);
+    assert_eq!(parsed[0]["code"], "E005");
+    assert_eq!(parsed[1]["code"], "E001");
+    assert_eq!(parsed[2]["code"], "E003");
+}