use axum::extract::FromRequestParts;
use axum::http::request::Parts;
use axum::http::StatusCode;
use axum::response::{IntoResponse, Response};
use axum::Json;
use serde_json::json;
use std::sync::Arc;
use crate::config::settings::Settings;
use crate::domain::repositories::task_repository::TaskRepository;
use crate::domain::services::rate_limiting_service::RateLimitingService;
use crate::presentation::middleware::auth_middleware::AuthState;
use crate::queue::task_queue::TaskQueue;
#[derive(Clone)]
pub struct CrawlRsDeps {
pub queue: Arc<dyn TaskQueue>,
pub settings: Arc<Settings>,
pub task_repo: Arc<dyn TaskRepository>,
pub rate_limiting_service: Arc<dyn RateLimitingService>,
pub auth_state: AuthState,
}
fn missing_extension(name: &str) -> Response {
let status = StatusCode::INTERNAL_SERVER_ERROR;
let body = Json(json!({ "error": format!("Missing extension: {}", name) }));
(status, body).into_response()
}
impl<S> FromRequestParts<S> for CrawlRsDeps
where
S: Send + Sync,
{
type Rejection = Response;
async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
let queue = parts
.extensions
.get::<Arc<dyn TaskQueue>>()
.cloned()
.ok_or_else(|| missing_extension("TaskQueue"))?;
let settings = parts
.extensions
.get::<Arc<Settings>>()
.cloned()
.ok_or_else(|| missing_extension("Settings"))?;
let task_repo = parts
.extensions
.get::<Arc<dyn TaskRepository>>()
.cloned()
.ok_or_else(|| missing_extension("TaskRepository"))?;
let rate_limiting_service = parts
.extensions
.get::<Arc<dyn RateLimitingService>>()
.cloned()
.ok_or_else(|| missing_extension("RateLimitingService"))?;
let auth_state = parts
.extensions
.get::<AuthState>()
.cloned()
.ok_or_else(|| missing_extension("AuthState"))?;
Ok(CrawlRsDeps {
queue,
settings,
task_repo,
rate_limiting_service,
auth_state,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use async_trait::async_trait;
use axum::extract::FromRequestParts;
use axum::http::request::Parts;
use axum::http::Request;
use std::collections::HashSet;
use std::sync::Arc;
use crate::common::test_helpers::create_test_db_pool;
use crate::domain::auth::ApiKeyScope;
use crate::domain::models::Task;
use crate::domain::repositories::task_repository::{RepositoryError, TaskQueryParams};
use crate::domain::services::rate_limiting_service::{
BacklogService, ConcurrencyConfig, ConcurrencyControlService, ConcurrencyResult,
QuotaService, RateLimitConfig, RateLimitResult, RateLimitService, RateLimitingError,
};
use crate::queue::task_queue::QueueError;
struct MockTaskQueue;
#[async_trait]
impl TaskQueue for MockTaskQueue {
async fn enqueue(&self, task: Task) -> Result<Task, QueueError> {
Ok(task)
}
async fn dequeue(
&self,
_worker_id: crate::domain::id::Id,
) -> Result<Option<Task>, QueueError> {
Ok(None)
}
async fn complete(&self, _task_id: crate::domain::id::Id) -> Result<(), QueueError> {
Ok(())
}
async fn fail(&self, _task_id: crate::domain::id::Id) -> Result<(), QueueError> {
Ok(())
}
async fn cancel(&self, _task_id: crate::domain::id::Id) -> Result<(), QueueError> {
Ok(())
}
}
struct MockTaskRepo;
#[async_trait]
impl crate::domain::repositories::task_repository::TaskRepository for MockTaskRepo {
async fn create(&self, task: &Task) -> Result<Task, RepositoryError> {
Ok(task.clone())
}
async fn find_by_id(
&self,
_id: crate::domain::id::Id,
) -> Result<Option<Task>, RepositoryError> {
Ok(None)
}
async fn update(&self, task: &Task) -> Result<Task, RepositoryError> {
Ok(task.clone())
}
async fn acquire_next(
&self,
_worker_id: crate::domain::id::Id,
) -> Result<Option<Task>, RepositoryError> {
Ok(None)
}
async fn mark_completed(
&self,
_id: crate::domain::id::Id,
_lock_token: Option<crate::domain::id::Id>,
) -> Result<u64, RepositoryError> {
Ok(1)
}
async fn mark_failed(
&self,
_id: crate::domain::id::Id,
_lock_token: Option<crate::domain::id::Id>,
) -> Result<u64, RepositoryError> {
Ok(1)
}
async fn mark_cancelled(&self, _id: crate::domain::id::Id) -> Result<u64, RepositoryError> {
Ok(1)
}
async fn exists_by_url(&self, _url: &str) -> Result<bool, RepositoryError> {
Ok(false)
}
async fn find_existing_urls(
&self,
_urls: &[String],
) -> Result<HashSet<String>, RepositoryError> {
Ok(HashSet::new())
}
async fn reset_stuck_tasks(
&self,
_timeout: chrono::Duration,
) -> Result<u64, RepositoryError> {
Ok(0)
}
async fn cancel_tasks_by_crawl_id(
&self,
_crawl_id: crate::domain::id::Id,
) -> Result<u64, RepositoryError> {
Ok(0)
}
async fn expire_tasks(&self) -> Result<u64, RepositoryError> {
Ok(0)
}
async fn find_by_crawl_id(
&self,
_crawl_id: crate::domain::id::Id,
) -> Result<Vec<Task>, RepositoryError> {
Ok(vec![])
}
async fn query_tasks(
&self,
_params: TaskQueryParams,
) -> Result<(Vec<Task>, u64), RepositoryError> {
Ok((vec![], 0))
}
async fn batch_cancel(
&self,
_task_ids: Vec<crate::domain::id::Id>,
_team_id: crate::domain::id::Id,
_force: bool,
) -> Result<
(
Vec<crate::domain::id::Id>,
Vec<(crate::domain::id::Id, String)>,
),
RepositoryError,
> {
Ok((vec![], vec![]))
}
async fn renew_lock(
&self,
_task_id: crate::domain::id::Id,
_worker_id: crate::domain::id::Id,
_extend_seconds: i64,
) -> Result<bool, RepositoryError> {
Ok(true)
}
}
struct MockRateLimitService;
#[async_trait]
impl RateLimitService for MockRateLimitService {
async fn check_rate_limit(
&self,
_api_key: &str,
_endpoint: &str,
) -> Result<RateLimitResult, RateLimitingError> {
Ok(RateLimitResult::Allowed)
}
async fn get_team_rate_limit_config(
&self,
_team_id: crate::domain::id::Id,
) -> Result<RateLimitConfig, RateLimitingError> {
Ok(RateLimitConfig::default())
}
async fn update_team_rate_limit_config(
&self,
_team_id: crate::domain::id::Id,
_config: RateLimitConfig,
) -> Result<(), RateLimitingError> {
Ok(())
}
async fn cleanup_expired_rate_limits(&self) -> Result<u64, RateLimitingError> {
Ok(0)
}
}
#[async_trait]
impl ConcurrencyControlService for MockRateLimitService {
async fn check_team_concurrency(
&self,
_team_id: crate::domain::id::Id,
_task_id: crate::domain::id::Id,
) -> Result<ConcurrencyResult, RateLimitingError> {
Ok(ConcurrencyResult::Allowed)
}
async fn release_team_concurrency_slot(
&self,
_team_id: crate::domain::id::Id,
_task_id: crate::domain::id::Id,
) -> Result<(), RateLimitingError> {
Ok(())
}
async fn get_team_current_concurrency(
&self,
_team_id: crate::domain::id::Id,
) -> Result<u32, RateLimitingError> {
Ok(0)
}
async fn get_team_concurrency_config(
&self,
_team_id: crate::domain::id::Id,
) -> Result<ConcurrencyConfig, RateLimitingError> {
Ok(ConcurrencyConfig::default())
}
async fn update_team_concurrency_config(
&self,
_team_id: crate::domain::id::Id,
_config: ConcurrencyConfig,
) -> Result<(), RateLimitingError> {
Ok(())
}
}
#[async_trait]
impl BacklogService for MockRateLimitService {
async fn process_backlog_tasks(
&self,
_team_id: crate::domain::id::Id,
) -> Result<u32, RateLimitingError> {
Ok(0)
}
}
#[async_trait]
impl QuotaService for MockRateLimitService {
async fn check_and_deduct_quota(
&self,
_team_id: crate::domain::id::Id,
_amount: i64,
_transaction_type: crate::domain::models::CreditsTransactionType,
_description: String,
_reference_id: Option<crate::domain::id::Id>,
) -> Result<(), RateLimitingError> {
Ok(())
}
async fn get_quota_balance(
&self,
_team_id: crate::domain::id::Id,
) -> Result<i64, RateLimitingError> {
Ok(1000)
}
async fn refund_quota(
&self,
_team_id: crate::domain::id::Id,
_amount: i64,
_description: String,
_reference_id: Option<crate::domain::id::Id>,
) -> Result<(), RateLimitingError> {
Ok(())
}
}
#[async_trait]
impl RateLimitingService for MockRateLimitService {}
fn make_parts_with_extensions() -> Parts {
let request = Request::builder().body(()).unwrap();
let (mut parts, _) = request.into_parts();
parts
.extensions
.insert(Arc::new(MockTaskQueue) as Arc<dyn TaskQueue>);
parts
.extensions
.insert(Arc::new(Settings::default()) as Arc<Settings>);
parts
.extensions
.insert(Arc::new(MockTaskRepo) as Arc<dyn TaskRepository>);
parts
.extensions
.insert(Arc::new(MockRateLimitService) as Arc<dyn RateLimitingService>);
parts.extensions.insert(AuthState::new(
create_test_db_pool(),
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
ApiKeyScope::default(),
));
parts
}
#[tokio::test]
async fn test_app_deps_extracts_all_fields() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let mut parts = make_parts_with_extensions();
let result = CrawlRsDeps::from_request_parts(&mut parts, &()).await;
assert!(result.is_ok(), "CrawlRsDeps should extract successfully");
}
#[tokio::test]
async fn test_app_deps_missing_task_queue_returns_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let request = Request::builder().body(()).unwrap();
let (mut parts, _) = request.into_parts();
parts
.extensions
.insert(Arc::new(Settings::default()) as Arc<Settings>);
parts
.extensions
.insert(Arc::new(MockTaskRepo) as Arc<dyn TaskRepository>);
parts
.extensions
.insert(Arc::new(MockRateLimitService) as Arc<dyn RateLimitingService>);
parts.extensions.insert(AuthState::new(
create_test_db_pool(),
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
ApiKeyScope::default(),
));
let result = CrawlRsDeps::from_request_parts(&mut parts, &()).await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_app_deps_missing_settings_returns_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let request = Request::builder().body(()).unwrap();
let (mut parts, _) = request.into_parts();
parts
.extensions
.insert(Arc::new(MockTaskQueue) as Arc<dyn TaskQueue>);
parts
.extensions
.insert(Arc::new(MockTaskRepo) as Arc<dyn TaskRepository>);
parts
.extensions
.insert(Arc::new(MockRateLimitService) as Arc<dyn RateLimitingService>);
parts.extensions.insert(AuthState::new(
create_test_db_pool(),
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
ApiKeyScope::default(),
));
let result = CrawlRsDeps::from_request_parts(&mut parts, &()).await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_app_deps_missing_task_repo_returns_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let request = Request::builder().body(()).unwrap();
let (mut parts, _) = request.into_parts();
parts
.extensions
.insert(Arc::new(MockTaskQueue) as Arc<dyn TaskQueue>);
parts
.extensions
.insert(Arc::new(Settings::default()) as Arc<Settings>);
parts
.extensions
.insert(Arc::new(MockRateLimitService) as Arc<dyn RateLimitingService>);
parts.extensions.insert(AuthState::new(
create_test_db_pool(),
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
ApiKeyScope::default(),
));
let result = CrawlRsDeps::from_request_parts(&mut parts, &()).await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_app_deps_missing_rate_limit_returns_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let request = Request::builder().body(()).unwrap();
let (mut parts, _) = request.into_parts();
parts
.extensions
.insert(Arc::new(MockTaskQueue) as Arc<dyn TaskQueue>);
parts
.extensions
.insert(Arc::new(Settings::default()) as Arc<Settings>);
parts
.extensions
.insert(Arc::new(MockTaskRepo) as Arc<dyn TaskRepository>);
parts.extensions.insert(AuthState::new(
create_test_db_pool(),
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
ApiKeyScope::default(),
));
let result = CrawlRsDeps::from_request_parts(&mut parts, &()).await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_app_deps_missing_auth_state_returns_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let request = Request::builder().body(()).unwrap();
let (mut parts, _) = request.into_parts();
parts
.extensions
.insert(Arc::new(MockTaskQueue) as Arc<dyn TaskQueue>);
parts
.extensions
.insert(Arc::new(Settings::default()) as Arc<Settings>);
parts
.extensions
.insert(Arc::new(MockTaskRepo) as Arc<dyn TaskRepository>);
parts
.extensions
.insert(Arc::new(MockRateLimitService) as Arc<dyn RateLimitingService>);
let result = CrawlRsDeps::from_request_parts(&mut parts, &()).await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_app_deps_empty_extensions_returns_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let request = Request::builder().body(()).unwrap();
let (mut parts, _) = request.into_parts();
let result = CrawlRsDeps::from_request_parts(&mut parts, &()).await;
assert!(result.is_err());
}
#[test]
fn test_app_deps_clone() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let deps = CrawlRsDeps {
queue: Arc::new(MockTaskQueue),
settings: Arc::new(Settings::default()),
task_repo: Arc::new(MockTaskRepo),
rate_limiting_service: Arc::new(MockRateLimitService),
auth_state: AuthState::new(
create_test_db_pool(),
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
ApiKeyScope::default(),
),
};
let cloned = deps.clone();
assert_eq!(cloned.auth_state.team_id, deps.auth_state.team_id);
assert_eq!(cloned.auth_state.api_key_id, deps.auth_state.api_key_id);
}
#[test]
fn test_app_deps_struct_fields_accessible() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let deps = CrawlRsDeps {
queue: Arc::new(MockTaskQueue),
settings: Arc::new(Settings::default()),
task_repo: Arc::new(MockTaskRepo),
rate_limiting_service: Arc::new(MockRateLimitService),
auth_state: AuthState::new(
create_test_db_pool(),
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
ApiKeyScope::default(),
),
};
let _ = &deps.queue;
let _ = &deps.settings;
let _ = &deps.task_repo;
let _ = &deps.rate_limiting_service;
let _ = &deps.auth_state;
}
}