test: move application tests to tests/

test_support/test_helpers -> tests/support; watched_at unified w/ domain test_watched_at (2024-03-15).
Kept inline: users::diary_filter tests (feed_sort_to_direction_all_variants, paged_user_filter_builds_correctly) - pub(super) helpers in private module.
Dropped stale never-compiled users/tests/get_users.rs (old execute signature).

crates/application/tests/diary/edit_review_test.rs

@@ -0,0 +1,155 @@
+use crate::support::edit_review_command;
+use std::sync::Arc;
+
+use domain::{
+    models::ReviewEdit,
+    ports::ReviewRepository,
+    testing::{InMemoryStore, NoopEventPublisher, test_review},
+    value_objects::{Comment, MovieId, ReviewId, UserId, WatchMedium},
+};
+
+use application::diary::{commands::EditReviewCommand, deps::EditReviewDeps, edit_review};
+
+async fn setup() -> (
+    Arc<InMemoryStore>,
+    Arc<NoopEventPublisher>,
+    ReviewId,
+    UserId,
+) {
+    let reviews = InMemoryStore::new();
+    let events = NoopEventPublisher::new();
+    let user_id = UserId::generate();
+    let review = test_review(&MovieId::generate(), &user_id, 3).apply_edit(ReviewEdit {
+        comment: Some(Some(Comment::new("original comment".into()).unwrap())),
+        watch_medium: Some(Some(WatchMedium::Streaming)),
+        ..Default::default()
+    });
+    let review_id = review.id().clone();
+    reviews.save_review(&review).await.unwrap();
+    (reviews, events, review_id, user_id)
+}
+
+fn deps(reviews: &Arc<InMemoryStore>, events: &Arc<NoopEventPublisher>) -> EditReviewDeps {
+    EditReviewDeps {
+        review: Arc::clone(reviews) as _,
+        event_publisher: Arc::clone(events) as _,
+    }
+}
+
+#[tokio::test]
+async fn edit_own_review_updates_rating() {
+    let (reviews, events, review_id, user_id) = setup().await;
+
+    edit_review::execute(
+        &deps(&reviews, &events),
+        EditReviewCommand {
+            review_id: review_id.value(),
+            requesting_user_id: user_id.value(),
+            ..edit_review_command(5)
+        },
+    )
+    .await
+    .unwrap();
+
+    let updated = reviews.get_review_by_id(&review_id).await.unwrap().unwrap();
+    assert_eq!(updated.rating().value(), 5);
+    assert_eq!(updated.comment().unwrap().value(), "original comment");
+    assert_eq!(updated.watch_medium(), Some(&WatchMedium::Streaming));
+}
+
+#[tokio::test]
+async fn edit_nonexistent_review_returns_not_found() {
+    let reviews = InMemoryStore::new();
+    let events = NoopEventPublisher::new();
+
+    let err = edit_review::execute(&deps(&reviews, &events), edit_review_command(5))
+        .await
+        .unwrap_err();
+
+    assert!(matches!(err, domain::errors::DomainError::NotFound(_)));
+}
+
+#[tokio::test]
+async fn edit_other_users_review_returns_forbidden() {
+    let (reviews, events, review_id, _user_id) = setup().await;
+
+    let err = edit_review::execute(
+        &deps(&reviews, &events),
+        EditReviewCommand {
+            review_id: review_id.value(),
+            ..edit_review_command(5)
+        },
+    )
+    .await
+    .unwrap_err();
+
+    assert!(matches!(err, domain::errors::DomainError::Forbidden(_)));
+}
+
+#[tokio::test]
+async fn edit_publishes_review_updated_event() {
+    let (reviews, events, review_id, user_id) = setup().await;
+
+    edit_review::execute(
+        &deps(&reviews, &events),
+        EditReviewCommand {
+            review_id: review_id.value(),
+            requesting_user_id: user_id.value(),
+            ..edit_review_command(1)
+        },
+    )
+    .await
+    .unwrap();
+
+    let published = events.published();
+    assert_eq!(published.len(), 1);
+    assert!(matches!(
+        published[0],
+        domain::events::DomainEvent::ReviewUpdated { .. }
+    ));
+}
+
+#[tokio::test]
+async fn edit_sets_watch_medium() {
+    let (reviews, events, review_id, user_id) = setup().await;
+
+    edit_review::execute(
+        &deps(&reviews, &events),
+        EditReviewCommand {
+            rating: None,
+            review_id: review_id.value(),
+            requesting_user_id: user_id.value(),
+            watch_medium: Some(Some(WatchMedium::Cinema)),
+            ..edit_review_command(1)
+        },
+    )
+    .await
+    .unwrap();
+
+    let updated = reviews.get_review_by_id(&review_id).await.unwrap().unwrap();
+    assert_eq!(updated.watch_medium(), Some(&WatchMedium::Cinema));
+}
+
+#[tokio::test]
+async fn editing_a_review_fails_when_the_store_refuses() {
+    let (_, events, review_id, user_id) = setup().await;
+    let deps = EditReviewDeps {
+        review: Arc::new(domain::testing::RefusingReviewRepository),
+        event_publisher: Arc::clone(&events) as _,
+    };
+
+    let result = edit_review::execute(
+        &deps,
+        EditReviewCommand {
+            review_id: review_id.value(),
+            requesting_user_id: user_id.value(),
+            ..edit_review_command(5)
+        },
+    )
+    .await;
+
+    assert!(matches!(
+        result,
+        Err(domain::errors::DomainError::InfrastructureError(m)) if m == "refused"
+    ));
+}