refactor: extract inline test modules to separate files

crates/presentation/src/handlers/federation_actors/mod.rs

@@ -0,0 +1,123 @@
+use crate::{
+    errors::ApiError,
+    extractors::{Deps, FromAppState, OptionalAuthUser},
+    handlers::feed::to_thought_response,
+    state::AppState,
+};
+use api_types::{
+    requests::PaginationQuery,
+    responses::{ActorConnectionPageResponse, ActorConnectionResponse},
+};
+use application::use_cases::federation_management::{
+    get_actor_connections_page, get_remote_actor_posts,
+};
+use axum::{
+    extract::{Path, Query},
+    Json,
+};
+use activitypub_base::ActivityPubRepository;
+use domain::{
+    models::feed::PageParams,
+    ports::{
+        FederationActionPort, FederationSchedulerPort, FeedRepository,
+        RemoteActorConnectionRepository,
+    },
+};
+use std::sync::Arc;
+
+pub struct FederationActorsDeps {
+    pub federation: Arc<dyn FederationActionPort>,
+    pub ap_repo: Arc<dyn ActivityPubRepository>,
+    pub feed: Arc<dyn FeedRepository>,
+    pub federation_scheduler: Arc<dyn FederationSchedulerPort>,
+    pub remote_actor_connections: Arc<dyn RemoteActorConnectionRepository>,
+}
+
+impl FromAppState for FederationActorsDeps {
+    fn from_state(s: &AppState) -> Self {
+        Self {
+            federation: s.federation.clone(),
+            ap_repo: s.ap_repo.clone(),
+            feed: s.feed.clone(),
+            federation_scheduler: s.federation_scheduler.clone(),
+            remote_actor_connections: s.remote_actor_connections.clone(),
+        }
+    }
+}
+
+pub async fn remote_actor_posts_handler(
+    Deps(d): Deps<FederationActorsDeps>,
+    Path(handle): Path<String>,
+    Query(q): Query<PaginationQuery>,
+    OptionalAuthUser(viewer): OptionalAuthUser,
+) -> Result<Json<serde_json::Value>, ApiError> {
+    let page = PageParams {
+        page: q.page(),
+        per_page: q.per_page(),
+    };
+    let result = get_remote_actor_posts(
+        &*d.federation,
+        &*d.ap_repo,
+        &*d.feed,
+        &*d.federation_scheduler,
+        &handle,
+        page,
+        viewer.as_ref(),
+    )
+    .await?;
+    Ok(Json(serde_json::json!({
+        "total": result.total,
+        "page": result.page,
+        "per_page": result.per_page,
+        "items": result.items.iter().map(to_thought_response).collect::<Vec<_>>(),
+    })))
+}
+
+pub async fn actor_followers_handler(
+    Deps(d): Deps<FederationActorsDeps>,
+    Path(handle): Path<String>,
+    Query(q): Query<PaginationQuery>,
+) -> Result<Json<ActorConnectionPageResponse>, ApiError> {
+    actor_connections_handler(d, handle, "followers", q.page() as u32).await
+}
+
+pub async fn actor_following_handler(
+    Deps(d): Deps<FederationActorsDeps>,
+    Path(handle): Path<String>,
+    Query(q): Query<PaginationQuery>,
+) -> Result<Json<ActorConnectionPageResponse>, ApiError> {
+    actor_connections_handler(d, handle, "following", q.page() as u32).await
+}
+
+async fn actor_connections_handler(
+    d: FederationActorsDeps,
+    handle: String,
+    connection_type: &str,
+    page: u32,
+) -> Result<Json<ActorConnectionPageResponse>, ApiError> {
+    let (items, has_more) = get_actor_connections_page(
+        &*d.federation,
+        &*d.remote_actor_connections,
+        &*d.federation_scheduler,
+        &handle,
+        connection_type,
+        page,
+    )
+    .await?;
+    Ok(Json(ActorConnectionPageResponse {
+        items: items
+            .into_iter()
+            .map(|a| ActorConnectionResponse {
+                handle: a.handle,
+                display_name: a.display_name,
+                avatar_url: a.avatar_url,
+                url: a.url,
+            })
+            .collect(),
+        page,
+        has_more,
+    }))
+}
+
+#[cfg(test)]
+mod tests;