structural refactor and codebase improvements

crates/application/src/wrapup/tests/delete.rs

@@ -4,6 +4,7 @@ use domain::testing::InMemoryWrapUpRepository;
 use domain::value_objects::WrapUpId;
 
 use crate::wrapup::delete;
+use crate::wrapup::deps::DeleteWrapUpDeps;
 
 #[tokio::test]
 async fn deletes_existing_wrapup() {
@@ -21,13 +22,19 @@ async fn deletes_existing_wrapup() {
         completed_at: None,
     });
 
-    delete::execute(repo.clone(), id).await.unwrap();
+    let deps = DeleteWrapUpDeps {
+        wrapup_repo: repo.clone(),
+    };
+    delete::execute(&deps, id).await.unwrap();
     assert_eq!(repo.store.lock().unwrap().len(), 0);
 }
 
 #[tokio::test]
 async fn fails_when_not_found() {
     let repo = InMemoryWrapUpRepository::new();
-    let result = delete::execute(repo.clone(), WrapUpId::generate()).await;
+    let deps = DeleteWrapUpDeps {
+        wrapup_repo: repo.clone(),
+    };
+    let result = delete::execute(&deps, WrapUpId::generate()).await;
     assert!(result.is_err());
 }

crates/application/src/wrapup/tests/generate.rs

@@ -5,8 +5,21 @@ use domain::testing::{InMemoryWrapUpRepository, NoopEventPublisher};
 use domain::value_objects::WrapUpId;
 use uuid::Uuid;
 
+use std::sync::Arc;
+
+use crate::wrapup::deps::GenerateWrapUpDeps;
 use crate::wrapup::{commands::RequestWrapUpCommand, generate};
 
+fn deps(
+    repo: &Arc<InMemoryWrapUpRepository>,
+    events: &Arc<NoopEventPublisher>,
+) -> GenerateWrapUpDeps {
+    GenerateWrapUpDeps {
+        wrapup_repo: Arc::clone(repo) as _,
+        event_publisher: Arc::clone(events) as _,
+    }
+}
+
 fn past_cmd() -> RequestWrapUpCommand {
     RequestWrapUpCommand {
         user_id: Some(Uuid::nil()),
@@ -20,7 +33,7 @@ async fn creates_pending_record_and_emits_event() {
     let repo = InMemoryWrapUpRepository::new();
     let events = NoopEventPublisher::new();
 
-    let id = generate::execute(repo.clone(), events.clone(), past_cmd())
+    let id = generate::execute(&deps(&repo, &events), past_cmd())
         .await
         .unwrap();
 
@@ -54,7 +67,7 @@ async fn reuses_existing_ready_wrapup() {
     });
     let events = NoopEventPublisher::new();
 
-    let id = generate::execute(repo.clone(), events.clone(), past_cmd())
+    let id = generate::execute(&deps(&repo, &events), past_cmd())
         .await
         .unwrap();
     assert_eq!(id, existing_id);
@@ -78,7 +91,7 @@ async fn replaces_failed_wrapup() {
 
     let events = NoopEventPublisher::new();
 
-    let id = generate::execute(repo.clone(), events.clone(), past_cmd())
+    let id = generate::execute(&deps(&repo, &events), past_cmd())
         .await
         .unwrap();
 
@@ -93,8 +106,7 @@ async fn rejects_future_end_date() {
     let repo = InMemoryWrapUpRepository::new();
     let events = NoopEventPublisher::new();
     let err = generate::execute(
-        repo.clone(),
-        events.clone(),
+        &deps(&repo, &events),
         RequestWrapUpCommand {
             user_id: None,
             start_date: NaiveDate::from_ymd_opt(2030, 1, 1).unwrap(),

crates/application/src/wrapup/tests/get_ready_report.rs

@@ -0,0 +1,152 @@
+use chrono::NaiveDate;
+use uuid::Uuid;
+
+use domain::errors::DomainError;
+use domain::models::wrapup::{DateRange, WrapUpRecord, WrapUpScope, WrapUpStatus};
+use domain::ports::WrapUpRepository;
+use domain::services::wrapup_analyzer;
+use domain::testing::InMemoryWrapUpRepository;
+use domain::value_objects::WrapUpId;
+
+use crate::wrapup::deps::GetReadyReportDeps;
+use crate::wrapup::get_ready_report;
+
+fn year_range(year: i32) -> DateRange {
+    DateRange::new(
+        NaiveDate::from_ymd_opt(year, 1, 1).unwrap(),
+        NaiveDate::from_ymd_opt(year + 1, 1, 1).unwrap(),
+    )
+    .unwrap()
+}
+
+fn record(
+    user_id: Option<Uuid>,
+    year: i32,
+    status: WrapUpStatus,
+    with_report: bool,
+) -> WrapUpRecord {
+    let range = year_range(year);
+    let domain_scope = match user_id {
+        Some(u) => WrapUpScope::User(u),
+        None => WrapUpScope::Global,
+    };
+    let report = if with_report {
+        Some(wrapup_analyzer::build_report(
+            domain_scope,
+            range.clone(),
+            &[],
+        ))
+    } else {
+        None
+    };
+    WrapUpRecord {
+        id: WrapUpId::generate(),
+        user_id,
+        start_date: range.start(),
+        end_date: range.end(),
+        status,
+        report,
+        error_message: None,
+        created_at: chrono::Utc::now().naive_utc(),
+        completed_at: None,
+    }
+}
+
+#[tokio::test]
+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))
+        .await
+        .unwrap();
+
+    let deps = GetReadyReportDeps { wrapup_repo: repo };
+
+    let report = get_ready_report::execute(&deps, WrapUpScope::User(user_id), 2024)
+        .await
+        .unwrap();
+    assert_eq!(report.total_movies, 0);
+}
+
+#[tokio::test]
+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,
+    ))
+    .await
+    .unwrap();
+
+    let deps = GetReadyReportDeps { wrapup_repo: repo };
+
+    let err = get_ready_report::execute(&deps, WrapUpScope::User(user_id), 2024)
+        .await
+        .unwrap_err();
+    assert!(matches!(err, DomainError::NotFound(_)), "got {err:?}");
+}
+
+#[tokio::test]
+async fn ready_report_is_not_found_when_report_absent() {
+    let repo = InMemoryWrapUpRepository::new();
+    let user_id = Uuid::new_v4();
+    // 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();
+
+    let deps = GetReadyReportDeps { wrapup_repo: repo };
+
+    let err = get_ready_report::execute(&deps, WrapUpScope::User(user_id), 2024)
+        .await
+        .unwrap_err();
+    assert!(matches!(err, DomainError::NotFound(_)), "got {err:?}");
+}
+
+#[tokio::test]
+async fn ready_report_is_not_found_when_no_record_exists() {
+    let repo = InMemoryWrapUpRepository::new();
+    let deps = GetReadyReportDeps { wrapup_repo: repo };
+
+    let err = get_ready_report::execute(&deps, WrapUpScope::User(Uuid::new_v4()), 2024)
+        .await
+        .unwrap_err();
+    assert!(matches!(err, DomainError::NotFound(_)), "got {err:?}");
+}
+
+#[tokio::test]
+async fn ready_report_global_scope_ignores_user_id() {
+    let repo = InMemoryWrapUpRepository::new();
+    repo.create(&record(None, 2024, WrapUpStatus::Ready, true))
+        .await
+        .unwrap();
+
+    let deps = GetReadyReportDeps { wrapup_repo: repo };
+
+    get_ready_report::execute(&deps, WrapUpScope::Global, 2024)
+        .await
+        .unwrap();
+}
+
+/// The old handlers guarded `NaiveDate::from_ymd_opt` up front and returned a bare
+/// 400 for a year that can't form a valid date — that guard moved into the use
+/// case along with the rest of the year->date-range conversion. A distinguishable
+/// error (ValidationError, not NotFound) lets the handler still map it to 400.
+#[tokio::test]
+async fn ready_report_is_validation_error_for_unrepresentable_year() {
+    let repo = InMemoryWrapUpRepository::new();
+    let deps = GetReadyReportDeps { wrapup_repo: repo };
+
+    let err = get_ready_report::execute(&deps, WrapUpScope::Global, 999_999)
+        .await
+        .unwrap_err();
+    assert!(
+        matches!(err, DomainError::ValidationError(_)),
+        "got {err:?}"
+    );
+}

crates/application/src/wrapup/tests/get_wrapup.rs

@@ -3,6 +3,7 @@ use domain::models::wrapup::{WrapUpRecord, WrapUpStatus};
 use domain::testing::InMemoryWrapUpRepository;
 use domain::value_objects::WrapUpId;
 
+use crate::wrapup::deps::GetWrapUpDeps;
 use crate::wrapup::get_wrapup;
 
 #[tokio::test]
@@ -21,7 +22,10 @@ async fn returns_record_when_exists() {
         completed_at: None,
     });
 
-    let result = get_wrapup::execute(repo.clone(), id).await.unwrap();
+    let deps = GetWrapUpDeps {
+        wrapup_repo: repo.clone(),
+    };
+    let result = get_wrapup::execute(&deps, id).await.unwrap();
     assert!(result.is_some());
     assert_eq!(result.unwrap().status, WrapUpStatus::Pending);
 }
@@ -29,7 +33,10 @@ async fn returns_record_when_exists() {
 #[tokio::test]
 async fn returns_none_when_missing() {
     let repo = InMemoryWrapUpRepository::new();
-    let result = get_wrapup::execute(repo.clone(), WrapUpId::generate())
+    let deps = GetWrapUpDeps {
+        wrapup_repo: repo.clone(),
+    };
+    let result = get_wrapup::execute(&deps, WrapUpId::generate())
         .await
         .unwrap();
     assert!(result.is_none());

crates/application/src/wrapup/tests/list_wrapups.rs

@@ -4,6 +4,7 @@ use domain::testing::InMemoryWrapUpRepository;
 use domain::value_objects::WrapUpId;
 use uuid::Uuid;
 
+use crate::wrapup::deps::ListWrapUpsDeps;
 use crate::wrapup::list_wrapups::{self, ListWrapUpsQuery};
 
 fn make_record(user_id: Option<Uuid>) -> WrapUpRecord {
@@ -31,7 +32,10 @@ async fn filters_by_user() {
         store.push(make_record(None));
     }
 
-    let result = list_wrapups::execute(repo.clone(), ListWrapUpsQuery { user_id: Some(uid) })
+    let deps = ListWrapUpsDeps {
+        wrapup_repo: repo.clone(),
+    };
+    let result = list_wrapups::execute(&deps, ListWrapUpsQuery { user_id: Some(uid) })
         .await
         .unwrap();
     assert_eq!(result.len(), 1);
@@ -48,7 +52,10 @@ async fn returns_global_when_no_user() {
         store.push(make_record(Some(Uuid::new_v4())));
     }
 
-    let result = list_wrapups::execute(repo.clone(), ListWrapUpsQuery { user_id: None })
+    let deps = ListWrapUpsDeps {
+        wrapup_repo: repo.clone(),
+    };
+    let result = list_wrapups::execute(&deps, ListWrapUpsQuery { user_id: None })
         .await
         .unwrap();
     assert_eq!(result.len(), 2);