134 lines
3.8 KiB
Rust
134 lines
3.8 KiB
Rust
use chrono::NaiveDateTime;
|
|
use domain::{
|
|
events::DomainEvent,
|
|
value_objects::{ExternalMetadataId, MovieId, Rating, ReviewId, UserId},
|
|
};
|
|
use event_payload::EventPayload;
|
|
use uuid::Uuid;
|
|
|
|
fn fixed_dt() -> NaiveDateTime {
|
|
chrono::DateTime::from_timestamp(1_700_000_000, 0)
|
|
.unwrap()
|
|
.naive_utc()
|
|
}
|
|
|
|
fn review_logged() -> DomainEvent {
|
|
DomainEvent::ReviewLogged {
|
|
review_id: ReviewId::from_uuid(Uuid::new_v4()),
|
|
movie_id: MovieId::from_uuid(Uuid::new_v4()),
|
|
user_id: UserId::from_uuid(Uuid::new_v4()),
|
|
rating: Rating::new(4).unwrap(),
|
|
watched_at: fixed_dt(),
|
|
}
|
|
}
|
|
|
|
fn review_updated() -> DomainEvent {
|
|
DomainEvent::ReviewUpdated {
|
|
review_id: ReviewId::from_uuid(Uuid::new_v4()),
|
|
movie_id: MovieId::from_uuid(Uuid::new_v4()),
|
|
user_id: UserId::from_uuid(Uuid::new_v4()),
|
|
rating: Rating::new(3).unwrap(),
|
|
watched_at: fixed_dt(),
|
|
}
|
|
}
|
|
|
|
fn movie_discovered() -> DomainEvent {
|
|
DomainEvent::MovieDiscovered {
|
|
movie_id: MovieId::from_uuid(Uuid::new_v4()),
|
|
external_metadata_id: ExternalMetadataId::new("tt1234567".into()).unwrap(),
|
|
}
|
|
}
|
|
|
|
fn round_trip(event: DomainEvent) {
|
|
let payload = EventPayload::from(&event);
|
|
let json = serde_json::to_string(&payload).expect("serialize");
|
|
let back: EventPayload = serde_json::from_str(&json).expect("deserialize");
|
|
let recovered = DomainEvent::try_from(back).expect("try_from");
|
|
assert_eq!(EventPayload::from(&event), EventPayload::from(&recovered));
|
|
}
|
|
|
|
#[test]
|
|
fn round_trip_review_logged() {
|
|
round_trip(review_logged());
|
|
}
|
|
|
|
#[test]
|
|
fn round_trip_review_updated() {
|
|
round_trip(review_updated());
|
|
}
|
|
|
|
#[test]
|
|
fn round_trip_movie_discovered() {
|
|
round_trip(movie_discovered());
|
|
}
|
|
|
|
#[test]
|
|
fn serialized_format_is_tagged() {
|
|
let payload = EventPayload::from(&movie_discovered());
|
|
let json = serde_json::to_string(&payload).unwrap();
|
|
assert!(json.contains(r#""type":"MovieDiscovered""#));
|
|
assert!(json.contains(r#""data":"#));
|
|
}
|
|
|
|
#[test]
|
|
fn event_type_strings() {
|
|
assert_eq!(
|
|
EventPayload::from(&review_logged()).event_type(),
|
|
"ReviewLogged"
|
|
);
|
|
assert_eq!(
|
|
EventPayload::from(&review_updated()).event_type(),
|
|
"ReviewUpdated"
|
|
);
|
|
assert_eq!(
|
|
EventPayload::from(&movie_discovered()).event_type(),
|
|
"MovieDiscovered"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn round_trip_image_stored() {
|
|
let event = DomainEvent::ImageStored {
|
|
key: "avatars/abc123".into(),
|
|
};
|
|
let payload = EventPayload::from(&event);
|
|
let json = serde_json::to_string(&payload).unwrap();
|
|
let back: EventPayload = serde_json::from_str(&json).unwrap();
|
|
let recovered = DomainEvent::try_from(back).unwrap();
|
|
assert_eq!(EventPayload::from(&event), EventPayload::from(&recovered));
|
|
}
|
|
|
|
#[test]
|
|
fn image_stored_event_type() {
|
|
let payload = EventPayload::from(&DomainEvent::ImageStored {
|
|
key: "posters/x".into(),
|
|
});
|
|
assert_eq!(payload.event_type(), "ImageStored");
|
|
}
|
|
|
|
#[test]
|
|
fn a_message_round_trips_its_event_id_and_decodes_without_one() {
|
|
use event_payload::EventMessage;
|
|
|
|
let with_id = EventMessage {
|
|
event_id: Some(Uuid::new_v4().to_string()),
|
|
payload: EventPayload::from(&review_logged()),
|
|
};
|
|
let json = serde_json::to_string(&with_id).unwrap();
|
|
assert_eq!(
|
|
serde_json::from_str::<EventMessage>(&json).unwrap(),
|
|
with_id
|
|
);
|
|
|
|
let legacy = serde_json::to_string(&EventPayload::from(&review_logged())).unwrap();
|
|
let decoded: EventMessage = serde_json::from_str(&legacy).unwrap();
|
|
assert_eq!(decoded.event_id, None);
|
|
|
|
let unit = EventMessage {
|
|
event_id: Some("x".into()),
|
|
payload: EventPayload::SearchReindexRequested,
|
|
};
|
|
let json = serde_json::to_string(&unit).unwrap();
|
|
assert_eq!(serde_json::from_str::<EventMessage>(&json).unwrap(), unit);
|
|
}
|