add 400+ unit tests for domain and application layers

Extract ReviewLogger trait to decouple import/integrations
from diary::log_review (cross-module coupling smell).

Add in-memory fakes for all repository ports, enabling
isolated testing of every use case module without a database.

Coverage: domain+application 22% → 80%, 427 tests.

crates/application/src/import/tests/execute.rs

@@ -0,0 +1,558 @@
+use std::sync::Arc;
+
+use chrono::Utc;
+use domain::models::{AnnotatedRow, ImportSession, import::RowResult};
+use domain::ports::ImportSessionRepository;
+use domain::testing::InMemoryImportSessionRepository;
+use domain::value_objects::{ImportSessionId, UserId};
+use uuid::Uuid;
+
+use crate::import::commands::ExecuteImportCommand;
+use crate::import::execute;
+use crate::test_helpers::TestContextBuilder;
+
+fn make_session_with_rows(user_id: UserId, session_id: ImportSessionId) -> ImportSession {
+    let now = Utc::now().naive_utc();
+    let mut session = ImportSession::new(session_id, user_id, now);
+    session.row_results = Some(vec![
+        AnnotatedRow {
+            result: RowResult::Valid(domain::models::ImportRow {
+                title: Some("Test Movie".into()),
+                release_year: Some("2024".into()),
+                rating: Some("4".into()),
+                watched_at: Some("2024-06-01".into()),
+                external_metadata_id: None,
+                director: None,
+                comment: None,
+            }),
+            is_duplicate: false,
+        },
+        AnnotatedRow {
+            result: RowResult::Valid(domain::models::ImportRow {
+                title: Some("Another".into()),
+                release_year: Some("2023".into()),
+                rating: Some("3".into()),
+                watched_at: Some("2024-07-01".into()),
+                external_metadata_id: None,
+                director: None,
+                comment: None,
+            }),
+            is_duplicate: false,
+        },
+    ]);
+    session
+}
+
+#[tokio::test]
+async fn imports_confirmed_rows() {
+    let sessions = InMemoryImportSessionRepository::new();
+    let uid = Uuid::new_v4();
+    let sid = ImportSessionId::generate();
+
+    let session = make_session_with_rows(UserId::from_uuid(uid), sid.clone());
+    sessions.create(&session).await.unwrap();
+
+    let ctx = TestContextBuilder::new()
+        .with_import_sessions(Arc::clone(&sessions) as _)
+        .build();
+
+    let result = execute::execute(
+        &ctx,
+        ExecuteImportCommand {
+            user_id: uid,
+            session_id: sid.value(),
+            confirmed_indices: vec![0, 1],
+        },
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(result.imported, 2);
+    assert_eq!(result.skipped_duplicates, 0);
+    assert!(result.failed.is_empty());
+}
+
+#[tokio::test]
+async fn skips_unconfirmed_rows() {
+    let sessions = InMemoryImportSessionRepository::new();
+    let uid = Uuid::new_v4();
+    let sid = ImportSessionId::generate();
+
+    let session = make_session_with_rows(UserId::from_uuid(uid), sid.clone());
+    sessions.create(&session).await.unwrap();
+
+    let ctx = TestContextBuilder::new()
+        .with_import_sessions(Arc::clone(&sessions) as _)
+        .build();
+
+    let result = execute::execute(
+        &ctx,
+        ExecuteImportCommand {
+            user_id: uid,
+            session_id: sid.value(),
+            confirmed_indices: vec![0],
+        },
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(result.imported, 1);
+    assert_eq!(result.skipped_duplicates, 1);
+}
+
+#[tokio::test]
+async fn fails_when_session_not_found() {
+    let ctx = TestContextBuilder::new().build();
+    let result = execute::execute(
+        &ctx,
+        ExecuteImportCommand {
+            user_id: Uuid::new_v4(),
+            session_id: Uuid::new_v4(),
+            confirmed_indices: vec![],
+        },
+    )
+    .await;
+
+    assert!(result.is_err());
+}
+
+#[tokio::test]
+async fn handles_datetime_format() {
+    let sessions = InMemoryImportSessionRepository::new();
+    let uid = Uuid::new_v4();
+    let sid = ImportSessionId::generate();
+
+    let now = Utc::now().naive_utc();
+    let mut session = ImportSession::new(sid.clone(), UserId::from_uuid(uid), now);
+    session.row_results = Some(vec![AnnotatedRow {
+        result: RowResult::Valid(domain::models::ImportRow {
+            title: Some("DateTime Movie".into()),
+            release_year: Some("2024".into()),
+            rating: Some("5".into()),
+            watched_at: Some("2024-06-01T12:30:00".into()),
+            external_metadata_id: None,
+            director: None,
+            comment: None,
+        }),
+        is_duplicate: false,
+    }]);
+    sessions.create(&session).await.unwrap();
+
+    let ctx = TestContextBuilder::new()
+        .with_import_sessions(Arc::clone(&sessions) as _)
+        .build();
+
+    let result = execute::execute(
+        &ctx,
+        ExecuteImportCommand {
+            user_id: uid,
+            session_id: sid.value(),
+            confirmed_indices: vec![0],
+        },
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(result.imported, 1);
+    assert!(result.failed.is_empty());
+}
+
+#[tokio::test]
+async fn fails_on_invalid_rating() {
+    let sessions = InMemoryImportSessionRepository::new();
+    let uid = Uuid::new_v4();
+    let sid = ImportSessionId::generate();
+
+    let now = Utc::now().naive_utc();
+    let mut session = ImportSession::new(sid.clone(), UserId::from_uuid(uid), now);
+    session.row_results = Some(vec![AnnotatedRow {
+        result: RowResult::Valid(domain::models::ImportRow {
+            title: Some("Bad Rating Movie".into()),
+            release_year: Some("2024".into()),
+            rating: Some("not_a_number".into()),
+            watched_at: Some("2024-06-01".into()),
+            external_metadata_id: None,
+            director: None,
+            comment: None,
+        }),
+        is_duplicate: false,
+    }]);
+    sessions.create(&session).await.unwrap();
+
+    let ctx = TestContextBuilder::new()
+        .with_import_sessions(Arc::clone(&sessions) as _)
+        .build();
+
+    let result = execute::execute(
+        &ctx,
+        ExecuteImportCommand {
+            user_id: uid,
+            session_id: sid.value(),
+            confirmed_indices: vec![0],
+        },
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(result.imported, 0);
+    assert_eq!(result.failed.len(), 1);
+}
+
+#[tokio::test]
+async fn fails_on_missing_watched_at() {
+    let sessions = InMemoryImportSessionRepository::new();
+    let uid = Uuid::new_v4();
+    let sid = ImportSessionId::generate();
+
+    let now = Utc::now().naive_utc();
+    let mut session = ImportSession::new(sid.clone(), UserId::from_uuid(uid), now);
+    session.row_results = Some(vec![AnnotatedRow {
+        result: RowResult::Valid(domain::models::ImportRow {
+            title: Some("No Date Movie".into()),
+            release_year: Some("2024".into()),
+            rating: Some("4".into()),
+            watched_at: None,
+            external_metadata_id: None,
+            director: None,
+            comment: None,
+        }),
+        is_duplicate: false,
+    }]);
+    sessions.create(&session).await.unwrap();
+
+    let ctx = TestContextBuilder::new()
+        .with_import_sessions(Arc::clone(&sessions) as _)
+        .build();
+
+    let result = execute::execute(
+        &ctx,
+        ExecuteImportCommand {
+            user_id: uid,
+            session_id: sid.value(),
+            confirmed_indices: vec![0],
+        },
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(result.imported, 0);
+    assert_eq!(result.failed.len(), 1);
+}
+
+#[tokio::test]
+async fn imports_row_with_external_metadata_id() {
+    let sessions = InMemoryImportSessionRepository::new();
+    let uid = Uuid::new_v4();
+    let sid = ImportSessionId::generate();
+
+    let now = Utc::now().naive_utc();
+    let mut session = ImportSession::new(sid.clone(), UserId::from_uuid(uid), now);
+    session.row_results = Some(vec![AnnotatedRow {
+        result: RowResult::Valid(domain::models::ImportRow {
+            title: Some("TMDB Movie".into()),
+            release_year: Some("2024".into()),
+            rating: Some("5".into()),
+            watched_at: Some("2024-06-01".into()),
+            external_metadata_id: Some("tt9999999".into()),
+            director: None,
+            comment: None,
+        }),
+        is_duplicate: false,
+    }]);
+    sessions.create(&session).await.unwrap();
+
+    let ctx = TestContextBuilder::new()
+        .with_import_sessions(Arc::clone(&sessions) as _)
+        .build();
+
+    let result = execute::execute(
+        &ctx,
+        ExecuteImportCommand {
+            user_id: uid,
+            session_id: sid.value(),
+            confirmed_indices: vec![0],
+        },
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(result.imported, 1);
+    assert!(result.failed.is_empty());
+}
+
+#[tokio::test]
+async fn imports_row_with_director_and_comment() {
+    let sessions = InMemoryImportSessionRepository::new();
+    let uid = Uuid::new_v4();
+    let sid = ImportSessionId::generate();
+
+    let now = Utc::now().naive_utc();
+    let mut session = ImportSession::new(sid.clone(), UserId::from_uuid(uid), now);
+    session.row_results = Some(vec![AnnotatedRow {
+        result: RowResult::Valid(domain::models::ImportRow {
+            title: Some("Directed Movie".into()),
+            release_year: Some("2022".into()),
+            rating: Some("4".into()),
+            watched_at: Some("2024-06-01".into()),
+            external_metadata_id: None,
+            director: Some("John Director".into()),
+            comment: Some("A great film".into()),
+        }),
+        is_duplicate: false,
+    }]);
+    sessions.create(&session).await.unwrap();
+
+    let ctx = TestContextBuilder::new()
+        .with_import_sessions(Arc::clone(&sessions) as _)
+        .build();
+
+    let result = execute::execute(
+        &ctx,
+        ExecuteImportCommand {
+            user_id: uid,
+            session_id: sid.value(),
+            confirmed_indices: vec![0],
+        },
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(result.imported, 1);
+    assert!(result.failed.is_empty());
+}
+
+#[tokio::test]
+async fn handles_space_separated_datetime_format() {
+    let sessions = InMemoryImportSessionRepository::new();
+    let uid = Uuid::new_v4();
+    let sid = ImportSessionId::generate();
+
+    let now = Utc::now().naive_utc();
+    let mut session = ImportSession::new(sid.clone(), UserId::from_uuid(uid), now);
+    session.row_results = Some(vec![AnnotatedRow {
+        result: RowResult::Valid(domain::models::ImportRow {
+            title: Some("Space DateTime".into()),
+            release_year: Some("2024".into()),
+            rating: Some("3".into()),
+            watched_at: Some("2024-06-01 14:30:00".into()),
+            external_metadata_id: None,
+            director: None,
+            comment: None,
+        }),
+        is_duplicate: false,
+    }]);
+    sessions.create(&session).await.unwrap();
+
+    let ctx = TestContextBuilder::new()
+        .with_import_sessions(Arc::clone(&sessions) as _)
+        .build();
+
+    let result = execute::execute(
+        &ctx,
+        ExecuteImportCommand {
+            user_id: uid,
+            session_id: sid.value(),
+            confirmed_indices: vec![0],
+        },
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(result.imported, 1);
+    assert!(result.failed.is_empty());
+}
+
+#[tokio::test]
+async fn reports_invalid_row_result_errors() {
+    let sessions = InMemoryImportSessionRepository::new();
+    let uid = Uuid::new_v4();
+    let sid = ImportSessionId::generate();
+
+    let now = Utc::now().naive_utc();
+    let mut session = ImportSession::new(sid.clone(), UserId::from_uuid(uid), now);
+    session.row_results = Some(vec![AnnotatedRow {
+        result: RowResult::Invalid {
+            errors: vec!["missing title".into(), "bad year".into()],
+            raw: vec![("col1".into(), "val1".into())],
+        },
+        is_duplicate: false,
+    }]);
+    sessions.create(&session).await.unwrap();
+
+    let ctx = TestContextBuilder::new()
+        .with_import_sessions(Arc::clone(&sessions) as _)
+        .build();
+
+    let result = execute::execute(
+        &ctx,
+        ExecuteImportCommand {
+            user_id: uid,
+            session_id: sid.value(),
+            confirmed_indices: vec![0],
+        },
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(result.imported, 0);
+    assert_eq!(result.failed.len(), 1);
+    assert!(result.failed[0].1.contains("missing title"));
+    assert!(result.failed[0].1.contains("bad year"));
+}
+
+#[tokio::test]
+async fn fails_on_missing_rating() {
+    let sessions = InMemoryImportSessionRepository::new();
+    let uid = Uuid::new_v4();
+    let sid = ImportSessionId::generate();
+
+    let now = Utc::now().naive_utc();
+    let mut session = ImportSession::new(sid.clone(), UserId::from_uuid(uid), now);
+    session.row_results = Some(vec![AnnotatedRow {
+        result: RowResult::Valid(domain::models::ImportRow {
+            title: Some("No Rating Movie".into()),
+            release_year: Some("2024".into()),
+            rating: None,
+            watched_at: Some("2024-06-01".into()),
+            external_metadata_id: None,
+            director: None,
+            comment: None,
+        }),
+        is_duplicate: false,
+    }]);
+    sessions.create(&session).await.unwrap();
+
+    let ctx = TestContextBuilder::new()
+        .with_import_sessions(Arc::clone(&sessions) as _)
+        .build();
+
+    let result = execute::execute(
+        &ctx,
+        ExecuteImportCommand {
+            user_id: uid,
+            session_id: sid.value(),
+            confirmed_indices: vec![0],
+        },
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(result.imported, 0);
+    assert_eq!(result.failed.len(), 1);
+    assert!(result.failed[0].1.contains("missing rating"));
+}
+
+#[tokio::test]
+async fn fails_on_unparseable_date() {
+    let sessions = InMemoryImportSessionRepository::new();
+    let uid = Uuid::new_v4();
+    let sid = ImportSessionId::generate();
+
+    let now = Utc::now().naive_utc();
+    let mut session = ImportSession::new(sid.clone(), UserId::from_uuid(uid), now);
+    session.row_results = Some(vec![AnnotatedRow {
+        result: RowResult::Valid(domain::models::ImportRow {
+            title: Some("Bad Date Movie".into()),
+            release_year: Some("2024".into()),
+            rating: Some("3".into()),
+            watched_at: Some("not-a-date".into()),
+            external_metadata_id: None,
+            director: None,
+            comment: None,
+        }),
+        is_duplicate: false,
+    }]);
+    sessions.create(&session).await.unwrap();
+
+    let ctx = TestContextBuilder::new()
+        .with_import_sessions(Arc::clone(&sessions) as _)
+        .build();
+
+    let result = execute::execute(
+        &ctx,
+        ExecuteImportCommand {
+            user_id: uid,
+            session_id: sid.value(),
+            confirmed_indices: vec![0],
+        },
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(result.imported, 0);
+    assert_eq!(result.failed.len(), 1);
+    assert!(result.failed[0].1.contains("cannot parse watched_at"));
+}
+
+#[tokio::test]
+async fn imports_row_without_release_year() {
+    let sessions = InMemoryImportSessionRepository::new();
+    let uid = Uuid::new_v4();
+    let sid = ImportSessionId::generate();
+
+    let now = Utc::now().naive_utc();
+    let mut session = ImportSession::new(sid.clone(), UserId::from_uuid(uid), now);
+    session.row_results = Some(vec![AnnotatedRow {
+        result: RowResult::Valid(domain::models::ImportRow {
+            title: Some("No Year Movie".into()),
+            release_year: None,
+            rating: Some("4".into()),
+            watched_at: Some("2024-06-01".into()),
+            external_metadata_id: None,
+            director: None,
+            comment: None,
+        }),
+        is_duplicate: false,
+    }]);
+    sessions.create(&session).await.unwrap();
+
+    let ctx = TestContextBuilder::new()
+        .with_import_sessions(Arc::clone(&sessions) as _)
+        .build();
+
+    let result = execute::execute(
+        &ctx,
+        ExecuteImportCommand {
+            user_id: uid,
+            session_id: sid.value(),
+            confirmed_indices: vec![0],
+        },
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(result.imported, 1);
+    assert!(result.failed.is_empty());
+}
+
+#[tokio::test]
+async fn deletes_session_after_import() {
+    let sessions = InMemoryImportSessionRepository::new();
+    let uid = Uuid::new_v4();
+    let sid = ImportSessionId::generate();
+
+    let session = make_session_with_rows(UserId::from_uuid(uid), sid.clone());
+    sessions.create(&session).await.unwrap();
+    assert_eq!(sessions.count(), 1);
+
+    let ctx = TestContextBuilder::new()
+        .with_import_sessions(Arc::clone(&sessions) as _)
+        .build();
+
+    execute::execute(
+        &ctx,
+        ExecuteImportCommand {
+            user_id: uid,
+            session_id: sid.value(),
+            confirmed_indices: vec![0],
+        },
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(
+        sessions.count(),
+        0,
+        "session should be deleted after import"
+    );
+}