use std::sync::{Arc, Mutex};
use async_trait::async_trait;
use super::{
DomainEvent, DomainEventDispatchError, DomainEventDispatcher, DomainEventFailurePolicy,
DomainEventHandler, DomainEventName,
};
use crate::result::BoxError;
#[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 builder_normalizes_optional_fields_and_metadata() {
let event = DomainEvent::builder("user.created")
.expect("event should build")
.subject(" usr_\n01 ")
.actor(" admin ")
.metadata_value(" source ", "console")
.metadata_value("Request-ID", "req_01")
.metadata_value("bad/key", "ignored")
.build();
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::builder("user.created")
.expect("event should build")
.subject(subject)
.actor(actor)
.idempotency_key(idempotency_key)
.correlation_id(correlation_id)
.metadata_value("credential", metadata_value)
.build();
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 builder_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::builder("user.created")
.expect("event should build")
.metadata(metadata)
.build();
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())
}
}