domainforge 0.13.0

package/domainforge-core/tests/phase_14_determinism_tests.rs

@@ -0,0 +1,166 @@
+use domainforge_core::graph::Graph;
+use domainforge_core::policy::{Expression, Policy, PolicyKind};
+use domainforge_core::primitives::{Entity, Flow, Resource};
+use domainforge_core::units::unit_from_string;
+use rust_decimal::Decimal;
+
+#[test]
+fn test_flow_iteration_order_stable() {
+    let mut graph = Graph::new();
+
+    let entity1 = Entity::new_with_namespace("Supplier", "supply_chain");
+    let entity2 = Entity::new_with_namespace("Manufacturer", "supply_chain");
+    let entity3 = Entity::new_with_namespace("Distributor", "supply_chain");
+
+    let resource = Resource::new_with_namespace("Parts", unit_from_string("kg"), "supply_chain");
+
+    let entity1_id = entity1.id().clone();
+    let entity2_id = entity2.id().clone();
+    let entity3_id = entity3.id().clone();
+    let resource_id = resource.id().clone();
+
+    graph.add_entity(entity1).unwrap();
+    graph.add_entity(entity2).unwrap();
+    graph.add_entity(entity3).unwrap();
+    graph.add_resource(resource).unwrap();
+
+    let flow1 = Flow::new(
+        resource_id.clone(),
+        entity1_id.clone(),
+        entity2_id.clone(),
+        Decimal::new(100, 0),
+    );
+    let flow2 = Flow::new(
+        resource_id.clone(),
+        entity2_id.clone(),
+        entity3_id.clone(),
+        Decimal::new(200, 0),
+    );
+    let flow3 = Flow::new(resource_id, entity1_id, entity3_id, Decimal::new(150, 0));
+
+    graph.add_flow(flow1.clone()).unwrap();
+    graph.add_flow(flow2.clone()).unwrap();
+    graph.add_flow(flow3.clone()).unwrap();
+
+    let flows1: Vec<_> = graph.all_flows().iter().map(|f| f.id().clone()).collect();
+    let flows2: Vec<_> = graph.all_flows().iter().map(|f| f.id().clone()).collect();
+
+    assert_eq!(flows1, flows2, "Flow iteration order must be stable");
+}
+
+#[test]
+fn test_entity_iteration_order_stable() {
+    let mut graph = Graph::new();
+
+    let entity1 = Entity::new_with_namespace("Entity_A", "test");
+    let entity2 = Entity::new_with_namespace("Entity_B", "test");
+    let entity3 = Entity::new_with_namespace("Entity_C", "test");
+
+    graph.add_entity(entity1.clone()).unwrap();
+    graph.add_entity(entity2.clone()).unwrap();
+    graph.add_entity(entity3.clone()).unwrap();
+
+    let entities1: Vec<_> = graph
+        .all_entities()
+        .iter()
+        .map(|e| e.id().clone())
+        .collect();
+    let entities2: Vec<_> = graph
+        .all_entities()
+        .iter()
+        .map(|e| e.id().clone())
+        .collect();
+
+    assert_eq!(
+        entities1, entities2,
+        "Entity iteration order must be stable"
+    );
+}
+
+#[test]
+fn test_resource_iteration_order_stable() {
+    let mut graph = Graph::new();
+
+    let resource1 = Resource::new_with_namespace("Resource_A", unit_from_string("units"), "test");
+    let resource2 = Resource::new_with_namespace("Resource_B", unit_from_string("units"), "test");
+    let resource3 = Resource::new_with_namespace("Resource_C", unit_from_string("units"), "test");
+
+    graph.add_resource(resource1.clone()).unwrap();
+    graph.add_resource(resource2.clone()).unwrap();
+    graph.add_resource(resource3.clone()).unwrap();
+
+    let resources1: Vec<_> = graph
+        .all_resources()
+        .iter()
+        .map(|r| r.id().clone())
+        .collect();
+    let resources2: Vec<_> = graph
+        .all_resources()
+        .iter()
+        .map(|r| r.id().clone())
+        .collect();
+
+    assert_eq!(
+        resources1, resources2,
+        "Resource iteration order must be stable"
+    );
+}
+
+#[test]
+fn test_policy_kind_constraint() {
+    let expr = Expression::Literal(serde_json::json!(true));
+    let policy = Policy::new("test_policy", expr).with_kind(PolicyKind::Constraint);
+
+    assert_eq!(policy.kind(), &PolicyKind::Constraint);
+}
+
+#[test]
+fn test_policy_kind_derivation() {
+    let expr = Expression::Literal(serde_json::json!(true));
+    let policy = Policy::new("test_policy", expr).with_kind(PolicyKind::Derivation);
+
+    assert_eq!(policy.kind(), &PolicyKind::Derivation);
+}
+
+#[test]
+fn test_policy_kind_obligation() {
+    let expr = Expression::Literal(serde_json::json!(true));
+    let policy = Policy::new("test_policy", expr).with_kind(PolicyKind::Obligation);
+
+    assert_eq!(policy.kind(), &PolicyKind::Obligation);
+}
+
+#[test]
+fn test_policy_priority_ordering() {
+    let expr1 = Expression::Literal(serde_json::json!(true));
+    let expr2 = Expression::Literal(serde_json::json!(true));
+    let expr3 = Expression::Literal(serde_json::json!(true));
+
+    let policy1 = Policy::new("policy_a", expr1).with_priority(10);
+    let policy2 = Policy::new("policy_b", expr2).with_priority(5);
+    let policy3 = Policy::new("policy_c", expr3).with_priority(20);
+
+    let mut policies = [policy1, policy2, policy3];
+    // sort the array in-place via a mutable slice
+    policies[..].sort_by_key(|p| p.priority);
+
+    assert_eq!(policies[0].name, "policy_b");
+    assert_eq!(policies[1].name, "policy_a");
+    assert_eq!(policies[2].name, "policy_c");
+}
+
+#[test]
+fn test_policy_evaluation_is_pure() {
+    let mut graph = Graph::new();
+    let entity = Entity::new_with_namespace("TestEntity", "test");
+    graph.add_entity(entity).unwrap();
+
+    let expr = Expression::Literal(serde_json::json!(true));
+    let policy = Policy::new("pure_policy", expr);
+
+    let result1 = policy.evaluate(&graph).unwrap();
+    let result2 = policy.evaluate(&graph).unwrap();
+
+    assert_eq!(result1.is_satisfied, result2.is_satisfied);
+    assert_eq!(result1.violations.len(), result2.violations.len());
+}

package/domainforge-core/tests/phase_15_validation_error_tests.rs

@@ -0,0 +1,136 @@
+use domainforge_core::units::Dimension;
+use domainforge_core::validation_error::ValidationError;
+
+#[test]
+fn test_syntax_error_with_range() {
+    let error = ValidationError::syntax_error_with_range("Unexpected token", 10, 5, 10, 12);
+
+    let message = format!("{}", error);
+    assert!(message.contains("10:5 to 10:12"));
+    assert!(message.contains("Unexpected token"));
+}
+
+#[test]
+fn test_unit_error_with_suggestion() {
+    let error = ValidationError::unit_error(Dimension::Mass, Dimension::Volume, "Flow line 42")
+        .with_suggestion("Convert volume to mass using density, or use compatible units");
+
+    let message = format!("{}", error);
+    assert!(message.contains("Unit error"));
+    assert!(message.contains("Mass"));
+    assert!(message.contains("Volume"));
+    assert!(message.contains("Suggestion: Convert volume to mass"));
+}
+
+#[test]
+fn test_scope_error() {
+    let error = ValidationError::scope_error(
+        "quantity",
+        vec!["Flow".to_string(), "Instance".to_string()],
+        "Policy line 15",
+    )
+    .with_suggestion("Use 'flow.quantity' to access the quantity field");
+
+    let message = format!("{}", error);
+    assert!(message.contains("Scope error"));
+    assert!(message.contains("quantity"));
+    assert!(message.contains("Available in: Flow, Instance"));
+    assert!(message.contains("Suggestion: Use 'flow.quantity'"));
+}
+
+#[test]
+fn test_determinism_error() {
+    let error = ValidationError::determinism_error(
+        "Random function used in policy evaluation",
+        "Remove random() calls and use deterministic expressions",
+    );
+
+    let message = format!("{}", error);
+    assert!(message.contains("Determinism error"));
+    assert!(message.contains("Random function"));
+    assert!(message.contains("Hint: Remove random()"));
+}
+
+#[test]
+fn test_undefined_reference_with_suggestion() {
+    let error = ValidationError::undefined_reference("Entity", "Supplier", "Flow line 8")
+        .with_suggestion("Did you mean 'SupplierCorp'?");
+
+    let message = format!("{}", error);
+    assert!(message.contains("Undefined Entity"));
+    assert!(message.contains("Supplier"));
+    assert!(message.contains("Flow line 8"));
+    assert!(message.contains("Suggestion: Did you mean"));
+}
+
+#[test]
+fn test_duplicate_declaration() {
+    let error = ValidationError::duplicate_declaration("MyEntity", "line 10", "line 25");
+
+    let message = format!("{}", error);
+    assert!(message.contains("Duplicate declaration"));
+    assert!(message.contains("MyEntity"));
+    assert!(message.contains("first at line 10"));
+    assert!(message.contains("duplicate at line 25"));
+}
+
+#[test]
+fn test_type_error_with_types() {
+    let error = ValidationError::type_error(
+        "Cannot compare string with number",
+        "Policy expression line 5",
+    )
+    .with_types("Number", "String")
+    .with_suggestion("Cast the string to a number or compare with another string");
+
+    let message = format!("{}", error);
+    assert!(message.contains("Type error"));
+    assert!(message.contains("expected Number, found String"));
+    assert!(message.contains("Suggestion: Cast the string"));
+}
+
+#[test]
+fn test_invalid_expression_with_suggestion() {
+    let error = ValidationError::invalid_expression("Division by zero", "Flow calculation line 12")
+        .with_suggestion("Ensure denominator is never zero");
+
+    let message = format!("{}", error);
+    assert!(message.contains("Invalid expression"));
+    assert!(message.contains("Division by zero"));
+    assert!(message.contains("Suggestion: Ensure denominator"));
+}
+
+#[test]
+fn test_unit_error_dimensions() {
+    let error =
+        ValidationError::unit_error(Dimension::Length, Dimension::Mass, "Resource conversion");
+
+    let message = format!("{}", error);
+    assert!(message.contains("Length"));
+    assert!(message.contains("Mass"));
+}
+
+#[test]
+fn test_scope_error_empty_available() {
+    let error = ValidationError::scope_error("unknown_var", vec![], "Policy line 20");
+
+    let message = format!("{}", error);
+    assert!(message.contains("Scope error"));
+    assert!(message.contains("unknown_var"));
+    assert!(!message.contains("Available in:"));
+}
+
+#[test]
+fn test_error_display_formatting() {
+    let errors = vec![
+        ValidationError::syntax_error("Missing semicolon", 5, 10),
+        ValidationError::type_error("Type mismatch", "line 3"),
+        ValidationError::determinism_error("Non-deterministic", "Use fixed values"),
+    ];
+
+    for error in errors {
+        let message = format!("{}", error);
+        assert!(!message.is_empty());
+        assert!(message.len() > 10);
+    }
+}

package/domainforge-core/tests/phase_16_unicode_tests.rs

@@ -0,0 +1,248 @@
+use domainforge_core::parser::{parse, unescape_string};
+
+#[test]
+fn test_unicode_entity_names() {
+    let source = r#"
+        Entity "Müller GmbH" in germany
+        Entity "北京公司" in china
+        Entity "Société Générale" in france
+    "#;
+
+    let ast = parse(source);
+    assert!(
+        ast.is_ok(),
+        "Should parse Unicode entity names: {:?}",
+        ast.err()
+    );
+}
+
+#[test]
+fn test_unicode_resource_names() {
+    let source = r#"
+        Resource "Produits" kg in france
+        Resource "製品" units in japan
+        Resource "Продукция" liters in russia
+    "#;
+
+    let ast = parse(source);
+    assert!(
+        ast.is_ok(),
+        "Should parse Unicode resource names: {:?}",
+        ast.err()
+    );
+}
+
+#[test]
+fn test_unicode_identifiers_in_policies() {
+    let source = r#"
+        Entity "Company" in business
+        Policy règle_française as: true
+    "#;
+
+    let ast = parse(source);
+    assert!(
+        ast.is_ok(),
+        "Should parse Unicode identifiers: {:?}",
+        ast.err()
+    );
+}
+
+#[test]
+fn test_escape_sequence_backslash() {
+    let result = unescape_string(r"path\\to\\file");
+    assert_eq!(result.unwrap(), r"path\to\file");
+}
+
+#[test]
+fn test_escape_sequence_quote() {
+    let result = unescape_string(r#"Company with \"Quotes\""#);
+    assert_eq!(result.unwrap(), r#"Company with "Quotes""#);
+}
+
+#[test]
+fn test_escape_sequence_newline() {
+    let result = unescape_string(r"Line1\nLine2");
+    assert_eq!(result.unwrap(), "Line1\nLine2");
+}
+
+#[test]
+fn test_escape_sequence_tab() {
+    let result = unescape_string(r"Column1\tColumn2");
+    assert_eq!(result.unwrap(), "Column1\tColumn2");
+}
+
+#[test]
+fn test_escape_sequence_carriage_return() {
+    let result = unescape_string(r"Text\rMore");
+    assert_eq!(result.unwrap(), "Text\rMore");
+}
+
+#[test]
+fn test_escape_sequence_unicode() {
+    let result = unescape_string(r"\u{1F600}");
+    assert_eq!(result.unwrap(), "😀");
+
+    let result = unescape_string(r"\u{4E2D}");
+    assert_eq!(result.unwrap(), "中");
+
+    let result = unescape_string(r"\u{41}");
+    assert_eq!(result.unwrap(), "A");
+}
+
+#[test]
+fn test_escape_sequences_in_entity() {
+    let source = r#"
+        Entity "Company with \"Quotes\"" in test
+    "#;
+
+    let ast = parse(source);
+    assert!(
+        ast.is_ok(),
+        "Should parse escape sequences: {:?}",
+        ast.err()
+    );
+}
+
+#[test]
+fn test_multiline_string_literal() {
+    let source = r####"
+        Policy long_description as: """
+        This is a multi-line
+        policy description
+        that spans multiple lines
+        """ contains "multi-line"
+    "####;
+
+    let ast = parse(source);
+    assert!(
+        ast.is_ok(),
+        "Should parse multi-line strings: {:?}",
+        ast.err()
+    );
+}
+
+#[test]
+fn test_multiline_string_in_resource() {
+    let source = r####"
+        Resource """Complex
+        Resource
+        Name""" kg
+    "####;
+
+    let ast = parse(source);
+    assert!(
+        ast.is_ok(),
+        "Should parse multi-line resource names: {:?}",
+        ast.err()
+    );
+}
+
+#[test]
+fn test_mixed_unicode_and_escapes() {
+    let result = unescape_string(r"日本\n製品\t\u{1F1EF}\u{1F1F5}");
+    assert_eq!(result.unwrap(), "日本\n製品\t🇯🇵");
+}
+
+#[test]
+fn test_complex_unicode_entities() {
+    let source = r#"
+        Entity "Москва" in russia
+        Entity "القاهرة" in egypt
+        Entity "서울" in korea
+        Entity "Αθήνα" in greece
+    "#;
+
+    let ast = parse(source);
+    assert!(
+        ast.is_ok(),
+        "Should parse complex Unicode names: {:?}",
+        ast.err()
+    );
+}
+
+#[test]
+fn test_unicode_emoji_in_names() {
+    let source = r#"
+        Entity "Company 🏢" in tech
+        Resource "Product 📦" units in warehouse
+    "#;
+
+    let ast = parse(source);
+    assert!(ast.is_ok(), "Should parse emoji in names: {:?}", ast.err());
+}
+
+#[test]
+fn test_all_escape_sequences_combined() {
+    let result = unescape_string(r#"Line 1\nLine 2\tTabbed\r\"Quoted\"\\\u{2764}"#);
+    assert_eq!(result.unwrap(), "Line 1\nLine 2\tTabbed\r\"Quoted\"\\❤");
+}
+
+#[test]
+fn test_multiline_preserves_content() {
+    let source = r####"
+        Policy description as: """
+First line
+    Indented line
+Last line
+        """ = """
+First line
+    Indented line
+Last line
+        """
+    "####;
+
+    let ast = parse(source);
+    assert!(
+        ast.is_ok(),
+        "Should parse and preserve multiline content: {:?}",
+        ast.err()
+    );
+}
+
+#[test]
+fn test_empty_multiline_string() {
+    let source = r####"
+        Policy empty as: """"""
+    "####;
+
+    let ast = parse(source);
+    assert!(
+        ast.is_ok(),
+        "Should parse empty multiline string: {:?}",
+        ast.err()
+    );
+}
+
+#[test]
+fn test_unicode_in_flow() {
+    let source = r#"
+        Entity "发送方" in china
+        Entity "接收方" in china
+        Resource "资源" kg in china
+        Flow "资源" from "发送方" to "接收方" quantity 100
+    "#;
+
+    let ast = parse(source);
+    assert!(ast.is_ok(), "Should parse Unicode in flow: {:?}", ast.err());
+}
+
+#[test]
+fn test_rtl_text_support() {
+    let source = r#"
+        Entity "الشركة" in middle_east
+        Resource "المنتج" units
+    "#;
+
+    let ast = parse(source);
+    assert!(ast.is_ok(), "Should parse RTL text: {:?}", ast.err());
+}
+
+#[test]
+fn test_mixed_scripts() {
+    let source = r#"
+        Entity "АБВ-ABC-αβγ-123" in test
+    "#;
+
+    let ast = parse(source);
+    assert!(ast.is_ok(), "Should parse mixed scripts: {:?}", ast.err());
+}