domain: add cross-cutting value objects (SystemId, DateTimeStamp, Checksum, StructuredData)

crates/domain/tests/domain_tests.rs

@@ -0,0 +1 @@
+mod value_objects;

crates/domain/tests/value_objects/checksum.rs

@@ -0,0 +1,27 @@
+use domain::value_objects::Checksum;
+
+#[test]
+fn accepts_valid_sha256() {
+    let hex = "a".repeat(64);
+    assert!(Checksum::new(&hex).is_ok());
+}
+
+#[test]
+fn rejects_short() {
+    let hex = "a".repeat(63);
+    assert!(Checksum::new(&hex).is_err());
+}
+
+#[test]
+fn rejects_non_hex() {
+    let mut hex = "a".repeat(63);
+    hex.push('g');
+    assert!(Checksum::new(&hex).is_err());
+}
+
+#[test]
+fn normalizes_to_lowercase() {
+    let hex = "A".repeat(64);
+    let cs = Checksum::new(&hex).unwrap();
+    assert_eq!(cs.as_str(), "a".repeat(64));
+}

crates/domain/tests/value_objects/date_time_stamp.rs

@@ -0,0 +1,30 @@
+use chrono::Utc;
+use domain::value_objects::DateTimeStamp;
+
+#[test]
+fn now_is_recent() {
+    let before = Utc::now();
+    let ts = DateTimeStamp::now();
+    let after = Utc::now();
+    assert!(*ts.as_datetime() >= before);
+    assert!(*ts.as_datetime() <= after);
+}
+
+#[test]
+fn ordering() {
+    let a = DateTimeStamp::from_datetime(
+        chrono::DateTime::parse_from_rfc3339("2024-01-01T00:00:00Z").unwrap().into(),
+    );
+    let b = DateTimeStamp::from_datetime(
+        chrono::DateTime::parse_from_rfc3339("2025-01-01T00:00:00Z").unwrap().into(),
+    );
+    assert!(a < b);
+}
+
+#[test]
+fn serde_roundtrip() {
+    let ts = DateTimeStamp::now();
+    let json = serde_json::to_string(&ts).unwrap();
+    let back: DateTimeStamp = serde_json::from_str(&json).unwrap();
+    assert_eq!(ts, back);
+}

crates/domain/tests/value_objects/mod.rs

@@ -0,0 +1,4 @@
+mod checksum;
+mod date_time_stamp;
+mod structured_data;
+mod system_id;

crates/domain/tests/value_objects/structured_data.rs

@@ -0,0 +1,45 @@
+use domain::value_objects::{MetadataValue, StructuredData};
+
+#[test]
+fn insert_and_get() {
+    let mut sd = StructuredData::new();
+    sd.insert("key", MetadataValue::String("value".into()));
+    assert_eq!(sd.get_string("key"), Some("value"));
+    assert_eq!(sd.len(), 1);
+    assert!(!sd.is_empty());
+}
+
+#[test]
+fn merge_from_overwrites() {
+    let mut a = StructuredData::new();
+    a.insert("k", MetadataValue::Integer(1));
+
+    let mut b = StructuredData::new();
+    b.insert("k", MetadataValue::Integer(2));
+
+    a.merge_from(b);
+    assert!(matches!(a.get("k"), Some(MetadataValue::Integer(2))));
+}
+
+#[test]
+fn serde_roundtrip() {
+    let mut sd = StructuredData::new();
+    sd.insert("s", MetadataValue::String("hello".into()));
+    sd.insert("i", MetadataValue::Integer(42));
+    sd.insert("f", MetadataValue::Float(3.14));
+    sd.insert("b", MetadataValue::Boolean(true));
+    sd.insert("n", MetadataValue::Null);
+
+    let json = serde_json::to_string(&sd).unwrap();
+    let back: StructuredData = serde_json::from_str(&json).unwrap();
+    assert_eq!(sd, back);
+}
+
+#[test]
+fn remove_works() {
+    let mut sd = StructuredData::new();
+    sd.insert("k", MetadataValue::Integer(1));
+    let removed = sd.remove("k");
+    assert!(matches!(removed, Some(MetadataValue::Integer(1))));
+    assert!(sd.is_empty());
+}

crates/domain/tests/value_objects/system_id.rs

@@ -0,0 +1,31 @@
+use domain::value_objects::SystemId;
+use uuid::Uuid;
+
+#[test]
+fn unique_generation() {
+    let a = SystemId::new();
+    let b = SystemId::new();
+    assert_ne!(a, b);
+}
+
+#[test]
+fn uuid_roundtrip() {
+    let uuid = Uuid::new_v4();
+    let id = SystemId::from_uuid(uuid);
+    assert_eq!(*id.as_uuid(), uuid);
+}
+
+#[test]
+fn display_matches_uuid() {
+    let uuid = Uuid::new_v4();
+    let id = SystemId::from_uuid(uuid);
+    assert_eq!(id.to_string(), uuid.to_string());
+}
+
+#[test]
+fn serde_roundtrip() {
+    let id = SystemId::new();
+    let json = serde_json::to_string(&id).unwrap();
+    let back: SystemId = serde_json::from_str(&json).unwrap();
+    assert_eq!(id, back);
+}