domainforge 0.13.0

package/domainforge-core/tests/sbvr_flow_facts_tests.rs

@@ -0,0 +1,55 @@
+#[cfg(test)]
+mod sbvr_flow_facts_tests {
+    use domainforge_core::primitives::{Entity, Flow, Resource};
+    use domainforge_core::sbvr::SbvrModel;
+    use domainforge_core::{unit_from_string, Graph};
+    use rust_decimal::Decimal;
+
+    #[test]
+    fn test_flow_fact_includes_resource_and_destination() {
+        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 camera = Resource::new_with_namespace(
+            "Camera",
+            unit_from_string("units"),
+            "default".to_string(),
+        );
+
+        let warehouse_id = warehouse.id().clone();
+        let factory_id = factory.id().clone();
+        let camera_id = camera.id().clone();
+        let factory_id_str = factory_id.to_string();
+
+        graph.add_entity(warehouse).unwrap();
+        graph.add_entity(factory).unwrap();
+        graph.add_resource(camera).unwrap();
+
+        let flow = Flow::new_with_namespace(
+            camera_id.clone(),
+            warehouse_id.clone(),
+            factory_id.clone(),
+            Decimal::new(100, 0),
+            "default",
+        );
+        graph.add_flow(flow.clone()).unwrap();
+
+        let sbvr_model = SbvrModel::from_graph(&graph).unwrap();
+
+        let flow_fact = sbvr_model
+            .facts
+            .iter()
+            .find(|f| f.id == flow.id().to_string())
+            .expect("Flow fact not found");
+
+        assert_eq!(flow_fact.subject, warehouse_id.to_string());
+        assert_eq!(flow_fact.verb, "transfers");
+        assert_eq!(flow_fact.object, camera_id.to_string());
+        assert_eq!(
+            flow_fact.destination.as_deref(),
+            Some(factory_id_str.as_str())
+        );
+        assert_eq!(flow_fact.schema_version, "2.0");
+    }
+}

package/domainforge-core/tests/sbvr_parsing_tests.rs

@@ -0,0 +1,53 @@
+use domainforge_core::sbvr::{RuleType, SbvrModel, TermType};
+
+#[test]
+fn test_sbvr_parsing_from_xml() {
+    let xml = r#"<?xml version="1.0" encoding="UTF-8"?>
+<xmi:XMI xmlns:xmi="http://www.omg.org/XMI" xmlns:sbvr="http://www.omg.org/spec/SBVR/20080801">
+  <sbvr:Vocabulary name="Test_Model">
+    <sbvr:GeneralConcept id="c1" name="Customer">
+      <sbvr:Definition>A person who buys things</sbvr:Definition>
+    </sbvr:GeneralConcept>
+    <sbvr:IndividualConcept id="r1" name="GoldParams">
+      <sbvr:Definition>Parameters for gold status</sbvr:Definition>
+    </sbvr:IndividualConcept>
+    <sbvr:FactType id="f1">
+       <sbvr:Subject>c1</sbvr:Subject>
+       <sbvr:Verb>has</sbvr:Verb>
+       <sbvr:Object>r1</sbvr:Object>
+    </sbvr:FactType>
+    <sbvr:Obligation id="rule1" name="MustBeValid">
+      <sbvr:Expression>It is obligatory that...</sbvr:Expression>
+      <sbvr:Severity>Error</sbvr:Severity>
+    </sbvr:Obligation>
+  </sbvr:Vocabulary>
+</xmi:XMI>"#;
+
+    let model = SbvrModel::from_xmi(xml).expect("Failed to parse SBVR XML");
+
+    // Check Vocabulary
+    assert_eq!(model.vocabulary.len(), 2);
+    let term1 = model
+        .vocabulary
+        .iter()
+        .find(|t| t.name == "Customer")
+        .unwrap();
+    assert!(matches!(term1.term_type, TermType::GeneralConcept));
+    assert_eq!(
+        term1.definition.as_deref(),
+        Some("A person who buys things")
+    );
+
+    // Check Facts
+    assert_eq!(model.facts.len(), 1);
+    let fact = &model.facts[0];
+    assert_eq!(fact.subject, "c1");
+    assert_eq!(fact.verb, "has");
+
+    // Check Rules
+    assert_eq!(model.rules.len(), 1);
+    let rule = &model.rules[0];
+    assert_eq!(rule.name, "MustBeValid");
+    assert!(matches!(rule.rule_type, RuleType::Obligation));
+    assert_eq!(rule.expression, "It is obligatory that...");
+}

package/domainforge-core/tests/semantic_pack_alias_resolution.rs

@@ -0,0 +1,197 @@
+use domainforge_core::semantic_pack::*;
+
+fn make_concept(id: &str, canonical_name: &str, status: ConceptStatus) -> ConceptDef {
+    ConceptDef {
+        id: id.to_string(),
+        canonical_name: canonical_name.to_string(),
+        kind: ConceptKind::Entity,
+        status,
+        definition: ConceptDefinition {
+            text: format!("Definition of {}", canonical_name),
+            definition_hash: String::new(),
+            decision_ref: format!("dec_{}", id),
+        },
+        owner: "owner@test.com".to_string(),
+        source_refs: vec![],
+        examples: vec![],
+        counterexamples: vec![],
+        allowed_predicates: vec![],
+        valid_contexts: vec![],
+    }
+}
+
+fn make_alias(alias: &str, target_id: &str, status: AliasStatus) -> AliasDef {
+    AliasDef {
+        alias: alias.to_string(),
+        normalized_alias: normalize_lookup_key(alias),
+        target_concept_id: target_id.to_string(),
+        status,
+        confidence: None,
+        decision_ref: format!("dec_alias_{}", alias),
+        source_ref: SourceRef::synthetic("test://alias"),
+    }
+}
+
+fn make_pack_with_concepts_and_aliases(
+    concepts: Vec<ConceptDef>,
+    aliases: Vec<AliasDef>,
+) -> SemanticPack {
+    SemanticPack {
+        schema_version: "0.3".to_string(),
+        pack_id: "test-org/test-domain/1.0.0".to_string(),
+        org_id: "test-org".to_string(),
+        domain_id: "test-domain".to_string(),
+        pack_version: "1.0.0".to_string(),
+        meaning_version: "1.0.0".to_string(),
+        meaning_fingerprint: String::new(),
+        source_graph_hash: "sha256:test".to_string(),
+        build_config_hash: "sha256:cfg".to_string(),
+        review_manifest_hash: "sha256:rev".to_string(),
+        created_at: "2026-06-07T00:00:00Z".to_string(),
+        generator: schema::GeneratorInfo {
+            name: "domainforge-core".to_string(),
+            version: "0.3".to_string(),
+        },
+        trust: schema::PackTrust {
+            approval_state: ApprovalState::Candidate,
+            signature_state: SignatureState::Unsigned,
+            signed_by: None,
+            signature_alg: None,
+            signature: None,
+        },
+        concepts,
+        relations: vec![],
+        metrics: vec![],
+        dimensions: vec![],
+        units: vec![],
+        aliases,
+        mapping_rules: vec![],
+        compatibility: schema::CompatibilityInfo::default(),
+    }
+}
+
+#[test]
+fn alias_resolution_uses_full_candidate_set() {
+    let concepts = vec![
+        make_concept("supplier", "Supplier", ConceptStatus::Active),
+        make_concept("vendor", "VendorConcept", ConceptStatus::Active),
+    ];
+
+    let aliases = vec![
+        make_alias("Vendor", "supplier", AliasStatus::Approved),
+        make_alias("vendor", "vendor", AliasStatus::Approved),
+    ];
+
+    let pack = make_pack_with_concepts_and_aliases(concepts, aliases);
+    let options = ValidationOptions::default();
+    let source_ref = SourceRef::synthetic("test://term");
+
+    let request = ResolveRequest {
+        raw_text: "Vendor",
+        expected_kind: None,
+        source_ref,
+    };
+    let result = resolve_concept(&request, &pack, &options);
+
+    // "Vendor" normalizes to "vendor", matching two approved aliases targeting
+    // different concepts → expect an ambiguity diagnostic.
+    assert!(
+        result.diagnostic_code.is_some(),
+        "expected ambiguity diagnostic for conflicting 'vendor' aliases, got resolved_concept_id={:?}",
+        result.resolved_concept_id
+    );
+}
+
+#[test]
+fn approved_and_deprecated_alias_same_key_blocks_approved_build() {
+    let concepts = vec![
+        make_concept("supplier_a", "SupplierA", ConceptStatus::Active),
+        make_concept("supplier_b", "SupplierB", ConceptStatus::Active),
+    ];
+
+    let aliases = vec![
+        make_alias("Vendor", "supplier_a", AliasStatus::Approved),
+        make_alias("Vendor", "supplier_b", AliasStatus::Deprecated),
+    ];
+
+    let input = PackBuildInput {
+        org_id: "test-org".to_string(),
+        domain_id: "test-domain".to_string(),
+        pack_version: "1.0.0".to_string(),
+        meaning_version: "1.0.0".to_string(),
+        approval: ApprovalState::Approved,
+        concepts,
+        relations: vec![],
+        metrics: vec![],
+        dimensions: vec![],
+        units: vec![],
+        aliases,
+        mapping_rules: vec![],
+        review_records: vec![
+            ReviewRecord {
+                decision_id: "dec_1".to_string(),
+                subject_type: "concept".to_string(),
+                subject_id: "supplier_a".to_string(),
+                decision: ReviewDecision::Approve,
+                rationale: "ok".to_string(),
+                reviewer: "r@test.com".to_string(),
+                reviewed_at: "2026-06-07T00:00:00Z".to_string(),
+                definition_hash: "sha256:x".to_string(),
+                previous_definition_hash: None,
+                new_definition_hash: None,
+            },
+            ReviewRecord {
+                decision_id: "dec_2".to_string(),
+                subject_type: "concept".to_string(),
+                subject_id: "supplier_b".to_string(),
+                decision: ReviewDecision::Approve,
+                rationale: "ok".to_string(),
+                reviewer: "r@test.com".to_string(),
+                reviewed_at: "2026-06-07T00:00:00Z".to_string(),
+                definition_hash: "sha256:x".to_string(),
+                previous_definition_hash: None,
+                new_definition_hash: None,
+            },
+        ],
+        previous_pack: None,
+        allow_first_approved_version: true,
+        source_graph_hash: "sha256:test".to_string(),
+    };
+
+    let result = build_semantic_pack(input);
+    assert!(result.is_err());
+    let diags = result.unwrap_err();
+    assert!(diags
+        .iter()
+        .any(|d| d.code == SemanticDiagnosticCode::AliasConflict));
+}
+
+#[test]
+fn approved_and_deprecated_alias_same_key_is_ambiguous() {
+    let concepts = vec![
+        make_concept("supplier_a", "SupplierA", ConceptStatus::Active),
+        make_concept("supplier_b", "SupplierB", ConceptStatus::Active),
+    ];
+
+    let aliases = vec![
+        make_alias("Provider", "supplier_a", AliasStatus::Ambiguous),
+        make_alias("Provider", "supplier_b", AliasStatus::Ambiguous),
+    ];
+
+    let pack = make_pack_with_concepts_and_aliases(concepts, aliases);
+    let options = ValidationOptions::default();
+    let source_ref = SourceRef::synthetic("test://term");
+
+    let request = ResolveRequest {
+        raw_text: "Provider",
+        expected_kind: None,
+        source_ref,
+    };
+    let result = resolve_concept(&request, &pack, &options);
+
+    assert_eq!(result.semantic_truth, SemanticTruth::Unknown);
+    assert_eq!(
+        result.diagnostic_code,
+        Some(SemanticDiagnosticCode::AmbiguousAlias)
+    );
+}

package/domainforge-core/tests/semantic_pack_build.rs

@@ -0,0 +1,302 @@
+use domainforge_core::semantic_pack::*;
+
+fn make_concept(
+    id: &str,
+    canonical_name: &str,
+    status: ConceptStatus,
+    definition_text: &str,
+    owner: &str,
+) -> ConceptDef {
+    ConceptDef {
+        id: id.to_string(),
+        canonical_name: canonical_name.to_string(),
+        kind: ConceptKind::Entity,
+        status,
+        definition: ConceptDefinition {
+            text: definition_text.to_string(),
+            definition_hash: String::new(),
+            decision_ref: format!("dec_{}", id),
+        },
+        owner: owner.to_string(),
+        source_refs: vec![],
+        examples: vec![],
+        counterexamples: vec![],
+        allowed_predicates: vec![],
+        valid_contexts: vec![],
+    }
+}
+
+fn make_review_record(subject_id: &str, decision: ReviewDecision, def_hash: &str) -> ReviewRecord {
+    ReviewRecord {
+        decision_id: format!("dec_{}", subject_id),
+        subject_type: "concept".to_string(),
+        subject_id: subject_id.to_string(),
+        decision,
+        rationale: format!("Review for {}", subject_id),
+        reviewer: "reviewer@test.com".to_string(),
+        reviewed_at: "2026-06-07T00:00:00Z".to_string(),
+        definition_hash: def_hash.to_string(),
+        previous_definition_hash: None,
+        new_definition_hash: None,
+    }
+}
+
+fn minimal_build_input() -> PackBuildInput {
+    let supplier = make_concept(
+        "supplier",
+        "Supplier",
+        ConceptStatus::Active,
+        "A party that provides goods or services",
+        "owner@test.com",
+    );
+    let review = make_review_record("supplier", ReviewDecision::Approve, "sha256:placeholder");
+
+    PackBuildInput {
+        org_id: "test-org".to_string(),
+        domain_id: "test-domain".to_string(),
+        pack_version: "1.0.0".to_string(),
+        meaning_version: "1.0.0".to_string(),
+        approval: ApprovalState::Candidate,
+        concepts: vec![supplier],
+        relations: vec![],
+        metrics: vec![],
+        dimensions: vec![],
+        units: vec![],
+        aliases: vec![],
+        mapping_rules: vec![],
+        review_records: vec![review],
+        previous_pack: None,
+        allow_first_approved_version: false,
+        source_graph_hash: "sha256:test".to_string(),
+    }
+}
+
+fn minimal_approved_build_input() -> PackBuildInput {
+    let mut input = minimal_build_input();
+    input.approval = ApprovalState::Approved;
+    input.allow_first_approved_version = true;
+
+    let supplier = make_concept(
+        "supplier",
+        "Supplier",
+        ConceptStatus::Active,
+        "A party that provides goods or services",
+        "owner@test.com",
+    );
+    input.concepts = vec![supplier];
+
+    let review = make_review_record("supplier", ReviewDecision::Approve, "sha256:placeholder");
+    input.review_records = vec![review];
+
+    input
+}
+
+#[test]
+fn build_is_deterministic_across_repeated_runs() {
+    let input = minimal_build_input();
+    let out1 = build_semantic_pack(input.clone()).unwrap();
+    let out2 = build_semantic_pack(input).unwrap();
+
+    assert_eq!(out1.meaning_fingerprint, out2.meaning_fingerprint);
+
+    let mut p1 = out1.pack.clone();
+    let mut p2 = out2.pack.clone();
+    p1.created_at = String::new();
+    p2.created_at = String::new();
+    assert_eq!(
+        serde_json::to_string(&p1).unwrap(),
+        serde_json::to_string(&p2).unwrap(),
+    );
+}
+
+#[test]
+fn approved_pack_requires_review_manifest() {
+    let mut input = minimal_approved_build_input();
+    input.review_records = vec![];
+
+    let result = build_semantic_pack(input);
+    assert!(result.is_err());
+    let diags = result.unwrap_err();
+    assert!(diags
+        .iter()
+        .any(|d| d.code == SemanticDiagnosticCode::UnreviewedConcept));
+}
+
+#[test]
+fn missing_definition_produces_warning_on_approved_pack() {
+    let mut input = minimal_approved_build_input();
+    input.concepts[0].definition.text = String::new();
+    input.concepts[0].definition.definition_hash = String::new();
+
+    let result = build_semantic_pack(input);
+    match result {
+        Ok(out) => {
+            assert!(out
+                .pre_pack_diagnostics
+                .iter()
+                .any(|d| d.code == SemanticDiagnosticCode::MissingDefinition));
+        }
+        Err(diags) => {
+            assert!(diags
+                .iter()
+                .any(|d| d.code == SemanticDiagnosticCode::MissingDefinition));
+        }
+    }
+}
+
+#[test]
+fn missing_owner_produces_warning_on_approved_pack() {
+    let mut input = minimal_approved_build_input();
+    input.concepts[0].owner = String::new();
+
+    let result = build_semantic_pack(input);
+    match result {
+        Ok(out) => {
+            assert!(out
+                .pre_pack_diagnostics
+                .iter()
+                .any(|d| d.code == SemanticDiagnosticCode::MissingOwner));
+        }
+        Err(diags) => {
+            assert!(diags
+                .iter()
+                .any(|d| d.code == SemanticDiagnosticCode::MissingOwner));
+        }
+    }
+}
+
+#[test]
+fn duplicate_canonical_name_is_invalid() {
+    let mut input = minimal_approved_build_input();
+    let dup = make_concept(
+        "supplier_v2",
+        "Supplier",
+        ConceptStatus::Active,
+        "Duplicate supplier",
+        "owner@test.com",
+    );
+    input.concepts.push(dup);
+    input.review_records.push(make_review_record(
+        "supplier_v2",
+        ReviewDecision::Approve,
+        "sha256:placeholder",
+    ));
+
+    let result = build_semantic_pack(input);
+    assert!(result.is_err());
+    let diags = result.unwrap_err();
+    assert!(diags
+        .iter()
+        .any(|d| d.code == SemanticDiagnosticCode::DuplicateCanonicalName));
+}
+
+#[test]
+fn pack_hash_excludes_signature_fields() {
+    let input = minimal_build_input();
+    let out = build_semantic_pack(input).unwrap();
+
+    assert!(out.pack.trust.signature.is_none());
+    assert_eq!(out.pack.trust.signature_state, SignatureState::Unsigned);
+}
+
+#[test]
+fn meaning_fingerprint_change_requires_meaning_version_bump() {
+    let input1 = minimal_build_input();
+    let out1 = build_semantic_pack(input1).unwrap();
+
+    let mut input2 = minimal_build_input();
+    input2.previous_pack = Some(out1.pack.clone());
+    input2.meaning_version = "1.0.0".to_string();
+
+    let changed_concept = make_concept(
+        "supplier",
+        "Supplier",
+        ConceptStatus::Active,
+        "CHANGED definition text",
+        "owner@test.com",
+    );
+    input2.concepts = vec![changed_concept];
+
+    let review = make_review_record("supplier", ReviewDecision::Approve, "sha256:placeholder");
+    input2.review_records = vec![review];
+
+    let result = build_semantic_pack(input2);
+    if let Err(diags) = &result {
+        if diags
+            .iter()
+            .any(|d| d.code == SemanticDiagnosticCode::MeaningVersionNotBumped)
+        {
+            return;
+        }
+    }
+
+    let mut input3 = minimal_build_input();
+    input3.previous_pack = Some(out1.pack);
+    input3.meaning_version = "1.0.1".to_string();
+    let changed = make_concept(
+        "supplier",
+        "Supplier",
+        ConceptStatus::Active,
+        "CHANGED definition text",
+        "owner@test.com",
+    );
+    input3.concepts = vec![changed];
+    let review2 = make_review_record("supplier", ReviewDecision::Approve, "sha256:placeholder");
+    input3.review_records = vec![review2];
+
+    let out3 = build_semantic_pack(input3).unwrap();
+    assert_ne!(out3.meaning_fingerprint, out1.meaning_fingerprint);
+}
+
+#[test]
+fn canonical_json_sorts_examples_and_counterexamples() {
+    let mut concept = make_concept(
+        "test",
+        "Test",
+        ConceptStatus::Active,
+        "Test definition",
+        "owner@test.com",
+    );
+    concept.examples = vec![
+        "z_example".to_string(),
+        "a_example".to_string(),
+        "m_example".to_string(),
+    ];
+    concept.counterexamples = vec!["z_counter".to_string(), "a_counter".to_string()];
+
+    let mut input = minimal_build_input();
+    input.concepts = vec![concept];
+
+    let out = build_semantic_pack(input).unwrap();
+    let c = &out.pack.concepts[0];
+    assert_eq!(c.examples, vec!["a_example", "m_example", "z_example"]);
+    assert_eq!(c.counterexamples, vec!["a_counter", "z_counter"]);
+}
+
+#[test]
+fn unsigned_fixture_bypass_is_cli_only_and_audited() {
+    let pack = build_semantic_pack(minimal_build_input()).unwrap().pack;
+
+    let options = ValidationOptions {
+        mode: ValidationMode::Warn,
+        unknown_concept_policy: UnknownConceptPolicy::Warning,
+        deprecated_policy: DeprecatedPolicy::Warn,
+        require_signed_pack: true,
+        allow_unsigned_test_fixtures: true,
+    };
+
+    let result = validate_graph_with_pack(&pack, "test://fixture", &options);
+    assert!(result.unsigned_fixture_bypass_used);
+    assert_ne!(result.status, SemanticValidationStatus::Blocked);
+
+    let options_strict = ValidationOptions {
+        mode: ValidationMode::Strict,
+        ..options.clone()
+    };
+    let options_no_bypass = ValidationOptions {
+        allow_unsigned_test_fixtures: false,
+        ..options_strict
+    };
+    let result_blocked = validate_graph_with_pack(&pack, "test://fixture", &options_no_bypass);
+    assert_eq!(result_blocked.status, SemanticValidationStatus::Blocked);
+}