domainforge 0.13.0

package/domainforge-core/tests/temporal_semantics_tests.rs

@@ -0,0 +1,214 @@
+use domainforge_core::parser::parse_expression_from_str;
+use domainforge_core::policy::{BinaryOp, Expression};
+
+#[test]
+fn test_parse_time_literal() {
+    let source = r#""2025-12-31T23:59:59Z""#;
+    let result = parse_expression_from_str(source);
+
+    assert!(
+        result.is_ok(),
+        "Failed to parse time literal: {:?}",
+        result.err()
+    );
+
+    match result.unwrap() {
+        Expression::TimeLiteral(timestamp) => {
+            assert_eq!(timestamp, "2025-12-31T23:59:59Z");
+        }
+        other => panic!("Expected TimeLiteral, got {:?}", other),
+    }
+}
+
+#[test]
+fn test_parse_time_literal_with_offset() {
+    let source = r#""2025-12-31T23:59:59+05:00""#;
+    let result = parse_expression_from_str(source);
+
+    assert!(
+        result.is_ok(),
+        "Failed to parse time literal with offset: {:?}",
+        result.err()
+    );
+
+    match result.unwrap() {
+        Expression::TimeLiteral(timestamp) => {
+            assert_eq!(timestamp, "2025-12-31T23:59:59+05:00");
+        }
+        other => panic!("Expected TimeLiteral, got {:?}", other),
+    }
+}
+
+#[test]
+fn test_parse_interval_literal() {
+    let source = r#"interval("09:00", "17:00")"#;
+    let result = parse_expression_from_str(source);
+
+    assert!(
+        result.is_ok(),
+        "Failed to parse interval literal: {:?}",
+        result.err()
+    );
+
+    match result.unwrap() {
+        Expression::IntervalLiteral { start, end } => {
+            assert_eq!(start, "09:00");
+            assert_eq!(end, "17:00");
+        }
+        other => panic!("Expected IntervalLiteral, got {:?}", other),
+    }
+}
+
+#[test]
+fn test_parse_before_operator() {
+    let source = r#"f.created_at before "2025-12-31T23:59:59Z""#;
+    let result = parse_expression_from_str(source);
+
+    assert!(
+        result.is_ok(),
+        "Failed to parse before operator: {:?}",
+        result.err()
+    );
+
+    match result.unwrap() {
+        Expression::Binary { op, left, right } => {
+            assert_eq!(op, BinaryOp::Before);
+
+            // Verify left side is member access
+            match *left {
+                Expression::MemberAccess { object, member } => {
+                    assert_eq!(object, "f");
+                    assert_eq!(member, "created_at");
+                }
+                other => panic!("Expected MemberAccess on left, got {:?}", other),
+            }
+
+            // Verify right side is time literal
+            match *right {
+                Expression::TimeLiteral(timestamp) => {
+                    assert_eq!(timestamp, "2025-12-31T23:59:59Z");
+                }
+                other => panic!("Expected TimeLiteral on right, got {:?}", other),
+            }
+        }
+        other => panic!("Expected Binary expression, got {:?}", other),
+    }
+}
+
+#[test]
+fn test_parse_after_operator() {
+    let source = r#"f.resolved_at after "2025-01-01T00:00:00Z""#;
+    let result = parse_expression_from_str(source);
+
+    assert!(
+        result.is_ok(),
+        "Failed to parse after operator: {:?}",
+        result.err()
+    );
+
+    match result.unwrap() {
+        Expression::Binary { op, left, right } => {
+            assert_eq!(op, BinaryOp::After);
+
+            // Verify left side is member access
+            match *left {
+                Expression::MemberAccess { object, member } => {
+                    assert_eq!(object, "f");
+                    assert_eq!(member, "resolved_at");
+                }
+                other => panic!("Expected MemberAccess on left, got {:?}", other),
+            }
+
+            // Verify right side is time literal
+            match *right {
+                Expression::TimeLiteral(timestamp) => {
+                    assert_eq!(timestamp, "2025-01-01T00:00:00Z");
+                }
+                other => panic!("Expected TimeLiteral on right, got {:?}", other),
+            }
+        }
+        other => panic!("Expected Binary expression, got {:?}", other),
+    }
+}
+
+#[test]
+fn test_parse_during_operator() {
+    let source = r#"f.timestamp during interval("09:00", "17:00")"#;
+    let result = parse_expression_from_str(source);
+
+    assert!(
+        result.is_ok(),
+        "Failed to parse during operator: {:?}",
+        result.err()
+    );
+
+    match result.unwrap() {
+        Expression::Binary { op, left, right } => {
+            assert_eq!(op, BinaryOp::During);
+
+            // Verify left side is member access
+            match *left {
+                Expression::MemberAccess { object, member } => {
+                    assert_eq!(object, "f");
+                    assert_eq!(member, "timestamp");
+                }
+                other => panic!("Expected MemberAccess on left, got {:?}", other),
+            }
+
+            // Verify right side is interval literal
+            match *right {
+                Expression::IntervalLiteral { start, end } => {
+                    assert_eq!(start, "09:00");
+                    assert_eq!(end, "17:00");
+                }
+                other => panic!("Expected IntervalLiteral on right, got {:?}", other),
+            }
+        }
+        other => panic!("Expected Binary expression, got {:?}", other),
+    }
+}
+
+#[test]
+fn test_temporal_expression_display() {
+    let time_expr = Expression::TimeLiteral("2025-12-31T23:59:59Z".to_string());
+    assert_eq!(format!("{}", time_expr), r#""2025-12-31T23:59:59Z""#);
+
+    let interval_expr = Expression::IntervalLiteral {
+        start: "09:00".to_string(),
+        end: "17:00".to_string(),
+    };
+    assert_eq!(
+        format!("{}", interval_expr),
+        r#"interval("09:00", "17:00")"#
+    );
+}
+
+#[test]
+fn test_temporal_operators_display() {
+    assert_eq!(format!("{}", BinaryOp::Before), "BEFORE");
+    assert_eq!(format!("{}", BinaryOp::After), "AFTER");
+    assert_eq!(format!("{}", BinaryOp::During), "DURING");
+}
+
+#[test]
+fn test_complex_temporal_policy() {
+    // Test a more complex policy with temporal logic
+    let source = r#"(f.created_at before "2025-12-31T23:59:59Z") and (f.timestamp during interval("09:00", "17:00"))"#;
+    let result = parse_expression_from_str(source);
+
+    assert!(
+        result.is_ok(),
+        "Failed to parse complex temporal policy: {:?}",
+        result.err()
+    );
+
+    // Just verify it parses successfully
+    match result.unwrap() {
+        Expression::Binary {
+            op: BinaryOp::And, ..
+        } => {
+            // Success - we have an AND expression with temporal sub-expressions
+        }
+        other => panic!("Expected AND expression, got {:?}", other),
+    }
+}

package/domainforge-core/tests/three_valued_quantifiers_tests.rs

@@ -0,0 +1,164 @@
+use domainforge_core::{
+    policy::{BinaryOp, Expression, Policy, Quantifier},
+    primitives::{Entity, Flow, Resource},
+    units::unit_from_string,
+    Graph,
+};
+use rust_decimal::Decimal;
+use std::str::FromStr;
+
+fn build_graph_with_optional_flow_attribute() -> Graph {
+    let mut graph = Graph::new();
+
+    let warehouse = Entity::new_with_namespace("Warehouse", "default");
+    let factory = Entity::new_with_namespace("Factory", "default");
+    let product = Resource::new_with_namespace("Widget", unit_from_string("units"), "default");
+
+    let warehouse_id = warehouse.id().clone();
+    let factory_id = factory.id().clone();
+    let product_id = product.id().clone();
+
+    graph.add_entity(warehouse).unwrap();
+    graph.add_entity(factory).unwrap();
+    graph.add_resource(product).unwrap();
+
+    // Flow with missing optional attribute "tag"
+    let mut flow1 = Flow::new(
+        product_id.clone(),
+        warehouse_id.clone(),
+        factory_id.clone(),
+        Decimal::from_str("100").unwrap(),
+    );
+    // Explicitly set tag to Null so substitution finds the field and the evaluator treats it as NULL
+    flow1.set_attribute("tag", serde_json::Value::Null);
+    graph.add_flow(flow1).unwrap();
+
+    // Flow with tag present
+    let mut flow2 = Flow::new(
+        product_id.clone(),
+        warehouse_id.clone(),
+        factory_id.clone(),
+        Decimal::from_str("200").unwrap(),
+    );
+    flow2.set_attribute("tag", serde_json::json!("X"));
+    graph.add_flow(flow2).unwrap();
+
+    graph
+}
+
+#[test]
+fn test_forall_with_nulls_results_in_unknown() {
+    let graph = build_graph_with_optional_flow_attribute();
+
+    // ForAll f in flows: f.tag == "X" -> one flow has tag X, one has null -> overall Unknown (Null)
+    let expr = Expression::quantifier(
+        Quantifier::ForAll,
+        "flow",
+        Expression::variable("flows"),
+        Expression::comparison("flow.tag", "==", "X").unwrap(),
+    );
+
+    let policy = Policy::new("ForAll TagX", expr);
+    let result = policy.evaluate(&graph).unwrap();
+
+    // Backward-compatible boolean => false when Unknown
+    assert!(!result.is_satisfied);
+    // New tri-state shows None for Unknown
+    assert_eq!(result.is_satisfied_tristate, None);
+    // Violations should indicate Unknown with severity derived from modality
+    assert_eq!(result.violations.len(), 1);
+    assert_eq!(
+        result.violations[0].severity,
+        domainforge_core::policy::Severity::Error
+    );
+}
+
+#[test]
+fn test_exists_with_true_and_null_returns_true() {
+    let graph = build_graph_with_optional_flow_attribute();
+
+    // Exists f in flows: f.tag == "X" -> one flow True, one Null -> Should be True
+    let expr = Expression::quantifier(
+        Quantifier::Exists,
+        "flow",
+        Expression::variable("flows"),
+        Expression::comparison("flow.tag", "==", "X").unwrap(),
+    );
+
+    let policy = Policy::new("Exists TagX", expr);
+    let result = policy.evaluate(&graph).unwrap();
+    assert!(result.is_satisfied);
+    assert_eq!(result.is_satisfied_tristate, Some(true));
+    assert_eq!(result.violations.len(), 0);
+}
+
+#[test]
+fn test_exists_unique_with_duplicate_true_returns_false() {
+    let graph = build_graph_with_optional_flow_attribute();
+
+    // Add a third flow which has tag "X" to create duplicate true
+    let mut graph2 = graph.clone();
+    let mut flow3 = Flow::new(
+        graph2.all_resources()[0].id().clone(),
+        graph2.all_entities()[0].id().clone(),
+        graph2.all_entities()[1].id().clone(),
+        Decimal::from_str("300").unwrap(),
+    );
+    flow3.set_attribute("tag", serde_json::json!("X"));
+    graph2.add_flow(flow3).unwrap();
+
+    // ExistsUnique should now be false since more than 1 true
+    let expr = Expression::quantifier(
+        Quantifier::ExistsUnique,
+        "flow",
+        Expression::variable("flows"),
+        Expression::comparison("flow.tag", "==", "X").unwrap(),
+    );
+
+    let policy = Policy::new("ExistsUnique TagX", expr);
+    let result = policy.evaluate(&graph2).unwrap();
+    assert!(!result.is_satisfied);
+    assert_eq!(result.is_satisfied_tristate, Some(false));
+}
+
+#[test]
+fn test_nested_null_propagation_and_forall_unknown() {
+    let mut graph = build_graph_with_optional_flow_attribute();
+
+    // Update flows: set tag Null and quantities positive so AND of (tag == X) and (quantity > 0)
+    // yields Null for tag==X and True for quantity -> overall Null per AND when no False.
+    // The graph contains one flow with tag Null and one with tag "X" and quantity >0 so ForAll yields False.
+    // For this test, we modify both flows to have tag Null to force Unknown.
+    let flow_id2 = graph.all_flows()[1].id().clone();
+    // Update attributes by finding flows via graph.get_flow
+    if let Some(mut f2) = graph.get_flow(&flow_id2).cloned() {
+        f2.set_attribute("tag", serde_json::Value::Null);
+        // replace flow in graph
+        let _ = graph.remove_flow(&flow_id2);
+        graph.add_flow(f2).unwrap();
+    }
+
+    let expr = Expression::quantifier(
+        Quantifier::ForAll,
+        "flow",
+        Expression::variable("flows"),
+        Expression::binary(
+            BinaryOp::And,
+            Expression::comparison("flow.tag", "==", "X").unwrap(),
+            Expression::comparison("flow.quantity", ">", 0).unwrap(),
+        ),
+    );
+
+    let policy = Policy::new("Nested Null ForAll", expr);
+    let result = policy.evaluate(&graph).unwrap();
+    // All flows have Null tag; equality is Null -> AND is Null -> ForAll over Nulls yields Null
+    assert_eq!(result.is_satisfied_tristate, None);
+    assert!(
+        !result.violations.is_empty(),
+        "Expected at least one violation when evaluation is NULL"
+    );
+    assert_eq!(
+        result.violations[0].severity,
+        domainforge_core::policy::Severity::Error
+    );
+}

package/domainforge-core/tests/turtle_entity_export_tests.rs

@@ -0,0 +1,38 @@
+use domainforge_core::primitives::Entity;
+use domainforge_core::{kg::KnowledgeGraph, Graph};
+
+#[test]
+fn test_entity_name_with_quotes_exports_correctly() {
+    let mut graph = Graph::new();
+    let entity = Entity::new_with_namespace(r#"Entity "With Quotes""#, "test");
+    graph.add_entity(entity).unwrap();
+
+    let kg = KnowledgeGraph::from_graph(&graph).unwrap();
+    let turtle = kg.to_turtle();
+
+    assert!(turtle.contains(r#"rdfs:label "Entity \"With Quotes\""#));
+}
+
+#[test]
+fn test_entity_namespace_with_newline_exports_correctly() {
+    let mut graph = Graph::new();
+    let entity = Entity::new_with_namespace("TestEntity", "namespace\nwith\nnewlines");
+    graph.add_entity(entity).unwrap();
+
+    let kg = KnowledgeGraph::from_graph(&graph).unwrap();
+    let turtle = kg.to_turtle();
+
+    assert!(turtle.contains(r#"sea:namespace "namespace\nwith\nnewlines""#));
+}
+
+#[test]
+fn test_entity_with_backslashes_exports_correctly() {
+    let mut graph = Graph::new();
+    let entity = Entity::new_with_namespace(r#"Entity\With\Backslashes"#, "default".to_string());
+    graph.add_entity(entity).unwrap();
+
+    let kg = KnowledgeGraph::from_graph(&graph).unwrap();
+    let turtle = kg.to_turtle();
+
+    assert!(turtle.contains(r#"rdfs:label "Entity\\With\\Backslashes""#));
+}

package/domainforge-core/tests/turtle_escaping_tests.rs

@@ -0,0 +1,53 @@
+#[cfg(test)]
+mod turtle_escaping_tests {
+    use domainforge_core::kg::KnowledgeGraph;
+
+    #[test]
+    fn test_escape_backslash() {
+        let input = r#"Name\With\Backslash"#;
+        let escaped = KnowledgeGraph::escape_turtle_literal(input);
+        assert_eq!(escaped, r#"Name\\With\\Backslash"#);
+    }
+
+    #[test]
+    fn test_escape_double_quote() {
+        let input = r#"Name"With"Quotes"#;
+        let escaped = KnowledgeGraph::escape_turtle_literal(input);
+        assert_eq!(escaped, r#"Name\"With\"Quotes"#);
+    }
+
+    #[test]
+    fn test_escape_newline() {
+        let input = "Name\nWith\nNewlines";
+        let escaped = KnowledgeGraph::escape_turtle_literal(input);
+        assert_eq!(escaped, r#"Name\nWith\nNewlines"#);
+    }
+
+    #[test]
+    fn test_escape_carriage_return() {
+        let input = "Name\rWith\rReturns";
+        let escaped = KnowledgeGraph::escape_turtle_literal(input);
+        assert_eq!(escaped, r#"Name\rWith\rReturns"#);
+    }
+
+    #[test]
+    fn test_escape_tab() {
+        let input = "Name\tWith\tTabs";
+        let escaped = KnowledgeGraph::escape_turtle_literal(input);
+        assert_eq!(escaped, r#"Name\tWith\tTabs"#);
+    }
+
+    #[test]
+    fn test_escape_combined_characters() {
+        let input = "Complex\\\"Name\n\r\t";
+        let escaped = KnowledgeGraph::escape_turtle_literal(input);
+        assert_eq!(escaped, r#"Complex\\\"Name\n\r\t"#);
+    }
+
+    #[test]
+    fn test_no_escape_needed() {
+        let input = "SimpleNameWithoutSpecialChars";
+        let escaped = KnowledgeGraph::escape_turtle_literal(input);
+        assert_eq!(escaped, "SimpleNameWithoutSpecialChars");
+    }
+}

package/domainforge-core/tests/turtle_resource_export_tests.rs

@@ -0,0 +1,34 @@
+#[cfg(test)]
+mod turtle_resource_export_tests {
+    use domainforge_core::primitives::Resource;
+    use domainforge_core::{kg::KnowledgeGraph, unit_from_string, Graph};
+
+    #[test]
+    fn test_resource_name_with_special_chars_exports_correctly() {
+        let mut graph = Graph::new();
+        let resource = Resource::new_with_namespace(
+            "Camera\n(High\tQuality)",
+            unit_from_string("units"),
+            "test",
+        );
+        graph.add_resource(resource).unwrap();
+
+        let kg = KnowledgeGraph::from_graph(&graph).unwrap();
+        let turtle = kg.to_turtle();
+
+        assert!(turtle.contains(r#"rdfs:label "Camera\n(High\tQuality)""#));
+    }
+
+    #[test]
+    fn test_resource_unit_display_format() {
+        let mut graph = Graph::new();
+        let resource =
+            Resource::new_with_namespace("Steel", unit_from_string("kg"), "default".to_string());
+        graph.add_resource(resource).unwrap();
+
+        let kg = KnowledgeGraph::from_graph(&graph).unwrap();
+        let turtle = kg.to_turtle();
+
+        assert!(turtle.contains(r#"sea:unit "kg""#));
+    }
+}

package/domainforge-core/tests/type_inference_tests.rs

@@ -0,0 +1,40 @@
+use domainforge_core::policy::type_inference::{check_comparison, ExprType};
+use domainforge_core::units::Dimension;
+
+#[test]
+fn test_check_comparison_valid() {
+    let q1 = ExprType::Quantity {
+        dimension: Dimension::Mass,
+    };
+    let q2 = ExprType::Quantity {
+        dimension: Dimension::Mass,
+    };
+    assert!(check_comparison(&q1, &q2).is_ok());
+
+    let n1 = ExprType::Numeric;
+    let n2 = ExprType::Numeric;
+    assert!(check_comparison(&n1, &n2).is_ok());
+}
+
+#[test]
+fn test_check_comparison_unit_mismatch() {
+    let q1 = ExprType::Quantity {
+        dimension: Dimension::Mass,
+    };
+    let q2 = ExprType::Quantity {
+        dimension: Dimension::Length,
+    };
+    let result = check_comparison(&q1, &q2);
+    assert!(result.is_err());
+    // Check error message content if possible, or just that it matches expected variant
+}
+
+#[test]
+fn test_check_comparison_mixed_types() {
+    let q = ExprType::Quantity {
+        dimension: Dimension::Mass,
+    };
+    let n = ExprType::Numeric;
+    assert!(check_comparison(&q, &n).is_err());
+    assert!(check_comparison(&n, &q).is_err());
+}