footing 0.1.13

Feature-gated foundations for Rust backend services
Documentation
use std::sync::{Arc, Mutex};

use async_trait::async_trait;

use super::{
    DomainEvent, DomainEventDispatchError, DomainEventDispatcher, DomainEventFailurePolicy,
    DomainEventHandler, DomainEventName,
};
use crate::result::BoxError;

#[test]
fn event_fields_truncate_on_unicode_boundaries() {
    for (input, expected) in [
        ("δΈ­".repeat(200), "δΈ­".repeat(170)),
        ("πŸ™‚".repeat(200), "πŸ™‚".repeat(128)),
        (format!("{}πŸ™‚", "a".repeat(511)), "a".repeat(511)),
    ] {
        let event = DomainEvent::new("test.event").unwrap().with_subject(input);
        assert_eq!(event.subject(), Some(expected.as_str()));
    }
}

#[test]
fn validates_event_names() {
    assert!(DomainEventName::new("user.created").is_ok());
    assert!(DomainEventName::new("UserCreated").is_err());
    assert!(DomainEventName::new("user-created").is_err());
}

#[test]
fn events_round_trip_optional_fields_and_json_metadata_in_binary_formats() {
    let empty = DomainEvent::new("user.created").unwrap();
    let populated = empty
        .clone()
        .with_subject("usr_01")
        .with_actor("admin")
        .with_idempotency_key("operation_01")
        .with_correlation_id("req_01")
        .with_metadata_value(
            "data",
            serde_json::json!({
                "values": [null, true, 42, 2.5, "δΈ­ζ–‡\n\"\\"],
                "nested": {"empty": []}
            }),
        );

    for event in [empty, populated] {
        let bytes = postcard::to_allocvec(&event).unwrap();
        assert_eq!(postcard::from_bytes::<DomainEvent>(&bytes).unwrap(), event);
        let json = serde_json::to_value(&event).unwrap();
        assert!(json["metadata"].is_object());
        assert_eq!(serde_json::from_value::<DomainEvent>(json).unwrap(), event);
    }
}

#[test]
fn event_normalizes_optional_fields_and_metadata() {
    let event = DomainEvent::new("user.created")
        .expect("event should build")
        .with_subject(" usr_\n01 ")
        .with_actor(" admin ")
        .with_metadata_value(" source ", "console")
        .with_metadata_value("Request-ID", "req_01")
        .with_metadata_value("bad/key", "ignored");

    assert_eq!(event.name().as_str(), "user.created");
    assert_eq!(event.subject(), Some("usr_01"));
    assert_eq!(event.actor(), Some("admin"));
    assert_eq!(event.metadata()["source"], "console");
    assert_eq!(event.metadata()["request-id"], "req_01");
    assert!(!event.metadata().contains_key("bad/key"));
}

#[test]
fn domain_event_debug_redacts_identifiers_and_metadata_without_changing_wire_data() {
    let subject = "private-subject";
    let actor = "private-actor";
    let idempotency_key = "private-idempotency-key";
    let correlation_id = "private-correlation-id";
    let metadata_value = "private-metadata-value";
    let event = DomainEvent::new("user.created")
        .expect("event should build")
        .with_subject(subject)
        .with_actor(actor)
        .with_idempotency_key(idempotency_key)
        .with_correlation_id(correlation_id)
        .with_metadata_value("credential", metadata_value);

    let debug = format!("{event:?}");
    assert!(debug.contains("[REDACTED]"));
    for sensitive in [
        subject,
        actor,
        idempotency_key,
        correlation_id,
        metadata_value,
    ] {
        assert!(!debug.contains(sensitive));
    }

    let wire = serde_json::to_value(event).expect("event should serialize");
    assert_eq!(wire["subject"], subject);
    assert_eq!(wire["actor"], actor);
    assert_eq!(wire["idempotency_key"], idempotency_key);
    assert_eq!(wire["correlation_id"], correlation_id);
    assert_eq!(wire["metadata"]["credential"], metadata_value);
}

#[test]
fn event_normalizes_bulk_metadata_like_single_metadata_values() {
    let mut metadata = serde_json::Map::new();
    metadata.insert(" Request-ID ".to_owned(), "req_01".into());
    metadata.insert("bad/key".to_owned(), "ignored".into());
    metadata.insert("".to_owned(), "ignored".into());

    let event = DomainEvent::new("user.created")
        .expect("event should build")
        .with_metadata(metadata);

    assert_eq!(event.metadata()["request-id"], "req_01");
    assert_eq!(event.metadata().len(), 1);
}

#[test]
fn deserialization_validates_name_and_normalizes_fields() {
    let value = serde_json::json!({
        "name": "user.created",
        "subject": " usr_\n01 ",
        "actor": " admin ",
        "metadata": {
            " Request-ID ": "req_01",
            "bad/key": "ignored"
        }
    });
    let event: DomainEvent =
        serde_json::from_value(value).expect("valid event JSON should deserialize");

    assert_eq!(event.name().as_str(), "user.created");
    assert_eq!(event.subject(), Some("usr_01"));
    assert_eq!(event.actor(), Some("admin"));
    assert_eq!(event.metadata()["request-id"], "req_01");
    assert_eq!(event.metadata().len(), 1);

    assert!(serde_json::from_value::<DomainEventName>(serde_json::json!("UserCreated")).is_err());
    assert!(
        serde_json::from_value::<DomainEvent>(serde_json::json!({ "name": "UserCreated" }))
            .is_err()
    );
}

#[tokio::test]
async fn dispatcher_invokes_handlers_in_order() {
    let seen = Arc::new(Mutex::new(Vec::new()));
    let dispatcher = DomainEventDispatcher::new()
        .with_handler(Arc::new(RecordingHandler::new("first", Arc::clone(&seen))))
        .with_handler(Arc::new(RecordingHandler::new("second", Arc::clone(&seen))));
    let event = DomainEvent::new("user.created").expect("event should build");

    let summary = dispatcher
        .publish(&event)
        .await
        .expect("dispatch should succeed");

    assert_eq!(summary.handlers(), 2);
    assert_eq!(summary.succeeded(), 2);
    assert_eq!(
        &*seen.lock().expect("seen lock should not poison"),
        &["first", "second"]
    );
}

#[tokio::test]
async fn dispatcher_can_stop_on_first_error() {
    let dispatcher = DomainEventDispatcher::new()
        .with_failure_policy(DomainEventFailurePolicy::StopOnFirstError)
        .with_handler(Arc::new(FailingHandler));
    let event = DomainEvent::new("user.created").expect("event should build");

    let error = dispatcher
        .publish(&event)
        .await
        .expect_err("dispatch should fail");

    assert!(matches!(
        error,
        DomainEventDispatchError::HandlerFailed { .. }
    ));
    assert_eq!(error.summary().failed(), 1);
    assert_eq!(error.summary().failures()[0].handler(), "failing");
    let debug = format!("{error:?}");
    assert!(debug.contains("[REDACTED]"));
    assert!(!debug.contains("handler failed"));
}

#[tokio::test]
async fn dispatcher_records_failure_details_when_continuing() {
    let seen = Arc::new(Mutex::new(Vec::new()));
    let dispatcher = DomainEventDispatcher::new()
        .with_handler(Arc::new(FailingHandler))
        .with_handler(Arc::new(RecordingHandler::new("second", Arc::clone(&seen))));
    let event = DomainEvent::new("user.created").expect("event should build");

    let summary = dispatcher
        .publish(&event)
        .await
        .expect("dispatch should continue");

    assert_eq!(summary.handlers(), 2);
    assert_eq!(summary.succeeded(), 1);
    assert_eq!(summary.failed(), 1);
    assert_eq!(summary.failures()[0].handler(), "failing");
    assert!(summary.failures()[0].message().contains("handler failed"));
    assert!(!format!("{summary:?}").contains("handler failed"));
    assert_eq!(
        &*seen.lock().expect("seen lock should not poison"),
        &["second"]
    );
}

struct RecordingHandler {
    name: &'static str,
    seen: Arc<Mutex<Vec<&'static str>>>,
}

impl RecordingHandler {
    fn new(name: &'static str, seen: Arc<Mutex<Vec<&'static str>>>) -> Self {
        Self { name, seen }
    }
}

#[async_trait]
impl DomainEventHandler for RecordingHandler {
    fn name(&self) -> &str {
        self.name
    }

    async fn handle(&self, _event: &DomainEvent) -> Result<(), BoxError> {
        self.seen
            .lock()
            .expect("seen lock should not poison")
            .push(self.name);
        Ok(())
    }
}

struct FailingHandler;

#[async_trait]
impl DomainEventHandler for FailingHandler {
    fn name(&self) -> &str {
        "failing"
    }

    async fn handle(&self, _event: &DomainEvent) -> Result<(), BoxError> {
        Err("handler failed".into())
    }
}