domainforge 0.13.0

package/domainforge-core/tests/protobuf_projection_tests.rs

@@ -0,0 +1,199 @@
+//! Protobuf projection integration tests
+//!
+//! Tests the full pipeline: parse SEA -> Graph -> ProtoFile -> .proto text
+
+use domainforge_core::parser::ast::ast_to_graph;
+use domainforge_core::parser::parse_source;
+use domainforge_core::projection::protobuf::ProtobufEngine;
+
+#[test]
+fn test_parse_entity_to_protobuf() {
+    let source = r#"
+        Entity "Customer"
+        Entity "Order"
+        Entity "Product"
+    "#;
+
+    let ast = parse_source(source).expect("Failed to parse");
+    let graph = ast_to_graph(ast).expect("Failed to build graph");
+
+    let proto = ProtobufEngine::project(&graph, "", "test.package");
+
+    assert_eq!(proto.package, "test.package");
+    assert_eq!(proto.messages.len(), 3);
+
+    // Messages should be sorted alphabetically
+    assert_eq!(proto.messages[0].name, "Customer");
+    assert_eq!(proto.messages[1].name, "Order");
+    assert_eq!(proto.messages[2].name, "Product");
+
+    // Each message should have id and name fields
+    for msg in &proto.messages {
+        assert!(msg.fields.iter().any(|f| f.name == "id"));
+        assert!(msg.fields.iter().any(|f| f.name == "name"));
+    }
+}
+
+#[test]
+fn test_parse_resource_to_protobuf() {
+    let source = r#"
+        Resource "Money" USD
+        Resource "Inventory" units
+    "#;
+
+    let ast = parse_source(source).expect("Failed to parse");
+    let graph = ast_to_graph(ast).expect("Failed to build graph");
+
+    let proto = ProtobufEngine::project(&graph, "", "resources.package");
+
+    assert_eq!(proto.messages.len(), 2);
+
+    // Each resource message should have id, name, quantity, unit fields
+    for msg in &proto.messages {
+        let field_names: Vec<&str> = msg.fields.iter().map(|f| f.name.as_str()).collect();
+        assert!(field_names.contains(&"id"));
+        assert!(field_names.contains(&"name"));
+        assert!(field_names.contains(&"quantity"));
+        assert!(field_names.contains(&"unit"));
+    }
+}
+
+#[test]
+fn test_namespace_filtering() {
+    let source = r#"
+        @namespace "logistics"
+        Entity "Warehouse"
+        Entity "Vehicle"
+    "#;
+
+    let ast = parse_source(source).expect("Failed to parse");
+    let graph = ast_to_graph(ast).expect("Failed to build graph");
+
+    // Filter by logistics namespace
+    let proto = ProtobufEngine::project(&graph, "logistics", "logistics.package");
+    assert_eq!(proto.messages.len(), 2);
+
+    // Filter by non-existent namespace
+    let proto_empty = ProtobufEngine::project(&graph, "finance", "finance.package");
+    assert_eq!(proto_empty.messages.len(), 0);
+}
+
+#[test]
+fn test_protobuf_text_output() {
+    let source = r#"
+        Entity "PaymentProcessor"
+    "#;
+
+    let ast = parse_source(source).expect("Failed to parse");
+    let graph = ast_to_graph(ast).expect("Failed to build graph");
+
+    let proto = ProtobufEngine::project(&graph, "", "payments");
+    let proto_text = proto.to_proto_string();
+
+    // Check essential proto3 elements
+    assert!(proto_text.contains("syntax = \"proto3\";"));
+    assert!(proto_text.contains("package payments;"));
+    assert!(proto_text.contains("message PaymentProcessor {"));
+    assert!(proto_text.contains("string id = 1;"));
+    assert!(proto_text.contains("string name = 2;"));
+}
+
+#[test]
+fn test_governance_messages() {
+    let source = r#"
+        Entity "TestEntity"
+    "#;
+
+    let ast = parse_source(source).expect("Failed to parse");
+    let graph = ast_to_graph(ast).expect("Failed to build graph");
+
+    let proto = ProtobufEngine::project_with_options(
+        &graph,
+        "",
+        "governance.test",
+        "GovernanceProjection",
+        true,
+    );
+
+    // Should have entity + 2 governance messages
+    assert_eq!(proto.messages.len(), 3);
+
+    let message_names: Vec<&str> = proto.messages.iter().map(|m| m.name.as_str()).collect();
+    assert!(message_names.contains(&"PolicyViolation"));
+    assert!(message_names.contains(&"MetricEvent"));
+    assert!(message_names.contains(&"TestEntity"));
+}
+
+#[test]
+fn test_protobuf_projection_declaration() {
+    let source = r#"
+        Entity "Vendor"
+
+        Projection "vendor_proto" for protobuf {
+            Entity "Vendor" {
+                package: "vendor.api"
+            }
+        }
+    "#;
+
+    let ast = parse_source(source).expect("Failed to parse");
+    let graph = ast_to_graph(ast).expect("Failed to build graph");
+
+    // Verify the projection was parsed
+    assert_eq!(graph.projection_count(), 1);
+
+    // Project to protobuf
+    let proto = ProtobufEngine::project(&graph, "", "vendor.api");
+    assert_eq!(proto.messages.len(), 1);
+    assert_eq!(proto.messages[0].name, "Vendor");
+}
+
+#[test]
+fn test_deterministic_field_ordering() {
+    let source = r#"
+        Entity "Customer"
+        Entity "Order"
+    "#;
+
+    let ast1 = parse_source(source).expect("Failed to parse");
+    let graph1 = ast_to_graph(ast1).expect("Failed to build graph");
+    let proto1 = ProtobufEngine::project(&graph1, "", "test");
+
+    let ast2 = parse_source(source).expect("Failed to parse");
+    let graph2 = ast_to_graph(ast2).expect("Failed to build graph");
+    let proto2 = ProtobufEngine::project(&graph2, "", "test");
+
+    // Messages should be identical (same count, same names, same fields)
+    assert_eq!(proto1.messages.len(), proto2.messages.len());
+
+    for (m1, m2) in proto1.messages.iter().zip(proto2.messages.iter()) {
+        assert_eq!(m1.name, m2.name);
+        assert_eq!(m1.fields.len(), m2.fields.len());
+
+        for (f1, f2) in m1.fields.iter().zip(m2.fields.iter()) {
+            assert_eq!(f1.name, f2.name);
+            assert_eq!(f1.number, f2.number);
+        }
+    }
+}
+
+#[test]
+fn test_proto_options() {
+    let source = r#"
+        Entity "Example"
+    "#;
+
+    let ast = parse_source(source).expect("Failed to parse");
+    let graph = ast_to_graph(ast).expect("Failed to build graph");
+
+    let mut proto = ProtobufEngine::project(&graph, "", "com.example");
+    proto.options.java_package = Some("com.example.proto".to_string());
+    proto.options.java_multiple_files = true;
+    proto.options.go_package = Some("github.com/example/proto".to_string());
+
+    let proto_text = proto.to_proto_string();
+
+    assert!(proto_text.contains("option java_package = \"com.example.proto\";"));
+    assert!(proto_text.contains("option java_multiple_files = true;"));
+    assert!(proto_text.contains("option go_package = \"github.com/example/proto\";"));
+}

package/domainforge-core/tests/quantity_tests.rs

@@ -0,0 +1,41 @@
+#[cfg(feature = "formatting")]
+use domainforge_core::primitives::quantity::QuantityFormatter;
+use domainforge_core::primitives::Quantity;
+use domainforge_core::units::Dimension;
+#[cfg(feature = "formatting")]
+use icu_locid::locale;
+
+#[cfg(feature = "formatting")]
+#[test]
+fn test_quantity_formatting_en_us() {
+    let quantity = Quantity::new(1500.0, "USD".to_string(), Dimension::Currency).unwrap();
+    let formatter = QuantityFormatter::new(locale!("en-US"));
+    assert_eq!(formatter.format(&quantity).unwrap(), "1,500 \"USD\"");
+}
+
+#[cfg(feature = "formatting")]
+#[test]
+fn test_quantity_formatting_de_de() {
+    let quantity = Quantity::new(1500.0, "EUR".to_string(), Dimension::Currency).unwrap();
+    let formatter = QuantityFormatter::new(locale!("de-DE"));
+    assert_eq!(formatter.format(&quantity).unwrap(), "1.500 \"EUR\"");
+}
+
+#[cfg(feature = "formatting")]
+#[test]
+fn test_quantity_formatting_fr_fr() {
+    let quantity = Quantity::new(1500.0, "EUR".to_string(), Dimension::Currency).unwrap();
+    let formatter = QuantityFormatter::new(locale!("fr-FR"));
+    // ICU might use narrow non-breaking space or space depending on version/data
+    // We'll check if it contains the number formatted correctly
+    let formatted = formatter.format(&quantity).unwrap();
+    assert!(formatted.contains("1") && formatted.contains("500"));
+    assert!(formatted.contains("\"EUR\""));
+}
+
+#[test]
+fn test_quantity_validation() {
+    assert!(Quantity::new(f64::NAN, "USD".to_string(), Dimension::Currency).is_err());
+    assert!(Quantity::new(f64::INFINITY, "USD".to_string(), Dimension::Currency).is_err());
+    assert!(Quantity::new(f64::NEG_INFINITY, "USD".to_string(), Dimension::Currency).is_err());
+}

package/domainforge-core/tests/rdf_xml_typed_literal_tests.rs

@@ -0,0 +1,105 @@
+#[cfg(test)]
+mod rdf_xml_typed_literal_tests {
+    use domainforge_core::primitives::{Entity, Flow, Resource};
+    use domainforge_core::{
+        kg::{KnowledgeGraph, Triple},
+        unit_from_string, Graph,
+    };
+    use roxmltree::Document;
+    use rust_decimal::Decimal;
+
+    #[test]
+    fn test_decimal_datatype_preserved() {
+        let mut graph = Graph::new();
+
+        let supplier = Entity::new_with_namespace("Supplier", "default".to_string());
+        let manufacturer = Entity::new_with_namespace("Manufacturer", "default".to_string());
+        let money =
+            Resource::new_with_namespace("Money", unit_from_string("USD"), "default".to_string());
+
+        let supplier_id = supplier.id().clone();
+        let manufacturer_id = manufacturer.id().clone();
+        let money_id = money.id().clone();
+
+        graph.add_entity(supplier).unwrap();
+        graph.add_entity(manufacturer).unwrap();
+        graph.add_resource(money).unwrap();
+
+        let flow = Flow::new_with_namespace(
+            money_id,
+            supplier_id,
+            manufacturer_id,
+            Decimal::new(2500, 2),
+            "default",
+        );
+        graph.add_flow(flow).unwrap();
+
+        let kg = KnowledgeGraph::from_graph(&graph).unwrap();
+        let rdf_xml = kg.to_rdf_xml();
+
+        assert!(
+            rdf_xml.contains("rdf:datatype=\"http://www.w3.org/2001/XMLSchema#decimal\"")
+                || rdf_xml.contains("rdf:datatype=\"http://domainforge.ai/xsd#decimal\"")
+        );
+    }
+
+    #[test]
+    fn test_language_tag_preserved() {
+        let mut kg = KnowledgeGraph::new();
+        kg.triples.push(Triple {
+            subject: "sea:TestEntity".to_string(),
+            predicate: "rdfs:label".to_string(),
+            object: "\"Warehouse\"@en".to_string(),
+        });
+
+        let rdf_xml = kg.to_rdf_xml();
+
+        let doc = Document::parse(&rdf_xml).expect("Failed to parse RDF/XML");
+        let label_node = doc
+            .descendants()
+            .find(|node| {
+                node.is_element()
+                    && node.tag_name().name() == "label"
+                    && node.tag_name().namespace() == Some("http://www.w3.org/2000/01/rdf-schema#")
+            })
+            .expect("Missing rdfs:label element");
+
+        assert_eq!(label_node.text(), Some("Warehouse"));
+        // Use namespace-aware attribute lookup: roxmltree allows checking attributes by
+        // expanded name (namespace URI, local name). The `xml:lang` attribute lives in
+        // the XML namespace "http://www.w3.org/XML/1998/namespace".
+        assert_eq!(
+            label_node.attribute(("http://www.w3.org/XML/1998/namespace", "lang")),
+            Some("en")
+        );
+    }
+
+    #[test]
+    fn test_escaped_literal_in_xml() {
+        let mut graph = Graph::new();
+        let warehouse = Entity::new_with_namespace("Warehouse", "default".to_string());
+        let resource = Resource::new_with_namespace(
+            "Resource<With>&Special\"'Chars",
+            unit_from_string("units"),
+            "default".to_string(),
+        );
+
+        graph.add_entity(warehouse).unwrap();
+        graph.add_resource(resource).unwrap();
+
+        let kg = KnowledgeGraph::from_graph(&graph).unwrap();
+        let rdf_xml = kg.to_rdf_xml();
+
+        assert!(rdf_xml.contains("&lt;"));
+        assert!(rdf_xml.contains("&gt;"));
+        assert!(rdf_xml.contains("&amp;"));
+        assert!(rdf_xml.contains("&quot;"));
+        assert!(rdf_xml.contains("&apos;"));
+    }
+
+    #[test]
+    fn test_escape_xml_helper_covers_all_entities() {
+        let escaped = KnowledgeGraph::escape_xml("&<>\"'");
+        assert_eq!(escaped, "&amp;&lt;&gt;&quot;&apos;");
+    }
+}

package/domainforge-core/tests/registry_schema_tests.rs

@@ -0,0 +1,33 @@
+use jsonschema::{Draft, JSONSchema};
+use serde_json::Value;
+use std::fs;
+use std::path::PathBuf;
+
+#[test]
+fn registry_schema_validates_sample() {
+    let manifest = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let schema_path = manifest
+        .join("..")
+        .join("schemas")
+        .join("sea-registry.schema.json");
+    let schema = fs::read_to_string(&schema_path).expect("schema must exist");
+    let schema_json: Value = serde_json::from_str(&schema).expect("valid JSON schema");
+    let compiled = JSONSchema::options()
+        .with_draft(Draft::Draft7)
+        .compile(&schema_json)
+        .expect("schema compiles");
+
+    let sample_toml = r#"
+version = 1
+default_namespace = "default"
+
+[[namespaces]]
+namespace = "logistics"
+patterns = ["domains/logistics/**/*.sea"]
+"#;
+    let value: toml::Value = toml::from_str(sample_toml).expect("valid toml");
+    let json_val = serde_json::to_value(value).expect("serde conversion");
+
+    let result = compiled.validate(&json_val);
+    assert!(result.is_ok(), "schema must validate sample registry");
+}

package/domainforge-core/tests/resource_tests.rs

@@ -0,0 +1,50 @@
+use domainforge_core::primitives::Resource;
+use domainforge_core::units::{unit_from_string, Dimension, Unit};
+use rust_decimal::Decimal;
+use serde_json::json;
+use uuid::Uuid;
+
+#[test]
+fn test_resource_new_creates_valid_uuid() {
+    let units = unit_from_string("units");
+    let resource = Resource::new_with_namespace("Camera", units, "default".to_string());
+    assert!(Uuid::parse_str(&resource.id().to_string()).is_ok());
+}
+
+#[test]
+fn test_resource_name_and_unit_stored() {
+    let kg = unit_from_string("kg");
+    let resource = Resource::new_with_namespace("Steel Beam", kg, "default".to_string());
+    assert_eq!(resource.name(), "Steel Beam");
+    assert_eq!(resource.unit().symbol(), "kg");
+}
+
+#[test]
+fn test_resource_with_namespace() {
+    let currency = unit_from_string("USD");
+    let resource = Resource::new_with_namespace("USD", currency, "finance");
+    assert_eq!(resource.namespace(), "finance");
+}
+
+#[test]
+fn test_resource_set_attribute() {
+    let kg = unit_from_string("kg");
+    let mut resource = Resource::new_with_namespace("Gold", kg, "default".to_string());
+    resource.set_attribute("purity", json!(0.999));
+    assert_eq!(resource.get_attribute("purity"), Some(&json!(0.999)));
+}
+
+#[test]
+fn test_resource_serializes() {
+    let oz = Unit::new(
+        "oz",
+        "ounce",
+        Dimension::Mass,
+        Decimal::new(28349523, 9),
+        "oz",
+    );
+    let resource = Resource::new_with_namespace("Silver", oz, "default".to_string());
+    let json = serde_json::to_string(&resource).unwrap();
+    assert!(json.contains("Silver"));
+    assert!(json.contains("oz"));
+}

package/domainforge-core/tests/resource_unit_tests.rs

@@ -0,0 +1,24 @@
+use domainforge_core::primitives::Resource;
+use domainforge_core::units::{Dimension, Unit};
+use rust_decimal::Decimal;
+
+#[test]
+fn test_resource_with_unit() {
+    let kg = Unit::new("kg", "kilogram", Dimension::Mass, Decimal::from(1), "kg");
+    let gold = Resource::new_with_namespace("Gold", kg, "default".to_string());
+
+    assert_eq!(gold.name(), "Gold");
+    assert_eq!(gold.unit().symbol(), "kg");
+    assert_eq!(gold.unit().dimension(), &Dimension::Mass);
+}
+
+#[test]
+fn test_resource_unit_serialization() {
+    let kg = Unit::new("kg", "kilogram", Dimension::Mass, Decimal::from(1), "kg");
+    let gold = Resource::new_with_namespace("Gold", kg, "default".to_string());
+
+    let json = serde_json::to_string(&gold).unwrap();
+    let deserialized: Resource = serde_json::from_str(&json).unwrap();
+
+    assert_eq!(gold.unit().symbol(), deserialized.unit().symbol());
+}

package/domainforge-core/tests/roles_relations_tests.rs

@@ -0,0 +1,61 @@
+use domainforge_core::kg::KnowledgeGraph;
+use domainforge_core::parser::parse_to_graph;
+use domainforge_core::sbvr::SbvrModel;
+
+#[test]
+fn parses_roles_relations_and_projects() {
+    let dsl = r#"
+        Role "Payer"
+        Role "Payee"
+
+        Resource "Money" units
+
+        Entity "Alice"
+        Entity "Bob"
+
+        Flow "Money" from "Alice" to "Bob" quantity 10
+
+        Relation "Payment"
+          subject: "Payer"
+          predicate: "pays"
+          object: "Payee"
+          via: flow "Money"
+
+        Policy role_check as:
+          exists e in entities: (e has_role "Payer")
+    "#;
+
+    let mut graph = parse_to_graph(dsl).expect("should parse role and relation declarations");
+
+    assert_eq!(graph.role_count(), 2);
+    assert_eq!(graph.relation_count(), 1);
+
+    let payer_role = graph
+        .find_role_by_name("Payer")
+        .expect("payer role should exist");
+    let alice = graph
+        .find_entity_by_name("Alice")
+        .expect("alice entity should exist");
+
+    graph
+        .assign_role_to_entity(alice, payer_role)
+        .expect("role assignment should succeed");
+
+    let validation = graph.validate();
+    assert_eq!(
+        validation.error_count, 0,
+        "policy should pass once role assigned"
+    );
+
+    let kg = KnowledgeGraph::from_graph(&graph).expect("kg projection should succeed");
+    assert!(kg
+        .triples
+        .iter()
+        .any(|triple| triple.predicate == "sea:subjectRole" && triple.object.contains("Payer")));
+
+    let sbvr = SbvrModel::from_graph(&graph).expect("sbvr projection should succeed");
+    assert!(sbvr
+        .facts
+        .iter()
+        .any(|fact| fact.verb == "pays" && fact.object.contains("Payee")));
+}

package/domainforge-core/tests/round_trip_tests.rs

@@ -0,0 +1,34 @@
+use domainforge_core::parser::{parse_to_graph, PrettyPrinter};
+
+#[test]
+fn test_round_trip_basic() {
+    let source = r#"Entity "Server"
+Resource "CPU"
+"#;
+
+    // 1. Parse to Graph
+    let graph = parse_to_graph(source).unwrap();
+
+    // 2. Graph to AST
+    let ast = graph.to_ast();
+
+    // 3. AST to Source (PrettyPrint)
+    let printer = PrettyPrinter::new();
+    let printed = printer.print(&ast);
+
+    println!("Printed:\n{}", printed);
+
+    // 4. Parse Printed to Graph
+    let graph2 = parse_to_graph(&printed).unwrap();
+
+    // 5. Compare Graphs (structural check via serialization)
+    let graph_json =
+        serde_json::to_value(&graph).expect("Failed to serialize graph for comparison");
+    let graph2_json =
+        serde_json::to_value(&graph2).expect("Failed to serialize parsed graph for comparison");
+    assert_eq!(graph_json, graph2_json);
+
+    // 6. Ensure serialized forms stay stable across another round-trip
+    let printed_again = printer.print(&graph2.to_ast());
+    assert_eq!(printed, printed_again);
+}

package/domainforge-core/tests/runtime_toggle_tests.rs

@@ -0,0 +1,70 @@
+use domainforge_core::graph::Graph;
+use domainforge_core::policy::{BinaryOp, Expression, Policy, Severity};
+use domainforge_core::primitives::Entity;
+
+#[test]
+fn test_runtime_toggle_three_valued_logic() {
+    // Create a graph with an entity that has a null attribute
+    let mut graph = Graph::new();
+
+    let mut entity = Entity::new_with_namespace("TestEntity".to_string(), "default".to_string());
+    entity.set_attribute("status", serde_json::Value::Null);
+    graph.add_entity(entity).unwrap();
+
+    // Create a policy that inspects the null status attribute so modes diverge
+    let policy = Policy::new(
+        "TestPolicy",
+        Expression::binary(
+            BinaryOp::Equal,
+            Expression::member_access("TestEntity", "status"),
+            Expression::literal(true),
+        ),
+    );
+
+    // Test with three-valued logic enabled (default)
+    graph.set_evaluation_mode(true);
+    let result_with_tristate = policy.evaluate(&graph).unwrap();
+
+    // NULL attribute bubbles up to an indeterminate result
+    assert_eq!(result_with_tristate.is_satisfied_tristate, None);
+    assert!(!result_with_tristate.is_satisfied);
+    assert_eq!(result_with_tristate.violations.len(), 1);
+    assert_eq!(result_with_tristate.violations[0].severity, Severity::Error);
+
+    // Test with three-valued logic disabled
+    graph.set_evaluation_mode(false);
+    let result_without_tristate = policy.evaluate(&graph).unwrap();
+
+    // Boolean mode treats missing data as false
+    assert_eq!(result_without_tristate.is_satisfied_tristate, Some(false));
+    assert!(!result_without_tristate.is_satisfied);
+    assert_eq!(result_without_tristate.violations.len(), 1);
+    assert_eq!(
+        result_without_tristate.violations[0].severity,
+        Severity::Error
+    );
+}
+
+#[test]
+fn test_runtime_toggle_default_is_three_valued() {
+    let graph = Graph::new();
+
+    // Default should be three-valued logic enabled
+    assert!(graph.use_three_valued_logic());
+}
+
+#[test]
+fn test_runtime_toggle_can_be_changed() {
+    let mut graph = Graph::new();
+
+    // Start with default (three-valued enabled)
+    assert!(graph.use_three_valued_logic());
+
+    // Disable three-valued logic
+    graph.set_evaluation_mode(false);
+    assert!(!graph.use_three_valued_logic());
+
+    // Re-enable three-valued logic
+    graph.set_evaluation_mode(true);
+    assert!(graph.use_three_valued_logic());
+}

package/domainforge-core/tests/sbvr_fact_schema_tests.rs

@@ -0,0 +1,60 @@
+#[cfg(test)]
+mod sbvr_fact_schema_tests {
+    use domainforge_core::sbvr::SbvrFactType;
+
+    #[test]
+    fn test_fact_type_includes_destination_and_schema_version() {
+        let fact = SbvrFactType {
+            id: "fact-001".to_string(),
+            subject: "entity-from".to_string(),
+            verb: "transfers".to_string(),
+            object: "resource-123".to_string(),
+            destination: Some("entity-to".to_string()),
+            schema_version: "2.0".to_string(),
+        };
+
+        let json = serde_json::to_string(&fact).unwrap();
+        let value: serde_json::Value = serde_json::from_str(&json).unwrap();
+
+        assert_eq!(value["schema_version"], "2.0");
+        assert_eq!(value["destination"].as_str(), Some("entity-to"));
+        assert_eq!(value["object"], "resource-123");
+    }
+
+    #[test]
+    fn test_fact_v1_upgrade_without_destination() {
+        let legacy = r#"{
+            "id":"legacy-fact",
+            "subject":"legacy-from",
+            "verb":"transfers",
+            "object":"legacy-to"
+        }"#;
+
+        let upgraded: SbvrFactType = serde_json::from_str(legacy).unwrap();
+        assert_eq!(upgraded.schema_version, "2.0");
+        assert_eq!(upgraded.destination, None);
+        assert_eq!(upgraded.object, "legacy-to");
+    }
+
+    #[test]
+    fn test_sbvr_fact_round_trip() {
+        let fact = SbvrFactType {
+            id: "fact-002".to_string(),
+            subject: "warehouse".to_string(),
+            verb: "transfers".to_string(),
+            object: "camera-resource".to_string(),
+            destination: Some("factory".to_string()),
+            schema_version: "2.0".to_string(),
+        };
+
+        let json = serde_json::to_string(&fact).unwrap();
+        let deserialized: SbvrFactType = serde_json::from_str(&json).unwrap();
+
+        assert_eq!(deserialized.id, "fact-002");
+        assert_eq!(deserialized.subject, "warehouse");
+        assert_eq!(deserialized.verb, "transfers");
+        assert_eq!(deserialized.object, "camera-resource");
+        assert_eq!(deserialized.destination.as_deref(), Some("factory"));
+        assert_eq!(deserialized.schema_version, "2.0");
+    }
+}