test: refusing fakes, failure-path tests, shared panic stubs

crates/adapters/http-axum/src/extractors/tests.rs

@@ -10,420 +10,28 @@ use axum::{
 use bootstrap::Repositories;
 use domain::{
     errors::DomainError,
-    events::DomainEvent,
-    models::{
-        DiaryEntry, DiaryFilter, EntityType, FeedEntry, GeneratedToken, IndexableDocument, Movie,
-        Person, PersonCredits, PersonEnrichmentData, PersonId, Review, ReviewHistory, SearchQuery,
-        SearchResults, UserStats, UserTrends,
-        collections::{PageParams, Paginated},
-        insights::WatchRow,
-    },
-    ports::{
-        AuthService, DiaryQuery, EventPublisher, FollowGraphQuery, InsightsQuery, MetadataClient,
-        MovieCommand, MovieQuery, ObjectStorage, PasswordHasher, PersonCommand, PersonQuery,
-        PosterFetcherClient, ReviewRepository, SearchCommand, SearchPort, StatsRepository,
-        UserRepository, WatchlistRepository,
-    },
-    testing::InMemoryStore,
-    value_objects::{
-        Email, ExternalMetadataId, MovieId, MovieTitle, PasswordHash, PosterUrl, ReleaseYear,
-        ReviewId, UserId,
+    models::GeneratedToken,
+    ports::{AuthService, FollowGraphQuery, PersonQuery, SearchPort, UserRepository},
+    testing::{
+        InMemoryStore, PanicAuthService, PanicDiaryExporter, PanicDiaryQuery, PanicDocumentParser,
+        PanicEventPublisher, PanicGoalCommand, PanicGoalQuery, PanicImportProfileRepository,
+        PanicImportSessionRepository, PanicInsightsQuery, PanicMetadataClient, PanicMovieCommand,
+        PanicMovieProfileRepository, PanicMovieQuery, PanicObjectStorage, PanicPasswordHasher,
+        PanicPersonCommand, PanicPersonQuery, PanicPosterFetcher, PanicProfileFieldsRepo,
+        PanicRefreshSessionRepository, PanicRemoteGoalRepository, PanicRemoteWatchlistRepository,
+        PanicReviewRepository, PanicRssFeedRenderer, PanicSearchCommand, PanicSearchPort,
+        PanicStatsRepository, PanicUserRepository, PanicUserSettingsRepository,
+        PanicWatchEventCommand, PanicWatchEventQuery, PanicWatchlistRepository,
+        PanicWebhookTokenRepository, PanicWrapUpRepository, PanicWrapUpStatsQuery,
     },
+    value_objects::UserId,
 };
 use std::sync::Arc;
 use tower::ServiceExt;
 
-// --- Panic stubs (defined once) ---
+// --- Local stubs ---
 
-pub struct Panic;
-
-#[async_trait::async_trait]
-impl MovieCommand for Panic {
-    async fn upsert_movie(&self, _: &Movie) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn delete_movie(&self, _: &MovieId) -> Result<(), DomainError> {
-        panic!()
-    }
-}
-#[async_trait::async_trait]
-impl MovieQuery for Panic {
-    async fn get_movie_by_external_id(
-        &self,
-        _: &ExternalMetadataId,
-    ) -> Result<Option<Movie>, DomainError> {
-        panic!()
-    }
-    async fn get_movie_by_id(&self, _: &MovieId) -> Result<Option<Movie>, DomainError> {
-        panic!()
-    }
-    async fn get_movies_by_title_and_year(
-        &self,
-        _: &MovieTitle,
-        _: &ReleaseYear,
-    ) -> Result<Vec<Movie>, DomainError> {
-        panic!()
-    }
-    async fn existing_external_ids(
-        &self,
-        _: &[ExternalMetadataId],
-    ) -> Result<std::collections::HashSet<String>, DomainError> {
-        panic!()
-    }
-    async fn existing_title_year_pairs(
-        &self,
-        _: &[(MovieTitle, ReleaseYear)],
-    ) -> Result<std::collections::HashSet<(String, u16)>, DomainError> {
-        panic!()
-    }
-    async fn list_movies(
-        &self,
-        _: &domain::models::collections::PageParams,
-        _: &domain::models::MovieFilter,
-    ) -> Result<domain::models::collections::Paginated<domain::models::MovieSummary>, DomainError>
-    {
-        panic!()
-    }
-    async fn list_movies_with_external_id(
-        &self,
-    ) -> Result<Vec<domain::models::Movie>, DomainError> {
-        Ok(vec![])
-    }
-}
-#[async_trait::async_trait]
-impl ReviewRepository for Panic {
-    async fn save_review(&self, _: &Review) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn get_review_by_id(&self, _: &ReviewId) -> Result<Option<Review>, DomainError> {
-        panic!()
-    }
-    async fn update_review(&self, _: &Review) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn delete_review(&self, _: &ReviewId) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn get_all_reviews_for_user(&self, _: &UserId) -> Result<Vec<Review>, DomainError> {
-        panic!()
-    }
-}
-#[async_trait::async_trait]
-impl DiaryQuery for Panic {
-    async fn query_diary(&self, _: &DiaryFilter) -> Result<Paginated<DiaryEntry>, DomainError> {
-        panic!()
-    }
-    async fn query_activity_feed(
-        &self,
-        _: &PageParams,
-    ) -> Result<Paginated<FeedEntry>, DomainError> {
-        panic!()
-    }
-    async fn query_activity_feed_filtered(
-        &self,
-        _: &PageParams,
-        _: &domain::models::FeedSortBy,
-        _: Option<&str>,
-        _: Option<&domain::models::FollowingFilter>,
-    ) -> Result<Paginated<FeedEntry>, DomainError> {
-        panic!()
-    }
-    async fn get_review_history(&self, _: &MovieId) -> Result<ReviewHistory, DomainError> {
-        panic!()
-    }
-    async fn get_user_history(&self, _: &UserId) -> Result<Vec<DiaryEntry>, DomainError> {
-        panic!()
-    }
-    fn stream_user_history(
-        &self,
-        _: UserId,
-    ) -> futures::stream::BoxStream<'static, Result<DiaryEntry, DomainError>> {
-        panic!()
-    }
-    async fn get_movie_stats(
-        &self,
-        _: &MovieId,
-    ) -> Result<domain::models::MovieStats, DomainError> {
-        panic!()
-    }
-    async fn get_movie_social_feed(
-        &self,
-        _: &MovieId,
-        _: &PageParams,
-    ) -> Result<Paginated<FeedEntry>, DomainError> {
-        panic!()
-    }
-    async fn count_local_posts(&self) -> Result<u64, DomainError> {
-        panic!()
-    }
-}
-#[async_trait::async_trait]
-impl StatsRepository for Panic {
-    async fn get_user_stats(&self, _: &UserId) -> Result<UserStats, DomainError> {
-        panic!()
-    }
-    async fn get_user_trends(&self, _: &UserId) -> Result<UserTrends, DomainError> {
-        panic!()
-    }
-    async fn count_reviews_in_year(&self, _: &UserId, _: u16) -> Result<u32, DomainError> {
-        panic!()
-    }
-}
-#[async_trait::async_trait]
-impl InsightsQuery for Panic {
-    async fn get_watch_rows(&self, _: &UserId) -> Result<Vec<WatchRow>, DomainError> {
-        panic!()
-    }
-}
-#[async_trait::async_trait]
-impl MetadataClient for Panic {
-    async fn fetch_movie_metadata(
-        &self,
-        _: &domain::models::MetadataSearchCriteria,
-    ) -> Result<Movie, DomainError> {
-        panic!()
-    }
-    async fn get_poster_url(
-        &self,
-        _: &ExternalMetadataId,
-    ) -> Result<Option<PosterUrl>, DomainError> {
-        panic!()
-    }
-}
-#[async_trait::async_trait]
-impl PosterFetcherClient for Panic {
-    async fn fetch_poster_bytes(&self, _: &PosterUrl) -> Result<Vec<u8>, DomainError> {
-        panic!()
-    }
-}
-#[async_trait::async_trait]
-impl ObjectStorage for Panic {
-    async fn store(&self, _: &str, _: &[u8]) -> Result<String, DomainError> {
-        panic!()
-    }
-    async fn get(&self, _: &str) -> Result<Vec<u8>, DomainError> {
-        panic!()
-    }
-    async fn get_stream(
-        &self,
-        _: &str,
-    ) -> Result<futures::stream::BoxStream<'static, Result<bytes::Bytes, DomainError>>, DomainError>
-    {
-        panic!()
-    }
-    async fn delete(&self, _: &str) -> Result<(), DomainError> {
-        panic!()
-    }
-}
-#[async_trait::async_trait]
-impl AuthService for Panic {
-    async fn generate_token(&self, _: &UserId) -> Result<GeneratedToken, DomainError> {
-        panic!()
-    }
-    async fn validate_token(&self, _: &str) -> Result<UserId, DomainError> {
-        panic!()
-    }
-}
-#[async_trait::async_trait]
-impl PasswordHasher for Panic {
-    async fn hash(&self, _: &str) -> Result<PasswordHash, DomainError> {
-        panic!()
-    }
-    async fn verify(&self, _: &str, _: &PasswordHash) -> Result<bool, DomainError> {
-        panic!()
-    }
-}
-#[async_trait::async_trait]
-impl UserRepository for Panic {
-    async fn find_by_email(&self, _: &Email) -> Result<Option<domain::models::User>, DomainError> {
-        panic!()
-    }
-    async fn save(&self, _: &domain::models::User) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn find_by_id(&self, _: &UserId) -> Result<Option<domain::models::User>, DomainError> {
-        panic!()
-    }
-    async fn find_by_username(
-        &self,
-        _: &domain::value_objects::Username,
-    ) -> Result<Option<domain::models::User>, DomainError> {
-        panic!()
-    }
-    async fn list_with_stats(&self) -> Result<Vec<domain::models::UserSummary>, DomainError> {
-        panic!()
-    }
-    async fn update_profile(
-        &self,
-        _: &UserId,
-        _: &domain::models::UserProfile,
-    ) -> Result<(), DomainError> {
-        panic!()
-    }
-}
-#[async_trait::async_trait]
-impl domain::ports::UserProfileFieldsRepository for Panic {
-    async fn get_fields(
-        &self,
-        _: &UserId,
-    ) -> Result<Vec<domain::models::ProfileField>, DomainError> {
-        panic!()
-    }
-    async fn set_fields(
-        &self,
-        _: &UserId,
-        _: Vec<domain::models::ProfileField>,
-    ) -> Result<(), DomainError> {
-        panic!()
-    }
-}
-#[async_trait::async_trait]
-impl EventPublisher for Panic {
-    async fn publish(&self, _: &DomainEvent) -> Result<(), DomainError> {
-        panic!()
-    }
-}
-#[async_trait::async_trait]
-impl domain::ports::ImportSessionRepository for Panic {
-    async fn create(&self, _: &domain::models::ImportSession) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn get(
-        &self,
-        _: &domain::value_objects::ImportSessionId,
-        _: &UserId,
-    ) -> Result<Option<domain::models::ImportSession>, DomainError> {
-        panic!()
-    }
-    async fn update(&self, _: &domain::models::ImportSession) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn delete(&self, _: &domain::value_objects::ImportSessionId) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn delete_expired(&self) -> Result<u64, DomainError> {
-        panic!()
-    }
-    async fn delete_expired_for_user(&self, _: &UserId) -> Result<(), DomainError> {
-        panic!()
-    }
-}
-#[async_trait::async_trait]
-impl domain::ports::ImportProfileRepository for Panic {
-    async fn save(&self, _: &domain::models::ImportProfile) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn list_for_user(
-        &self,
-        _: &UserId,
-    ) -> Result<Vec<domain::models::ImportProfile>, DomainError> {
-        panic!()
-    }
-    async fn get(
-        &self,
-        _: &domain::value_objects::ImportProfileId,
-        _: &UserId,
-    ) -> Result<Option<domain::models::ImportProfile>, DomainError> {
-        panic!()
-    }
-    async fn delete(&self, _: &domain::value_objects::ImportProfileId) -> Result<(), DomainError> {
-        panic!()
-    }
-}
-#[async_trait::async_trait]
-impl WatchlistRepository for Panic {
-    async fn add(&self, _: &domain::models::WatchlistEntry) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn remove(
-        &self,
-        _: &domain::value_objects::UserId,
-        _: &domain::value_objects::MovieId,
-    ) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn remove_if_present(
-        &self,
-        _: &domain::value_objects::UserId,
-        _: &domain::value_objects::MovieId,
-    ) -> Result<bool, DomainError> {
-        Ok(false)
-    }
-    async fn get_for_user(
-        &self,
-        _: &domain::value_objects::UserId,
-        _: &domain::models::collections::PageParams,
-    ) -> Result<
-        domain::models::collections::Paginated<domain::models::WatchlistWithMovie>,
-        DomainError,
-    > {
-        panic!()
-    }
-    async fn contains(
-        &self,
-        _: &domain::value_objects::UserId,
-        _: &domain::value_objects::MovieId,
-    ) -> Result<bool, DomainError> {
-        Ok(false)
-    }
-}
-#[async_trait::async_trait]
-impl domain::ports::MovieProfileRepository for Panic {
-    async fn upsert(&self, _: &domain::models::MovieProfile) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn get_by_movie_id(
-        &self,
-        _: &domain::value_objects::MovieId,
-    ) -> Result<Option<domain::models::MovieProfile>, DomainError> {
-        Ok(None)
-    }
-    async fn list_stale(
-        &self,
-    ) -> Result<Vec<(domain::value_objects::MovieId, String)>, DomainError> {
-        Ok(vec![])
-    }
-}
-impl domain::ports::DiaryExporter for Panic {
-    fn stream_entries(
-        &self,
-        _stream: futures::stream::BoxStream<
-            'static,
-            Result<domain::models::DiaryEntry, domain::errors::DomainError>,
-        >,
-        _format: domain::models::ExportFormat,
-    ) -> futures::stream::BoxStream<'static, Result<bytes::Bytes, domain::errors::DomainError>>
-    {
-        panic!("Panic DiaryExporter called")
-    }
-}
-
-impl domain::ports::DocumentParser for Panic {
-    fn parse(
-        &self,
-        _: &[u8],
-        _: domain::models::FileFormat,
-    ) -> Result<domain::models::ParsedFile, domain::models::ImportError> {
-        panic!()
-    }
-    fn apply_mapping(
-        &self,
-        _: &domain::models::ParsedFile,
-        _: &[domain::models::FieldMapping],
-    ) -> Vec<domain::models::AnnotatedRow> {
-        panic!()
-    }
-}
-
-impl domain::ports::RssFeedRenderer for Panic {
-    fn render_feed(
-        &self,
-        _: &[DiaryEntry],
-        _: &domain::ports::FeedChannel<'_>,
-    ) -> Result<String, DomainError> {
-        panic!()
-    }
-}
+struct PanicReviewLogger;
 
 struct RejectingAuth;
 #[async_trait::async_trait]
@@ -437,334 +45,7 @@ impl AuthService for RejectingAuth {
 }
 
 #[async_trait::async_trait]
-impl PersonCommand for Panic {
-    async fn upsert_batch(&self, _: &[Person]) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn backfill_from_credits_batch(
-        &self,
-        _batch_size: u32,
-    ) -> Result<(u64, bool), DomainError> {
-        panic!()
-    }
-    async fn update_enrichment(
-        &self,
-        _: &PersonId,
-        _: &PersonEnrichmentData,
-    ) -> Result<(), DomainError> {
-        panic!()
-    }
-}
-#[async_trait::async_trait]
-impl PersonQuery for Panic {
-    async fn get_by_id(&self, _: &PersonId) -> Result<Option<Person>, DomainError> {
-        panic!()
-    }
-    async fn get_by_external_id(
-        &self,
-        _: &domain::models::ExternalPersonId,
-    ) -> Result<Option<Person>, DomainError> {
-        panic!()
-    }
-    async fn get_credits(&self, _: &PersonId) -> Result<PersonCredits, DomainError> {
-        panic!()
-    }
-    async fn list_orphaned_persons(&self) -> Result<Vec<PersonId>, DomainError> {
-        panic!()
-    }
-    async fn list_page(
-        &self,
-        _limit: u32,
-        _offset: u32,
-    ) -> Result<Vec<domain::models::Person>, DomainError> {
-        panic!()
-    }
-}
-#[async_trait::async_trait]
-impl SearchPort for Panic {
-    async fn search(&self, _: &SearchQuery) -> Result<SearchResults, DomainError> {
-        panic!()
-    }
-}
-#[async_trait::async_trait]
-impl SearchCommand for Panic {
-    async fn index(&self, _: IndexableDocument) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn remove(&self, _: EntityType, _: &str) -> Result<(), DomainError> {
-        panic!()
-    }
-}
-#[async_trait::async_trait]
-impl domain::ports::RemoteWatchlistRepository for Panic {
-    async fn save(&self, _: domain::models::RemoteWatchlistEntry) -> Result<(), DomainError> {
-        Ok(())
-    }
-    async fn remove_by_ap_id(&self, _: &str, _: &str) -> Result<(), DomainError> {
-        Ok(())
-    }
-    async fn get_by_actor_url(
-        &self,
-        _: &str,
-    ) -> Result<Vec<domain::models::RemoteWatchlistEntry>, DomainError> {
-        Ok(vec![])
-    }
-    async fn remove_all_by_actor(&self, _: &str) -> Result<(), DomainError> {
-        Ok(())
-    }
-    async fn get_by_derived_uuid(
-        &self,
-        _: uuid::Uuid,
-    ) -> Result<Vec<domain::models::RemoteWatchlistEntry>, DomainError> {
-        Ok(vec![])
-    }
-}
-
-#[async_trait::async_trait]
-impl domain::ports::WatchEventCommand for Panic {
-    async fn save(&self, _: &domain::models::WatchEvent) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn update_status(
-        &self,
-        _: &domain::value_objects::WatchEventId,
-        _: domain::models::WatchEventStatus,
-    ) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn update_status_batch(
-        &self,
-        _: &[domain::value_objects::WatchEventId],
-        _: domain::models::WatchEventStatus,
-    ) -> Result<u64, DomainError> {
-        panic!()
-    }
-    async fn delete_non_pending_older_than(
-        &self,
-        _: chrono::NaiveDateTime,
-    ) -> Result<u64, DomainError> {
-        panic!()
-    }
-}
-#[async_trait::async_trait]
-impl domain::ports::WatchEventQuery for Panic {
-    async fn list_pending(
-        &self,
-        _: &domain::value_objects::UserId,
-    ) -> Result<Vec<domain::models::WatchEvent>, DomainError> {
-        panic!()
-    }
-    async fn get_by_id(
-        &self,
-        _: &domain::value_objects::WatchEventId,
-    ) -> Result<Option<domain::models::WatchEvent>, DomainError> {
-        panic!()
-    }
-    async fn get_by_ids(
-        &self,
-        _: &[domain::value_objects::WatchEventId],
-    ) -> Result<Vec<domain::models::WatchEvent>, DomainError> {
-        panic!()
-    }
-    async fn find_duplicate(
-        &self,
-        _: &domain::value_objects::UserId,
-        _: &str,
-        _: chrono::NaiveDateTime,
-    ) -> Result<bool, DomainError> {
-        panic!()
-    }
-}
-#[async_trait::async_trait]
-impl domain::ports::WebhookTokenRepository for Panic {
-    async fn save(&self, _: &domain::models::WebhookToken) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn find_by_token_hash(
-        &self,
-        _: &str,
-    ) -> Result<Option<domain::models::WebhookToken>, DomainError> {
-        panic!()
-    }
-    async fn list_by_user(
-        &self,
-        _: &domain::value_objects::UserId,
-    ) -> Result<Vec<domain::models::WebhookToken>, DomainError> {
-        panic!()
-    }
-    async fn delete(
-        &self,
-        _: &domain::value_objects::WebhookTokenId,
-        _: &domain::value_objects::UserId,
-    ) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn touch_last_used(
-        &self,
-        _: &domain::value_objects::WebhookTokenId,
-    ) -> Result<(), DomainError> {
-        panic!()
-    }
-}
-
-#[async_trait::async_trait]
-impl domain::ports::WrapUpStatsQuery for Panic {
-    async fn get_reviews_with_profiles(
-        &self,
-        _: &domain::models::wrapup::WrapUpScope,
-        _: &domain::models::wrapup::DateRange,
-    ) -> Result<Vec<domain::models::WrapUpMovieRow>, DomainError> {
-        panic!()
-    }
-}
-
-#[async_trait::async_trait]
-impl domain::ports::WrapUpRepository for Panic {
-    async fn create(&self, _: &domain::models::wrapup::WrapUpRecord) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn update_status(
-        &self,
-        _: &domain::value_objects::WrapUpId,
-        _: &domain::models::wrapup::WrapUpStatus,
-        _: Option<&str>,
-    ) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn set_complete(
-        &self,
-        _: &domain::value_objects::WrapUpId,
-        _: &domain::models::wrapup::WrapUpReport,
-    ) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn get_by_id(
-        &self,
-        _: &domain::value_objects::WrapUpId,
-    ) -> Result<Option<domain::models::wrapup::WrapUpRecord>, DomainError> {
-        panic!()
-    }
-    async fn list_for_user(
-        &self,
-        _: uuid::Uuid,
-    ) -> Result<Vec<domain::models::wrapup::WrapUpRecord>, DomainError> {
-        panic!()
-    }
-    async fn list_global(&self) -> Result<Vec<domain::models::wrapup::WrapUpRecord>, DomainError> {
-        panic!()
-    }
-    async fn find_existing(
-        &self,
-        _: Option<uuid::Uuid>,
-        _: chrono::NaiveDate,
-        _: chrono::NaiveDate,
-    ) -> Result<Option<domain::models::wrapup::WrapUpRecord>, DomainError> {
-        panic!()
-    }
-    async fn delete(&self, _: &domain::value_objects::WrapUpId) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn delete_failed_older_than(&self, _: chrono::NaiveDateTime) -> Result<u64, DomainError> {
-        panic!()
-    }
-}
-
-#[async_trait::async_trait]
-impl domain::ports::GoalCommand for Panic {
-    async fn save(&self, _: &domain::models::Goal) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn update(&self, _: &domain::models::Goal) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn delete(
-        &self,
-        _: &domain::value_objects::GoalId,
-        _: &domain::value_objects::UserId,
-    ) -> Result<(), DomainError> {
-        panic!()
-    }
-}
-
-#[async_trait::async_trait]
-impl domain::ports::GoalQuery for Panic {
-    async fn find_by_user_and_year(
-        &self,
-        _: &domain::value_objects::UserId,
-        _: u16,
-    ) -> Result<Option<domain::models::Goal>, DomainError> {
-        panic!()
-    }
-    async fn list_for_user(
-        &self,
-        _: &domain::value_objects::UserId,
-    ) -> Result<Vec<domain::models::Goal>, DomainError> {
-        panic!()
-    }
-}
-
-#[async_trait::async_trait]
-impl domain::ports::UserSettingsRepository for Panic {
-    async fn get(
-        &self,
-        _: &domain::value_objects::UserId,
-    ) -> Result<domain::models::UserSettings, DomainError> {
-        panic!()
-    }
-    async fn save(&self, _: &domain::models::UserSettings) -> Result<(), DomainError> {
-        panic!()
-    }
-}
-
-#[async_trait::async_trait]
-impl domain::ports::RemoteGoalRepository for Panic {
-    async fn save(&self, _: domain::models::RemoteGoalEntry) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn update_by_ap_id(&self, _: &str, _: u32, _: u32) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn remove_by_ap_id(&self, _: &str, _: &str) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn remove_all_by_actor(&self, _: &str) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn get_by_actor_url(
-        &self,
-        _: &str,
-    ) -> Result<Vec<domain::models::RemoteGoalEntry>, DomainError> {
-        panic!()
-    }
-}
-
-#[async_trait::async_trait]
-impl domain::ports::RefreshSessionRepository for Panic {
-    async fn create(&self, _: &domain::models::RefreshSession) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn get_by_token(
-        &self,
-        _: &str,
-    ) -> Result<Option<domain::models::RefreshSession>, DomainError> {
-        panic!()
-    }
-    async fn revoke(&self, _: &str) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn revoke_all_for_user(
-        &self,
-        _: &domain::value_objects::UserId,
-    ) -> Result<(), DomainError> {
-        panic!()
-    }
-    async fn delete_expired(&self) -> Result<u64, DomainError> {
-        panic!()
-    }
-}
-
-#[async_trait::async_trait]
-impl application::ports::ReviewLogger for Panic {
+impl application::ports::ReviewLogger for PanicReviewLogger {
     async fn log_review(
         &self,
         _: application::diary::commands::LogReviewCommand,
@@ -773,43 +54,41 @@ impl application::ports::ReviewLogger for Panic {
     }
 }
 
-// --- Repositories factory — `Panic` stubs everywhere ---
+// --- Repositories factory — `Panic*` stubs everywhere ---
 
 pub(crate) fn test_repositories() -> Repositories {
-    let repo = Arc::new(Panic);
-
     Repositories {
-        movie_command: Arc::clone(&repo) as _,
-        movie_query: Arc::clone(&repo) as _,
-        review: Arc::clone(&repo) as _,
-        diary: Arc::clone(&repo) as _,
-        stats: Arc::clone(&repo) as _,
-        user: Arc::clone(&repo) as _,
-        import_session: Arc::clone(&repo) as _,
-        import_profile: Arc::clone(&repo) as _,
-        movie_profile: Arc::clone(&repo) as _,
-        watchlist: Arc::clone(&repo) as _,
-        watch_event_command: Arc::clone(&repo) as _,
-        watch_event_query: Arc::clone(&repo) as _,
-        webhook_token: Arc::clone(&repo) as _,
-        profile_fields: Arc::clone(&repo) as _,
-        person_command: Arc::clone(&repo) as _,
-        person_query: Arc::clone(&repo) as _,
-        search_port: Arc::clone(&repo) as _,
-        search_command: Arc::clone(&repo) as _,
-        remote_watchlist: Arc::clone(&repo) as _,
+        movie_command: Arc::new(PanicMovieCommand) as _,
+        movie_query: Arc::new(PanicMovieQuery) as _,
+        review: Arc::new(PanicReviewRepository) as _,
+        diary: Arc::new(PanicDiaryQuery) as _,
+        stats: Arc::new(PanicStatsRepository) as _,
+        user: Arc::new(PanicUserRepository) as _,
+        import_session: Arc::new(PanicImportSessionRepository) as _,
+        import_profile: Arc::new(PanicImportProfileRepository) as _,
+        movie_profile: Arc::new(PanicMovieProfileRepository) as _,
+        watchlist: Arc::new(PanicWatchlistRepository) as _,
+        watch_event_command: Arc::new(PanicWatchEventCommand) as _,
+        watch_event_query: Arc::new(PanicWatchEventQuery) as _,
+        webhook_token: Arc::new(PanicWebhookTokenRepository) as _,
+        profile_fields: Arc::new(PanicProfileFieldsRepo) as _,
+        person_command: Arc::new(PanicPersonCommand) as _,
+        person_query: Arc::new(PanicPersonQuery) as _,
+        search_port: Arc::new(PanicSearchPort) as _,
+        search_command: Arc::new(PanicSearchCommand) as _,
+        remote_watchlist: Arc::new(PanicRemoteWatchlistRepository) as _,
         social_command: Arc::new(domain::ports::noop::NoopSocialCommand) as _,
         follow_graph: Arc::new(domain::ports::noop::NoopSocialQuery) as _,
         block_query: Arc::new(domain::ports::noop::NoopSocialQuery) as _,
         federation_admin: Arc::new(domain::ports::noop::NoopFederationAdminQuery) as _,
-        wrapup_stats: Arc::clone(&repo) as _,
-        wrapup_repo: Arc::clone(&repo) as _,
-        insights: Arc::clone(&repo) as _,
-        goal_command: Arc::clone(&repo) as _,
-        goal_query: Arc::clone(&repo) as _,
-        user_settings: Arc::clone(&repo) as _,
-        remote_goal: Arc::clone(&repo) as _,
-        refresh_session: Arc::clone(&repo) as _,
+        wrapup_stats: Arc::new(PanicWrapUpStatsQuery) as _,
+        wrapup_repo: Arc::new(PanicWrapUpRepository) as _,
+        insights: Arc::new(PanicInsightsQuery) as _,
+        goal_command: Arc::new(PanicGoalCommand) as _,
+        goal_query: Arc::new(PanicGoalQuery) as _,
+        user_settings: Arc::new(PanicUserSettingsRepository) as _,
+        remote_goal: Arc::new(PanicRemoteGoalRepository) as _,
+        refresh_session: Arc::new(PanicRefreshSessionRepository) as _,
         federated_profile: None,
     }
 }
@@ -823,18 +102,16 @@ pub(crate) fn build_test_state_from(
     repos: Repositories,
     auth_service: Arc<dyn AuthService>,
 ) -> crate::state::AppState {
-    let repo = Arc::new(Panic);
-
     let services = application::Services {
         auth: auth_service,
-        password_hasher: Arc::clone(&repo) as _,
-        metadata: Arc::clone(&repo) as _,
-        poster_fetcher: Arc::clone(&repo) as _,
-        object_storage: Arc::clone(&repo) as _,
-        event_publisher: Arc::clone(&repo) as _,
-        diary_exporter: Arc::clone(&repo) as _,
-        document_parser: Arc::clone(&repo) as _,
-        review_logger: Arc::clone(&repo) as _,
+        password_hasher: Arc::new(PanicPasswordHasher) as _,
+        metadata: Arc::new(PanicMetadataClient) as _,
+        poster_fetcher: Arc::new(PanicPosterFetcher) as _,
+        object_storage: Arc::new(PanicObjectStorage) as _,
+        event_publisher: Arc::new(PanicEventPublisher) as _,
+        diary_exporter: Arc::new(PanicDiaryExporter) as _,
+        document_parser: Arc::new(PanicDocumentParser) as _,
+        review_logger: Arc::new(PanicReviewLogger) as _,
         person_enrichment: None,
     };
 
@@ -867,7 +144,7 @@ pub(crate) fn build_test_state_from(
             #[cfg(feature = "federation")]
             ap_blocklist: Arc::new(domain::ports::noop::NoopInstanceBlocklist),
         },
-        rss_renderer: Arc::new(Panic),
+        rss_renderer: Arc::new(PanicRssFeedRenderer),
     }
 }
 
@@ -875,13 +152,13 @@ pub fn make_test_state(auth_service: Arc<dyn AuthService>) -> crate::state::AppS
     build_test_state_from(test_repositories(), auth_service)
 }
 
-/// Reusable default test `AppState`: `Panic` stubs everywhere, real prebuilt `deps`.
+/// Reusable default test `AppState`: `Panic*` stubs everywhere, real prebuilt `deps`.
 /// Callers that need a specific stub swapped in should use one of the
 /// `test_app_state_with_*` constructors below, which inject BEFORE `build_deps`
 /// runs — mutating the returned `AppState` afterwards would only reach `repos`,
 /// not the prebuilt `deps`.
 pub(crate) fn test_app_state() -> crate::state::AppState {
-    make_test_state(Arc::new(Panic))
+    make_test_state(Arc::new(PanicAuthService))
 }
 
 /// Test state with `person_query` overridden BEFORE `build_deps` runs, so the
@@ -892,7 +169,7 @@ pub(crate) fn test_app_state_with_person_query(
 ) -> crate::state::AppState {
     let mut repos = test_repositories();
     repos.person_query = person_query;
-    build_test_state_from(repos, Arc::new(Panic))
+    build_test_state_from(repos, Arc::new(PanicAuthService))
 }
 
 /// Test state with `search_port` overridden BEFORE `build_deps` runs, so the
@@ -903,7 +180,7 @@ pub(crate) fn test_app_state_with_search_port(
 ) -> crate::state::AppState {
     let mut repos = test_repositories();
     repos.search_port = search_port;
-    build_test_state_from(repos, Arc::new(Panic))
+    build_test_state_from(repos, Arc::new(PanicAuthService))
 }
 
 /// Test state with `follow_graph` overridden BEFORE `build_deps` runs, so the

crates/adapters/http-axum/src/tests/context.rs

@@ -8,7 +8,7 @@ fn prebuilt_deps_share_port_instances_with_repos() {
 
     let state = crate::extractors::tests::build_test_state_from(
         repos,
-        Arc::new(crate::extractors::tests::Panic),
+        Arc::new(domain::testing::PanicAuthService),
     );
 
     assert!(