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).
2026-10-26 01:02:34 +01:00
parent 2f133afb96
commit 6c295866a0
51 changed files with 1281 additions and 329 deletions
--- a/crates/adapters/sqlite/tests/repositories/outbox_writes_test.rs
+++ b/crates/adapters/sqlite/tests/repositories/outbox_writes_test.rs
@@ -4,7 +4,8 @@ use domain::{
    events::DomainEvent,
    models::{ProfileField, UserProfile, WatchlistEntry},
    ports::{
-        GoalCommand, MovieCommand, UserProfileFieldsRepository, UserRepository, WatchlistRepository,
+        GoalCommand, MovieCommand, UserProfileFieldsRepository, UserRepository, WatchEventCommand,
+        WatchlistRepository, WrapUpRepository,
    },
    testing::{test_goal, test_movie, test_user},
    value_objects::UserId,
@@ -161,7 +162,7 @@ async fn watchlist_fixture() -> (SqlitePool, UserId, domain::models::Movie) {
    let (pool, user) = pool_with_user().await;
    let movie = test_movie("Heat");
    SqliteMovieRepository::new(pool.clone())
-        .upsert_movie(&movie)
+        .upsert_movie(&movie, &[])
        .await
        .unwrap();
    (pool, user.id().clone(), movie)
@@ -419,3 +420,295 @@ async fn a_failing_enqueue_rolls_back_the_profile_fields_replacement() {
        "delete of the old fields rolled back"
    );
 }
+
+fn movie_discovered(movie: &domain::models::Movie) -> DomainEvent {
+    DomainEvent::MovieDiscovered {
+        movie_id: movie.id().clone(),
+        external_metadata_id: domain::value_objects::ExternalMetadataId::new("tmdb:1".into())
+            .unwrap(),
+    }
+}
+
+fn movie_deleted(movie: &domain::models::Movie) -> DomainEvent {
+    DomainEvent::MovieDeleted {
+        movie_id: movie.id().clone(),
+        poster_path: None,
+    }
+}
+
+#[tokio::test]
+async fn upserting_a_movie_writes_the_movie_and_its_event_in_one_commit() {
+    let pool = migrated_pool().await;
+    let movie = test_movie("Heat");
+
+    SqliteMovieRepository::new(pool.clone())
+        .upsert_movie(&movie, &[movie_discovered(&movie)])
+        .await
+        .unwrap();
+
+    assert_eq!(count(&pool, "movies").await, 1);
+    assert_eq!(count(&pool, "event_queue").await, 1);
+}
+
+#[tokio::test]
+async fn a_failing_enqueue_rolls_back_the_movie_upsert_of_a_new_movie() {
+    let pool = migrated_pool().await;
+    let movie = test_movie("Heat");
+    fail_event_inserts(&pool).await;
+
+    let result = SqliteMovieRepository::new(pool.clone())
+        .upsert_movie(&movie, &[movie_discovered(&movie)])
+        .await;
+
+    assert!(result.is_err());
+    assert_eq!(count(&pool, "movies").await, 0);
+}
+
+#[tokio::test]
+async fn a_failing_enqueue_rolls_back_a_movie_update() {
+    let pool = migrated_pool().await;
+    let repo = SqliteMovieRepository::new(pool.clone());
+    let mut movie = test_movie("Heat");
+    repo.upsert_movie(&movie, &[]).await.unwrap();
+    movie.update_poster(domain::value_objects::PosterPath::new("posters/new.jpg".into()).unwrap());
+    fail_event_inserts(&pool).await;
+
+    let result = repo.upsert_movie(&movie, &[movie_discovered(&movie)]).await;
+
+    assert!(result.is_err());
+    let poster: Option<String> = sqlx::query_scalar("SELECT poster_path FROM movies")
+        .fetch_one(&pool)
+        .await
+        .unwrap();
+    assert_eq!(poster, None, "poster update rolled back");
+}
+
+#[tokio::test]
+async fn deleting_a_movie_writes_the_removal_and_its_event_in_one_commit() {
+    let pool = migrated_pool().await;
+    let repo = SqliteMovieRepository::new(pool.clone());
+    let movie = test_movie("Heat");
+    repo.upsert_movie(&movie, &[]).await.unwrap();
+
+    repo.delete_movie(movie.id(), &[movie_deleted(&movie)])
+        .await
+        .unwrap();
+
+    assert_eq!(count(&pool, "movies").await, 0);
+    assert_eq!(count(&pool, "event_queue").await, 1);
+}
+
+#[tokio::test]
+async fn a_failing_enqueue_rolls_back_the_movie_delete() {
+    let pool = migrated_pool().await;
+    let repo = SqliteMovieRepository::new(pool.clone());
+    let movie = test_movie("Heat");
+    repo.upsert_movie(&movie, &[]).await.unwrap();
+    fail_event_inserts(&pool).await;
+
+    let result = repo
+        .delete_movie(movie.id(), &[movie_deleted(&movie)])
+        .await;
+
+    assert!(result.is_err());
+    assert_eq!(count(&pool, "movies").await, 1, "delete rolled back");
+}
+
+#[tokio::test]
+async fn deleting_an_absent_movie_enqueues_no_event() {
+    let pool = migrated_pool().await;
+    let movie = test_movie("Heat");
+
+    SqliteMovieRepository::new(pool.clone())
+        .delete_movie(movie.id(), &[movie_deleted(&movie)])
+        .await
+        .unwrap();
+
+    assert_eq!(count(&pool, "event_queue").await, 0);
+}
+
+fn wrapup_record(user_id: Option<uuid::Uuid>) -> domain::models::wrapup::WrapUpRecord {
+    use domain::models::wrapup::WrapUpStatus;
+    domain::models::wrapup::WrapUpRecord {
+        id: domain::value_objects::WrapUpId::generate(),
+        user_id,
+        start_date: chrono::NaiveDate::from_ymd_opt(2024, 1, 1).unwrap(),
+        end_date: chrono::NaiveDate::from_ymd_opt(2024, 12, 31).unwrap(),
+        status: WrapUpStatus::Pending,
+        report: None,
+        error_message: None,
+        created_at: chrono::Utc::now().naive_utc(),
+        completed_at: None,
+    }
+}
+
+fn wrapup_requested(record: &domain::models::wrapup::WrapUpRecord) -> DomainEvent {
+    DomainEvent::WrapUpRequested {
+        wrapup_id: record.id.clone(),
+        user_id: None,
+        start_date: record.start_date,
+        end_date: record.end_date,
+    }
+}
+
+fn wrapup_completed(record: &domain::models::wrapup::WrapUpRecord) -> DomainEvent {
+    DomainEvent::WrapUpCompleted {
+        wrapup_id: record.id.clone(),
+    }
+}
+
+fn empty_report() -> domain::models::wrapup::WrapUpReport {
+    serde_json::from_value(serde_json::json!({
+        "scope": "Global",
+        "date_range": { "start": "2024-01-01", "end": "2024-12-31" },
+        "generated_at": "2025-01-01T00:00:00Z",
+        "total_movies": 0,
+        "total_watch_time_minutes": 0,
+        "movies_per_month": [],
+        "rating_distribution": [0, 0, 0, 0, 0],
+        "top_directors": [],
+        "top_actors": [],
+        "director_diversity": 0,
+        "actor_diversity": 0,
+        "top_genres": [],
+        "genre_diversity": 0,
+        "top_keywords": [],
+        "language_distribution": [],
+        "watch_medium_distribution": [],
+        "total_rewatches": 0,
+        "poster_paths": [],
+        "top_cast_profile_paths": [],
+    }))
+    .expect("minimal wrap-up report")
+}
+
+#[tokio::test]
+async fn creating_a_wrapup_writes_the_record_and_its_event_in_one_commit() {
+    let pool = migrated_pool().await;
+    let record = wrapup_record(None);
+
+    sqlite::SqliteWrapUpRepository::new(pool.clone())
+        .create(&record, &[wrapup_requested(&record)])
+        .await
+        .unwrap();
+
+    assert_eq!(count(&pool, "wrap_up_records").await, 1);
+    assert_eq!(count(&pool, "event_queue").await, 1);
+}
+
+#[tokio::test]
+async fn a_failing_enqueue_rolls_back_the_wrapup_create() {
+    let pool = migrated_pool().await;
+    let record = wrapup_record(None);
+    fail_event_inserts(&pool).await;
+
+    let result = sqlite::SqliteWrapUpRepository::new(pool.clone())
+        .create(&record, &[wrapup_requested(&record)])
+        .await;
+
+    assert!(result.is_err());
+    assert_eq!(count(&pool, "wrap_up_records").await, 0);
+}
+
+#[tokio::test]
+async fn completing_a_wrapup_writes_the_report_and_its_event_in_one_commit() {
+    let pool = migrated_pool().await;
+    let repo = sqlite::SqliteWrapUpRepository::new(pool.clone());
+    let record = wrapup_record(None);
+    repo.create(&record, &[]).await.unwrap();
+
+    repo.set_complete(&record.id, &empty_report(), &[wrapup_completed(&record)])
+        .await
+        .unwrap();
+
+    let status: String = sqlx::query_scalar("SELECT status FROM wrap_up_records")
+        .fetch_one(&pool)
+        .await
+        .unwrap();
+    assert_eq!(status, "ready");
+    assert_eq!(count(&pool, "event_queue").await, 1);
+}
+
+#[tokio::test]
+async fn a_failing_enqueue_rolls_back_the_wrapup_completion() {
+    let pool = migrated_pool().await;
+    let repo = sqlite::SqliteWrapUpRepository::new(pool.clone());
+    let record = wrapup_record(None);
+    repo.create(&record, &[]).await.unwrap();
+    fail_event_inserts(&pool).await;
+
+    let result = repo
+        .set_complete(&record.id, &empty_report(), &[wrapup_completed(&record)])
+        .await;
+
+    assert!(result.is_err());
+    let status: String = sqlx::query_scalar("SELECT status FROM wrap_up_records")
+        .fetch_one(&pool)
+        .await
+        .unwrap();
+    assert_eq!(status, "pending", "completion rolled back");
+}
+
+#[tokio::test]
+async fn completing_a_missing_wrapup_is_not_found_and_enqueues_no_event() {
+    let pool = migrated_pool().await;
+    let record = wrapup_record(None);
+
+    let result = sqlite::SqliteWrapUpRepository::new(pool.clone())
+        .set_complete(&record.id, &empty_report(), &[wrapup_completed(&record)])
+        .await;
+
+    assert!(matches!(
+        result,
+        Err(domain::errors::DomainError::NotFound(_))
+    ));
+    assert_eq!(count(&pool, "event_queue").await, 0);
+}
+
+fn watch_event_for(user_id: &UserId) -> domain::models::WatchEvent {
+    domain::models::WatchEvent::new(
+        user_id.clone(),
+        "Heat".into(),
+        Some(1995),
+        None,
+        domain::models::WatchEventSource::Jellyfin,
+        chrono::Utc::now().naive_utc(),
+        None,
+    )
+}
+
+fn watch_event_ingested(user_id: &UserId) -> DomainEvent {
+    DomainEvent::WatchEventIngested {
+        user_id: user_id.clone(),
+        title: "Heat".into(),
+        source: "jellyfin".into(),
+    }
+}
+
+#[tokio::test]
+async fn saving_a_watch_event_writes_the_row_and_its_event_in_one_commit() {
+    let (pool, user) = pool_with_user().await;
+    let event = watch_event_for(user.id());
+
+    sqlite::SqliteWatchEventRepository::new(pool.clone())
+        .save(&event, &[watch_event_ingested(user.id())])
+        .await
+        .unwrap();
+
+    assert_eq!(count(&pool, "watch_events").await, 1);
+    assert_eq!(count(&pool, "event_queue").await, 1);
+}
+
+#[tokio::test]
+async fn a_failing_enqueue_rolls_back_the_watch_event_save() {
+    let (pool, user) = pool_with_user().await;
+    let event = watch_event_for(user.id());
+    fail_event_inserts(&pool).await;
+
+    let result = sqlite::SqliteWatchEventRepository::new(pool.clone())
+        .save(&event, &[watch_event_ingested(user.id())])
+        .await;
+
+    assert!(result.is_err());
+    assert_eq!(count(&pool, "watch_events").await, 0);
+}