GKaszewski/movies-diary
1
0
Fork 0
Code Issues 9 Pull Requests Actions Packages Projects Releases Wiki Activity

feat: atomic wrapup, movie, integration writes

Browse Source 
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).
This commit is contained in:
Gabriel Kaszewski
2026-10-26 01:02:34 +01:00
parent 2f133afb96
commit 6c295866a0
51 changed files with 1281 additions and 329 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
crates/application/src/diary/delete_review.rs
View File

@@ -33,18 +33,15 @@ pub async fn execute(deps: &DeleteReviewDeps, cmd: DeleteReviewCommand) -> Resul
let history = deps.diary.get_review_history(&movie_id).await?;
if history.viewings().is_empty() {
let poster_path = history.movie().poster_path().cloned();
deps.movie_command.delete_movie(&movie_id).await?;
// best-effort: movie is already deleted, so publish failure is non-fatal
if let Err(e) = deps
.event_publisher
.publish(&DomainEvent::MovieDeleted {
movie_id,
poster_path,
})
.await
{
tracing::warn!("failed to publish MovieDeleted event: {e}");
}
deps.movie_command
.delete_movie(
&movie_id,
&[DomainEvent::MovieDeleted {
movie_id: movie_id.clone(),
poster_path,
}],
)
.await?;
}
Ok(())

5
crates/application/src/diary/deps.rs
View File

@@ -1,8 +1,8 @@
use std::sync::Arc;
use domain::ports::{
DiaryExporter, DiaryQuery, EventPublisher, FollowGraphQuery, MovieCommand,
MovieProfileRepository, MovieQuery, ReviewRepository, UserRepository,
DiaryExporter, DiaryQuery, FollowGraphQuery, MovieCommand, MovieProfileRepository, MovieQuery,
ReviewRepository, UserRepository,
};
use crate::config::AppSettings;
@@ -11,7 +11,6 @@ pub struct DeleteReviewDeps {
pub review: Arc<dyn ReviewRepository>,
pub diary: Arc<dyn DiaryQuery>,
pub movie_command: Arc<dyn MovieCommand>,
pub event_publisher: Arc<dyn EventPublisher>,
}
pub struct EditReviewDeps {

11
crates/application/src/diary/review_logger.rs
View File

@@ -5,10 +5,7 @@ use domain::{
errors::DomainError,
events::DomainEvent,
models::Review,
ports::{
EventPublisher, MetadataClient, MovieCommand, MovieQuery, ReviewRepository,
WatchlistRepository,
},
ports::{MetadataClient, MovieCommand, MovieQuery, ReviewRepository, WatchlistRepository},
value_objects::{Comment, Rating, UserId},
};
@@ -22,7 +19,6 @@ pub struct DefaultReviewLogger {
review_repo: Arc<dyn ReviewRepository>,
watchlist_repo: Arc<dyn WatchlistRepository>,
metadata_client: Arc<dyn MetadataClient>,
event_publisher: Arc<dyn EventPublisher>,
}
impl DefaultReviewLogger {
@@ -32,7 +28,6 @@ impl DefaultReviewLogger {
review_repo: Arc<dyn ReviewRepository>,
watchlist_repo: Arc<dyn WatchlistRepository>,
metadata_client: Arc<dyn MetadataClient>,
event_publisher: Arc<dyn EventPublisher>,
) -> Self {
Self {
movie_command,
@@ -40,7 +35,6 @@ impl DefaultReviewLogger {
review_repo,
watchlist_repo,
metadata_client,
event_publisher,
}
}
}
@@ -57,13 +51,12 @@ impl ReviewLogger for DefaultReviewLogger {
self.movie_command.as_ref(),
self.movie_query.as_ref(),
self.metadata_client.as_ref(),
self.event_publisher.as_ref(),
)
.await?;
// Always upsert: even existing movies may have updated metadata
if !is_new_movie {
self.movie_command.upsert_movie(&movie).await?;
self.movie_command.upsert_movie(&movie, &[]).await?;
}
let review = Review::new(

3
crates/application/src/integrations/deps.rs
View File

@@ -1,6 +1,6 @@
use std::sync::Arc;
use domain::ports::{EventPublisher, WatchEventCommand, WatchEventQuery, WebhookTokenRepository};
use domain::ports::{WatchEventCommand, WatchEventQuery, WebhookTokenRepository};
use crate::ports::ReviewLogger;
@@ -8,7 +8,6 @@ pub struct IngestWatchEventDeps {
pub webhook_token: Arc<dyn WebhookTokenRepository>,
pub watch_event_command: Arc<dyn WatchEventCommand>,
pub watch_event_query: Arc<dyn WatchEventQuery>,
pub event_publisher: Arc<dyn EventPublisher>,
}
pub struct ConfirmWatchEventsDeps {

20
crates/application/src/integrations/ingest.rs
View File

@@ -49,16 +49,16 @@ pub async fn execute(
None,
);
deps.watch_event_command.save(&event).await?;
let _ = deps
.event_publisher
.publish(&DomainEvent::WatchEventIngested {
user_id: event.user_id().clone(),
title: event.title().to_string(),
source: event.source().to_string(),
})
.await;
deps.watch_event_command
.save(
&event,
&[DomainEvent::WatchEventIngested {
user_id: event.user_id().clone(),
title: event.title().to_string(),
source: event.source().to_string(),
}],
)
.await?;
Ok(())
}

17
crates/application/src/jobs/wrapup.rs
View File

@@ -5,26 +5,17 @@ use async_trait::async_trait;
use chrono::Datelike;
use domain::{
errors::DomainError,
ports::{EventPublisher, PeriodicJob, UserRepository, WrapUpRepository},
ports::{PeriodicJob, UserRepository, WrapUpRepository},
};
pub struct WrapUpAutoGenerateJob {
user: Arc<dyn UserRepository>,
wrapup_repo: Arc<dyn WrapUpRepository>,
event_publisher: Arc<dyn EventPublisher>,
}
impl WrapUpAutoGenerateJob {
pub fn new(
user: Arc<dyn UserRepository>,
wrapup_repo: Arc<dyn WrapUpRepository>,
event_publisher: Arc<dyn EventPublisher>,
) -> Self {
Self {
user,
wrapup_repo,
event_publisher,
}
pub fn new(user: Arc<dyn UserRepository>, wrapup_repo: Arc<dyn WrapUpRepository>) -> Self {
Self { user, wrapup_repo }
}
}
@@ -60,7 +51,6 @@ impl PeriodicJob for WrapUpAutoGenerateJob {
};
let deps = crate::wrapup::deps::GenerateWrapUpDeps {
wrapup_repo: self.wrapup_repo.clone(),
event_publisher: self.event_publisher.clone(),
};
if let Err(e) = crate::wrapup::generate::execute(&deps, cmd).await {
tracing::warn!(
@@ -81,7 +71,6 @@ impl PeriodicJob for WrapUpAutoGenerateJob {
};
let deps = crate::wrapup::deps::GenerateWrapUpDeps {
wrapup_repo: self.wrapup_repo.clone(),
event_publisher: self.event_publisher.clone(),
};
if let Err(e) = crate::wrapup::generate::execute(&deps, cmd).await {
tracing::warn!("auto-generate global wrapup failed: {e}");

22
crates/application/src/movies/poster_sync_handler.rs
View File

@@ -85,20 +85,14 @@ impl PosterSyncHandler {
let poster_path = PosterPath::new(stored_path)?;
movie.update_poster(poster_path);
self.movie_command.upsert_movie(&movie).await?;
if let Err(e) = self
.event_publisher
.publish(&DomainEvent::PosterSynced {
movie_id: movie.id().clone(),
})
.await
{
tracing::warn!(
"failed to emit PosterSynced for {}: {e}",
movie.id().value()
);
}
self.movie_command
.upsert_movie(
&movie,
&[DomainEvent::PosterSynced {
movie_id: movie.id().clone(),
}],
)
.await?;
Ok(())
}

21
crates/application/src/movies/resolve.rs
View File

@@ -2,7 +2,7 @@ use domain::{
errors::DomainError,
events::DomainEvent,
models::Movie,
ports::{EventPublisher, MetadataClient, MovieCommand, MovieQuery},
ports::{MetadataClient, MovieCommand, MovieQuery},
value_objects::MovieId,
};
@@ -14,7 +14,6 @@ pub async fn resolve_and_persist_movie(
movie_command: &dyn MovieCommand,
movie_query: &dyn MovieQuery,
metadata_client: &dyn MetadataClient,
event_publisher: &dyn EventPublisher,
) -> Result<(Movie, bool), DomainError> {
let (movie, is_new) = if let Some(id) = input.movie_id {
let movie_id = MovieId::from_uuid(id);
@@ -34,15 +33,15 @@ pub async fn resolve_and_persist_movie(
};
if is_new {
movie_command.upsert_movie(&movie).await?;
if let Some(ext_id) = movie.external_metadata_id() {
let _ = event_publisher
.publish(&DomainEvent::MovieDiscovered {
movie_id: movie.id().clone(),
external_metadata_id: ext_id.clone(),
})
.await;
}
let events: Vec<DomainEvent> = movie
.external_metadata_id()
.map(|ext_id| DomainEvent::MovieDiscovered {
movie_id: movie.id().clone(),
external_metadata_id: ext_id.clone(),
})
.into_iter()
.collect();
movie_command.upsert_movie(&movie, &events).await?;
}
Ok((movie, is_new))

2
crates/application/src/movies/sync_poster.rs
View File

@@ -59,7 +59,7 @@ pub async fn execute(deps: &SyncPosterDeps, cmd: SyncPosterCommand) -> Result<()
let poster_path = PosterPath::new(stored_path)?;
movie.update_poster(poster_path);
deps.movie_command.upsert_movie(&movie).await?;
deps.movie_command.upsert_movie(&movie, &[]).await?;
// Refresh search index so the new poster_path is reflected immediately.
// Fetch existing profile if available for a complete index document.

1
crates/application/src/watchlist/add.rs
View File

@@ -18,7 +18,6 @@ pub async fn execute(
deps.movie_command.as_ref(),
deps.movie_query.as_ref(),
deps.metadata.as_ref(),
deps.event_publisher.as_ref(),
)
.await?;

5
crates/application/src/watchlist/deps.rs
View File

@@ -1,8 +1,8 @@
use std::sync::Arc;
use domain::ports::{
EventPublisher, MetadataClient, MovieCommand, MovieQuery, RemoteWatchlistRepository,
UserRepository, WatchlistRepository,
MetadataClient, MovieCommand, MovieQuery, RemoteWatchlistRepository, UserRepository,
WatchlistRepository,
};
pub struct WatchlistAddDeps {
@@ -10,7 +10,6 @@ pub struct WatchlistAddDeps {
pub movie_query: Arc<dyn MovieQuery>,
pub metadata: Arc<dyn MetadataClient>,
pub watchlist: Arc<dyn WatchlistRepository>,
pub event_publisher: Arc<dyn EventPublisher>,
}
pub struct GetWatchlistForOwnerDeps {

4
crates/application/src/wrapup/deps.rs
View File

@@ -1,10 +1,9 @@
use std::sync::Arc;
use domain::ports::{EventPublisher, WrapUpRepository, WrapUpStatsQuery};
use domain::ports::{WrapUpRepository, WrapUpStatsQuery};
pub struct HandleWrapUpRequestedDeps {
pub wrapup_repo: Arc<dyn WrapUpRepository>,
pub event_publisher: Arc<dyn EventPublisher>,
pub wrapup_stats: Arc<dyn WrapUpStatsQuery>,
}
@@ -18,7 +17,6 @@ pub struct DeleteWrapUpDeps {
pub struct GenerateWrapUpDeps {
pub wrapup_repo: Arc<dyn WrapUpRepository>,
pub event_publisher: Arc<dyn EventPublisher>,
}
pub struct GetWrapUpDeps {

4
crates/application/src/wrapup/event_handler.rs
View File

@@ -3,7 +3,7 @@ use std::sync::Arc;
use async_trait::async_trait;
use domain::errors::DomainError;
use domain::events::DomainEvent;
use domain::ports::{EventHandler, EventPublisher, WrapUpRepository, WrapUpStatsQuery};
use domain::ports::{EventHandler, WrapUpRepository, WrapUpStatsQuery};
use tokio::sync::Semaphore;
use super::deps::HandleWrapUpRequestedDeps;
@@ -16,13 +16,11 @@ pub struct WrapUpEventHandler {
impl WrapUpEventHandler {
pub fn new(
wrapup_repo: Arc<dyn WrapUpRepository>,
event_publisher: Arc<dyn EventPublisher>,
wrapup_stats: Arc<dyn WrapUpStatsQuery>,
) -> Self {
Self {
deps: HandleWrapUpRequestedDeps {
wrapup_repo,
event_publisher,
wrapup_stats,
},
semaphore: Arc::new(Semaphore::new(2)),

19
crates/application/src/wrapup/generate.rs
View File

@@ -46,15 +46,16 @@ pub async fn execute(
created_at: Utc::now().naive_utc(),
completed_at: None,
};
deps.wrapup_repo.create(&record).await?;
deps.event_publisher
.publish(&DomainEvent::WrapUpRequested {
wrapup_id: id.clone(),
user_id: cmd.user_id.map(UserId::from_uuid),
start_date: date_range.start(),
end_date: date_range.end(),
})
deps.wrapup_repo
.create(
&record,
&[DomainEvent::WrapUpRequested {
wrapup_id: id.clone(),
user_id: cmd.user_id.map(UserId::from_uuid),
start_date: date_range.start(),
end_date: date_range.end(),
}],
)
.await?;
Ok(id)

12
crates/application/src/wrapup/handle_requested.rs
View File

@@ -37,10 +37,14 @@ pub async fn execute(
match compute::execute(deps.wrapup_stats.clone(), query).await {
Ok(report) => {
deps.wrapup_repo.set_complete(&wrapup_id, &report).await?;
deps.event_publisher
.publish(&DomainEvent::WrapUpCompleted { wrapup_id })
deps.wrapup_repo
.set_complete(
&wrapup_id,
&report,
&[DomainEvent::WrapUpCompleted {
wrapup_id: wrapup_id.clone(),
}],
)
.await?;
Ok(())
}

125
crates/application/tests/diary/delete_review_test.rs
View File

@@ -3,7 +3,7 @@ use std::sync::Arc;
use domain::{
ports::{MovieCommand, MovieQuery, ReviewRepository},
testing::{FakeDiaryQuery, InMemoryStore, NoopEventPublisher},
testing::{FakeDiaryQuery, InMemoryStore, RefusingMovieCommand},
value_objects::{MovieId, UserId},
};
@@ -16,13 +16,12 @@ async fn deleting_a_review_removes_it() {
let movies = InMemoryStore::new();
let reviews = Arc::clone(&movies);
let diary = FakeDiaryQuery::new();
let events = NoopEventPublisher::new();
let movie = test_movie_with_year("Terminator", 1984);
let user_id = UserId::from_uuid(uuid::Uuid::new_v4());
let review = test_review(movie.id(), &user_id, 4);
movies.upsert_movie(&movie).await.unwrap();
movies.upsert_movie(&movie, &[]).await.unwrap();
reviews.save_review(&review, &[]).await.unwrap();
diary.seed_history(movie.clone(), vec![]);
@@ -30,7 +29,6 @@ async fn deleting_a_review_removes_it() {
review: Arc::clone(&reviews) as _,
diary: diary.clone() as _,
movie_command: Arc::clone(&movies) as _,
event_publisher: Arc::clone(&events) as _,
};
delete_review::execute(
@@ -55,7 +53,6 @@ async fn deleting_another_users_review_is_unauthorized() {
let reviews = InMemoryStore::new();
let diary = FakeDiaryQuery::new();
let movies = Arc::clone(&reviews);
let events = NoopEventPublisher::new();
let movie_id = MovieId::from_uuid(uuid::Uuid::new_v4());
let owner_id = UserId::from_uuid(uuid::Uuid::new_v4());
@@ -68,7 +65,6 @@ async fn deleting_another_users_review_is_unauthorized() {
review: Arc::clone(&reviews) as _,
diary: diary as _,
movie_command: movies as _,
event_publisher: Arc::clone(&events) as _,
};
let result = delete_review::execute(
@@ -88,18 +84,16 @@ async fn deleting_another_users_review_is_unauthorized() {
async fn deleting_a_review_removes_it_and_records_its_event_together() {
let movies = InMemoryStore::new();
let diary = FakeDiaryQuery::new();
let events = NoopEventPublisher::new();
let movie = test_movie_with_year("Terminator", 1984);
let user_id = UserId::from_uuid(uuid::Uuid::new_v4());
let review = test_review(movie.id(), &user_id, 4);
movies.upsert_movie(&movie).await.unwrap();
movies.upsert_movie(&movie, &[]).await.unwrap();
movies.save_review(&review, &[]).await.unwrap();
diary.seed_history(movie.clone(), vec![review.clone()]);
let deps = DeleteReviewDeps {
review: Arc::clone(&movies) as _,
diary: diary.clone() as _,
movie_command: Arc::clone(&movies) as _,
event_publisher: Arc::clone(&events) as _,
};
delete_review::execute(
@@ -125,7 +119,6 @@ async fn deleting_a_review_removes_it_and_records_its_event_together() {
async fn a_refused_delete_propagates_and_records_nothing() {
let movies = InMemoryStore::new();
let diary = FakeDiaryQuery::new();
let events = NoopEventPublisher::new();
let user_id = UserId::from_uuid(uuid::Uuid::new_v4());
let review = test_review(&MovieId::generate(), &user_id, 4);
movies.save_review(&review, &[]).await.unwrap();
@@ -135,7 +128,6 @@ async fn a_refused_delete_propagates_and_records_nothing() {
))),
diary: diary as _,
movie_command: Arc::clone(&movies) as _,
event_publisher: Arc::clone(&events) as _,
};
let result = delete_review::execute(
@@ -151,3 +143,114 @@ async fn a_refused_delete_propagates_and_records_nothing() {
assert_eq!(movies.review_count(), 1);
assert!(movies.recorded_events().is_empty());
}
#[tokio::test]
async fn deleting_the_last_review_records_movie_deleted_with_the_movie_delete() {
let movies = InMemoryStore::new();
let diary = FakeDiaryQuery::new();
let movie = test_movie_with_year("Terminator", 1984);
let user_id = UserId::from_uuid(uuid::Uuid::new_v4());
let review = test_review(movie.id(), &user_id, 4);
movies.upsert_movie(&movie, &[]).await.unwrap();
movies.save_review(&review, &[]).await.unwrap();
diary.seed_history(movie.clone(), vec![]);
let deps = DeleteReviewDeps {
review: Arc::clone(&movies) as _,
diary: diary as _,
movie_command: Arc::clone(&movies) as _,
};
delete_review::execute(
&deps,
DeleteReviewCommand {
review_id: review.id().value(),
requesting_user_id: user_id.value(),
},
)
.await
.unwrap();
assert!(movies.get_movie_by_id(movie.id()).await.unwrap().is_none());
let recorded = movies.recorded_events();
assert!(matches!(
recorded[0],
domain::events::DomainEvent::ReviewDeleted { .. }
));
assert!(matches!(
&recorded[1],
domain::events::DomainEvent::MovieDeleted { movie_id, .. } if movie_id == movie.id()
));
assert_eq!(recorded.len(), 2);
}
#[tokio::test]
async fn deleting_a_review_while_viewings_remain_keeps_the_movie_and_records_no_movie_deleted() {
let movies = InMemoryStore::new();
let diary = FakeDiaryQuery::new();
let movie = test_movie_with_year("Terminator", 1984);
let user_id = UserId::from_uuid(uuid::Uuid::new_v4());
let review = test_review(movie.id(), &user_id, 4);
let other = test_review(movie.id(), &UserId::from_uuid(uuid::Uuid::new_v4()), 3);
movies.upsert_movie(&movie, &[]).await.unwrap();
movies.save_review(&review, &[]).await.unwrap();
movies.save_review(&other, &[]).await.unwrap();
diary.seed_history(movie.clone(), vec![other.clone()]);
let deps = DeleteReviewDeps {
review: Arc::clone(&movies) as _,
diary: diary as _,
movie_command: Arc::clone(&movies) as _,
};
delete_review::execute(
&deps,
DeleteReviewCommand {
review_id: review.id().value(),
requesting_user_id: user_id.value(),
},
)
.await
.unwrap();
assert!(movies.get_movie_by_id(movie.id()).await.unwrap().is_some());
assert!(
!movies
.recorded_events()
.iter()
.any(|e| matches!(e, domain::events::DomainEvent::MovieDeleted { .. }))
);
}
#[tokio::test]
async fn a_refused_movie_delete_propagates_and_records_no_movie_deleted() {
let movies = InMemoryStore::new();
let diary = FakeDiaryQuery::new();
let movie = test_movie_with_year("Terminator", 1984);
let user_id = UserId::from_uuid(uuid::Uuid::new_v4());
let review = test_review(movie.id(), &user_id, 4);
movies.upsert_movie(&movie, &[]).await.unwrap();
movies.save_review(&review, &[]).await.unwrap();
diary.seed_history(movie.clone(), vec![]);
let deps = DeleteReviewDeps {
review: Arc::clone(&movies) as _,
diary: diary as _,
movie_command: Arc::new(RefusingMovieCommand),
};
let result = delete_review::execute(
&deps,
DeleteReviewCommand {
review_id: review.id().value(),
requesting_user_id: user_id.value(),
},
)
.await;
assert!(result.is_err());
assert!(movies.get_movie_by_id(movie.id()).await.unwrap().is_some());
assert!(
!movies
.recorded_events()
.iter()
.any(|e| matches!(e, domain::events::DomainEvent::MovieDeleted { .. }))
);
}

2
crates/application/tests/diary/get_movie_social_page_test.rs
View File

@@ -40,7 +40,7 @@ async fn returns_movie_social_page() {
let movie = test_movie_with_year("Social Movie", 2024);
let movie_uuid = movie.id().value();
movies.upsert_movie(&movie).await.unwrap();
movies.upsert_movie(&movie, &[]).await.unwrap();
let deps = GetMovieSocialPageDeps {
movie_query: Arc::clone(&movies) as _,

15
crates/application/tests/diary/log_review_test.rs
View File

@@ -5,7 +5,7 @@ use std::sync::Arc;
use domain::ports::MovieCommand;
use domain::testing::{InMemoryStore, NoopEventPublisher};
use domain::testing::InMemoryStore;
use application::{
diary::commands::LogReviewCommand, diary::log_review, diary::review_logger::DefaultReviewLogger,
@@ -14,7 +14,6 @@ use application::{
fn build_logger(
movies: &Arc<InMemoryStore>,
reviews: &Arc<InMemoryStore>,
events: &Arc<NoopEventPublisher>,
) -> Arc<dyn application::ports::ReviewLogger> {
Arc::new(DefaultReviewLogger::new(
Arc::clone(movies) as _,
@@ -22,7 +21,6 @@ fn build_logger(
Arc::clone(reviews) as _,
TestContextBuilder::new().watchlist_repo,
Arc::new(domain::testing::FakeMetadataClient) as _,
Arc::clone(events) as _,
))
}
@@ -30,8 +28,7 @@ fn build_logger(
async fn logging_a_review_creates_the_movie_and_the_review() {
let movies = InMemoryStore::new();
let reviews = Arc::clone(&movies);
let events = NoopEventPublisher::new();
let logger = build_logger(&movies, &reviews, &events);
let logger = build_logger(&movies, &reviews);
let user_id = uuid::Uuid::new_v4();
let cmd = log_review_command_manual(user_id, "Blade Runner", 1982);
@@ -52,10 +49,9 @@ async fn logging_a_review_reuses_an_existing_movie() {
let existing_movie = test_movie_with_year("Alien", 1979);
let movie_uuid = existing_movie.id().value();
movies.upsert_movie(&existing_movie).await.unwrap();
movies.upsert_movie(&existing_movie, &[]).await.unwrap();
let events = NoopEventPublisher::new();
let logger = build_logger(&movies, &reviews, &events);
let logger = build_logger(&movies, &reviews);
let cmd = LogReviewCommand {
rating: 5,
@@ -72,8 +68,7 @@ async fn logging_a_review_reuses_an_existing_movie() {
async fn logging_a_review_with_an_invalid_rating_fails() {
let movies = InMemoryStore::new();
let reviews = Arc::clone(&movies);
let events = NoopEventPublisher::new();
let logger = build_logger(&movies, &reviews, &events);
let logger = build_logger(&movies, &reviews);
let cmd = LogReviewCommand {
rating: 6,

45
crates/application/tests/diary/review_logger_test.rs
View File

@@ -8,7 +8,7 @@ use domain::{
models::WatchlistEntry,
models::{MetadataSearchCriteria, Movie},
ports::{MetadataClient, MovieCommand, WatchlistRepository},
testing::{FakeMetadataClient, InMemoryStore, NoopEventPublisher},
testing::{FakeMetadataClient, InMemoryStore},
value_objects::{ExternalMetadataId, MovieId, PosterUrl, UserId},
};
use uuid::Uuid;
@@ -21,7 +21,6 @@ fn make_logger(
movies: &Arc<InMemoryStore>,
reviews: &Arc<InMemoryStore>,
watchlist: &Arc<InMemoryStore>,
events: &Arc<NoopEventPublisher>,
) -> DefaultReviewLogger {
DefaultReviewLogger::new(
Arc::clone(movies) as _,
@@ -29,7 +28,6 @@ fn make_logger(
Arc::clone(reviews) as _,
Arc::clone(watchlist) as _,
Arc::new(FakeMetadataClient) as _,
Arc::clone(events) as _,
)
}
@@ -38,8 +36,7 @@ async fn logs_review_with_manual_movie() {
let movies = InMemoryStore::new();
let reviews = Arc::clone(&movies);
let watchlist = Arc::clone(&movies);
let events = NoopEventPublisher::new();
let logger = make_logger(&movies, &reviews, &watchlist, &events);
let logger = make_logger(&movies, &reviews, &watchlist);
let uid = Uuid::new_v4();
let cmd = log_review_command_manual(uid, "Test Film", 2024);
@@ -55,8 +52,7 @@ async fn removes_from_watchlist_on_review() {
let movies = InMemoryStore::new();
let reviews = Arc::clone(&movies);
let watchlist = Arc::clone(&movies);
let events = NoopEventPublisher::new();
let logger = make_logger(&movies, &reviews, &watchlist, &events);
let logger = make_logger(&movies, &reviews, &watchlist);
let uid = Uuid::new_v4();
let user_id = UserId::from_uuid(uid);
@@ -64,7 +60,7 @@ async fn removes_from_watchlist_on_review() {
// Create and store movie
let movie = test_movie_with_year("Watchlisted Film", 2024);
let movie_id = movie.id().value();
movies.upsert_movie(&movie).await.unwrap();
movies.upsert_movie(&movie, &[]).await.unwrap();
// Add to watchlist
let entry = WatchlistEntry::new(user_id.clone(), MovieId::from_uuid(movie_id));
@@ -87,13 +83,6 @@ async fn removes_from_watchlist_on_review() {
.any(|e| matches!(e, domain::events::DomainEvent::WatchlistEntryRemoved { .. })),
"the removal event rides the watchlist write"
);
assert!(
!events
.published()
.iter()
.any(|e| matches!(e, domain::events::DomainEvent::WatchlistEntryRemoved { .. })),
"no longer published out of band"
);
}
#[tokio::test]
@@ -101,12 +90,11 @@ async fn logs_review_with_existing_movie_by_id() {
let movies = InMemoryStore::new();
let reviews = Arc::clone(&movies);
let watchlist = Arc::clone(&movies);
let events = NoopEventPublisher::new();
let logger = make_logger(&movies, &reviews, &watchlist, &events);
let logger = make_logger(&movies, &reviews, &watchlist);
let movie = test_movie_with_year("Existing Film", 2020);
let movie_uuid = movie.id().value();
movies.upsert_movie(&movie).await.unwrap();
movies.upsert_movie(&movie, &[]).await.unwrap();
let cmd = LogReviewCommand {
rating: 3,
@@ -124,8 +112,7 @@ async fn existing_movie_not_found_returns_error() {
let movies = InMemoryStore::new();
let reviews = Arc::clone(&movies);
let watchlist = Arc::clone(&movies);
let events = NoopEventPublisher::new();
let logger = make_logger(&movies, &reviews, &watchlist, &events);
let logger = make_logger(&movies, &reviews, &watchlist);
let cmd = log_review_command(Uuid::new_v4(), Uuid::new_v4());
@@ -137,8 +124,7 @@ async fn invalid_rating_returns_error() {
let movies = InMemoryStore::new();
let reviews = Arc::clone(&movies);
let watchlist = Arc::clone(&movies);
let events = NoopEventPublisher::new();
let logger = make_logger(&movies, &reviews, &watchlist, &events);
let logger = make_logger(&movies, &reviews, &watchlist);
let cmd = LogReviewCommand {
rating: 6,
@@ -157,8 +143,7 @@ async fn watchlist_not_present_does_not_publish_removed() {
let movies = InMemoryStore::new();
let reviews = Arc::clone(&movies);
let watchlist = Arc::clone(&movies);
let events = NoopEventPublisher::new();
let logger = make_logger(&movies, &reviews, &watchlist, &events);
let logger = make_logger(&movies, &reviews, &watchlist);
let cmd = log_review_command_manual(Uuid::new_v4(), "No Watchlist Film", 2024);
@@ -197,11 +182,10 @@ impl MetadataClient for MetadataClientWithExternalId {
}
#[tokio::test]
async fn publishes_movie_discovered_for_new_movie_with_external_id() {
async fn movie_discovered_rides_the_movie_write_for_a_new_movie_with_external_id() {
let movies = InMemoryStore::new();
let reviews = Arc::clone(&movies);
let watchlist = Arc::clone(&movies);
let events = NoopEventPublisher::new();
let logger = DefaultReviewLogger::new(
Arc::clone(&movies) as _,
@@ -209,7 +193,6 @@ async fn publishes_movie_discovered_for_new_movie_with_external_id() {
Arc::clone(&reviews) as _,
Arc::clone(&watchlist) as _,
Arc::new(MetadataClientWithExternalId) as _,
Arc::clone(&events) as _,
);
let cmd = LogReviewCommand {
@@ -219,12 +202,12 @@ async fn publishes_movie_discovered_for_new_movie_with_external_id() {
logger.log_review(cmd).await.unwrap();
let published = events.published();
let published = movies.recorded_events();
assert!(
published
.iter()
.any(|e| matches!(e, domain::events::DomainEvent::MovieDiscovered { .. })),
"should publish MovieDiscovered for new movie with external_metadata_id"
"MovieDiscovered must be recorded with the movie write"
);
}
@@ -237,7 +220,6 @@ async fn logging_a_review_fails_when_the_review_store_refuses() {
Arc::new(domain::testing::RefusingReviewRepository),
Arc::clone(&movies) as _,
Arc::new(FakeMetadataClient),
NoopEventPublisher::new(),
);
let result = logger
@@ -256,7 +238,6 @@ async fn logging_a_review_saves_the_review_and_its_event_together() {
Arc::clone(&movies) as _,
Arc::clone(&movies) as _,
Arc::new(FakeMetadataClient),
Arc::new(domain::testing::RefusingEventPublisher),
);
logger
@@ -282,7 +263,6 @@ async fn a_refused_save_propagates_and_records_nothing() {
Arc::new(domain::testing::RefusingReviewRepository),
Arc::clone(&movies) as _,
Arc::new(FakeMetadataClient),
NoopEventPublisher::new(),
);
let result = logger
@@ -303,7 +283,6 @@ async fn enrichment_request_rides_the_review_save() {
Arc::clone(&movies) as _,
Arc::clone(&movies) as _,
Arc::new(MetadataClientWithExternalId),
NoopEventPublisher::new(),
);
logger

4
crates/application/tests/import/apply_mapping_test.rs
View File

@@ -110,7 +110,7 @@ async fn marks_duplicate_by_external_id() {
let ext_id = ExternalMetadataId::new("tt1234567".into()).unwrap();
let movie = test_movie_with_external_id("Known Movie", 2020, ext_id);
movies.upsert_movie(&movie).await.unwrap();
movies.upsert_movie(&movie, &[]).await.unwrap();
let parser = Arc::new(DuplicateTestParser {
rows: vec![ImportRow {
@@ -158,7 +158,7 @@ async fn marks_duplicate_by_title_and_year() {
let sessions = Arc::clone(&movies);
let movie = test_movie_with_year("Duplicate Film", 2022);
movies.upsert_movie(&movie).await.unwrap();
movies.upsert_movie(&movie, &[]).await.unwrap();
let parser = Arc::new(DuplicateTestParser {
rows: vec![ImportRow {

22
crates/application/tests/integrations/confirm_test.rs
View File

@@ -3,7 +3,7 @@ use std::sync::Arc;
use domain::models::{WatchEvent, WatchEventSource};
use domain::ports::{MovieCommand, WatchEventCommand};
use domain::testing::{InMemoryStore, NoopEventPublisher};
use domain::testing::InMemoryStore;
use domain::value_objects::UserId;
use uuid::Uuid;
@@ -42,7 +42,7 @@ async fn confirms_watch_event_via_review_logger() {
None,
);
let event_id = event.id().value();
watch_events.save(&event).await.unwrap();
watch_events.save(&event, &[]).await.unwrap();
let result = confirm::execute(
&deps(&watch_events, noop_logger()),
@@ -86,7 +86,7 @@ async fn confirms_event_with_external_metadata_id_and_no_movie_id() {
None,
);
let event_id = event.id().value();
watch_events.save(&event).await.unwrap();
watch_events.save(&event, &[]).await.unwrap();
let result = confirm::execute(
&deps(&watch_events, noop_logger()),
@@ -121,7 +121,7 @@ async fn rejects_other_users_event() {
None,
);
let event_id = event.id().value();
watch_events.save(&event).await.unwrap();
watch_events.save(&event, &[]).await.unwrap();
let result = confirm::execute(
&deps(&watch_events, noop_logger()),
@@ -148,7 +148,6 @@ async fn fails_when_event_not_found() {
#[tokio::test]
async fn confirms_event_with_movie_id() {
let watch_events = InMemoryStore::new();
let events = NoopEventPublisher::new();
let uid = Uuid::new_v4();
let movie_uuid = Uuid::new_v4();
@@ -162,7 +161,7 @@ async fn confirms_event_with_movie_id() {
Some(domain::value_objects::MovieId::from_uuid(movie_uuid)),
);
let event_id = event.id().value();
watch_events.save(&event).await.unwrap();
watch_events.save(&event, &[]).await.unwrap();
// Also seed movie repo so review_logger can find it
let movies = domain::testing::InMemoryStore::new();
@@ -174,7 +173,7 @@ async fn confirms_event_with_movie_id() {
None,
None,
);
movies.upsert_movie(&movie).await.unwrap();
movies.upsert_movie(&movie, &[]).await.unwrap();
// Build a real review logger
let reviews = domain::testing::InMemoryStore::new();
@@ -186,7 +185,6 @@ async fn confirms_event_with_movie_id() {
Arc::clone(&reviews) as _,
Arc::clone(&watchlist) as _,
Arc::new(domain::testing::FakeMetadataClient) as _,
Arc::clone(&events) as _,
));
let result = confirm::execute(
@@ -214,7 +212,7 @@ async fn confirms_event_without_movie_id_and_without_external_metadata_id() {
None,
);
let event_id = event.id().value();
watch_events.save(&event).await.unwrap();
watch_events.save(&event, &[]).await.unwrap();
let result = confirm::execute(
&deps(&watch_events, noop_logger()),
@@ -260,8 +258,8 @@ async fn confirms_multiple_events() {
);
let id2 = event2.id().value();
watch_events.save(&event1).await.unwrap();
watch_events.save(&event2).await.unwrap();
watch_events.save(&event1, &[]).await.unwrap();
watch_events.save(&event2, &[]).await.unwrap();
let result = confirm::execute(
&deps(&watch_events, noop_logger()),
@@ -302,7 +300,7 @@ async fn confirms_event_without_year() {
None,
);
let event_id = event.id().value();
watch_events.save(&event).await.unwrap();
watch_events.save(&event, &[]).await.unwrap();
let result = confirm::execute(
&deps(&watch_events, noop_logger()),

4
crates/application/tests/integrations/dismiss_test.rs
View File

@@ -70,8 +70,8 @@ async fn dismisses_existing_events() {
);
let id1 = e1.id().value();
let id2 = e2.id().value();
watch_events.save(&e1).await.unwrap();
watch_events.save(&e2).await.unwrap();
watch_events.save(&e1, &[]).await.unwrap();
watch_events.save(&e2, &[]).await.unwrap();
let result = dismiss::execute(
&deps(&watch_events),

2
crates/application/tests/integrations/get_queue_test.rs
View File

@@ -46,7 +46,7 @@ async fn returns_pending_events() {
Utc::now().naive_utc(),
None,
);
events.save(&event).await.unwrap();
events.save(&event, &[]).await.unwrap();
let result = get_queue::execute(&deps(&events), GetWatchQueueQuery { user_id })
.await

50
crates/application/tests/integrations/ingest_test.rs
View File

@@ -2,8 +2,7 @@ use crate::support::generate_webhook_token_command;
use std::sync::Arc;
use domain::models::WatchEventSource;
use domain::ports::EventPublisher;
use domain::testing::{InMemoryStore, NoopEventPublisher};
use domain::testing::{InMemoryStore, RefusingWatchEventCommand};
use uuid::Uuid;
use application::integrations::commands::IngestWatchEventCommand;
@@ -27,10 +26,9 @@ impl domain::ports::MediaServerParser for FakeParser {
}
#[tokio::test]
async fn ingests_watch_event() {
async fn ingesting_saves_the_watch_event_and_records_its_event_together() {
let tokens = InMemoryStore::new();
let watch_events = Arc::clone(&tokens);
let event_publisher: Arc<dyn EventPublisher> = NoopEventPublisher::new();
let user_id = Uuid::new_v4();
let generated = generate_token::execute(
@@ -46,7 +44,6 @@ async fn ingests_watch_event() {
webhook_token: Arc::clone(&tokens) as _,
watch_event_command: Arc::clone(&watch_events) as _,
watch_event_query: Arc::clone(&watch_events) as _,
event_publisher: Arc::clone(&event_publisher),
};
let result = ingest::execute(
@@ -61,19 +58,58 @@ async fn ingests_watch_event() {
.await;
assert!(result.is_ok());
assert_eq!(watch_events.rows_in("watch_events"), 1);
let recorded = tokens.recorded_events();
assert_eq!(recorded.len(), 1);
assert!(matches!(
&recorded[0],
domain::events::DomainEvent::WatchEventIngested { title, .. } if title == "Test"
));
}
#[tokio::test]
async fn a_refused_save_propagates_and_records_nothing() {
let tokens = InMemoryStore::new();
let user_id = Uuid::new_v4();
let generated = generate_token::execute(
&GenerateWebhookTokenDeps {
webhook_token: Arc::clone(&tokens) as _,
},
generate_webhook_token_command(user_id),
)
.await
.unwrap();
let deps = IngestWatchEventDeps {
webhook_token: Arc::clone(&tokens) as _,
watch_event_command: Arc::new(RefusingWatchEventCommand),
watch_event_query: Arc::clone(&tokens) as _,
};
let result = ingest::execute(
&deps,
IngestWatchEventCommand {
token: generated.token_plaintext,
raw_payload: vec![],
source: WatchEventSource::Jellyfin,
},
&FakeParser,
)
.await;
assert!(result.is_err());
assert_eq!(tokens.rows_in("watch_events"), 0);
assert!(tokens.recorded_events().is_empty());
}
#[tokio::test]
async fn rejects_invalid_token() {
let tokens = InMemoryStore::new();
let watch_events = Arc::clone(&tokens);
let event_publisher: Arc<dyn EventPublisher> = NoopEventPublisher::new();
let deps = IngestWatchEventDeps {
webhook_token: Arc::clone(&tokens) as _,
watch_event_command: Arc::clone(&watch_events) as _,
watch_event_query: Arc::clone(&watch_events) as _,
event_publisher: Arc::clone(&event_publisher),
};
let result = ingest::execute(

4
crates/application/tests/movies.rs
View File

@@ -6,7 +6,11 @@ mod enrich_movie_test;
mod get_movie_profile_test;
#[path = "movies/get_movies_test.rs"]
mod get_movies_test;
#[path = "movies/poster_sync_handler_test.rs"]
mod poster_sync_handler_test;
#[path = "movies/request_enrichment_test.rs"]
mod request_enrichment_test;
#[path = "movies/resolve_test.rs"]
mod resolve_test;
#[path = "movies/sync_poster_test.rs"]
mod sync_poster_test;

4
crates/application/tests/movies/enrich_movie_test.rs
View File

@@ -19,7 +19,7 @@ async fn stores_profile_and_indexes() {
let movie = test_movie_with_year("Test", 2024);
let movie_id = MovieId::from_uuid(movie.id().value());
movie_repo.upsert_movie(&movie).await.unwrap();
movie_repo.upsert_movie(&movie, &[]).await.unwrap();
let profile = MovieProfile {
movie_id: movie_id.clone(),
@@ -68,7 +68,7 @@ async fn extracts_and_indexes_persons() {
let movie = test_movie_with_year("Cast Movie", 2024);
let movie_id = MovieId::from_uuid(movie.id().value());
movie_repo.upsert_movie(&movie).await.unwrap();
movie_repo.upsert_movie(&movie, &[]).await.unwrap();
let profile = MovieProfile {
movie_id: movie_id.clone(),

89
crates/application/tests/movies/poster_sync_handler_test.rs Normal file
View File

@@ -0,0 +1,89 @@
use std::sync::Arc;
use async_trait::async_trait;
use domain::{
errors::DomainError,
events::DomainEvent,
models::Movie,
ports::{EventHandler, MetadataClient, MovieCommand},
testing::{
FakePosterFetcher, InMemoryStore, NoopEventPublisher, NoopObjectStorage,
RefusingMovieCommand, test_movie_with_external_id,
},
value_objects::{ExternalMetadataId, PosterUrl},
};
use application::movies::poster_sync_handler::PosterSyncHandler;
struct MetadataWithPoster;
#[async_trait]
impl MetadataClient for MetadataWithPoster {
async fn fetch_movie_metadata(
&self,
_: &domain::models::MetadataSearchCriteria,
) -> Result<Movie, DomainError> {
unimplemented!()
}
async fn get_poster_url(
&self,
_: &ExternalMetadataId,
) -> Result<Option<PosterUrl>, DomainError> {
Ok(Some(
PosterUrl::new("https://example.com/poster.jpg".into()).unwrap(),
))
}
}
async fn seeded() -> (Arc<InMemoryStore>, Movie, DomainEvent) {
let store = InMemoryStore::new();
let ext = ExternalMetadataId::new("tmdb:42".into()).unwrap();
let movie = test_movie_with_external_id("Heat", 1995, ext.clone());
store.upsert_movie(&movie, &[]).await.unwrap();
let event = DomainEvent::MovieDiscovered {
movie_id: movie.id().clone(),
external_metadata_id: ext,
};
(store, movie, event)
}
fn handler(command: Arc<dyn MovieCommand>, store: &Arc<InMemoryStore>) -> PosterSyncHandler {
PosterSyncHandler::new(
command,
Arc::clone(store) as _,
Arc::new(MetadataWithPoster),
Arc::new(FakePosterFetcher),
Arc::new(NoopObjectStorage),
NoopEventPublisher::new(),
0,
)
}
#[tokio::test]
async fn poster_synced_rides_the_movie_write() {
let (store, movie, event) = seeded().await;
handler(Arc::clone(&store) as _, &store)
.handle(&event)
.await
.unwrap();
let recorded = store.recorded_events();
assert_eq!(recorded.len(), 1);
assert!(matches!(
&recorded[0],
DomainEvent::PosterSynced { movie_id } if movie_id == movie.id()
));
}
#[tokio::test]
async fn a_refused_upsert_propagates_and_records_nothing() {
let (store, _movie, event) = seeded().await;
let result = handler(Arc::new(RefusingMovieCommand), &store)
.handle(&event)
.await;
assert!(matches!(result, Err(DomainError::InfrastructureError(m)) if m == "refused"));
assert!(store.recorded_events().is_empty());
}

127
crates/application/tests/movies/resolve_test.rs Normal file
View File

@@ -0,0 +1,127 @@
use async_trait::async_trait;
use domain::{
errors::DomainError,
events::DomainEvent,
models::{MetadataSearchCriteria, Movie},
ports::{MetadataClient, MovieCommand},
testing::{
FakeMetadataClient, InMemoryStore, RefusingMovieCommand, test_movie_with_external_id,
test_movie_with_year,
},
value_objects::{ExternalMetadataId, PosterUrl},
};
use application::diary::commands::MovieInput;
use application::movies::resolve::resolve_and_persist_movie;
struct MetadataWithExternalId;
#[async_trait]
impl MetadataClient for MetadataWithExternalId {
async fn fetch_movie_metadata(&self, _: &MetadataSearchCriteria) -> Result<Movie, DomainError> {
Ok(test_movie_with_external_id(
"Discovered Film",
2024,
ExternalMetadataId::new("tmdb:99999".into()).unwrap(),
))
}
async fn get_poster_url(
&self,
_: &ExternalMetadataId,
) -> Result<Option<PosterUrl>, DomainError> {
Ok(None)
}
}
fn manual_input(title: &str) -> MovieInput {
MovieInput {
movie_id: None,
external_metadata_id: None,
manual_title: Some(title.into()),
manual_release_year: Some(2024),
manual_director: None,
}
}
#[tokio::test]
async fn a_new_movie_with_an_external_id_is_persisted_with_movie_discovered() {
let store = InMemoryStore::new();
let (movie, is_new) = resolve_and_persist_movie(
&manual_input("Discovered Film"),
store.as_ref(),
store.as_ref(),
&MetadataWithExternalId,
)
.await
.unwrap();
assert!(is_new);
assert_eq!(store.movie_count(), 1);
let recorded = store.recorded_events();
assert_eq!(recorded.len(), 1);
assert!(matches!(
&recorded[0],
DomainEvent::MovieDiscovered { movie_id, .. } if movie_id == movie.id()
));
}
#[tokio::test]
async fn a_new_movie_without_an_external_id_records_no_event() {
let store = InMemoryStore::new();
let (_, is_new) = resolve_and_persist_movie(
&manual_input("Home Movie"),
store.as_ref(),
store.as_ref(),
&FakeMetadataClient,
)
.await
.unwrap();
assert!(is_new);
assert_eq!(store.movie_count(), 1);
assert!(store.recorded_events().is_empty());
}
#[tokio::test]
async fn an_existing_movie_is_not_rewritten_and_records_no_event() {
let store = InMemoryStore::new();
let movie = test_movie_with_year("Known", 2001);
store.upsert_movie(&movie, &[]).await.unwrap();
let input = MovieInput {
movie_id: Some(movie.id().value()),
..manual_input("ignored")
};
let (resolved, is_new) = resolve_and_persist_movie(
&input,
store.as_ref(),
store.as_ref(),
&MetadataWithExternalId,
)
.await
.unwrap();
assert!(!is_new);
assert_eq!(resolved.id(), movie.id());
assert!(store.recorded_events().is_empty());
}
#[tokio::test]
async fn a_refused_upsert_propagates_and_records_nothing() {
let store = InMemoryStore::new();
let result = resolve_and_persist_movie(
&manual_input("Discovered Film"),
&RefusingMovieCommand,
store.as_ref(),
&MetadataWithExternalId,
)
.await;
assert!(matches!(result, Err(DomainError::InfrastructureError(m)) if m == "refused"));
assert_eq!(store.movie_count(), 0);
assert!(store.recorded_events().is_empty());
}

4
crates/application/tests/movies/sync_poster_test.rs
View File

@@ -41,7 +41,7 @@ async fn fails_when_no_external_id() {
let movies = InMemoryStore::new();
let movie = test_movie_with_year("Test", 2024);
let movie_id = movie.id().value();
movies.upsert_movie(&movie).await.unwrap();
movies.upsert_movie(&movie, &[]).await.unwrap();
let deps = SyncPosterDeps {
movie_command: Arc::clone(&movies) as _,
@@ -80,7 +80,7 @@ async fn syncs_poster_for_movie_with_external_id() {
let ext_id = ExternalMetadataId::new("tmdb:999".into()).unwrap();
let movie = test_movie_with_external_id("Poster Movie", 2024, ext_id);
let movie_id = movie.id().value();
movies.upsert_movie(&movie).await.unwrap();
movies.upsert_movie(&movie, &[]).await.unwrap();
let deps = SyncPosterDeps {
movie_command: Arc::clone(&movies) as _,

13
crates/application/tests/watchlist/add_test.rs
View File

@@ -5,7 +5,7 @@ use std::sync::Arc;
use domain::{
events::DomainEvent,
ports::MovieCommand,
testing::{InMemoryStore, NoopEventPublisher, RefusingWatchlistRepository},
testing::{InMemoryStore, RefusingWatchlistRepository},
};
use application::watchlist::{add, commands::AddToWatchlistCommand, deps::WatchlistAddDeps};
@@ -16,7 +16,6 @@ fn make_deps(movies: Arc<InMemoryStore>, watchlist: Arc<InMemoryStore>) -> Watch
movie_query: movies,
metadata: Arc::new(domain::testing::FakeMetadataClient),
watchlist,
event_publisher: NoopEventPublisher::new(),
}
}
@@ -27,7 +26,7 @@ async fn adding_to_the_watchlist_resolves_the_movie_and_saves_the_entry() {
let movie = test_movie_with_year("The Thing", 1982);
let movie_uuid = movie.id().value();
movies.upsert_movie(&movie).await.unwrap();
movies.upsert_movie(&movie, &[]).await.unwrap();
let deps = make_deps(Arc::clone(&movies), Arc::clone(&watchlist));
@@ -46,7 +45,7 @@ async fn adding_a_movie_already_on_the_watchlist_is_idempotent() {
let movie = test_movie_with_year("RoboCop", 1987);
let movie_uuid = movie.id().value();
let user_id = uuid::Uuid::new_v4();
movies.upsert_movie(&movie).await.unwrap();
movies.upsert_movie(&movie, &[]).await.unwrap();
let deps = make_deps(Arc::clone(&movies), Arc::clone(&watchlist));
@@ -98,7 +97,7 @@ async fn adding_the_same_movie_to_a_watchlist_twice_keeps_a_single_entry_and_suc
let movie = test_movie_with_year("Heat", 1995);
let movie_uuid = movie.id().value();
let user_id = uuid::Uuid::new_v4();
movies.upsert_movie(&movie).await.unwrap();
movies.upsert_movie(&movie, &[]).await.unwrap();
let deps = make_deps(Arc::clone(&movies), Arc::clone(&movies));
for _ in 0..2 {
@@ -114,7 +113,7 @@ async fn adding_the_same_movie_to_a_watchlist_twice_keeps_a_single_entry_and_suc
async fn adding_an_entry_records_the_entry_and_its_event_together() {
let movies = InMemoryStore::new();
let movie = test_movie_with_year("Heat", 1995);
movies.upsert_movie(&movie).await.unwrap();
movies.upsert_movie(&movie, &[]).await.unwrap();
let deps = make_deps(Arc::clone(&movies), Arc::clone(&movies));
add::execute(
@@ -137,7 +136,7 @@ async fn adding_an_entry_records_the_entry_and_its_event_together() {
async fn a_refused_add_propagates_and_records_nothing() {
let movies = InMemoryStore::new();
let movie = test_movie_with_year("Heat", 1995);
movies.upsert_movie(&movie).await.unwrap();
movies.upsert_movie(&movie, &[]).await.unwrap();
let deps = WatchlistAddDeps {
watchlist: Arc::new(RefusingWatchlistRepository),
..make_deps(Arc::clone(&movies), Arc::clone(&movies))

56
crates/application/tests/wrapup/generate_test.rs
View File

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

23
crates/application/tests/wrapup/get_ready_report_test.rs
View File

@@ -56,7 +56,7 @@ fn record(
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))
repo.create(&record(Some(user_id), 2024, WrapUpStatus::Ready, true), &[])
.await
.unwrap();
@@ -72,12 +72,10 @@ async fn ready_report_returns_report_when_ready() {
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,
))
repo.create(
&record(Some(user_id), 2024, WrapUpStatus::Generating, false),
&[],
)
.await
.unwrap();
@@ -96,9 +94,12 @@ async fn ready_report_is_not_found_when_report_absent() {
// 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();
repo.create(
&record(Some(user_id), 2024, WrapUpStatus::Ready, false),
&[],
)
.await
.unwrap();
let deps = GetReadyReportDeps { wrapup_repo: repo };
@@ -122,7 +123,7 @@ async fn ready_report_is_not_found_when_no_record_exists() {
#[tokio::test]
async fn ready_report_global_scope_ignores_user_id() {
let repo = InMemoryWrapUpRepository::new();
repo.create(&record(None, 2024, WrapUpStatus::Ready, true))
repo.create(&record(None, 2024, WrapUpStatus::Ready, true), &[])
.await
.unwrap();

64
crates/application/tests/wrapup/handle_requested_test.rs
View File

@@ -1,7 +1,7 @@
use chrono::{NaiveDate, Utc};
use domain::models::wrapup::{WrapUpRecord, WrapUpStatus};
use domain::ports::WrapUpRepository;
use domain::testing::{InMemoryWrapUpRepository, InMemoryWrapUpStatsQuery, NoopEventPublisher};
use domain::testing::{InMemoryWrapUpRepository, InMemoryWrapUpStatsQuery, RefusingWrapUpWrites};
use domain::value_objects::WrapUpId;
use application::wrapup::{deps::HandleWrapUpRequestedDeps, handle_requested};
@@ -22,11 +22,10 @@ async fn skips_if_already_ready() {
created_at: Utc::now().naive_utc(),
completed_at: None,
};
repo.create(&record).await.unwrap();
repo.create(&record, &[]).await.unwrap();
let deps = HandleWrapUpRequestedDeps {
wrapup_repo: repo.clone(),
event_publisher: NoopEventPublisher::new(),
wrapup_stats: InMemoryWrapUpStatsQuery::new(),
};
@@ -46,7 +45,6 @@ async fn skips_if_already_ready() {
async fn generates_wrapup_and_marks_complete() {
let repo = InMemoryWrapUpRepository::new();
let stats = InMemoryWrapUpStatsQuery::new();
let events = NoopEventPublisher::new();
let wrapup_id = WrapUpId::generate();
let uid = uuid::Uuid::new_v4();
@@ -61,11 +59,10 @@ async fn generates_wrapup_and_marks_complete() {
created_at: Utc::now().naive_utc(),
completed_at: None,
};
repo.create(&record).await.unwrap();
repo.create(&record, &[]).await.unwrap();
let deps = HandleWrapUpRequestedDeps {
wrapup_repo: repo.clone(),
event_publisher: events.clone(),
wrapup_stats: stats.clone(),
};
@@ -85,13 +82,13 @@ async fn generates_wrapup_and_marks_complete() {
assert_eq!(final_rec.status, WrapUpStatus::Ready);
assert!(final_rec.report.is_some());
// Verify event was published
let published = events.published();
assert!(
published
.iter()
.any(|e| matches!(e, domain::events::DomainEvent::WrapUpCompleted { .. }))
);
// The completion event is recorded together with the completed row.
let recorded = repo.recorded_events();
assert_eq!(recorded.len(), 1);
assert!(matches!(
&recorded[0],
domain::events::DomainEvent::WrapUpCompleted { wrapup_id: id } if *id == wrapup_id
));
}
#[tokio::test]
@@ -110,11 +107,10 @@ async fn skips_if_already_generating() {
created_at: Utc::now().naive_utc(),
completed_at: None,
};
repo.create(&record).await.unwrap();
repo.create(&record, &[]).await.unwrap();
let deps = HandleWrapUpRequestedDeps {
wrapup_repo: repo.clone(),
event_publisher: NoopEventPublisher::new(),
wrapup_stats: InMemoryWrapUpStatsQuery::new(),
};
@@ -132,4 +128,42 @@ async fn skips_if_already_generating() {
// Status should still be Generating (not changed to Ready)
let final_rec = repo.get_by_id(&wrapup_id).await.unwrap().unwrap();
assert_eq!(final_rec.status, WrapUpStatus::Generating);
assert!(repo.recorded_events().is_empty());
}
#[tokio::test]
async fn a_refused_completion_propagates_and_records_nothing() {
let inner = InMemoryWrapUpRepository::new();
let wrapup_id = WrapUpId::generate();
let record = WrapUpRecord {
id: wrapup_id.clone(),
user_id: None,
start_date: NaiveDate::from_ymd_opt(2024, 1, 1).unwrap(),
end_date: NaiveDate::from_ymd_opt(2024, 12, 31).unwrap(),
status: WrapUpStatus::Pending,
report: None,
error_message: None,
created_at: Utc::now().naive_utc(),
completed_at: None,
};
inner.create(&record, &[]).await.unwrap();
let deps = HandleWrapUpRequestedDeps {
wrapup_repo: RefusingWrapUpWrites::new(inner.clone()),
wrapup_stats: InMemoryWrapUpStatsQuery::new(),
};
let result = handle_requested::execute(
&deps,
wrapup_id.clone(),
None,
NaiveDate::from_ymd_opt(2024, 1, 1).unwrap(),
NaiveDate::from_ymd_opt(2024, 12, 31).unwrap(),
)
.await;
assert!(result.is_err());
let rec = inner.get_by_id(&wrapup_id).await.unwrap().unwrap();
assert_ne!(rec.status, WrapUpStatus::Ready);
assert!(rec.report.is_none());
assert!(inner.recorded_events().is_empty());
}