add 400+ unit tests for domain and application layers

Extract ReviewLogger trait to decouple import/integrations
from diary::log_review (cross-module coupling smell).

Add in-memory fakes for all repository ports, enabling
isolated testing of every use case module without a database.

Coverage: domain+application 22% → 80%, 427 tests.

crates/application/src/diary/review_logger.rs

@@ -0,0 +1,121 @@
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use domain::{
+    errors::DomainError,
+    events::DomainEvent,
+    models::{Movie, Review},
+    ports::{
+        EventPublisher, MetadataClient, MovieRepository, ReviewRepository, WatchlistRepository,
+    },
+    value_objects::{Comment, MovieId, Rating, UserId},
+};
+
+use crate::diary::commands::LogReviewCommand;
+use crate::diary::movie_resolver::{MovieResolver, MovieResolverDeps};
+use crate::ports::ReviewLogger;
+
+pub struct DefaultReviewLogger {
+    movie_repo: Arc<dyn MovieRepository>,
+    review_repo: Arc<dyn ReviewRepository>,
+    watchlist_repo: Arc<dyn WatchlistRepository>,
+    metadata_client: Arc<dyn MetadataClient>,
+    event_publisher: Arc<dyn EventPublisher>,
+}
+
+impl DefaultReviewLogger {
+    pub fn new(
+        movie_repo: Arc<dyn MovieRepository>,
+        review_repo: Arc<dyn ReviewRepository>,
+        watchlist_repo: Arc<dyn WatchlistRepository>,
+        metadata_client: Arc<dyn MetadataClient>,
+        event_publisher: Arc<dyn EventPublisher>,
+    ) -> Self {
+        Self {
+            movie_repo,
+            review_repo,
+            watchlist_repo,
+            metadata_client,
+            event_publisher,
+        }
+    }
+}
+
+#[async_trait]
+impl ReviewLogger for DefaultReviewLogger {
+    async fn log_review(&self, cmd: LogReviewCommand) -> Result<(), DomainError> {
+        let rating = Rating::new(cmd.rating)?;
+        let user_id = UserId::from_uuid(cmd.user_id);
+        let comment = cmd.comment.clone().map(Comment::new).transpose()?;
+
+        let (movie, is_new_movie) = if let Some(id) = cmd.input.movie_id {
+            let movie_id = MovieId::from_uuid(id);
+            let movie = self
+                .movie_repo
+                .get_movie_by_id(&movie_id)
+                .await?
+                .ok_or_else(|| DomainError::NotFound(format!("Movie {id}")))?;
+            (movie, false)
+        } else {
+            let deps = MovieResolverDeps {
+                repository: self.movie_repo.as_ref(),
+                metadata_client: self.metadata_client.as_ref(),
+            };
+            MovieResolver::default_pipeline()
+                .resolve(&cmd.input, &deps)
+                .await?
+        };
+
+        self.movie_repo.upsert_movie(&movie).await?;
+
+        let review = Review::new(movie.id().clone(), user_id, rating, comment, cmd.watched_at)?;
+        let review_event = self.review_repo.save_review(&review).await?;
+
+        let was_on_watchlist = self
+            .watchlist_repo
+            .remove_if_present(review.user_id(), review.movie_id())
+            .await?;
+        if was_on_watchlist {
+            let _ = self
+                .event_publisher
+                .publish(&DomainEvent::WatchlistEntryRemoved {
+                    user_id: review.user_id().clone(),
+                    movie_id: review.movie_id().clone(),
+                })
+                .await;
+        }
+
+        publish_events(&self.event_publisher, &movie, is_new_movie, review_event).await
+    }
+}
+
+#[cfg(test)]
+#[path = "tests/review_logger.rs"]
+mod tests;
+
+async fn publish_events(
+    publisher: &Arc<dyn EventPublisher>,
+    movie: &Movie,
+    is_new_movie: bool,
+    review_event: DomainEvent,
+) -> Result<(), DomainError> {
+    if is_new_movie && let Some(ext_id) = movie.external_metadata_id() {
+        publisher
+            .publish(&DomainEvent::MovieDiscovered {
+                movie_id: movie.id().clone(),
+                external_metadata_id: ext_id.clone(),
+            })
+            .await?;
+    }
+
+    if let Some(ext_id) = movie.external_metadata_id() {
+        publisher
+            .publish(&DomainEvent::MovieEnrichmentRequested {
+                movie_id: movie.id().clone(),
+                external_metadata_id: ext_id.value().to_string(),
+            })
+            .await?;
+    }
+
+    publisher.publish(&review_event).await
+}