feat: atomic wrapup, movie, integration writes

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).

crates/application/tests/diary/delete_review_test.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 
 use domain::{
     ports::{MovieCommand, MovieQuery, ReviewRepository},
-    testing::{FakeDiaryQuery, InMemoryStore, NoopEventPublisher},
+    testing::{FakeDiaryQuery, InMemoryStore, RefusingMovieCommand},
     value_objects::{MovieId, UserId},
 };
 
@@ -16,13 +16,12 @@ async fn deleting_a_review_removes_it() {
     let movies = InMemoryStore::new();
     let reviews = Arc::clone(&movies);
     let diary = FakeDiaryQuery::new();
-    let events = NoopEventPublisher::new();
 
     let movie = test_movie_with_year("Terminator", 1984);
     let user_id = UserId::from_uuid(uuid::Uuid::new_v4());
     let review = test_review(movie.id(), &user_id, 4);
 
-    movies.upsert_movie(&movie).await.unwrap();
+    movies.upsert_movie(&movie, &[]).await.unwrap();
     reviews.save_review(&review, &[]).await.unwrap();
     diary.seed_history(movie.clone(), vec![]);
 
@@ -30,7 +29,6 @@ async fn deleting_a_review_removes_it() {
         review: Arc::clone(&reviews) as _,
         diary: diary.clone() as _,
         movie_command: Arc::clone(&movies) as _,
-        event_publisher: Arc::clone(&events) as _,
     };
 
     delete_review::execute(
@@ -55,7 +53,6 @@ async fn deleting_another_users_review_is_unauthorized() {
     let reviews = InMemoryStore::new();
     let diary = FakeDiaryQuery::new();
     let movies = Arc::clone(&reviews);
-    let events = NoopEventPublisher::new();
 
     let movie_id = MovieId::from_uuid(uuid::Uuid::new_v4());
     let owner_id = UserId::from_uuid(uuid::Uuid::new_v4());
@@ -68,7 +65,6 @@ async fn deleting_another_users_review_is_unauthorized() {
         review: Arc::clone(&reviews) as _,
         diary: diary as _,
         movie_command: movies as _,
-        event_publisher: Arc::clone(&events) as _,
     };
 
     let result = delete_review::execute(
@@ -88,18 +84,16 @@ async fn deleting_another_users_review_is_unauthorized() {
 async fn deleting_a_review_removes_it_and_records_its_event_together() {
     let movies = InMemoryStore::new();
     let diary = FakeDiaryQuery::new();
-    let events = NoopEventPublisher::new();
     let movie = test_movie_with_year("Terminator", 1984);
     let user_id = UserId::from_uuid(uuid::Uuid::new_v4());
     let review = test_review(movie.id(), &user_id, 4);
-    movies.upsert_movie(&movie).await.unwrap();
+    movies.upsert_movie(&movie, &[]).await.unwrap();
     movies.save_review(&review, &[]).await.unwrap();
     diary.seed_history(movie.clone(), vec![review.clone()]);
     let deps = DeleteReviewDeps {
         review: Arc::clone(&movies) as _,
         diary: diary.clone() as _,
         movie_command: Arc::clone(&movies) as _,
-        event_publisher: Arc::clone(&events) as _,
     };
 
     delete_review::execute(
@@ -125,7 +119,6 @@ async fn deleting_a_review_removes_it_and_records_its_event_together() {
 async fn a_refused_delete_propagates_and_records_nothing() {
     let movies = InMemoryStore::new();
     let diary = FakeDiaryQuery::new();
-    let events = NoopEventPublisher::new();
     let user_id = UserId::from_uuid(uuid::Uuid::new_v4());
     let review = test_review(&MovieId::generate(), &user_id, 4);
     movies.save_review(&review, &[]).await.unwrap();
@@ -135,7 +128,6 @@ async fn a_refused_delete_propagates_and_records_nothing() {
         ))),
         diary: diary as _,
         movie_command: Arc::clone(&movies) as _,
-        event_publisher: Arc::clone(&events) as _,
     };
 
     let result = delete_review::execute(
@@ -151,3 +143,114 @@ async fn a_refused_delete_propagates_and_records_nothing() {
     assert_eq!(movies.review_count(), 1);
     assert!(movies.recorded_events().is_empty());
 }
+
+#[tokio::test]
+async fn deleting_the_last_review_records_movie_deleted_with_the_movie_delete() {
+    let movies = InMemoryStore::new();
+    let diary = FakeDiaryQuery::new();
+    let movie = test_movie_with_year("Terminator", 1984);
+    let user_id = UserId::from_uuid(uuid::Uuid::new_v4());
+    let review = test_review(movie.id(), &user_id, 4);
+    movies.upsert_movie(&movie, &[]).await.unwrap();
+    movies.save_review(&review, &[]).await.unwrap();
+    diary.seed_history(movie.clone(), vec![]);
+    let deps = DeleteReviewDeps {
+        review: Arc::clone(&movies) as _,
+        diary: diary as _,
+        movie_command: Arc::clone(&movies) as _,
+    };
+
+    delete_review::execute(
+        &deps,
+        DeleteReviewCommand {
+            review_id: review.id().value(),
+            requesting_user_id: user_id.value(),
+        },
+    )
+    .await
+    .unwrap();
+
+    assert!(movies.get_movie_by_id(movie.id()).await.unwrap().is_none());
+    let recorded = movies.recorded_events();
+    assert!(matches!(
+        recorded[0],
+        domain::events::DomainEvent::ReviewDeleted { .. }
+    ));
+    assert!(matches!(
+        &recorded[1],
+        domain::events::DomainEvent::MovieDeleted { movie_id, .. } if movie_id == movie.id()
+    ));
+    assert_eq!(recorded.len(), 2);
+}
+
+#[tokio::test]
+async fn deleting_a_review_while_viewings_remain_keeps_the_movie_and_records_no_movie_deleted() {
+    let movies = InMemoryStore::new();
+    let diary = FakeDiaryQuery::new();
+    let movie = test_movie_with_year("Terminator", 1984);
+    let user_id = UserId::from_uuid(uuid::Uuid::new_v4());
+    let review = test_review(movie.id(), &user_id, 4);
+    let other = test_review(movie.id(), &UserId::from_uuid(uuid::Uuid::new_v4()), 3);
+    movies.upsert_movie(&movie, &[]).await.unwrap();
+    movies.save_review(&review, &[]).await.unwrap();
+    movies.save_review(&other, &[]).await.unwrap();
+    diary.seed_history(movie.clone(), vec![other.clone()]);
+    let deps = DeleteReviewDeps {
+        review: Arc::clone(&movies) as _,
+        diary: diary as _,
+        movie_command: Arc::clone(&movies) as _,
+    };
+
+    delete_review::execute(
+        &deps,
+        DeleteReviewCommand {
+            review_id: review.id().value(),
+            requesting_user_id: user_id.value(),
+        },
+    )
+    .await
+    .unwrap();
+
+    assert!(movies.get_movie_by_id(movie.id()).await.unwrap().is_some());
+    assert!(
+        !movies
+            .recorded_events()
+            .iter()
+            .any(|e| matches!(e, domain::events::DomainEvent::MovieDeleted { .. }))
+    );
+}
+
+#[tokio::test]
+async fn a_refused_movie_delete_propagates_and_records_no_movie_deleted() {
+    let movies = InMemoryStore::new();
+    let diary = FakeDiaryQuery::new();
+    let movie = test_movie_with_year("Terminator", 1984);
+    let user_id = UserId::from_uuid(uuid::Uuid::new_v4());
+    let review = test_review(movie.id(), &user_id, 4);
+    movies.upsert_movie(&movie, &[]).await.unwrap();
+    movies.save_review(&review, &[]).await.unwrap();
+    diary.seed_history(movie.clone(), vec![]);
+    let deps = DeleteReviewDeps {
+        review: Arc::clone(&movies) as _,
+        diary: diary as _,
+        movie_command: Arc::new(RefusingMovieCommand),
+    };
+
+    let result = delete_review::execute(
+        &deps,
+        DeleteReviewCommand {
+            review_id: review.id().value(),
+            requesting_user_id: user_id.value(),
+        },
+    )
+    .await;
+
+    assert!(result.is_err());
+    assert!(movies.get_movie_by_id(movie.id()).await.unwrap().is_some());
+    assert!(
+        !movies
+            .recorded_events()
+            .iter()
+            .any(|e| matches!(e, domain::events::DomainEvent::MovieDeleted { .. }))
+    );
+}

crates/application/tests/diary/get_movie_social_page_test.rs

@@ -40,7 +40,7 @@ async fn returns_movie_social_page() {
 
     let movie = test_movie_with_year("Social Movie", 2024);
     let movie_uuid = movie.id().value();
-    movies.upsert_movie(&movie).await.unwrap();
+    movies.upsert_movie(&movie, &[]).await.unwrap();
 
     let deps = GetMovieSocialPageDeps {
         movie_query: Arc::clone(&movies) as _,

crates/application/tests/diary/log_review_test.rs

@@ -5,7 +5,7 @@ use std::sync::Arc;
 
 use domain::ports::MovieCommand;
 
-use domain::testing::{InMemoryStore, NoopEventPublisher};
+use domain::testing::InMemoryStore;
 
 use application::{
     diary::commands::LogReviewCommand, diary::log_review, diary::review_logger::DefaultReviewLogger,
@@ -14,7 +14,6 @@ use application::{
 fn build_logger(
     movies: &Arc<InMemoryStore>,
     reviews: &Arc<InMemoryStore>,
-    events: &Arc<NoopEventPublisher>,
 ) -> Arc<dyn application::ports::ReviewLogger> {
     Arc::new(DefaultReviewLogger::new(
         Arc::clone(movies) as _,
@@ -22,7 +21,6 @@ fn build_logger(
         Arc::clone(reviews) as _,
         TestContextBuilder::new().watchlist_repo,
         Arc::new(domain::testing::FakeMetadataClient) as _,
-        Arc::clone(events) as _,
     ))
 }
 
@@ -30,8 +28,7 @@ fn build_logger(
 async fn logging_a_review_creates_the_movie_and_the_review() {
     let movies = InMemoryStore::new();
     let reviews = Arc::clone(&movies);
-    let events = NoopEventPublisher::new();
-    let logger = build_logger(&movies, &reviews, &events);
+    let logger = build_logger(&movies, &reviews);
 
     let user_id = uuid::Uuid::new_v4();
     let cmd = log_review_command_manual(user_id, "Blade Runner", 1982);
@@ -52,10 +49,9 @@ async fn logging_a_review_reuses_an_existing_movie() {
 
     let existing_movie = test_movie_with_year("Alien", 1979);
     let movie_uuid = existing_movie.id().value();
-    movies.upsert_movie(&existing_movie).await.unwrap();
+    movies.upsert_movie(&existing_movie, &[]).await.unwrap();
 
-    let events = NoopEventPublisher::new();
-    let logger = build_logger(&movies, &reviews, &events);
+    let logger = build_logger(&movies, &reviews);
 
     let cmd = LogReviewCommand {
         rating: 5,
@@ -72,8 +68,7 @@ async fn logging_a_review_reuses_an_existing_movie() {
 async fn logging_a_review_with_an_invalid_rating_fails() {
     let movies = InMemoryStore::new();
     let reviews = Arc::clone(&movies);
-    let events = NoopEventPublisher::new();
-    let logger = build_logger(&movies, &reviews, &events);
+    let logger = build_logger(&movies, &reviews);
 
     let cmd = LogReviewCommand {
         rating: 6,

crates/application/tests/diary/review_logger_test.rs

@@ -8,7 +8,7 @@ use domain::{
     models::WatchlistEntry,
     models::{MetadataSearchCriteria, Movie},
     ports::{MetadataClient, MovieCommand, WatchlistRepository},
-    testing::{FakeMetadataClient, InMemoryStore, NoopEventPublisher},
+    testing::{FakeMetadataClient, InMemoryStore},
     value_objects::{ExternalMetadataId, MovieId, PosterUrl, UserId},
 };
 use uuid::Uuid;
@@ -21,7 +21,6 @@ fn make_logger(
     movies: &Arc<InMemoryStore>,
     reviews: &Arc<InMemoryStore>,
     watchlist: &Arc<InMemoryStore>,
-    events: &Arc<NoopEventPublisher>,
 ) -> DefaultReviewLogger {
     DefaultReviewLogger::new(
         Arc::clone(movies) as _,
@@ -29,7 +28,6 @@ fn make_logger(
         Arc::clone(reviews) as _,
         Arc::clone(watchlist) as _,
         Arc::new(FakeMetadataClient) as _,
-        Arc::clone(events) as _,
     )
 }
 
@@ -38,8 +36,7 @@ async fn logs_review_with_manual_movie() {
     let movies = InMemoryStore::new();
     let reviews = Arc::clone(&movies);
     let watchlist = Arc::clone(&movies);
-    let events = NoopEventPublisher::new();
-    let logger = make_logger(&movies, &reviews, &watchlist, &events);
+    let logger = make_logger(&movies, &reviews, &watchlist);
 
     let uid = Uuid::new_v4();
     let cmd = log_review_command_manual(uid, "Test Film", 2024);
@@ -55,8 +52,7 @@ async fn removes_from_watchlist_on_review() {
     let movies = InMemoryStore::new();
     let reviews = Arc::clone(&movies);
     let watchlist = Arc::clone(&movies);
-    let events = NoopEventPublisher::new();
-    let logger = make_logger(&movies, &reviews, &watchlist, &events);
+    let logger = make_logger(&movies, &reviews, &watchlist);
 
     let uid = Uuid::new_v4();
     let user_id = UserId::from_uuid(uid);
@@ -64,7 +60,7 @@ async fn removes_from_watchlist_on_review() {
     // Create and store movie
     let movie = test_movie_with_year("Watchlisted Film", 2024);
     let movie_id = movie.id().value();
-    movies.upsert_movie(&movie).await.unwrap();
+    movies.upsert_movie(&movie, &[]).await.unwrap();
 
     // Add to watchlist
     let entry = WatchlistEntry::new(user_id.clone(), MovieId::from_uuid(movie_id));
@@ -87,13 +83,6 @@ async fn removes_from_watchlist_on_review() {
             .any(|e| matches!(e, domain::events::DomainEvent::WatchlistEntryRemoved { .. })),
         "the removal event rides the watchlist write"
     );
-    assert!(
-        !events
-            .published()
-            .iter()
-            .any(|e| matches!(e, domain::events::DomainEvent::WatchlistEntryRemoved { .. })),
-        "no longer published out of band"
-    );
 }
 
 #[tokio::test]
@@ -101,12 +90,11 @@ async fn logs_review_with_existing_movie_by_id() {
     let movies = InMemoryStore::new();
     let reviews = Arc::clone(&movies);
     let watchlist = Arc::clone(&movies);
-    let events = NoopEventPublisher::new();
-    let logger = make_logger(&movies, &reviews, &watchlist, &events);
+    let logger = make_logger(&movies, &reviews, &watchlist);
 
     let movie = test_movie_with_year("Existing Film", 2020);
     let movie_uuid = movie.id().value();
-    movies.upsert_movie(&movie).await.unwrap();
+    movies.upsert_movie(&movie, &[]).await.unwrap();
 
     let cmd = LogReviewCommand {
         rating: 3,
@@ -124,8 +112,7 @@ async fn existing_movie_not_found_returns_error() {
     let movies = InMemoryStore::new();
     let reviews = Arc::clone(&movies);
     let watchlist = Arc::clone(&movies);
-    let events = NoopEventPublisher::new();
-    let logger = make_logger(&movies, &reviews, &watchlist, &events);
+    let logger = make_logger(&movies, &reviews, &watchlist);
 
     let cmd = log_review_command(Uuid::new_v4(), Uuid::new_v4());
 
@@ -137,8 +124,7 @@ async fn invalid_rating_returns_error() {
     let movies = InMemoryStore::new();
     let reviews = Arc::clone(&movies);
     let watchlist = Arc::clone(&movies);
-    let events = NoopEventPublisher::new();
-    let logger = make_logger(&movies, &reviews, &watchlist, &events);
+    let logger = make_logger(&movies, &reviews, &watchlist);
 
     let cmd = LogReviewCommand {
         rating: 6,
@@ -157,8 +143,7 @@ async fn watchlist_not_present_does_not_publish_removed() {
     let movies = InMemoryStore::new();
     let reviews = Arc::clone(&movies);
     let watchlist = Arc::clone(&movies);
-    let events = NoopEventPublisher::new();
-    let logger = make_logger(&movies, &reviews, &watchlist, &events);
+    let logger = make_logger(&movies, &reviews, &watchlist);
 
     let cmd = log_review_command_manual(Uuid::new_v4(), "No Watchlist Film", 2024);
 
@@ -197,11 +182,10 @@ impl MetadataClient for MetadataClientWithExternalId {
 }
 
 #[tokio::test]
-async fn publishes_movie_discovered_for_new_movie_with_external_id() {
+async fn movie_discovered_rides_the_movie_write_for_a_new_movie_with_external_id() {
     let movies = InMemoryStore::new();
     let reviews = Arc::clone(&movies);
     let watchlist = Arc::clone(&movies);
-    let events = NoopEventPublisher::new();
 
     let logger = DefaultReviewLogger::new(
         Arc::clone(&movies) as _,
@@ -209,7 +193,6 @@ async fn publishes_movie_discovered_for_new_movie_with_external_id() {
         Arc::clone(&reviews) as _,
         Arc::clone(&watchlist) as _,
         Arc::new(MetadataClientWithExternalId) as _,
-        Arc::clone(&events) as _,
     );
 
     let cmd = LogReviewCommand {
@@ -219,12 +202,12 @@ async fn publishes_movie_discovered_for_new_movie_with_external_id() {
 
     logger.log_review(cmd).await.unwrap();
 
-    let published = events.published();
+    let published = movies.recorded_events();
     assert!(
         published
             .iter()
             .any(|e| matches!(e, domain::events::DomainEvent::MovieDiscovered { .. })),
-        "should publish MovieDiscovered for new movie with external_metadata_id"
+        "MovieDiscovered must be recorded with the movie write"
     );
 }
 
@@ -237,7 +220,6 @@ async fn logging_a_review_fails_when_the_review_store_refuses() {
         Arc::new(domain::testing::RefusingReviewRepository),
         Arc::clone(&movies) as _,
         Arc::new(FakeMetadataClient),
-        NoopEventPublisher::new(),
     );
 
     let result = logger
@@ -256,7 +238,6 @@ async fn logging_a_review_saves_the_review_and_its_event_together() {
         Arc::clone(&movies) as _,
         Arc::clone(&movies) as _,
         Arc::new(FakeMetadataClient),
-        Arc::new(domain::testing::RefusingEventPublisher),
     );
 
     logger
@@ -282,7 +263,6 @@ async fn a_refused_save_propagates_and_records_nothing() {
         Arc::new(domain::testing::RefusingReviewRepository),
         Arc::clone(&movies) as _,
         Arc::new(FakeMetadataClient),
-        NoopEventPublisher::new(),
     );
 
     let result = logger
@@ -303,7 +283,6 @@ async fn enrichment_request_rides_the_review_save() {
         Arc::clone(&movies) as _,
         Arc::clone(&movies) as _,
         Arc::new(MetadataClientWithExternalId),
-        NoopEventPublisher::new(),
     );
 
     logger

crates/application/tests/import/apply_mapping_test.rs

@@ -110,7 +110,7 @@ async fn marks_duplicate_by_external_id() {
 
     let ext_id = ExternalMetadataId::new("tt1234567".into()).unwrap();
     let movie = test_movie_with_external_id("Known Movie", 2020, ext_id);
-    movies.upsert_movie(&movie).await.unwrap();
+    movies.upsert_movie(&movie, &[]).await.unwrap();
 
     let parser = Arc::new(DuplicateTestParser {
         rows: vec![ImportRow {
@@ -158,7 +158,7 @@ async fn marks_duplicate_by_title_and_year() {
     let sessions = Arc::clone(&movies);
 
     let movie = test_movie_with_year("Duplicate Film", 2022);
-    movies.upsert_movie(&movie).await.unwrap();
+    movies.upsert_movie(&movie, &[]).await.unwrap();
 
     let parser = Arc::new(DuplicateTestParser {
         rows: vec![ImportRow {

crates/application/tests/integrations/confirm_test.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 
 use domain::models::{WatchEvent, WatchEventSource};
 use domain::ports::{MovieCommand, WatchEventCommand};
-use domain::testing::{InMemoryStore, NoopEventPublisher};
+use domain::testing::InMemoryStore;
 use domain::value_objects::UserId;
 use uuid::Uuid;
 
@@ -42,7 +42,7 @@ async fn confirms_watch_event_via_review_logger() {
         None,
     );
     let event_id = event.id().value();
-    watch_events.save(&event).await.unwrap();
+    watch_events.save(&event, &[]).await.unwrap();
 
     let result = confirm::execute(
         &deps(&watch_events, noop_logger()),
@@ -86,7 +86,7 @@ async fn confirms_event_with_external_metadata_id_and_no_movie_id() {
         None,
     );
     let event_id = event.id().value();
-    watch_events.save(&event).await.unwrap();
+    watch_events.save(&event, &[]).await.unwrap();
 
     let result = confirm::execute(
         &deps(&watch_events, noop_logger()),
@@ -121,7 +121,7 @@ async fn rejects_other_users_event() {
         None,
     );
     let event_id = event.id().value();
-    watch_events.save(&event).await.unwrap();
+    watch_events.save(&event, &[]).await.unwrap();
 
     let result = confirm::execute(
         &deps(&watch_events, noop_logger()),
@@ -148,7 +148,6 @@ async fn fails_when_event_not_found() {
 #[tokio::test]
 async fn confirms_event_with_movie_id() {
     let watch_events = InMemoryStore::new();
-    let events = NoopEventPublisher::new();
     let uid = Uuid::new_v4();
     let movie_uuid = Uuid::new_v4();
 
@@ -162,7 +161,7 @@ async fn confirms_event_with_movie_id() {
         Some(domain::value_objects::MovieId::from_uuid(movie_uuid)),
     );
     let event_id = event.id().value();
-    watch_events.save(&event).await.unwrap();
+    watch_events.save(&event, &[]).await.unwrap();
 
     // Also seed movie repo so review_logger can find it
     let movies = domain::testing::InMemoryStore::new();
@@ -174,7 +173,7 @@ async fn confirms_event_with_movie_id() {
         None,
         None,
     );
-    movies.upsert_movie(&movie).await.unwrap();
+    movies.upsert_movie(&movie, &[]).await.unwrap();
 
     // Build a real review logger
     let reviews = domain::testing::InMemoryStore::new();
@@ -186,7 +185,6 @@ async fn confirms_event_with_movie_id() {
             Arc::clone(&reviews) as _,
             Arc::clone(&watchlist) as _,
             Arc::new(domain::testing::FakeMetadataClient) as _,
-            Arc::clone(&events) as _,
         ));
 
     let result = confirm::execute(
@@ -214,7 +212,7 @@ async fn confirms_event_without_movie_id_and_without_external_metadata_id() {
         None,
     );
     let event_id = event.id().value();
-    watch_events.save(&event).await.unwrap();
+    watch_events.save(&event, &[]).await.unwrap();
 
     let result = confirm::execute(
         &deps(&watch_events, noop_logger()),
@@ -260,8 +258,8 @@ async fn confirms_multiple_events() {
     );
     let id2 = event2.id().value();
 
-    watch_events.save(&event1).await.unwrap();
-    watch_events.save(&event2).await.unwrap();
+    watch_events.save(&event1, &[]).await.unwrap();
+    watch_events.save(&event2, &[]).await.unwrap();
 
     let result = confirm::execute(
         &deps(&watch_events, noop_logger()),
@@ -302,7 +300,7 @@ async fn confirms_event_without_year() {
         None,
     );
     let event_id = event.id().value();
-    watch_events.save(&event).await.unwrap();
+    watch_events.save(&event, &[]).await.unwrap();
 
     let result = confirm::execute(
         &deps(&watch_events, noop_logger()),

crates/application/tests/integrations/dismiss_test.rs

@@ -70,8 +70,8 @@ async fn dismisses_existing_events() {
     );
     let id1 = e1.id().value();
     let id2 = e2.id().value();
-    watch_events.save(&e1).await.unwrap();
-    watch_events.save(&e2).await.unwrap();
+    watch_events.save(&e1, &[]).await.unwrap();
+    watch_events.save(&e2, &[]).await.unwrap();
 
     let result = dismiss::execute(
         &deps(&watch_events),

crates/application/tests/integrations/get_queue_test.rs

@@ -46,7 +46,7 @@ async fn returns_pending_events() {
         Utc::now().naive_utc(),
         None,
     );
-    events.save(&event).await.unwrap();
+    events.save(&event, &[]).await.unwrap();
 
     let result = get_queue::execute(&deps(&events), GetWatchQueueQuery { user_id })
         .await

crates/application/tests/integrations/ingest_test.rs

@@ -2,8 +2,7 @@ use crate::support::generate_webhook_token_command;
 use std::sync::Arc;
 
 use domain::models::WatchEventSource;
-use domain::ports::EventPublisher;
-use domain::testing::{InMemoryStore, NoopEventPublisher};
+use domain::testing::{InMemoryStore, RefusingWatchEventCommand};
 use uuid::Uuid;
 
 use application::integrations::commands::IngestWatchEventCommand;
@@ -27,10 +26,9 @@ impl domain::ports::MediaServerParser for FakeParser {
 }
 
 #[tokio::test]
-async fn ingests_watch_event() {
+async fn ingesting_saves_the_watch_event_and_records_its_event_together() {
     let tokens = InMemoryStore::new();
     let watch_events = Arc::clone(&tokens);
-    let event_publisher: Arc<dyn EventPublisher> = NoopEventPublisher::new();
 
     let user_id = Uuid::new_v4();
     let generated = generate_token::execute(
@@ -46,7 +44,6 @@ async fn ingests_watch_event() {
         webhook_token: Arc::clone(&tokens) as _,
         watch_event_command: Arc::clone(&watch_events) as _,
         watch_event_query: Arc::clone(&watch_events) as _,
-        event_publisher: Arc::clone(&event_publisher),
     };
 
     let result = ingest::execute(
@@ -61,19 +58,58 @@ async fn ingests_watch_event() {
     .await;
 
     assert!(result.is_ok());
+    assert_eq!(watch_events.rows_in("watch_events"), 1);
+    let recorded = tokens.recorded_events();
+    assert_eq!(recorded.len(), 1);
+    assert!(matches!(
+        &recorded[0],
+        domain::events::DomainEvent::WatchEventIngested { title, .. } if title == "Test"
+    ));
+}
+
+#[tokio::test]
+async fn a_refused_save_propagates_and_records_nothing() {
+    let tokens = InMemoryStore::new();
+    let user_id = Uuid::new_v4();
+    let generated = generate_token::execute(
+        &GenerateWebhookTokenDeps {
+            webhook_token: Arc::clone(&tokens) as _,
+        },
+        generate_webhook_token_command(user_id),
+    )
+    .await
+    .unwrap();
+    let deps = IngestWatchEventDeps {
+        webhook_token: Arc::clone(&tokens) as _,
+        watch_event_command: Arc::new(RefusingWatchEventCommand),
+        watch_event_query: Arc::clone(&tokens) as _,
+    };
+
+    let result = ingest::execute(
+        &deps,
+        IngestWatchEventCommand {
+            token: generated.token_plaintext,
+            raw_payload: vec![],
+            source: WatchEventSource::Jellyfin,
+        },
+        &FakeParser,
+    )
+    .await;
+
+    assert!(result.is_err());
+    assert_eq!(tokens.rows_in("watch_events"), 0);
+    assert!(tokens.recorded_events().is_empty());
 }
 
 #[tokio::test]
 async fn rejects_invalid_token() {
     let tokens = InMemoryStore::new();
     let watch_events = Arc::clone(&tokens);
-    let event_publisher: Arc<dyn EventPublisher> = NoopEventPublisher::new();
 
     let deps = IngestWatchEventDeps {
         webhook_token: Arc::clone(&tokens) as _,
         watch_event_command: Arc::clone(&watch_events) as _,
         watch_event_query: Arc::clone(&watch_events) as _,
-        event_publisher: Arc::clone(&event_publisher),
     };
 
     let result = ingest::execute(

crates/application/tests/movies.rs

@@ -6,7 +6,11 @@ mod enrich_movie_test;
 mod get_movie_profile_test;
 #[path = "movies/get_movies_test.rs"]
 mod get_movies_test;
+#[path = "movies/poster_sync_handler_test.rs"]
+mod poster_sync_handler_test;
 #[path = "movies/request_enrichment_test.rs"]
 mod request_enrichment_test;
+#[path = "movies/resolve_test.rs"]
+mod resolve_test;
 #[path = "movies/sync_poster_test.rs"]
 mod sync_poster_test;

crates/application/tests/movies/enrich_movie_test.rs

@@ -19,7 +19,7 @@ async fn stores_profile_and_indexes() {
 
     let movie = test_movie_with_year("Test", 2024);
     let movie_id = MovieId::from_uuid(movie.id().value());
-    movie_repo.upsert_movie(&movie).await.unwrap();
+    movie_repo.upsert_movie(&movie, &[]).await.unwrap();
 
     let profile = MovieProfile {
         movie_id: movie_id.clone(),
@@ -68,7 +68,7 @@ async fn extracts_and_indexes_persons() {
 
     let movie = test_movie_with_year("Cast Movie", 2024);
     let movie_id = MovieId::from_uuid(movie.id().value());
-    movie_repo.upsert_movie(&movie).await.unwrap();
+    movie_repo.upsert_movie(&movie, &[]).await.unwrap();
 
     let profile = MovieProfile {
         movie_id: movie_id.clone(),

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());
+}

crates/application/tests/movies/resolve_test.rs

@@ -0,0 +1,127 @@
+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());
+}

crates/application/tests/movies/sync_poster_test.rs

@@ -41,7 +41,7 @@ async fn fails_when_no_external_id() {
     let movies = InMemoryStore::new();
     let movie = test_movie_with_year("Test", 2024);
     let movie_id = movie.id().value();
-    movies.upsert_movie(&movie).await.unwrap();
+    movies.upsert_movie(&movie, &[]).await.unwrap();
 
     let deps = SyncPosterDeps {
         movie_command: Arc::clone(&movies) as _,
@@ -80,7 +80,7 @@ async fn syncs_poster_for_movie_with_external_id() {
     let ext_id = ExternalMetadataId::new("tmdb:999".into()).unwrap();
     let movie = test_movie_with_external_id("Poster Movie", 2024, ext_id);
     let movie_id = movie.id().value();
-    movies.upsert_movie(&movie).await.unwrap();
+    movies.upsert_movie(&movie, &[]).await.unwrap();
 
     let deps = SyncPosterDeps {
         movie_command: Arc::clone(&movies) as _,

crates/application/tests/watchlist/add_test.rs

@@ -5,7 +5,7 @@ use std::sync::Arc;
 use domain::{
     events::DomainEvent,
     ports::MovieCommand,
-    testing::{InMemoryStore, NoopEventPublisher, RefusingWatchlistRepository},
+    testing::{InMemoryStore, RefusingWatchlistRepository},
 };
 
 use application::watchlist::{add, commands::AddToWatchlistCommand, deps::WatchlistAddDeps};
@@ -16,7 +16,6 @@ fn make_deps(movies: Arc<InMemoryStore>, watchlist: Arc<InMemoryStore>) -> Watch
         movie_query: movies,
         metadata: Arc::new(domain::testing::FakeMetadataClient),
         watchlist,
-        event_publisher: NoopEventPublisher::new(),
     }
 }
 
@@ -27,7 +26,7 @@ async fn adding_to_the_watchlist_resolves_the_movie_and_saves_the_entry() {
 
     let movie = test_movie_with_year("The Thing", 1982);
     let movie_uuid = movie.id().value();
-    movies.upsert_movie(&movie).await.unwrap();
+    movies.upsert_movie(&movie, &[]).await.unwrap();
 
     let deps = make_deps(Arc::clone(&movies), Arc::clone(&watchlist));
 
@@ -46,7 +45,7 @@ async fn adding_a_movie_already_on_the_watchlist_is_idempotent() {
     let movie = test_movie_with_year("RoboCop", 1987);
     let movie_uuid = movie.id().value();
     let user_id = uuid::Uuid::new_v4();
-    movies.upsert_movie(&movie).await.unwrap();
+    movies.upsert_movie(&movie, &[]).await.unwrap();
 
     let deps = make_deps(Arc::clone(&movies), Arc::clone(&watchlist));
 
@@ -98,7 +97,7 @@ async fn adding_the_same_movie_to_a_watchlist_twice_keeps_a_single_entry_and_suc
     let movie = test_movie_with_year("Heat", 1995);
     let movie_uuid = movie.id().value();
     let user_id = uuid::Uuid::new_v4();
-    movies.upsert_movie(&movie).await.unwrap();
+    movies.upsert_movie(&movie, &[]).await.unwrap();
     let deps = make_deps(Arc::clone(&movies), Arc::clone(&movies));
 
     for _ in 0..2 {
@@ -114,7 +113,7 @@ async fn adding_the_same_movie_to_a_watchlist_twice_keeps_a_single_entry_and_suc
 async fn adding_an_entry_records_the_entry_and_its_event_together() {
     let movies = InMemoryStore::new();
     let movie = test_movie_with_year("Heat", 1995);
-    movies.upsert_movie(&movie).await.unwrap();
+    movies.upsert_movie(&movie, &[]).await.unwrap();
     let deps = make_deps(Arc::clone(&movies), Arc::clone(&movies));
 
     add::execute(
@@ -137,7 +136,7 @@ async fn adding_an_entry_records_the_entry_and_its_event_together() {
 async fn a_refused_add_propagates_and_records_nothing() {
     let movies = InMemoryStore::new();
     let movie = test_movie_with_year("Heat", 1995);
-    movies.upsert_movie(&movie).await.unwrap();
+    movies.upsert_movie(&movie, &[]).await.unwrap();
     let deps = WatchlistAddDeps {
         watchlist: Arc::new(RefusingWatchlistRepository),
         ..make_deps(Arc::clone(&movies), Arc::clone(&movies))

crates/application/tests/wrapup/generate_test.rs

@@ -2,7 +2,7 @@ use crate::support::request_wrap_up_command;
 use chrono::NaiveDate;
 use domain::events::DomainEvent;
 use domain::models::wrapup::{WrapUpRecord, WrapUpStatus};
-use domain::testing::{InMemoryWrapUpRepository, NoopEventPublisher};
+use domain::testing::{InMemoryWrapUpRepository, RefusingWrapUpWrites};
 use domain::value_objects::WrapUpId;
 use uuid::Uuid;
 
@@ -11,13 +11,9 @@ use std::sync::Arc;
 use application::wrapup::deps::GenerateWrapUpDeps;
 use application::wrapup::{commands::RequestWrapUpCommand, generate};
 
-fn deps(
-    repo: &Arc<InMemoryWrapUpRepository>,
-    events: &Arc<NoopEventPublisher>,
-) -> GenerateWrapUpDeps {
+fn deps(repo: &Arc<InMemoryWrapUpRepository>) -> GenerateWrapUpDeps {
     GenerateWrapUpDeps {
         wrapup_repo: Arc::clone(repo) as _,
-        event_publisher: Arc::clone(events) as _,
     }
 }
 
@@ -26,25 +22,22 @@ fn past_cmd() -> RequestWrapUpCommand {
 }
 
 #[tokio::test]
-async fn creates_pending_record_and_emits_event() {
+async fn creates_pending_record_and_records_its_event_together() {
     let repo = InMemoryWrapUpRepository::new();
-    let events = NoopEventPublisher::new();
 
-    let id = generate::execute(&deps(&repo, &events), past_cmd())
-        .await
-        .unwrap();
+    let id = generate::execute(&deps(&repo), past_cmd()).await.unwrap();
 
     let stored = repo.store.lock().unwrap();
     assert_eq!(stored.len(), 1);
     assert_eq!(stored[0].id, id);
     assert_eq!(stored[0].status, WrapUpStatus::Pending);
 
-    let published = events.published();
-    assert!(
-        published
-            .iter()
-            .any(|e| matches!(e, DomainEvent::WrapUpRequested { .. }))
-    );
+    let recorded = repo.recorded_events();
+    assert_eq!(recorded.len(), 1);
+    assert!(matches!(
+        &recorded[0],
+        DomainEvent::WrapUpRequested { wrapup_id, .. } if *wrapup_id == id
+    ));
 }
 
 #[tokio::test]
@@ -62,13 +55,11 @@ async fn reuses_existing_ready_wrapup() {
         created_at: chrono::Utc::now().naive_utc(),
         completed_at: None,
     });
-    let events = NoopEventPublisher::new();
 
-    let id = generate::execute(&deps(&repo, &events), past_cmd())
-        .await
-        .unwrap();
+    let id = generate::execute(&deps(&repo), past_cmd()).await.unwrap();
     assert_eq!(id, existing_id);
     assert_eq!(repo.store.lock().unwrap().len(), 1);
+    assert!(repo.recorded_events().is_empty());
 }
 
 #[tokio::test]
@@ -86,11 +77,7 @@ async fn replaces_failed_wrapup() {
         completed_at: None,
     });
 
-    let events = NoopEventPublisher::new();
-
-    let id = generate::execute(&deps(&repo, &events), past_cmd())
-        .await
-        .unwrap();
+    let id = generate::execute(&deps(&repo), past_cmd()).await.unwrap();
 
     let stored = repo.store.lock().unwrap();
     assert_eq!(stored.len(), 1);
@@ -101,10 +88,23 @@ async fn replaces_failed_wrapup() {
 #[tokio::test]
 async fn rejects_future_end_date() {
     let repo = InMemoryWrapUpRepository::new();
-    let events = NoopEventPublisher::new();
-    let err = generate::execute(&deps(&repo, &events), request_wrap_up_command(None, 2030))
+    let err = generate::execute(&deps(&repo), request_wrap_up_command(None, 2030))
         .await
         .unwrap_err();
 
     assert!(err.to_string().contains("future"));
 }
+
+#[tokio::test]
+async fn a_refused_create_propagates_and_records_nothing() {
+    let inner = InMemoryWrapUpRepository::new();
+    let deps = GenerateWrapUpDeps {
+        wrapup_repo: RefusingWrapUpWrites::new(Arc::clone(&inner)),
+    };
+
+    let result = generate::execute(&deps, past_cmd()).await;
+
+    assert!(result.is_err());
+    assert!(inner.store.lock().unwrap().is_empty());
+    assert!(inner.recorded_events().is_empty());
+}

crates/application/tests/wrapup/get_ready_report_test.rs

@@ -56,7 +56,7 @@ fn record(
 async fn ready_report_returns_report_when_ready() {
     let repo = InMemoryWrapUpRepository::new();
     let user_id = Uuid::new_v4();
-    repo.create(&record(Some(user_id), 2024, WrapUpStatus::Ready, true))
+    repo.create(&record(Some(user_id), 2024, WrapUpStatus::Ready, true), &[])
         .await
         .unwrap();
 
@@ -72,12 +72,10 @@ async fn ready_report_returns_report_when_ready() {
 async fn ready_report_is_not_found_when_status_not_ready() {
     let repo = InMemoryWrapUpRepository::new();
     let user_id = Uuid::new_v4();
-    repo.create(&record(
-        Some(user_id),
-        2024,
-        WrapUpStatus::Generating,
-        false,
-    ))
+    repo.create(
+        &record(Some(user_id), 2024, WrapUpStatus::Generating, false),
+        &[],
+    )
     .await
     .unwrap();
 
@@ -96,9 +94,12 @@ async fn ready_report_is_not_found_when_report_absent() {
     // Status is Ready but `report` is None — an inconsistent-but-representable
     // state the old handler guarded against explicitly (`match record.report {
     // Some(r) => ..., None => 404 }`), separate from the status gate above.
-    repo.create(&record(Some(user_id), 2024, WrapUpStatus::Ready, false))
-        .await
-        .unwrap();
+    repo.create(
+        &record(Some(user_id), 2024, WrapUpStatus::Ready, false),
+        &[],
+    )
+    .await
+    .unwrap();
 
     let deps = GetReadyReportDeps { wrapup_repo: repo };
 
@@ -122,7 +123,7 @@ async fn ready_report_is_not_found_when_no_record_exists() {
 #[tokio::test]
 async fn ready_report_global_scope_ignores_user_id() {
     let repo = InMemoryWrapUpRepository::new();
-    repo.create(&record(None, 2024, WrapUpStatus::Ready, true))
+    repo.create(&record(None, 2024, WrapUpStatus::Ready, true), &[])
         .await
         .unwrap();
 

crates/application/tests/wrapup/handle_requested_test.rs

@@ -1,7 +1,7 @@
 use chrono::{NaiveDate, Utc};
 use domain::models::wrapup::{WrapUpRecord, WrapUpStatus};
 use domain::ports::WrapUpRepository;
-use domain::testing::{InMemoryWrapUpRepository, InMemoryWrapUpStatsQuery, NoopEventPublisher};
+use domain::testing::{InMemoryWrapUpRepository, InMemoryWrapUpStatsQuery, RefusingWrapUpWrites};
 use domain::value_objects::WrapUpId;
 
 use application::wrapup::{deps::HandleWrapUpRequestedDeps, handle_requested};
@@ -22,11 +22,10 @@ async fn skips_if_already_ready() {
         created_at: Utc::now().naive_utc(),
         completed_at: None,
     };
-    repo.create(&record).await.unwrap();
+    repo.create(&record, &[]).await.unwrap();
 
     let deps = HandleWrapUpRequestedDeps {
         wrapup_repo: repo.clone(),
-        event_publisher: NoopEventPublisher::new(),
         wrapup_stats: InMemoryWrapUpStatsQuery::new(),
     };
 
@@ -46,7 +45,6 @@ async fn skips_if_already_ready() {
 async fn generates_wrapup_and_marks_complete() {
     let repo = InMemoryWrapUpRepository::new();
     let stats = InMemoryWrapUpStatsQuery::new();
-    let events = NoopEventPublisher::new();
     let wrapup_id = WrapUpId::generate();
     let uid = uuid::Uuid::new_v4();
 
@@ -61,11 +59,10 @@ async fn generates_wrapup_and_marks_complete() {
         created_at: Utc::now().naive_utc(),
         completed_at: None,
     };
-    repo.create(&record).await.unwrap();
+    repo.create(&record, &[]).await.unwrap();
 
     let deps = HandleWrapUpRequestedDeps {
         wrapup_repo: repo.clone(),
-        event_publisher: events.clone(),
         wrapup_stats: stats.clone(),
     };
 
@@ -85,13 +82,13 @@ async fn generates_wrapup_and_marks_complete() {
     assert_eq!(final_rec.status, WrapUpStatus::Ready);
     assert!(final_rec.report.is_some());
 
-    // Verify event was published
-    let published = events.published();
-    assert!(
-        published
-            .iter()
-            .any(|e| matches!(e, domain::events::DomainEvent::WrapUpCompleted { .. }))
-    );
+    // The completion event is recorded together with the completed row.
+    let recorded = repo.recorded_events();
+    assert_eq!(recorded.len(), 1);
+    assert!(matches!(
+        &recorded[0],
+        domain::events::DomainEvent::WrapUpCompleted { wrapup_id: id } if *id == wrapup_id
+    ));
 }
 
 #[tokio::test]
@@ -110,11 +107,10 @@ async fn skips_if_already_generating() {
         created_at: Utc::now().naive_utc(),
         completed_at: None,
     };
-    repo.create(&record).await.unwrap();
+    repo.create(&record, &[]).await.unwrap();
 
     let deps = HandleWrapUpRequestedDeps {
         wrapup_repo: repo.clone(),
-        event_publisher: NoopEventPublisher::new(),
         wrapup_stats: InMemoryWrapUpStatsQuery::new(),
     };
 
@@ -132,4 +128,42 @@ async fn skips_if_already_generating() {
     // Status should still be Generating (not changed to Ready)
     let final_rec = repo.get_by_id(&wrapup_id).await.unwrap().unwrap();
     assert_eq!(final_rec.status, WrapUpStatus::Generating);
+    assert!(repo.recorded_events().is_empty());
+}
+
+#[tokio::test]
+async fn a_refused_completion_propagates_and_records_nothing() {
+    let inner = InMemoryWrapUpRepository::new();
+    let wrapup_id = WrapUpId::generate();
+    let record = WrapUpRecord {
+        id: wrapup_id.clone(),
+        user_id: None,
+        start_date: NaiveDate::from_ymd_opt(2024, 1, 1).unwrap(),
+        end_date: NaiveDate::from_ymd_opt(2024, 12, 31).unwrap(),
+        status: WrapUpStatus::Pending,
+        report: None,
+        error_message: None,
+        created_at: Utc::now().naive_utc(),
+        completed_at: None,
+    };
+    inner.create(&record, &[]).await.unwrap();
+    let deps = HandleWrapUpRequestedDeps {
+        wrapup_repo: RefusingWrapUpWrites::new(inner.clone()),
+        wrapup_stats: InMemoryWrapUpStatsQuery::new(),
+    };
+
+    let result = handle_requested::execute(
+        &deps,
+        wrapup_id.clone(),
+        None,
+        NaiveDate::from_ymd_opt(2024, 1, 1).unwrap(),
+        NaiveDate::from_ymd_opt(2024, 12, 31).unwrap(),
+    )
+    .await;
+
+    assert!(result.is_err());
+    let rec = inner.get_by_id(&wrapup_id).await.unwrap().unwrap();
+    assert_ne!(rec.status, WrapUpStatus::Ready);
+    assert!(rec.report.is_none());
+    assert!(inner.recorded_events().is_empty());
 }