114 lines
3.4 KiB
Rust
114 lines
3.4 KiB
Rust
use activitypub::{NewRemoteReview, RemoteReviewRepository};
|
|
use domain::{
|
|
events::DomainEvent,
|
|
models::{PersistedReview, Review, ReviewSource},
|
|
value_objects::{Comment, ExternalMetadataId, MovieId, Rating, ReviewId, UserId},
|
|
};
|
|
use sqlite_federation::SqliteFederationRepository;
|
|
use sqlx::SqlitePool;
|
|
|
|
const ACTOR: &str = "https://remote.example/users/ann";
|
|
const AP_ID: &str = "https://remote.example/reviews/1";
|
|
|
|
async fn migrated_pool() -> SqlitePool {
|
|
let pool = sqlx::sqlite::SqlitePoolOptions::new()
|
|
.max_connections(1)
|
|
.connect("sqlite::memory:")
|
|
.await
|
|
.unwrap();
|
|
sqlite::migrate(&pool).await.unwrap();
|
|
pool
|
|
}
|
|
|
|
async fn count(pool: &SqlitePool, table: &str) -> i64 {
|
|
sqlx::query_scalar(&format!("SELECT COUNT(*) FROM {table}"))
|
|
.fetch_one(pool)
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
fn remote_review(movie_id: &MovieId) -> Review {
|
|
let now = chrono::Utc::now().naive_utc();
|
|
Review::from_persistence(PersistedReview {
|
|
id: ReviewId::generate(),
|
|
movie_id: movie_id.clone(),
|
|
user_id: UserId::generate(),
|
|
rating: Rating::new(4).unwrap(),
|
|
comment: Some(Comment::new("good".into()).unwrap()),
|
|
watched_at: now,
|
|
created_at: now,
|
|
source: ReviewSource::Remote {
|
|
actor_url: ACTOR.into(),
|
|
},
|
|
watch_medium: None,
|
|
spoilers: false,
|
|
})
|
|
}
|
|
|
|
fn enrichment_requested(movie_id: &MovieId) -> DomainEvent {
|
|
DomainEvent::MovieEnrichmentRequested {
|
|
movie_id: movie_id.clone(),
|
|
external_metadata_id: ExternalMetadataId::new("tmdb:603".into()).unwrap(),
|
|
}
|
|
}
|
|
|
|
async fn save(pool: &SqlitePool, review: &Review, events: &[DomainEvent]) -> anyhow::Result<()> {
|
|
SqliteFederationRepository::new(pool.clone())
|
|
.save_remote_review(NewRemoteReview {
|
|
review,
|
|
ap_id: AP_ID,
|
|
movie_title: "The Matrix",
|
|
release_year: 1999,
|
|
external_metadata_id: Some("tmdb:603"),
|
|
poster_url: None,
|
|
events,
|
|
})
|
|
.await
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn saving_a_remote_review_writes_it_and_its_event_in_one_commit() {
|
|
let pool = migrated_pool().await;
|
|
let movie_id = MovieId::generate();
|
|
let review = remote_review(&movie_id);
|
|
|
|
save(&pool, &review, &[enrichment_requested(&movie_id)])
|
|
.await
|
|
.unwrap();
|
|
|
|
assert_eq!(count(&pool, "reviews").await, 1);
|
|
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_remote_review_and_its_movie() {
|
|
let pool = migrated_pool().await;
|
|
sqlx::query(
|
|
"CREATE TRIGGER fail_event_insert BEFORE INSERT ON event_queue \
|
|
BEGIN SELECT RAISE(ABORT, 'enqueue failed'); END",
|
|
)
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
let movie_id = MovieId::generate();
|
|
let review = remote_review(&movie_id);
|
|
|
|
let result = save(&pool, &review, &[enrichment_requested(&movie_id)]).await;
|
|
|
|
assert!(result.is_err());
|
|
assert_eq!(count(&pool, "reviews").await, 0);
|
|
assert_eq!(count(&pool, "movies").await, 0);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn a_remote_review_without_events_enqueues_nothing() {
|
|
let pool = migrated_pool().await;
|
|
let movie_id = MovieId::generate();
|
|
|
|
save(&pool, &remote_review(&movie_id), &[]).await.unwrap();
|
|
|
|
assert_eq!(count(&pool, "reviews").await, 1);
|
|
assert_eq!(count(&pool, "event_queue").await, 0);
|
|
}
|