code refactor

Reviewed-on: #26

crates/application/tests/movies/poster_sync_handler_test.rs

@@ -0,0 +1,89 @@
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use domain::{
+    errors::DomainError,
+    events::DomainEvent,
+    models::Movie,
+    ports::{EventHandler, MetadataClient, MovieCommand},
+    testing::{
+        FakePosterFetcher, InMemoryStore, NoopEventPublisher, NoopObjectStorage,
+        RefusingMovieCommand, test_movie_with_external_id,
+    },
+    value_objects::{ExternalMetadataId, PosterUrl},
+};
+
+use application::movies::poster_sync_handler::PosterSyncHandler;
+
+struct MetadataWithPoster;
+
+#[async_trait]
+impl MetadataClient for MetadataWithPoster {
+    async fn fetch_movie_metadata(
+        &self,
+        _: &domain::models::MetadataSearchCriteria,
+    ) -> Result<Movie, DomainError> {
+        unimplemented!()
+    }
+    async fn get_poster_url(
+        &self,
+        _: &ExternalMetadataId,
+    ) -> Result<Option<PosterUrl>, DomainError> {
+        Ok(Some(
+            PosterUrl::new("https://example.com/poster.jpg".into()).unwrap(),
+        ))
+    }
+}
+
+async fn seeded() -> (Arc<InMemoryStore>, Movie, DomainEvent) {
+    let store = InMemoryStore::new();
+    let ext = ExternalMetadataId::new("tmdb:42".into()).unwrap();
+    let movie = test_movie_with_external_id("Heat", 1995, ext.clone());
+    store.upsert_movie(&movie, &[]).await.unwrap();
+    let event = DomainEvent::MovieDiscovered {
+        movie_id: movie.id().clone(),
+        external_metadata_id: ext,
+    };
+    (store, movie, event)
+}
+
+fn handler(command: Arc<dyn MovieCommand>, store: &Arc<InMemoryStore>) -> PosterSyncHandler {
+    PosterSyncHandler::new(
+        command,
+        Arc::clone(store) as _,
+        Arc::new(MetadataWithPoster),
+        Arc::new(FakePosterFetcher),
+        Arc::new(NoopObjectStorage),
+        NoopEventPublisher::new(),
+        0,
+    )
+}
+
+#[tokio::test]
+async fn poster_synced_rides_the_movie_write() {
+    let (store, movie, event) = seeded().await;
+
+    handler(Arc::clone(&store) as _, &store)
+        .handle(&event)
+        .await
+        .unwrap();
+
+    let recorded = store.recorded_events();
+    assert_eq!(recorded.len(), 1);
+    assert!(matches!(
+        &recorded[0],
+        DomainEvent::PosterSynced { movie_id } if movie_id == movie.id()
+    ));
+}
+
+#[tokio::test]
+async fn a_refused_upsert_propagates_and_records_nothing() {
+    let (store, _movie, event) = seeded().await;
+
+    let result = handler(Arc::new(RefusingMovieCommand), &store)
+        .handle(&event)
+        .await;
+
+    assert!(matches!(result, Err(DomainError::InfrastructureError(m)) if m == "refused"));
+    assert!(store.recorded_events().is_empty());
+}