domainforge 0.13.0

package/domainforge-core/tests/calm_round_trip_tests.rs

@@ -0,0 +1,283 @@
+use domainforge_core::calm::{export, import};
+use domainforge_core::policy::Expression;
+use domainforge_core::policy::Policy;
+use domainforge_core::primitives::{Entity, Flow, Resource, ResourceInstance};
+use domainforge_core::units::unit_from_string;
+use domainforge_core::Graph;
+use rust_decimal::Decimal;
+use serde_json::Value;
+
+#[test]
+fn test_round_trip_simple_graph() {
+    let mut original_graph = Graph::new();
+
+    let entity = Entity::new_with_namespace("Warehouse".to_string(), "logistics".to_string());
+    original_graph.add_entity(entity).unwrap();
+
+    let calm_json = export(&original_graph).unwrap();
+    let imported_graph = import(calm_json).unwrap();
+
+    assert_eq!(original_graph.entity_count(), imported_graph.entity_count());
+
+    let imported_entity = imported_graph.all_entities()[0];
+    assert_eq!(imported_entity.name(), "Warehouse");
+    assert_eq!(imported_entity.namespace(), "logistics");
+}
+
+#[test]
+fn test_round_trip_complex_graph() {
+    let mut original_graph = Graph::new();
+
+    let warehouse = Entity::new_with_namespace("Warehouse A".to_string(), "logistics".to_string());
+    let factory = Entity::new_with_namespace("Factory B".to_string(), "manufacturing".to_string());
+    let cameras = Resource::new_with_namespace(
+        "Cameras".to_string(),
+        unit_from_string("units"),
+        "products".to_string(),
+    );
+
+    let warehouse_id = warehouse.id().clone();
+    let factory_id = factory.id().clone();
+    let cameras_id = cameras.id().clone();
+
+    original_graph.add_entity(warehouse).unwrap();
+    original_graph.add_entity(factory).unwrap();
+    original_graph.add_resource(cameras).unwrap();
+
+    let flow = Flow::new(
+        cameras_id.clone(),
+        warehouse_id.clone(),
+        factory_id.clone(),
+        Decimal::from(100),
+    );
+    original_graph.add_flow(flow).unwrap();
+
+    let calm_json = export(&original_graph).unwrap();
+
+    let imported_graph = import(calm_json).unwrap();
+
+    assert_eq!(original_graph.entity_count(), imported_graph.entity_count());
+    assert_eq!(
+        original_graph.resource_count(),
+        imported_graph.resource_count()
+    );
+    assert_eq!(original_graph.flow_count(), imported_graph.flow_count());
+
+    let entities = imported_graph.all_entities();
+    let entity_names: Vec<&str> = entities.iter().map(|e| e.name()).collect();
+    assert!(entity_names.contains(&"Warehouse A"));
+    assert!(entity_names.contains(&"Factory B"));
+
+    let resources = imported_graph.all_resources();
+    assert_eq!(resources.len(), 1);
+    assert_eq!(resources[0].name(), "Cameras");
+    assert_eq!(resources[0].unit().symbol(), "units");
+
+    let flows = imported_graph.all_flows();
+    assert_eq!(flows.len(), 1);
+    assert_eq!(flows[0].quantity().to_string(), "100");
+}
+
+#[test]
+fn test_round_trip_with_instances() {
+    let mut original_graph = Graph::new();
+
+    let warehouse = Entity::new_with_namespace("Warehouse".to_string(), "default".to_string());
+    let cameras = Resource::new_with_namespace(
+        "Cameras".to_string(),
+        unit_from_string("units"),
+        "default".to_string(),
+    );
+
+    let warehouse_id = warehouse.id().clone();
+    let cameras_id = cameras.id().clone();
+
+    original_graph.add_entity(warehouse).unwrap();
+    original_graph.add_resource(cameras).unwrap();
+
+    let instance = ResourceInstance::new(cameras_id.clone(), warehouse_id.clone());
+    original_graph.add_instance(instance).unwrap();
+
+    let calm_json = export(&original_graph).unwrap();
+
+    let imported_graph = import(calm_json).unwrap();
+
+    assert_eq!(original_graph.entity_count(), imported_graph.entity_count());
+    assert_eq!(
+        original_graph.resource_count(),
+        imported_graph.resource_count()
+    );
+    assert_eq!(
+        original_graph.instance_count(),
+        imported_graph.instance_count()
+    );
+}
+
+#[test]
+fn test_round_trip_preserves_metadata() {
+    let mut original_graph = Graph::new();
+
+    let entity = Entity::new_with_namespace("TestEntity".to_string(), "default".to_string());
+    original_graph.add_entity(entity).unwrap();
+
+    let calm_json = export(&original_graph).unwrap();
+
+    assert_eq!(calm_json["version"], "2.0");
+    assert_eq!(calm_json["metadata"]["sea:exported"], true);
+    assert_eq!(
+        calm_json["metadata"]["sea:version"],
+        domainforge_core::VERSION
+    );
+    assert!(calm_json["metadata"]["sea:timestamp"].is_string());
+
+    let imported_graph = import(calm_json).unwrap();
+
+    assert_eq!(original_graph.entity_count(), imported_graph.entity_count());
+}
+
+#[test]
+fn test_export_structure_compliance() {
+    let mut graph = Graph::new();
+
+    let entity = Entity::new_with_namespace("Test".to_string(), "default".to_string());
+    graph.add_entity(entity).unwrap();
+
+    let calm_json = export(&graph).unwrap();
+
+    assert!(calm_json["nodes"].is_array());
+    assert!(calm_json["relationships"].is_array());
+    assert!(calm_json["metadata"].is_object());
+    assert!(calm_json["version"].is_string());
+
+    let nodes = calm_json["nodes"].as_array().unwrap();
+    assert_eq!(nodes.len(), 1);
+
+    let node = &nodes[0];
+    assert!(node["unique-id"].is_string());
+    assert!(node["node-type"].is_string());
+    assert!(node["name"].is_string());
+    assert!(node["metadata"].is_object());
+    assert_eq!(node["metadata"]["sea:primitive"], "Entity");
+}
+
+#[test]
+fn test_semantic_equivalence_after_round_trip() {
+    let mut original_graph = Graph::new();
+
+    let e1 = Entity::new_with_namespace("Entity1".to_string(), "ns1".to_string());
+    let e2 = Entity::new_with_namespace("Entity2".to_string(), "ns1".to_string());
+    let r1 = Resource::new_with_namespace(
+        "Resource1".to_string(),
+        unit_from_string("kg"),
+        "ns2".to_string(),
+    );
+
+    let e1_id = e1.id().clone();
+    let e2_id = e2.id().clone();
+    let r1_id = r1.id().clone();
+
+    original_graph.add_entity(e1).unwrap();
+    original_graph.add_entity(e2).unwrap();
+    original_graph.add_resource(r1).unwrap();
+
+    let flow = Flow::new(
+        r1_id.clone(),
+        e1_id.clone(),
+        e2_id.clone(),
+        Decimal::new(2500, 2),
+    );
+    original_graph.add_flow(flow).unwrap();
+
+    let calm_json = export(&original_graph).unwrap();
+    let imported_graph = import(calm_json).unwrap();
+
+    let original_entities: Vec<(&str, &str)> = original_graph
+        .all_entities()
+        .iter()
+        .map(|e| (e.name(), e.namespace()))
+        .collect();
+
+    let imported_entities: Vec<(&str, &str)> = imported_graph
+        .all_entities()
+        .iter()
+        .map(|e| (e.name(), e.namespace()))
+        .collect();
+
+    for orig_entity in &original_entities {
+        assert!(
+            imported_entities.contains(orig_entity),
+            "Entity {:?} not found in imported graph",
+            orig_entity
+        );
+    }
+
+    assert_eq!(
+        original_graph.entity_count(),
+        imported_graph.entity_count(),
+        "Entity count mismatch after round trip"
+    );
+    assert_eq!(
+        original_graph.resource_count(),
+        imported_graph.resource_count(),
+        "Resource count mismatch after round trip"
+    );
+
+    assert_eq!(original_graph.flow_count(), imported_graph.flow_count());
+}
+
+#[test]
+fn test_export_import_policy_round_trip() {
+    let mut original_graph = Graph::new();
+
+    let entity = Entity::new_with_namespace("Warehouse".to_string(), "default".to_string());
+    original_graph.add_entity(entity).unwrap();
+
+    let expr = Expression::quantifier(
+        domainforge_core::policy::Quantifier::ForAll,
+        "f",
+        Expression::variable("flows"),
+        Expression::binary(
+            domainforge_core::policy::BinaryOp::GreaterThan,
+            Expression::member_access("f", "quantity"),
+            Expression::literal(0),
+        ),
+    );
+
+    let policy = Policy::new_with_namespace("MustHavePositiveQuantity", "default", expr);
+    original_graph.add_policy(policy).unwrap();
+
+    let calm_json = export(&original_graph).unwrap();
+    let imported_graph = import(calm_json).unwrap();
+
+    assert_eq!(original_graph.policy_count(), imported_graph.policy_count());
+}
+
+#[test]
+fn test_export_import_association_round_trip() {
+    let mut original_graph = Graph::new();
+    let a = Entity::new_with_namespace("A".to_string(), "default".to_string());
+    let b = Entity::new_with_namespace("B".to_string(), "default".to_string());
+
+    let a_id = a.id().clone();
+    let b_id = b.id().clone();
+
+    original_graph.add_entity(a).unwrap();
+    original_graph.add_entity(b).unwrap();
+
+    // Create association by adding it via the Graph API
+    original_graph
+        .add_association(&a_id, &b_id, "association")
+        .unwrap();
+
+    let calm_json = export(&original_graph).unwrap();
+    let imported_graph = import(calm_json).unwrap();
+
+    // Check the association was imported as an attribute on the source entity
+    let a_imported_id = imported_graph.find_entity_by_name("A").unwrap();
+    let a_entity = imported_graph.get_entity(&a_imported_id).unwrap();
+    let associations = a_entity.get_attribute("associations").unwrap();
+    assert!(associations.is_array());
+    let arr = associations.as_array().unwrap();
+    assert!(!arr.is_empty());
+    assert_eq!(arr[0]["type"], Value::String("association".to_string()));
+}

package/domainforge-core/tests/calm_schema_validation_tests.rs

@@ -0,0 +1,137 @@
+use domainforge_core::calm::export;
+use domainforge_core::primitives::{Entity, Flow, Resource, ResourceInstance};
+use domainforge_core::units::unit_from_string;
+use domainforge_core::Graph;
+use jsonschema::JSONSchema;
+use rust_decimal::Decimal;
+
+const CALM_SCHEMA: &str = include_str!("../schemas/calm-v1.schema.json");
+
+fn compile_calm_schema() -> JSONSchema {
+    let schema = serde_json::from_str(CALM_SCHEMA).expect("Invalid schema JSON");
+    JSONSchema::compile(&schema).expect("Failed to compile schema")
+}
+
+#[test]
+fn test_export_validates_against_schema() {
+    let compiled_schema = compile_calm_schema();
+
+    let mut graph = Graph::new();
+    let entity = Entity::new_with_namespace("TestEntity".to_string(), "default".to_string());
+    graph.add_entity(entity).unwrap();
+
+    let calm_json = export(&graph).unwrap();
+
+    let result = compiled_schema.validate(&calm_json);
+
+    if let Err(errors) = result {
+        for error in errors {
+            eprintln!("Validation error: {}", error);
+            eprintln!("Instance path: {}", error.instance_path);
+        }
+        panic!("CALM export does not validate against schema");
+    }
+}
+
+#[test]
+fn test_complex_export_validates_against_schema() {
+    let compiled_schema = compile_calm_schema();
+
+    let mut graph = Graph::new();
+
+    let warehouse = Entity::new_with_namespace("Warehouse".to_string(), "logistics".to_string());
+    let factory = Entity::new_with_namespace("Factory".to_string(), "manufacturing".to_string());
+    let cameras = Resource::new_with_namespace(
+        "Cameras".to_string(),
+        unit_from_string("units"),
+        "default".to_string(),
+    );
+
+    let warehouse_id = warehouse.id().clone();
+    let factory_id = factory.id().clone();
+    let cameras_id = cameras.id().clone();
+
+    graph.add_entity(warehouse).unwrap();
+    graph.add_entity(factory).unwrap();
+    graph.add_resource(cameras).unwrap();
+
+    let flow = Flow::new(cameras_id, warehouse_id, factory_id, Decimal::from(100));
+    graph.add_flow(flow).unwrap();
+
+    let calm_json = export(&graph).unwrap();
+
+    let result = compiled_schema.validate(&calm_json);
+
+    if let Err(errors) = result {
+        for error in errors {
+            eprintln!("Validation error: {}", error);
+            eprintln!("Instance path: {}", error.instance_path);
+        }
+        panic!("CALM export does not validate against schema");
+    }
+}
+
+#[test]
+fn test_schema_is_valid_json_schema() {
+    let schema = serde_json::from_str::<serde_json::Value>(CALM_SCHEMA);
+    assert!(schema.is_ok(), "CALM schema must be valid JSON");
+
+    let schema_value = schema.unwrap();
+    assert!(schema_value.is_object());
+    assert_eq!(
+        schema_value["$schema"],
+        "http://json-schema.org/draft-07/schema#"
+    );
+}
+
+#[test]
+fn test_empty_graph_validates() {
+    let compiled_schema = compile_calm_schema();
+
+    let graph = Graph::new();
+    let calm_json = export(&graph).unwrap();
+
+    let result = compiled_schema.validate(&calm_json);
+    assert!(result.is_ok(), "Empty graph export should validate");
+}
+
+#[test]
+fn test_all_node_types_validate() {
+    let compiled_schema = compile_calm_schema();
+
+    let mut graph = Graph::new();
+
+    // Add one entity
+    let entity = Entity::new_with_namespace("TestEntity".to_string(), "default".to_string());
+    graph.add_entity(entity).unwrap();
+
+    // Add one resource
+    let resource = Resource::new_with_namespace(
+        "TestResource".to_string(),
+        unit_from_string("units"),
+        "default".to_string(),
+    );
+    graph.add_resource(resource).unwrap();
+
+    // Add one flow
+    let flow = Flow::new(
+        graph.all_resources()[0].id().clone(),
+        graph.all_entities()[0].id().clone(),
+        graph.all_entities()[0].id().clone(),
+        Decimal::from(100),
+    );
+    graph.add_flow(flow).unwrap();
+
+    // Add one instance
+    let instance = ResourceInstance::new(
+        graph.all_resources()[0].id().clone(),
+        graph.all_entities()[0].id().clone(),
+    );
+    graph.add_instance(instance).unwrap(); // Export and validate
+    let calm_json = export(&graph).unwrap();
+    let result = compiled_schema.validate(&calm_json);
+    assert!(
+        result.is_ok(),
+        "Graph with all node types should export valid CALM JSON"
+    );
+}

package/domainforge-core/tests/cast_operator_tests.rs

@@ -0,0 +1,85 @@
+use domainforge_core::parser::parse_to_graph;
+
+#[test]
+fn test_cast_operator_parsing() {
+    let source = r#"
+    Dimension "Time1"
+    Unit "s1" of "Time1" factor 1 base "s1"
+    Unit "ms1" of "Time1" factor 0.001 base "s1"
+
+    Policy test_cast as: 1000 "ms1" as "s1" > 0.5 "s1"
+    "#;
+
+    let graph = parse_to_graph(source).expect("Failed to parse");
+    let policy = graph
+        .all_policies()
+        .into_iter()
+        .next()
+        .expect("No policy found");
+
+    let result = policy.evaluate(&graph).expect("Evaluation failed");
+    assert!(result.is_satisfied);
+}
+
+#[test]
+fn test_cast_operator_evaluation() {
+    let source = r#"
+    Dimension "Time2"
+    Unit "s2" of "Time2" factor 1 base "s2"
+    Unit "ms2" of "Time2" factor 0.001 base "s2"
+
+    Policy conversion_check as: (1000 "ms2" as "s2") = 1 "s2"
+    "#;
+
+    let graph = parse_to_graph(source).expect("Failed to parse");
+    let policy = graph
+        .all_policies()
+        .into_iter()
+        .next()
+        .expect("No policy found");
+
+    let result = policy.evaluate(&graph).expect("Evaluation failed");
+    assert!(result.is_satisfied);
+}
+
+#[test]
+fn test_cast_number_to_unit() {
+    let source = r#"
+    Dimension "Time3"
+    Unit "s3" of "Time3" factor 1 base "s3"
+
+    Policy assign_unit as: (10 as "s3") = 10 "s3"
+    "#;
+
+    let graph = parse_to_graph(source).expect("Failed to parse");
+    let policy = graph
+        .all_policies()
+        .into_iter()
+        .next()
+        .expect("No policy found");
+
+    let result = policy.evaluate(&graph).expect("Evaluation failed");
+    assert!(result.is_satisfied);
+}
+
+#[test]
+fn test_cast_incompatible_units_errors() {
+    let source = r#"
+    Dimension "Time4"
+    Unit "s4" of "Time4" factor 1 base "s4"
+    Dimension "Money4"
+    Unit "USD4" of "Money4" factor 1 base "USD4"
+
+    Policy invalid_cast as: 1 "s4" as "USD4"
+    "#;
+
+    let graph = parse_to_graph(source).expect("Failed to parse");
+    let policy = graph
+        .all_policies()
+        .into_iter()
+        .next()
+        .expect("No policy found");
+
+    let result = policy.evaluate(&graph);
+    assert!(result.is_err(), "Expected cast to fail across dimensions");
+}

package/domainforge-core/tests/cli_binary_check.rs

@@ -0,0 +1,37 @@
+#[cfg(feature = "cli")]
+use std::path::Path;
+
+#[cfg(feature = "cli")]
+fn get_sea_binary() -> String {
+    std::env::var("CARGO_BIN_EXE_sea").unwrap_or_else(|_| {
+        let mut path = std::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_binary_present_when_cli_feature_enabled() {
+    // This test should be run with `--features cli` to ensure the CLI is built
+    let bin = get_sea_binary();
+    assert!(Path::new(&bin).exists(), "CLI binary not found at {}", bin);
+}
+
+#[cfg(not(feature = "cli"))]
+#[test]
+fn test_cli_binary_check_skipped_without_feature() {
+    // When the CLI feature is disabled, we skip the binary presence check.
+    assert!(true);
+}