domainforge 0.13.0

package/domainforge-core/tests/dimension_unit_tests.rs

@@ -0,0 +1,80 @@
+//! Tests for parsing dimension and unit declarations.
+use domainforge_core::parser::ast::AstNode;
+use domainforge_core::parser::parse_source;
+use domainforge_core::units::{Dimension, UnitRegistry};
+use rust_decimal_macros::dec;
+#[test]
+fn test_parse_dimension() {
+    let source = r#"
+        Dimension "Currency"
+    "#;
+    let ast = parse_source(source).unwrap();
+    assert_eq!(ast.declarations.len(), 1);
+    match &ast.declarations[0].node {
+        AstNode::Dimension { name } => {
+            assert_eq!(name, "Currency");
+        }
+        _ => panic!("Expected Dimension declaration"),
+    }
+}
+#[test]
+fn test_parse_unit() {
+    let source = r#"
+        Unit "USD" of "Currency" factor 1 base "USD"
+    "#;
+    let ast = parse_source(source).unwrap();
+    assert_eq!(ast.declarations.len(), 1);
+    match &ast.declarations[0].node {
+        AstNode::UnitDeclaration {
+            symbol,
+            dimension,
+            ref factor,
+            base_unit,
+        } => {
+            assert_eq!(symbol, "USD");
+            assert_eq!(dimension, "Currency");
+            assert_eq!(*factor, dec!(1));
+            assert_eq!(base_unit, "USD");
+        }
+        _ => panic!("Expected UnitDeclaration"),
+    }
+}
+#[test]
+fn test_parse_unit_with_decimal_factor() {
+    let source = r#"
+        Unit "EUR" of "Currency" factor 1.07 base "USD"
+    "#;
+    let ast = parse_source(source).unwrap();
+    assert_eq!(ast.declarations.len(), 1);
+    match &ast.declarations[0].node {
+        AstNode::UnitDeclaration { ref factor, .. } => {
+            assert_eq!(*factor, dec!(1.07));
+        }
+        _ => panic!("Expected UnitDeclaration"),
+    }
+}
+
+#[test]
+fn test_register_from_json_case_insensitive_dimension() {
+    let mut registry = UnitRegistry::new();
+    let json = r#"[{"symbol":"NTEST","name":"Test","dimension":"currency","base_factor":1.0,"base_unit":"USD"}]"#;
+    registry
+        .register_from_json(json)
+        .expect("Failed to register from json");
+    let unit = registry.get_unit("NTEST").expect("Unit not registered");
+    assert_eq!(unit.dimension(), &Dimension::Currency);
+}
+
+#[test]
+fn test_dimension_from_str_is_case_insensitive() {
+    use std::str::FromStr;
+    let d1 = Dimension::from_str("currency").unwrap();
+    let d2 = Dimension::from_str("Currency").unwrap();
+    let d3 = Dimension::from_str("CURRENCY").unwrap();
+    assert_eq!(d1, Dimension::Currency);
+    assert_eq!(d2, Dimension::Currency);
+    assert_eq!(d3, Dimension::Currency);
+    // Custom dims parse to lowercased custom name
+    let c = Dimension::from_str("MyDim").unwrap();
+    assert_eq!(c, Dimension::Custom("mydim".to_string()));
+}

package/domainforge-core/tests/entity_tests.rs

@@ -0,0 +1,69 @@
+use domainforge_core::primitives::Entity;
+use serde_json::json;
+use uuid::Uuid;
+
+#[test]
+fn test_entity_new_creates_valid_uuid() {
+    let entity = Entity::new_with_namespace("Test Entity", "default".to_string());
+    assert!(Uuid::parse_str(&entity.id().to_string()).is_ok());
+}
+
+#[test]
+fn test_entity_name_is_stored() {
+    let entity = Entity::new_with_namespace("Assembly Line A", "default".to_string());
+    assert_eq!(entity.name(), "Assembly Line A");
+}
+
+#[test]
+fn test_entity_with_namespace() {
+    let entity = Entity::new_with_namespace("Warehouse", "logistics");
+    assert_eq!(entity.namespace(), "logistics");
+}
+
+#[test]
+fn test_entity_defaults_to_default_namespace() {
+    let entity = Entity::new_with_namespace("Factory", "default".to_string());
+    assert_eq!(entity.namespace(), "default");
+}
+
+#[test]
+fn test_entity_set_attribute() {
+    let mut entity = Entity::new_with_namespace("Factory", "default".to_string());
+    entity.set_attribute("capacity", json!(5000));
+    assert_eq!(entity.get_attribute("capacity"), Some(&json!(5000)));
+}
+
+#[test]
+fn test_entity_multiple_attributes() {
+    let mut entity = Entity::new_with_namespace("Warehouse", "default".to_string());
+    entity.set_attribute("capacity_sqft", json!(50000));
+    entity.set_attribute("climate_controlled", json!(true));
+
+    assert_eq!(entity.get_attribute("capacity_sqft"), Some(&json!(50000)));
+    assert_eq!(
+        entity.get_attribute("climate_controlled"),
+        Some(&json!(true))
+    );
+}
+
+#[test]
+fn test_entity_get_nonexistent_attribute() {
+    let entity = Entity::new_with_namespace("Entity", "default".to_string());
+    assert_eq!(entity.get_attribute("missing"), None);
+}
+
+#[test]
+fn test_entity_serializes_to_json() {
+    let entity = Entity::new_with_namespace("Test", "default".to_string());
+    let json = serde_json::to_string(&entity).unwrap();
+    assert!(json.contains("Test"));
+    assert!(json.contains("id"));
+}
+
+#[test]
+fn test_entity_deserializes_from_json() {
+    let entity = Entity::new_with_namespace("Original", "default".to_string());
+    let json = serde_json::to_string(&entity).unwrap();
+    let deserialized: Entity = serde_json::from_str(&json).unwrap();
+    assert_eq!(deserialized.name(), "Original");
+}

package/domainforge-core/tests/evolution_semantics_tests.rs

@@ -0,0 +1,157 @@
+use domainforge_core::parser::{parse, parse_to_graph, AstNode};
+use domainforge_core::SemanticVersion;
+
+#[test]
+fn test_parse_entity_with_version_and_annotations() {
+    let source = r#"
+        Entity "Vendor" v2.1.0
+          @replaces "Vendor" v2.0.0
+          @changes ["added credit_limit field", "removed legacy_id"]
+          in procurement
+    "#;
+    let ast = parse(source).unwrap();
+    assert_eq!(ast.declarations.len(), 1);
+
+    match &ast.declarations[0].node {
+        AstNode::Entity {
+            name,
+            version,
+            annotations,
+            ..
+        } => {
+            assert_eq!(name, "Vendor");
+            assert_eq!(version.as_ref().unwrap(), "2.1.0");
+            assert!(annotations.contains_key("replaces"));
+            assert!(annotations.contains_key("changes"));
+        }
+        _ => panic!("Expected Entity declaration"),
+    }
+}
+
+#[test]
+fn test_parse_concept_change() {
+    let source = r#"
+        ConceptChange "Vendor_v2_migration"
+          @from_version v2.0.0
+          @to_version v2.1.0
+          @migration_policy mandatory
+          @breaking_change true
+    "#;
+    let ast = parse(source).unwrap();
+    assert_eq!(ast.declarations.len(), 1);
+
+    match &ast.declarations[0].node {
+        AstNode::ConceptChange {
+            name,
+            from_version,
+            to_version,
+            migration_policy,
+            breaking_change,
+            ..
+        } => {
+            assert_eq!(name, "Vendor_v2_migration");
+            assert_eq!(from_version, "2.0.0");
+            assert_eq!(to_version, "2.1.0");
+            assert_eq!(migration_policy, "mandatory");
+            assert!(*breaking_change);
+        }
+        _ => panic!("Expected ConceptChange declaration"),
+    }
+}
+
+#[test]
+fn test_entity_version_in_graph() {
+    let source = r#"
+        Entity "Vendor" v2.1.0
+          @replaces "Vendor" v2.0.0
+          @changes ["added credit_limit field"]
+          in procurement
+    "#;
+    let graph = parse_to_graph(source).unwrap();
+
+    let entities = graph.all_entities();
+    assert_eq!(entities.len(), 1);
+
+    let entity = entities[0];
+    assert_eq!(entity.name(), "Vendor");
+    assert_eq!(entity.version(), Some(&SemanticVersion::new(2, 1, 0)));
+    assert_eq!(entity.replaces(), Some("Vendor v2.0.0"));
+    assert_eq!(entity.changes().len(), 1);
+    assert_eq!(entity.changes()[0], "added credit_limit field");
+}
+
+#[test]
+fn test_concept_change_in_graph() {
+    let source = r#"
+        ConceptChange "Vendor_v2_migration"
+          @from_version v2.0.0
+          @to_version v2.1.0
+          @migration_policy mandatory
+          @breaking_change true
+    "#;
+    let graph = parse_to_graph(source).unwrap();
+
+    let changes = graph.all_concept_changes();
+    assert_eq!(changes.len(), 1);
+
+    let change = changes[0];
+    assert_eq!(change.name(), "Vendor_v2_migration");
+    assert_eq!(change.from_version(), "2.0.0");
+    assert_eq!(change.to_version(), "2.1.0");
+    assert_eq!(change.migration_policy(), "mandatory");
+    assert!(change.is_breaking_change());
+}
+
+#[test]
+fn test_multiple_entity_versions() {
+    let source = r#"
+        Entity "Vendor" v2.0.0 in procurement
+        Entity "VendorV2" v2.1.0
+          @replaces "Vendor" v2.0.0
+          @changes ["added credit_limit field"]
+          in procurement
+    "#;
+    let graph = parse_to_graph(source).unwrap();
+
+    let entities = graph.all_entities();
+    assert_eq!(entities.len(), 2);
+}
+
+#[test]
+fn test_entity_without_version() {
+    let source = r#"
+        Entity "Vendor" in procurement
+    "#;
+    let graph = parse_to_graph(source).unwrap();
+
+    let entities = graph.all_entities();
+    assert_eq!(entities.len(), 1);
+    assert_eq!(entities[0].version(), None);
+}
+
+#[test]
+fn test_invalid_version_format() {
+    let source = r#"
+        Entity "Vendor" v2.1 in procurement
+    "#;
+    // This should fail parsing because version must be semver format
+    let result = parse(source);
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_concept_change_non_breaking() {
+    let source = r#"
+        ConceptChange "Vendor_v2_1_migration"
+          @from_version v2.1.0
+          @to_version v2.1.1
+          @migration_policy optional
+          @breaking_change false
+    "#;
+    let graph = parse_to_graph(source).unwrap();
+
+    let changes = graph.all_concept_changes();
+    assert_eq!(changes.len(), 1);
+    assert!(!changes[0].is_breaking_change());
+    assert_eq!(changes[0].migration_policy(), "optional");
+}

package/domainforge-core/tests/flow_tests.rs

@@ -0,0 +1,78 @@
+use domainforge_core::primitives::{Entity, Flow, Resource};
+use domainforge_core::units::unit_from_string;
+use domainforge_core::ConceptId;
+use rust_decimal::Decimal;
+use uuid::Uuid;
+
+#[test]
+fn test_flow_new_stores_references() {
+    let warehouse = Entity::new_with_namespace("Warehouse", "default".to_string());
+    let factory = Entity::new_with_namespace("Factory", "default".to_string());
+    let product =
+        Resource::new_with_namespace("Widget", unit_from_string("units"), "default".to_string());
+
+    let flow = Flow::new(
+        product.id().clone(),
+        warehouse.id().clone(),
+        factory.id().clone(),
+        Decimal::from(100),
+    );
+
+    assert_eq!(flow.quantity(), Decimal::from(100));
+    assert_eq!(flow.resource_id(), product.id());
+    assert_eq!(flow.from_id(), warehouse.id());
+    assert_eq!(flow.to_id(), factory.id());
+}
+
+#[test]
+fn test_flow_references_are_valid_uuids() {
+    let flow = Flow::new(
+        ConceptId::from_uuid(uuid::Uuid::new_v4()),
+        ConceptId::from_uuid(uuid::Uuid::new_v4()),
+        ConceptId::from_uuid(uuid::Uuid::new_v4()),
+        Decimal::from(50),
+    );
+
+    assert!(Uuid::parse_str(&flow.resource_id().to_string()).is_ok());
+    assert!(Uuid::parse_str(&flow.from_id().to_string()).is_ok());
+    assert!(Uuid::parse_str(&flow.to_id().to_string()).is_ok());
+    assert!(Uuid::parse_str(&flow.id().to_string()).is_ok());
+}
+
+#[test]
+fn test_flow_attributes() {
+    let mut flow = Flow::new(
+        ConceptId::from_uuid(uuid::Uuid::new_v4()),
+        ConceptId::from_uuid(uuid::Uuid::new_v4()),
+        ConceptId::from_uuid(uuid::Uuid::new_v4()),
+        Decimal::from(100),
+    );
+
+    flow.set_attribute("priority", serde_json::json!("high"));
+    flow.set_attribute("scheduled_date", serde_json::json!("2025-11-15"));
+
+    assert_eq!(
+        flow.get_attribute("priority"),
+        Some(&serde_json::json!("high"))
+    );
+    assert_eq!(
+        flow.get_attribute("scheduled_date"),
+        Some(&serde_json::json!("2025-11-15"))
+    );
+    assert_eq!(flow.get_attribute("nonexistent"), None);
+}
+
+#[test]
+fn test_flow_serialization() {
+    let flow = Flow::new(
+        ConceptId::from_uuid(uuid::Uuid::new_v4()),
+        ConceptId::from_uuid(uuid::Uuid::new_v4()),
+        ConceptId::from_uuid(uuid::Uuid::new_v4()),
+        Decimal::from(250),
+    );
+
+    let json = serde_json::to_string(&flow).unwrap();
+    let deserialized: Flow = serde_json::from_str(&json).unwrap();
+
+    assert_eq!(flow, deserialized);
+}

package/domainforge-core/tests/flow_unit_validation_tests.rs

@@ -0,0 +1,31 @@
+use domainforge_core::{
+    primitives::{Entity, Flow, Resource},
+    units::unit_from_string,
+    Graph,
+};
+use rust_decimal::Decimal;
+
+#[test]
+fn test_flow_creation_with_resource_unit() {
+    let mut graph = Graph::new();
+
+    let warehouse = Entity::new_with_namespace("Warehouse", "default".to_string());
+    let factory = Entity::new_with_namespace("Factory", "default".to_string());
+    let kg = unit_from_string("kg");
+    let gold = Resource::new_with_namespace("Gold", kg, "default".to_string());
+
+    graph.add_entity(warehouse.clone()).unwrap();
+    graph.add_entity(factory.clone()).unwrap();
+    graph.add_resource(gold.clone()).unwrap();
+
+    // For MVP, Flow quantity is assumed to be in the resource's unit
+    let flow = Flow::new(
+        gold.id().clone(),
+        warehouse.id().clone(),
+        factory.id().clone(),
+        Decimal::from(100),
+    );
+
+    let result = graph.add_flow(flow);
+    assert!(result.is_ok());
+}

package/domainforge-core/tests/graph_integration_tests.rs

@@ -0,0 +1,218 @@
+use domainforge_core::{
+    primitives::{Entity, Flow, Resource, ResourceInstance},
+    units::unit_from_string,
+    Graph,
+};
+use rust_decimal::Decimal;
+use std::str::FromStr;
+
+#[test]
+fn test_complete_supply_chain_graph() {
+    let mut graph = Graph::new();
+
+    let supplier = Entity::new_with_namespace("Steel Supplier", "default".to_string());
+    let warehouse = Entity::new_with_namespace("Central Warehouse", "default".to_string());
+    let manufacturer = Entity::new_with_namespace("Camera Manufacturer", "default".to_string());
+    let retailer = Entity::new_with_namespace("Electronics Retailer", "default".to_string());
+
+    let steel =
+        Resource::new_with_namespace("Steel", unit_from_string("kg"), "default".to_string());
+    let camera_parts = Resource::new_with_namespace(
+        "Camera Parts",
+        unit_from_string("units"),
+        "default".to_string(),
+    );
+    let cameras = Resource::new_with_namespace(
+        "Finished Cameras",
+        unit_from_string("units"),
+        "default".to_string(),
+    );
+
+    let supplier_id = supplier.id().clone();
+    let warehouse_id = warehouse.id().clone();
+    let manufacturer_id = manufacturer.id().clone();
+    let retailer_id = retailer.id().clone();
+
+    let steel_id = steel.id().clone();
+    let camera_parts_id = camera_parts.id().clone();
+    let cameras_id = cameras.id().clone();
+
+    graph.add_entity(supplier).unwrap();
+    graph.add_entity(warehouse).unwrap();
+    graph.add_entity(manufacturer).unwrap();
+    graph.add_entity(retailer).unwrap();
+
+    graph.add_resource(steel).unwrap();
+    graph.add_resource(camera_parts).unwrap();
+    graph.add_resource(cameras).unwrap();
+
+    let flow1 = Flow::new(
+        steel_id.clone(),
+        supplier_id.clone(),
+        warehouse_id.clone(),
+        Decimal::from_str("500").unwrap(),
+    );
+    let flow2 = Flow::new(
+        camera_parts_id.clone(),
+        warehouse_id.clone(),
+        manufacturer_id.clone(),
+        Decimal::from_str("200").unwrap(),
+    );
+    let flow3 = Flow::new(
+        cameras_id.clone(),
+        manufacturer_id.clone(),
+        retailer_id.clone(),
+        Decimal::from_str("150").unwrap(),
+    );
+
+    graph.add_flow(flow1).unwrap();
+    graph.add_flow(flow2).unwrap();
+    graph.add_flow(flow3).unwrap();
+
+    assert_eq!(graph.entity_count(), 4);
+    assert_eq!(graph.resource_count(), 3);
+    assert_eq!(graph.flow_count(), 3);
+
+    let warehouse_upstream = graph.upstream_entities(&warehouse_id);
+    assert_eq!(warehouse_upstream.len(), 1);
+    assert_eq!(warehouse_upstream[0].name(), "Steel Supplier");
+
+    let warehouse_downstream = graph.downstream_entities(&warehouse_id);
+    assert_eq!(warehouse_downstream.len(), 1);
+    assert_eq!(warehouse_downstream[0].name(), "Camera Manufacturer");
+
+    let manufacturer_upstream = graph.upstream_entities(&manufacturer_id);
+    assert_eq!(manufacturer_upstream.len(), 1);
+
+    let manufacturer_downstream = graph.downstream_entities(&manufacturer_id);
+    assert_eq!(manufacturer_downstream.len(), 1);
+    assert_eq!(manufacturer_downstream[0].name(), "Electronics Retailer");
+
+    let supplier_downstream = graph.downstream_entities(&supplier_id);
+    assert_eq!(supplier_downstream.len(), 1);
+
+    let retailer_upstream = graph.upstream_entities(&retailer_id);
+    assert_eq!(retailer_upstream.len(), 1);
+}
+
+#[test]
+fn test_graph_with_instances() {
+    let mut graph = Graph::new();
+
+    let warehouse = Entity::new_with_namespace("Warehouse", "default".to_string());
+    let cameras =
+        Resource::new_with_namespace("Cameras", unit_from_string("units"), "default".to_string());
+
+    let warehouse_id = warehouse.id().clone();
+    let cameras_id = cameras.id().clone();
+
+    graph.add_entity(warehouse).unwrap();
+    graph.add_resource(cameras).unwrap();
+
+    let instance1 = ResourceInstance::new(cameras_id.clone(), warehouse_id.clone());
+    let instance2 = ResourceInstance::new(cameras_id.clone(), warehouse_id.clone());
+
+    graph.add_instance(instance1).unwrap();
+    graph.add_instance(instance2).unwrap();
+
+    assert_eq!(graph.instance_count(), 2);
+}
+
+#[test]
+fn test_graph_validation_prevents_invalid_flows() {
+    let mut graph = Graph::new();
+
+    let warehouse = Entity::new_with_namespace("Warehouse", "default".to_string());
+    let cameras =
+        Resource::new_with_namespace("Cameras", unit_from_string("units"), "default".to_string());
+
+    let warehouse_id = warehouse.id().clone();
+    let cameras_id = cameras.id().clone();
+
+    graph.add_entity(warehouse).unwrap();
+    graph.add_resource(cameras).unwrap();
+
+    let fake_entity_id = domainforge_core::ConceptId::from_uuid(uuid::Uuid::new_v4());
+
+    let invalid_flow = Flow::new(
+        cameras_id,
+        warehouse_id,
+        fake_entity_id,
+        Decimal::from_str("100").unwrap(),
+    );
+
+    assert!(graph.add_flow(invalid_flow).is_err());
+    assert_eq!(graph.flow_count(), 0);
+}
+
+#[test]
+fn test_graph_multi_resource_flows() {
+    let mut graph = Graph::new();
+
+    let supplier = Entity::new_with_namespace("Supplier", "default".to_string());
+    let factory = Entity::new_with_namespace("Factory", "default".to_string());
+
+    let steel =
+        Resource::new_with_namespace("Steel", unit_from_string("kg"), "default".to_string());
+    let plastic =
+        Resource::new_with_namespace("Plastic", unit_from_string("kg"), "default".to_string());
+    let electronics = Resource::new_with_namespace(
+        "Electronics",
+        unit_from_string("units"),
+        "default".to_string(),
+    );
+
+    let supplier_id = supplier.id().clone();
+    let factory_id = factory.id().clone();
+
+    let steel_id = steel.id().clone();
+    let plastic_id = plastic.id().clone();
+    let electronics_id = electronics.id().clone();
+
+    graph.add_entity(supplier).unwrap();
+    graph.add_entity(factory).unwrap();
+    graph.add_resource(steel).unwrap();
+    graph.add_resource(plastic).unwrap();
+    graph.add_resource(electronics).unwrap();
+
+    let flow1 = Flow::new(
+        steel_id.clone(),
+        supplier_id.clone(),
+        factory_id.clone(),
+        Decimal::from_str("1000").unwrap(),
+    );
+    let flow2 = Flow::new(
+        plastic_id.clone(),
+        supplier_id.clone(),
+        factory_id.clone(),
+        Decimal::from_str("500").unwrap(),
+    );
+    let flow3 = Flow::new(
+        electronics_id.clone(),
+        supplier_id.clone(),
+        factory_id.clone(),
+        Decimal::from_str("200").unwrap(),
+    );
+
+    graph.add_flow(flow1).unwrap();
+    graph.add_flow(flow2).unwrap();
+    graph.add_flow(flow3).unwrap();
+
+    let flows_to_factory = graph.flows_to(&factory_id);
+    assert_eq!(flows_to_factory.len(), 3);
+
+    let flows_from_supplier = graph.flows_from(&supplier_id);
+    assert_eq!(flows_from_supplier.len(), 3);
+}
+
+#[test]
+fn test_empty_graph_queries() {
+    let graph = Graph::new();
+
+    let fake_id = domainforge_core::ConceptId::from_uuid(uuid::Uuid::new_v4());
+
+    assert_eq!(graph.flows_from(&fake_id).len(), 0);
+    assert_eq!(graph.flows_to(&fake_id).len(), 0);
+    assert_eq!(graph.upstream_entities(&fake_id).len(), 0);
+    assert_eq!(graph.downstream_entities(&fake_id).len(), 0);
+}