domainforge 0.13.0

package/domainforge-core/tests/semantic_pack_three_valued.rs

@@ -0,0 +1,250 @@
+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_pack_with_concepts(concepts: Vec<ConceptDef>) -> 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: vec![],
+        mapping_rules: vec![],
+        compatibility: schema::CompatibilityInfo::default(),
+    }
+}
+
+#[test]
+fn valid_concept_is_valid() {
+    let pack = make_pack_with_concepts(vec![make_concept(
+        "supplier",
+        "Supplier",
+        ConceptStatus::Active,
+    )]);
+    let options = ValidationOptions::default();
+    let source_ref = SourceRef::synthetic("test://term");
+
+    let request = ResolveRequest {
+        raw_text: "supplier",
+        expected_kind: None,
+        source_ref,
+    };
+    let result = resolve_concept(&request, &pack, &options);
+
+    assert_eq!(result.semantic_truth, SemanticTruth::Valid);
+    assert_eq!(result.resolved_concept_id, Some("supplier".to_string()));
+    assert!(result.diagnostic_code.is_none());
+}
+
+#[test]
+fn unknown_concept_is_unknown() {
+    let pack = make_pack_with_concepts(vec![make_concept(
+        "supplier",
+        "Supplier",
+        ConceptStatus::Active,
+    )]);
+    let options = ValidationOptions::default();
+    let source_ref = SourceRef::synthetic("test://term");
+
+    let request = ResolveRequest {
+        raw_text: "nonexistent",
+        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::UnknownConcept)
+    );
+    assert!(result.resolved_concept_id.is_none());
+}
+
+#[test]
+fn rejected_concept_is_invalid() {
+    let pack = make_pack_with_concepts(vec![make_concept(
+        "bad_thing",
+        "BadThing",
+        ConceptStatus::Rejected,
+    )]);
+    let options = ValidationOptions::default();
+    let source_ref = SourceRef::synthetic("test://term");
+
+    let request = ResolveRequest {
+        raw_text: "bad_thing",
+        expected_kind: None,
+        source_ref,
+    };
+    let result = resolve_concept(&request, &pack, &options);
+
+    assert_eq!(result.semantic_truth, SemanticTruth::Invalid);
+    assert_eq!(
+        result.diagnostic_code,
+        Some(SemanticDiagnosticCode::RejectedConcept)
+    );
+}
+
+#[test]
+fn proposed_concept_is_unknown() {
+    let pack = make_pack_with_concepts(vec![make_concept(
+        "draft_thing",
+        "DraftThing",
+        ConceptStatus::Proposed,
+    )]);
+    let options = ValidationOptions::default();
+    let source_ref = SourceRef::synthetic("test://term");
+
+    let request = ResolveRequest {
+        raw_text: "draft_thing",
+        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::ProposedConcept)
+    );
+    assert_eq!(result.resolved_concept_id, Some("draft_thing".to_string()));
+}
+
+#[test]
+fn deprecated_concept_is_valid_with_diagnostic() {
+    let pack = make_pack_with_concepts(vec![make_concept(
+        "old_thing",
+        "OldThing",
+        ConceptStatus::Deprecated,
+    )]);
+    let options = ValidationOptions::default();
+    let source_ref = SourceRef::synthetic("test://term");
+
+    let request = ResolveRequest {
+        raw_text: "old_thing",
+        expected_kind: None,
+        source_ref,
+    };
+    let result = resolve_concept(&request, &pack, &options);
+
+    assert_eq!(result.semantic_truth, SemanticTruth::Valid);
+    assert_eq!(
+        result.diagnostic_code,
+        Some(SemanticDiagnosticCode::DeprecatedConcept)
+    );
+    assert_eq!(result.resolved_concept_id, Some("old_thing".to_string()));
+}
+
+#[test]
+fn canonical_name_resolution_works() {
+    let pack = make_pack_with_concepts(vec![make_concept(
+        "supplier",
+        "Supplier",
+        ConceptStatus::Active,
+    )]);
+    let options = ValidationOptions::default();
+    let source_ref = SourceRef::synthetic("test://term");
+
+    let request = ResolveRequest {
+        raw_text: "Supplier",
+        expected_kind: None,
+        source_ref,
+    };
+    let result = resolve_concept(&request, &pack, &options);
+
+    assert_eq!(result.semantic_truth, SemanticTruth::Valid);
+    assert_eq!(result.resolved_concept_id, Some("supplier".to_string()));
+}
+
+#[test]
+fn resolution_is_case_insensitive() {
+    let pack = make_pack_with_concepts(vec![make_concept(
+        "supplier",
+        "Supplier",
+        ConceptStatus::Active,
+    )]);
+    let options = ValidationOptions::default();
+    let source_ref = SourceRef::synthetic("test://term");
+
+    let request = ResolveRequest {
+        raw_text: "SUPPLIER",
+        expected_kind: None,
+        source_ref,
+    };
+    let result = resolve_concept(&request, &pack, &options);
+
+    assert_eq!(result.semantic_truth, SemanticTruth::Valid);
+    assert_eq!(result.resolved_concept_id, Some("supplier".to_string()));
+}
+
+#[test]
+fn unknown_severity_depends_on_policy() {
+    let pack = make_pack_with_concepts(vec![]);
+
+    let options_warn = ValidationOptions {
+        unknown_concept_policy: UnknownConceptPolicy::Warning,
+        ..ValidationOptions::default()
+    };
+    let source_ref1 = SourceRef::synthetic("test://term");
+    let request1 = ResolveRequest {
+        raw_text: "unknown",
+        expected_kind: None,
+        source_ref: source_ref1,
+    };
+    let result_warn = resolve_concept(&request1, &pack, &options_warn);
+    assert_eq!(result_warn.diagnostic_severity, DiagnosticSeverity::Warning);
+
+    let options_error = ValidationOptions {
+        unknown_concept_policy: UnknownConceptPolicy::Error,
+        ..ValidationOptions::default()
+    };
+    let source_ref2 = SourceRef::synthetic("test://term");
+    let request2 = ResolveRequest {
+        raw_text: "unknown",
+        expected_kind: None,
+        source_ref: source_ref2,
+    };
+    let result_error = resolve_concept(&request2, &pack, &options_error);
+    assert_eq!(result_error.diagnostic_severity, DiagnosticSeverity::Error);
+}

package/domainforge-core/tests/semantic_pack_validate.rs

@@ -0,0 +1,196 @@
+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 make_minimal_pack() -> SemanticPack {
+    let supplier = make_concept(
+        "supplier",
+        "Supplier",
+        ConceptStatus::Active,
+        "A party that provides goods or services",
+        "owner@test.com",
+    );
+
+    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: vec![supplier],
+        relations: vec![],
+        metrics: vec![],
+        dimensions: vec![],
+        units: vec![],
+        aliases: vec![],
+        mapping_rules: vec![],
+        compatibility: schema::CompatibilityInfo::default(),
+    }
+}
+
+#[test]
+fn definition_hash_must_match_review_manifest() {
+    let mut 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: vec![make_concept(
+            "supplier",
+            "Supplier",
+            ConceptStatus::Active,
+            "A party that provides goods or services",
+            "owner@test.com",
+        )],
+        relations: vec![],
+        metrics: vec![],
+        dimensions: vec![],
+        units: vec![],
+        aliases: vec![],
+        mapping_rules: vec![],
+        review_records: vec![make_review_record(
+            "supplier",
+            ReviewDecision::Approve,
+            "sha256:WRONG_HASH",
+        )],
+        previous_pack: None,
+        allow_first_approved_version: true,
+        source_graph_hash: "sha256:test".to_string(),
+    };
+
+    input.concepts[0].definition.definition_hash = "sha256:ACTUAL_HASH".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::UnreviewedConcept));
+}
+
+#[test]
+fn rejected_concept_is_invalid_not_unknown() {
+    let mut pack = make_minimal_pack();
+    pack.concepts[0].status = ConceptStatus::Rejected;
+
+    let options = ValidationOptions::default();
+    let source_ref = SourceRef::synthetic("test://policy");
+    let diag = validate_term("supplier", &pack, &options, source_ref);
+
+    assert!(diag.is_some());
+    let d = diag.unwrap();
+    assert_eq!(d.semantic_truth, SemanticTruth::Invalid);
+    assert_eq!(d.code, SemanticDiagnosticCode::RejectedConcept);
+}
+
+#[test]
+fn deprecated_policy_error_in_strict_preserves_valid_truth() {
+    let mut pack = make_minimal_pack();
+    pack.concepts[0].status = ConceptStatus::Deprecated;
+
+    let mut options = ValidationOptions::strict();
+    options.deprecated_policy = DeprecatedPolicy::ErrorInStrict;
+
+    let source_ref = SourceRef::synthetic("test://policy");
+    let diag = validate_term("supplier", &pack, &options, source_ref);
+
+    assert!(diag.is_some());
+    let d = diag.unwrap();
+    assert_eq!(d.semantic_truth, SemanticTruth::Valid);
+    assert_eq!(d.code, SemanticDiagnosticCode::DeprecatedConcept);
+    assert_eq!(d.severity, DiagnosticSeverity::Error);
+}
+
+#[test]
+fn unknown_truth_survives_error_severity() {
+    let pack = make_minimal_pack();
+
+    let options = ValidationOptions {
+        unknown_concept_policy: UnknownConceptPolicy::Error,
+        ..ValidationOptions::default()
+    };
+
+    let source_ref = SourceRef::synthetic("test://policy");
+    let diag = validate_term("nonexistent_concept", &pack, &options, source_ref);
+
+    assert!(diag.is_some());
+    let d = diag.unwrap();
+    assert_eq!(d.semantic_truth, SemanticTruth::Unknown);
+    assert_eq!(d.severity, DiagnosticSeverity::Error);
+}
+
+#[test]
+fn expected_hash_mismatch_blocks_pack_load() {
+    let pack = make_minimal_pack();
+    let options = ValidationOptions {
+        mode: ValidationMode::Strict,
+        unknown_concept_policy: UnknownConceptPolicy::Error,
+        deprecated_policy: DeprecatedPolicy::ErrorInStrict,
+        require_signed_pack: true,
+        allow_unsigned_test_fixtures: false,
+    };
+
+    let result = validate_graph_with_pack(&pack, "test://source", &options);
+    assert_eq!(result.status, SemanticValidationStatus::Blocked);
+    assert!(result
+        .diagnostics
+        .iter()
+        .any(|d| d.code == SemanticDiagnosticCode::PackUnsigned));
+}

package/domainforge-core/tests/std_lib_tests.rs

@@ -0,0 +1,37 @@
+#![cfg(not(target_arch = "wasm32"))]
+use domainforge_core::parser::{parse_to_graph_with_options, ParseOptions};
+use domainforge_core::registry::NamespaceRegistry;
+use std::io::Write;
+use std::path::PathBuf;
+use tempfile::NamedTempFile;
+
+#[test]
+fn test_import_std_core() {
+    let source = r#"
+@namespace "app"
+import { System } from "std:core"
+
+Entity "MyApp" @replaces "System"
+"#;
+
+    // We need a registry for module resolution
+    let registry = NamespaceRegistry::new_empty(PathBuf::from("."))
+        .expect("Failed to create namespace registry");
+    let mut entry_file = NamedTempFile::new().expect("Failed to create entry file");
+    entry_file
+        .write_all(source.as_bytes())
+        .expect("Failed to write entry file");
+    let entry_path = entry_file
+        .path()
+        .canonicalize()
+        .expect("Failed to canonicalize entry path");
+    let options = ParseOptions {
+        default_namespace: Some("app".to_string()),
+        namespace_registry: Some(registry),
+        entry_path: Some(entry_path),
+        ..Default::default()
+    };
+
+    let result = parse_to_graph_with_options(source, &options);
+    assert!(result.is_ok());
+}

package/domainforge-core/tests/temporal_evaluation_tests.rs

@@ -0,0 +1,159 @@
+use domainforge_core::parser::parse_expression_from_str;
+use domainforge_core::policy::Policy;
+use domainforge_core::Graph;
+
+#[test]
+fn test_temporal_before_evaluation_true() {
+    let graph = Graph::new();
+
+    // Create a policy that checks if one timestamp is before another
+    let expr_str = r#""2025-01-01T00:00:00Z" before "2025-12-31T23:59:59Z""#;
+    let expr = parse_expression_from_str(expr_str).expect("Failed to parse expression");
+
+    let policy = Policy::new("test_before", expr);
+    let result = policy.evaluate(&graph).expect("Failed to evaluate policy");
+
+    assert!(
+        result.is_satisfied,
+        "Expected policy to be satisfied (earlier date before later date)"
+    );
+    assert_eq!(result.is_satisfied_tristate, Some(true));
+}
+
+#[test]
+fn test_temporal_before_evaluation_false() {
+    let graph = Graph::new();
+
+    // Later date is NOT before earlier date
+    let expr_str = r#""2025-12-31T23:59:59Z" before "2025-01-01T00:00:00Z""#;
+    let expr = parse_expression_from_str(expr_str).expect("Failed to parse expression");
+
+    let policy = Policy::new("test_before_false", expr);
+    let result = policy.evaluate(&graph).expect("Failed to evaluate policy");
+
+    assert!(
+        !result.is_satisfied,
+        "Expected policy to fail (later date not before earlier date)"
+    );
+    assert_eq!(result.is_satisfied_tristate, Some(false));
+}
+
+#[test]
+fn test_temporal_after_evaluation_true() {
+    let graph = Graph::new();
+
+    // Later date is after earlier date
+    let expr_str = r#""2025-12-31T23:59:59Z" after "2025-01-01T00:00:00Z""#;
+    let expr = parse_expression_from_str(expr_str).expect("Failed to parse expression");
+
+    let policy = Policy::new("test_after", expr);
+    let result = policy.evaluate(&graph).expect("Failed to evaluate policy");
+
+    assert!(
+        result.is_satisfied,
+        "Expected policy to be satisfied (later date after earlier date)"
+    );
+    assert_eq!(result.is_satisfied_tristate, Some(true));
+}
+
+#[test]
+fn test_temporal_after_evaluation_false() {
+    let graph = Graph::new();
+
+    // Earlier date is NOT after later date
+    let expr_str = r#""2025-01-01T00:00:00Z" after "2025-12-31T23:59:59Z""#;
+    let expr = parse_expression_from_str(expr_str).expect("Failed to parse expression");
+
+    let policy = Policy::new("test_after_false", expr);
+    let result = policy.evaluate(&graph).expect("Failed to evaluate policy");
+
+    assert!(
+        !result.is_satisfied,
+        "Expected policy to fail (earlier date not after later date)"
+    );
+    assert_eq!(result.is_satisfied_tristate, Some(false));
+}
+
+#[test]
+fn test_temporal_timezone_aware_comparison() {
+    let graph = Graph::new();
+
+    // Test that timezone-aware comparison works correctly
+    // 2025-01-01 00:00:00 UTC is BEFORE 2025-01-01 00:00:00 +05:00 (which is earlier in UTC)
+    let expr_str = r#""2025-01-01T00:00:00+05:00" before "2025-01-01T00:00:00Z""#;
+    let expr = parse_expression_from_str(expr_str).expect("Failed to parse expression");
+
+    let policy = Policy::new("test_timezone", expr);
+    let result = policy.evaluate(&graph).expect("Failed to evaluate policy");
+
+    // +05:00 means 5 hours ahead of UTC, so 2025-01-01T00:00:00+05:00 is actually 2024-12-31T19:00:00Z
+    // which is BEFORE 2025-01-01T00:00:00Z
+    assert!(
+        result.is_satisfied,
+        "Expected timezone-aware comparison to work correctly"
+    );
+}
+
+#[test]
+fn test_temporal_invalid_timestamp_error() {
+    let graph = Graph::new();
+
+    // Invalid timestamp should produce Null (unsatisfied) in 3VL
+    let expr_str = r#""not-a-timestamp" before "2025-01-01T00:00:00Z""#;
+    let expr = parse_expression_from_str(expr_str).expect("Failed to parse expression");
+
+    let policy = Policy::new("test_invalid", expr);
+    let result = policy.evaluate(&graph).expect("Failed to evaluate policy");
+
+    assert!(
+        !result.is_satisfied,
+        "Expected policy to be unsatisfied for invalid timestamp"
+    );
+    assert!(
+        result.is_satisfied_tristate.is_none(),
+        "Expected Null result for invalid timestamp"
+    );
+}
+
+#[test]
+fn test_temporal_during_not_implemented() {
+    let graph = Graph::new();
+
+    // 'during' operator should return a clear error
+    let expr_str = r#""2025-06-15T12:00:00Z" during interval("09:00", "17:00")"#;
+    let expr = parse_expression_from_str(expr_str).expect("Failed to parse expression");
+
+    let policy = Policy::new("test_during", expr);
+    let result = policy.evaluate(&graph);
+
+    assert!(result.is_err(), "Expected error for 'during' operator");
+    let err_msg = result.unwrap_err();
+    assert!(
+        err_msg.contains("during"),
+        "Error should mention 'during' operator: {}",
+        err_msg
+    );
+    assert!(
+        err_msg.contains("not yet implemented"),
+        "Error should indicate not implemented: {}",
+        err_msg
+    );
+}
+
+#[test]
+fn test_temporal_same_timestamp_not_before() {
+    let graph = Graph::new();
+
+    // Same timestamp should NOT be before itself
+    let expr_str = r#""2025-01-01T00:00:00Z" before "2025-01-01T00:00:00Z""#;
+    let expr = parse_expression_from_str(expr_str).expect("Failed to parse expression");
+
+    let policy = Policy::new("test_same", expr);
+    let result = policy.evaluate(&graph).expect("Failed to evaluate policy");
+
+    assert!(
+        !result.is_satisfied,
+        "Same timestamp should not be before itself"
+    );
+    assert_eq!(result.is_satisfied_tristate, Some(false));
+}