fix: NewRemoteReview param struct, atomic review+orphan movie delete

crates/adapters/sqlite/tests/repositories/review_repository_test.rs

@@ -135,36 +135,85 @@ async fn a_failing_enqueue_after_the_review_update_rolls_the_update_back() {
     assert_eq!(count(&pool, "event_queue").await, 0);
 }
 
+fn deleted(review: &domain::models::Review) -> DomainEvent {
+    DomainEvent::ReviewDeleted {
+        review_id: review.id().clone(),
+        user_id: review.user_id().clone(),
+    }
+}
+
+fn movie_deleted(review: &domain::models::Review) -> DomainEvent {
+    DomainEvent::MovieDeleted {
+        movie_id: review.movie_id().clone(),
+        poster_path: None,
+    }
+}
+
 #[tokio::test]
-async fn deleting_a_review_writes_the_removal_and_its_event_in_one_commit() {
+async fn deleting_the_last_review_removes_the_movie_and_enqueues_both_events_in_one_commit() {
     let (pool, review) = seeded().await;
     let repo = SqliteReviewRepository::new(pool.clone());
     repo.save_review(&review, &[]).await.unwrap();
-    let event = DomainEvent::ReviewDeleted {
-        review_id: review.id().clone(),
-        user_id: review.user_id().clone(),
-    };
 
-    repo.delete_review(review.id(), &[event]).await.unwrap();
+    repo.delete_review_and_orphaned_movie(
+        review.id(),
+        review.movie_id(),
+        &[deleted(&review)],
+        &[movie_deleted(&review)],
+    )
+    .await
+    .unwrap();
 
     assert_eq!(count(&pool, "reviews").await, 0);
+    assert_eq!(count(&pool, "movies").await, 0);
+    assert_eq!(count(&pool, "event_queue").await, 2);
+}
+
+#[tokio::test]
+async fn deleting_a_review_while_another_remains_keeps_the_movie_and_enqueues_only_review_deleted()
+{
+    let (pool, review) = seeded().await;
+    let repo = SqliteReviewRepository::new(pool.clone());
+    repo.save_review(&review, &[]).await.unwrap();
+    let other = test_review(review.movie_id(), review.user_id(), 3);
+    repo.save_review(&other, &[]).await.unwrap();
+
+    repo.delete_review_and_orphaned_movie(
+        review.id(),
+        review.movie_id(),
+        &[deleted(&review)],
+        &[movie_deleted(&review)],
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(count(&pool, "reviews").await, 1);
+    assert_eq!(count(&pool, "movies").await, 1);
     assert_eq!(count(&pool, "event_queue").await, 1);
 }
 
 #[tokio::test]
-async fn a_failing_enqueue_after_the_review_delete_rolls_the_delete_back() {
+async fn a_failing_enqueue_rolls_back_the_review_and_movie_delete() {
     let (pool, review) = seeded().await;
     let repo = SqliteReviewRepository::new(pool.clone());
     repo.save_review(&review, &[]).await.unwrap();
     fail_event_inserts(&pool).await;
-    let event = DomainEvent::ReviewDeleted {
-        review_id: review.id().clone(),
-        user_id: review.user_id().clone(),
-    };
 
-    let result = repo.delete_review(review.id(), &[event]).await;
+    let result = repo
+        .delete_review_and_orphaned_movie(
+            review.id(),
+            review.movie_id(),
+            &[deleted(&review)],
+            &[movie_deleted(&review)],
+        )
+        .await;
 
     assert!(result.is_err());
-    assert_eq!(count(&pool, "reviews").await, 1, "delete rolled back");
+    assert_eq!(
+        count(&pool, "reviews").await,
+        1,
+        "review delete rolled back"
+    );
+    assert_eq!(count(&pool, "movies").await, 1, "movie delete rolled back");
     assert_eq!(count(&pool, "event_queue").await, 0);
 }