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