domainforge 0.13.0

package/domainforge-core/tests/instance_integration_tests.rs

@@ -0,0 +1,98 @@
+use domainforge_core::parser::parse_to_graph;
+
+#[test]
+fn test_instance_stored_in_graph() {
+    let source = r#"
+Entity "Vendor"
+
+Instance vendor_123 of "Vendor" {
+    name: "Acme Corp",
+    credit_limit: 50000
+}
+"#;
+
+    let result = parse_to_graph(source);
+    assert!(result.is_ok(), "Failed to parse: {:?}", result.err());
+
+    let graph = result.unwrap();
+    assert_eq!(graph.entity_instance_count(), 1);
+
+    let instance = graph.get_entity_instance("vendor_123");
+    assert!(instance.is_some());
+
+    let instance = instance.unwrap();
+    assert_eq!(instance.name(), "vendor_123");
+    assert_eq!(instance.entity_type(), "Vendor");
+
+    // Check fields
+    let name_field = instance.get_field("name");
+    assert!(name_field.is_some());
+    assert_eq!(name_field.unwrap().as_str(), Some("Acme Corp"));
+
+    let credit_field = instance.get_field("credit_limit");
+    assert!(credit_field.is_some());
+    assert_eq!(credit_field.unwrap().as_f64(), Some(50000.0));
+}
+
+#[test]
+fn test_multiple_instances_in_graph() {
+    let source = r#"
+Entity "Vendor"
+
+Instance vendor_1 of "Vendor" {
+    name: "Acme Corp"
+}
+
+Instance vendor_2 of "Vendor" {
+    name: "Beta Inc"
+}
+"#;
+
+    let result = parse_to_graph(source);
+    assert!(result.is_ok(), "Failed to parse: {:?}", result.err());
+
+    let graph = result.unwrap();
+    assert_eq!(graph.entity_instance_count(), 2);
+
+    assert!(graph.get_entity_instance("vendor_1").is_some());
+    assert!(graph.get_entity_instance("vendor_2").is_some());
+}
+
+#[test]
+fn test_duplicate_instance_error() {
+    let source = r#"
+Entity "Vendor"
+
+Instance vendor_1 of "Vendor" {
+    name: "Acme Corp"
+}
+
+Instance vendor_1 of "Vendor" {
+    name: "Beta Inc"
+}
+"#;
+
+    let result = parse_to_graph(source);
+    assert!(result.is_err());
+    let error = result.unwrap_err();
+    assert!(error.to_string().contains("already exists"));
+}
+
+#[test]
+fn test_instance_minimal_no_fields() {
+    let source = r#"
+Entity "Vendor"
+
+Instance vendor_123 of "Vendor"
+"#;
+
+    let result = parse_to_graph(source);
+    assert!(result.is_ok(), "Failed to parse: {:?}", result.err());
+
+    let graph = result.unwrap();
+    assert_eq!(graph.entity_instance_count(), 1);
+
+    let instance = graph.get_entity_instance("vendor_123");
+    assert!(instance.is_some());
+    assert_eq!(instance.unwrap().fields().len(), 0);
+}

package/domainforge-core/tests/instance_parsing_tests.rs

@@ -0,0 +1,58 @@
+use domainforge_core::parser::parse;
+
+#[test]
+fn test_parse_instance_minimal() {
+    let source = r#"
+Instance vendor_123 of "Vendor"
+"#;
+
+    let result = parse(source);
+    assert!(result.is_ok(), "Failed to parse: {:?}", result.err());
+
+    let _graph = result.unwrap();
+    // For now, just verify it parses without error
+    // We'll add graph integration in the next step
+}
+
+#[test]
+fn test_parse_instance_with_fields() {
+    let source = r#"
+Instance vendor_123 of "Vendor" {
+    name: "Acme Corp",
+    credit_limit: 50000,
+    quantity: 10
+}
+"#;
+
+    let result = parse(source);
+    assert!(result.is_ok(), "Failed to parse: {:?}", result.err());
+}
+
+#[test]
+fn test_parse_instance_with_quantity_field() {
+    let source = r#"
+Instance vendor_123 of "Vendor" {
+    name: "Acme Corp",
+    credit_limit: 50000 "USD"
+}
+"#;
+
+    let result = parse(source);
+    assert!(result.is_ok(), "Failed to parse: {:?}", result.err());
+}
+
+#[test]
+fn test_parse_multiple_instances() {
+    let source = r#"
+Instance vendor_1 of "Vendor" {
+    name: "Acme Corp"
+}
+
+Instance vendor_2 of "Vendor" {
+    name: "Beta Inc"
+}
+"#;
+
+    let result = parse(source);
+    assert!(result.is_ok(), "Failed to parse: {:?}", result.err());
+}

package/domainforge-core/tests/instance_tests.rs

@@ -0,0 +1,61 @@
+use domainforge_core::primitives::{Entity, Resource, ResourceInstance};
+use domainforge_core::units::unit_from_string;
+use domainforge_core::ConceptId;
+
+#[test]
+fn test_instance_new_stores_references() {
+    let warehouse = Entity::new_with_namespace("Warehouse", "default".to_string());
+    let camera =
+        Resource::new_with_namespace("Camera", unit_from_string("units"), "default".to_string());
+
+    let instance = ResourceInstance::new(camera.id().clone(), warehouse.id().clone());
+
+    assert_eq!(instance.entity_id(), warehouse.id());
+    assert_eq!(instance.resource_id(), camera.id());
+}
+
+#[test]
+fn test_instance_references_are_valid_uuids() {
+    let instance = ResourceInstance::new(
+        ConceptId::from_uuid(uuid::Uuid::new_v4()),
+        ConceptId::from_uuid(uuid::Uuid::new_v4()),
+    );
+
+    assert!(!instance.id().to_string().is_empty());
+    assert!(!instance.resource_id().to_string().is_empty());
+    assert!(!instance.entity_id().to_string().is_empty());
+}
+
+#[test]
+fn test_instance_attributes() {
+    let mut instance = ResourceInstance::new(
+        ConceptId::from_uuid(uuid::Uuid::new_v4()),
+        ConceptId::from_uuid(uuid::Uuid::new_v4()),
+    );
+
+    instance.set_attribute("serial_number", serde_json::json!("SN12345"));
+    instance.set_attribute("manufacture_date", serde_json::json!("2025-01-15"));
+
+    assert_eq!(
+        instance.get_attribute("serial_number"),
+        Some(&serde_json::json!("SN12345"))
+    );
+    assert_eq!(
+        instance.get_attribute("manufacture_date"),
+        Some(&serde_json::json!("2025-01-15"))
+    );
+    assert_eq!(instance.get_attribute("nonexistent"), None);
+}
+
+#[test]
+fn test_instance_serialization() {
+    let instance = ResourceInstance::new(
+        ConceptId::from_uuid(uuid::Uuid::new_v4()),
+        ConceptId::from_uuid(uuid::Uuid::new_v4()),
+    );
+
+    let json = serde_json::to_string(&instance).unwrap();
+    let deserialized: ResourceInstance = serde_json::from_str(&json).unwrap();
+
+    assert_eq!(instance, deserialized);
+}

package/domainforge-core/tests/kg_uri_encoding_tests.rs

@@ -0,0 +1,53 @@
+use domainforge_core::primitives::Entity;
+use domainforge_core::Graph;
+
+#[test]
+fn test_kg_uri_encoding_rfc3986() {
+    let mut graph = Graph::new();
+
+    // Test characters that should be encoded to be safe in Turtle QNames or URIs
+    // We expect percent encoding for these
+    let special_chars = [
+        ("Space", " ", "%20"),
+        ("Colon", ":", "%3A"),
+        ("Slash", "/", "%2F"),
+        ("Hash", "#", "%23"),
+        // These might fail if URI_ENCODE_SET is not comprehensive enough
+        // But let's test what we expect for a robust implementation
+        ("Question", "?", "%3F"),
+        ("Ampersand", "&", "%26"),
+        ("Equals", "=", "%3D"),
+        ("Plus", "+", "%2B"),
+        ("Comma", ",", "%2C"),
+        ("At", "@", "%40"),
+        ("Semicolon", ";", "%3B"),
+    ];
+
+    for (name, char, encoded) in special_chars {
+        let entity_name = format!("Entity{}{}", name, char);
+        let entity = Entity::new_with_namespace(entity_name, "default".to_string());
+        graph.add_entity(entity).unwrap();
+
+        let turtle = graph.export_rdf("turtle").unwrap();
+        let expected = format!("sea:Entity{}{}", name, encoded);
+
+        // We check if the output contains the encoded version
+        // If it contains the unencoded version (e.g. sea:EntityQuestion?), it might be invalid Turtle
+        if !turtle.contains(&expected) {
+            println!(
+                "WARNING: '{}' was not encoded as '{}'. Output: {}",
+                char, encoded, turtle
+            );
+            // For now, we might assert failure if we want to enforce it,
+            // or we can just log it if we are exploring.
+            // But the task is "Add tests", implying we want to verify behavior.
+            // I'll assert it.
+            assert!(
+                turtle.contains(&expected),
+                "Failed to encode '{}' to '{}'",
+                char,
+                encoded
+            );
+        }
+    }
+}

package/domainforge-core/tests/lint_tests.rs

@@ -0,0 +1,19 @@
+use domainforge_core::parser::lint::Linter;
+
+#[test]
+fn test_lint_keyword_collision() {
+    let linter = Linter::new();
+    assert!(linter.check_identifier("Entity", false).is_err());
+    assert!(linter.check_identifier("Resource", false).is_err());
+    assert!(linter.check_identifier("Flow", false).is_err());
+    assert!(linter.check_identifier("Policy", false).is_err());
+    assert!(linter.check_identifier("Unit", false).is_err());
+    assert!(linter.check_identifier("Dimension", false).is_err());
+}
+
+#[test]
+fn test_lint_quoted_identifier() {
+    let linter = Linter::new();
+    assert!(linter.check_identifier("Entity", true).is_ok());
+    assert!(linter.check_identifier("MyEntity", false).is_ok());
+}

package/domainforge-core/tests/metric_tests.rs

@@ -0,0 +1,143 @@
+use chrono::Duration;
+use domainforge_core::parser::parse_to_graph;
+use domainforge_core::primitives::Severity;
+
+#[test]
+fn test_metric_parsing() {
+    let source = r#"
+        Metric "total_payment_volume" as: sum(flows.quantity)
+    "#;
+
+    let graph = parse_to_graph(source).expect("Failed to parse metrics");
+
+    assert_eq!(graph.metric_count(), 1);
+
+    let metric1 = graph
+        .get_metric(&domainforge_core::ConceptId::from_concept(
+            "default",
+            "total_payment_volume",
+        ))
+        .unwrap();
+    assert_eq!(metric1.name, "total_payment_volume");
+}
+
+#[test]
+fn test_metric_with_annotations() {
+    let source = r#"
+        Metric "high_value_payments" as: count(flows)
+            @threshold 100
+            @severity "warning"
+            @unit "USD"
+    "#;
+
+    let graph = parse_to_graph(source).expect("Failed to parse metric with annotations");
+
+    assert_eq!(graph.metric_count(), 1);
+
+    let metric = graph
+        .get_metric(&domainforge_core::ConceptId::from_concept(
+            "default",
+            "high_value_payments",
+        ))
+        .unwrap();
+    assert_eq!(metric.name, "high_value_payments");
+    assert!(metric.threshold.is_some());
+    assert_eq!(metric.threshold.unwrap().to_string(), "100");
+    assert!(matches!(metric.severity, Some(Severity::Warning)));
+    assert_eq!(metric.unit.as_deref(), Some("USD"));
+}
+
+#[test]
+fn test_metric_with_time_annotations() {
+    let source = r#"
+        Metric "payment_success_rate" as: count(flows)
+            @refresh_interval 60 "seconds"
+            @window 1 "hour"
+            @target 99.9
+    "#;
+
+    let graph = parse_to_graph(source).expect("Failed to parse metric with time annotations");
+
+    assert_eq!(graph.metric_count(), 1);
+
+    let metric = graph
+        .get_metric(&domainforge_core::ConceptId::from_concept(
+            "default",
+            "payment_success_rate",
+        ))
+        .unwrap();
+    assert_eq!(metric.name, "payment_success_rate");
+    assert!(metric.refresh_interval.is_some());
+    assert!(metric.window.is_some());
+    assert!(metric.target.is_some());
+    assert_eq!(metric.target.unwrap().to_string(), "99.9");
+}
+
+#[test]
+fn metric_rejects_unknown_severity() {
+    let source = r#"
+        Metric "invalid_severity" as: count(flows)
+            @severity "urgent"
+    "#;
+
+    let err = parse_to_graph(source).expect_err("Expected severity validation to fail");
+    let message = format!("{}", err);
+    assert!(
+        message.contains("Unknown severity") || message.contains("severity"),
+        "Unexpected error message: {}",
+        message
+    );
+}
+
+#[test]
+fn metric_rejects_unknown_units() {
+    let source = r#"
+        Metric "invalid_unit" as: count(flows)
+            @refresh_interval 5 "weeks"
+    "#;
+
+    let err = parse_to_graph(source).expect_err("Expected refresh interval validation to fail");
+    let message = format!("{}", err);
+    assert!(
+        message.contains("duration unit") || message.contains("Invalid"),
+        "Unexpected error message: {}",
+        message
+    );
+}
+
+#[test]
+fn metric_serializes_durations_with_serde() {
+    let source = r#"
+        Metric "serde_metric" as: count(flows)
+            @refresh_interval 90 "seconds"
+            @window 2 "hours"
+    "#;
+
+    let graph = parse_to_graph(source).expect("Failed to parse metric with durations");
+    let metric = graph
+        .get_metric(&domainforge_core::ConceptId::from_concept(
+            "default",
+            "serde_metric",
+        ))
+        .expect("Missing serde_metric")
+        .clone();
+
+    let json = serde_json::to_string(&metric).expect("Failed to serialize metric");
+    let restored: domainforge_core::primitives::Metric =
+        serde_json::from_str(&json).expect("Failed to deserialize metric");
+
+    assert_eq!(restored.refresh_interval, metric.refresh_interval);
+    assert_eq!(restored.window, metric.window);
+
+    // Spot-check that serde preserves values, not just structure.
+    assert_eq!(
+        restored.refresh_interval,
+        Some(Duration::seconds(90)),
+        "Refresh interval should round-trip through serde"
+    );
+    assert_eq!(
+        restored.window,
+        Some(Duration::hours(2)),
+        "Window should round-trip through serde"
+    );
+}

package/domainforge-core/tests/module_resolution_tests.rs

@@ -0,0 +1,100 @@
+#![cfg(not(target_arch = "wasm32"))]
+use domainforge_core::module::resolver::ModuleResolver;
+use domainforge_core::registry::NamespaceRegistry;
+use std::fs;
+use std::io::Write;
+use std::path::Path;
+use tempfile::tempdir;
+
+fn write_file(path: &Path, contents: &str) {
+    let mut file = fs::File::create(path).expect("unable to create file");
+    file.write_all(contents.as_bytes())
+        .expect("unable to write file");
+}
+
+fn create_registry(dir: &Path) -> std::path::PathBuf {
+    let registry_path = dir.join(".sea-registry.toml");
+    let registry = r#"
+version = 1
+default_namespace = "default"
+
+[[namespaces]]
+namespace = "acme.order"
+patterns = ["order.sea"]
+
+[[namespaces]]
+namespace = "acme.common"
+patterns = ["common.sea"]
+"#;
+    write_file(&registry_path, registry);
+    registry_path
+}
+
+#[test]
+fn resolves_dependencies_and_exports() {
+    let dir = tempdir().expect("tempdir");
+    let registry_path = create_registry(dir.path());
+
+    let order_file = dir.path().join("order.sea");
+    write_file(
+        &order_file,
+        r#"
+@namespace "acme.order"
+import { Customer } from "acme.common"
+export Entity "Order"
+"#,
+    );
+
+    let common_file = dir.path().join("common.sea");
+    write_file(
+        &common_file,
+        r#"
+@namespace "acme.common"
+export Entity "Customer"
+"#,
+    );
+
+    let registry = NamespaceRegistry::from_file(&registry_path).expect("registry");
+    let mut resolver = ModuleResolver::new(&registry).expect("resolver");
+
+    let order_content = fs::read_to_string(&order_file).unwrap();
+    let order_ast = resolver
+        .validate_entry(&order_file, &order_content)
+        .expect("entry should validate");
+
+    assert!(resolver
+        .validate_dependencies(&order_file, &order_ast)
+        .is_ok());
+}
+
+#[test]
+fn detects_dependency_cycles() {
+    let dir = tempdir().expect("tempdir");
+    let registry_path = create_registry(dir.path());
+
+    let order_file = dir.path().join("order.sea");
+    write_file(
+        &order_file,
+        r#"
+@namespace "acme.order"
+import * as common from "acme.common"
+export Entity "Order"
+"#,
+    );
+
+    let common_file = dir.path().join("common.sea");
+    write_file(
+        &common_file,
+        r#"
+@namespace "acme.common"
+import * as order from "acme.order"
+export Entity "Customer"
+"#,
+    );
+
+    let registry = NamespaceRegistry::from_file(&registry_path).expect("registry");
+    let mut resolver = ModuleResolver::new(&registry).expect("resolver");
+    let result = resolver.validate_entry(&order_file, &fs::read_to_string(&order_file).unwrap());
+
+    assert!(result.is_err(), "cycle should be detected");
+}