Gabriel Kaszewski
6c295866a0
Ride writes: WrapUpRequested/Completed (wrapup create/set_complete), MovieDiscovered (resolve upsert, new+ext id only), PosterSynced (poster handler upsert), MovieDeleted (delete_movie), WatchEventIngested (save). Deps drop event_publisher: wrapup, ingest, delete_review, watchlist add, review logger. Remaining .publish( sites: announce-only: users/delete_account UserDeleted, person/get + get_credits PersonEnrichmentRequested, jobs/enrichment_staleness, http-axum search, movies/sync_poster + poster_sync_handler + image-converter backfill + users/update_profile ImageStored (object storage), activitypub federation_event_bridge (reacting to events). rides write, deferred: social/execute (see report), activitypub review_handler MovieEnrichmentRequested (after save_remote_review).
128 lines
3.4 KiB
Rust
128 lines
3.4 KiB
Rust
use async_trait::async_trait;
|
|
use domain::{
|
|
errors::DomainError,
|
|
events::DomainEvent,
|
|
models::{MetadataSearchCriteria, Movie},
|
|
ports::{MetadataClient, MovieCommand},
|
|
testing::{
|
|
FakeMetadataClient, InMemoryStore, RefusingMovieCommand, test_movie_with_external_id,
|
|
test_movie_with_year,
|
|
},
|
|
value_objects::{ExternalMetadataId, PosterUrl},
|
|
};
|
|
|
|
use application::diary::commands::MovieInput;
|
|
use application::movies::resolve::resolve_and_persist_movie;
|
|
|
|
struct MetadataWithExternalId;
|
|
|
|
#[async_trait]
|
|
impl MetadataClient for MetadataWithExternalId {
|
|
async fn fetch_movie_metadata(&self, _: &MetadataSearchCriteria) -> Result<Movie, DomainError> {
|
|
Ok(test_movie_with_external_id(
|
|
"Discovered Film",
|
|
2024,
|
|
ExternalMetadataId::new("tmdb:99999".into()).unwrap(),
|
|
))
|
|
}
|
|
|
|
async fn get_poster_url(
|
|
&self,
|
|
_: &ExternalMetadataId,
|
|
) -> Result<Option<PosterUrl>, DomainError> {
|
|
Ok(None)
|
|
}
|
|
}
|
|
|
|
fn manual_input(title: &str) -> MovieInput {
|
|
MovieInput {
|
|
movie_id: None,
|
|
external_metadata_id: None,
|
|
manual_title: Some(title.into()),
|
|
manual_release_year: Some(2024),
|
|
manual_director: None,
|
|
}
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn a_new_movie_with_an_external_id_is_persisted_with_movie_discovered() {
|
|
let store = InMemoryStore::new();
|
|
|
|
let (movie, is_new) = resolve_and_persist_movie(
|
|
&manual_input("Discovered Film"),
|
|
store.as_ref(),
|
|
store.as_ref(),
|
|
&MetadataWithExternalId,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
assert!(is_new);
|
|
assert_eq!(store.movie_count(), 1);
|
|
let recorded = store.recorded_events();
|
|
assert_eq!(recorded.len(), 1);
|
|
assert!(matches!(
|
|
&recorded[0],
|
|
DomainEvent::MovieDiscovered { movie_id, .. } if movie_id == movie.id()
|
|
));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn a_new_movie_without_an_external_id_records_no_event() {
|
|
let store = InMemoryStore::new();
|
|
|
|
let (_, is_new) = resolve_and_persist_movie(
|
|
&manual_input("Home Movie"),
|
|
store.as_ref(),
|
|
store.as_ref(),
|
|
&FakeMetadataClient,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
assert!(is_new);
|
|
assert_eq!(store.movie_count(), 1);
|
|
assert!(store.recorded_events().is_empty());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn an_existing_movie_is_not_rewritten_and_records_no_event() {
|
|
let store = InMemoryStore::new();
|
|
let movie = test_movie_with_year("Known", 2001);
|
|
store.upsert_movie(&movie, &[]).await.unwrap();
|
|
let input = MovieInput {
|
|
movie_id: Some(movie.id().value()),
|
|
..manual_input("ignored")
|
|
};
|
|
|
|
let (resolved, is_new) = resolve_and_persist_movie(
|
|
&input,
|
|
store.as_ref(),
|
|
store.as_ref(),
|
|
&MetadataWithExternalId,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
assert!(!is_new);
|
|
assert_eq!(resolved.id(), movie.id());
|
|
assert!(store.recorded_events().is_empty());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn a_refused_upsert_propagates_and_records_nothing() {
|
|
let store = InMemoryStore::new();
|
|
|
|
let result = resolve_and_persist_movie(
|
|
&manual_input("Discovered Film"),
|
|
&RefusingMovieCommand,
|
|
store.as_ref(),
|
|
&MetadataWithExternalId,
|
|
)
|
|
.await;
|
|
|
|
assert!(matches!(result, Err(DomainError::InfrastructureError(m)) if m == "refused"));
|
|
assert_eq!(store.movie_count(), 0);
|
|
assert!(store.recorded_events().is_empty());
|
|
}
|