use axum::{
extract::{Extension, Json},
http::StatusCode,
response::IntoResponse,
};
use log::error;
use std::sync::Arc;
use crate::{
application::dto::search_request::{SearchRequestDto, SearchResponseDto, SearchResultDto},
common::constants::crawl_task,
domain::{
repositories::task_repository::TaskRepository,
services::rate_limiting_service::RateLimitingService,
services::search_service::{
SearchQuery, SearchResponse, SearchServiceError, SearchServiceTrait,
},
},
i18n::{I18nBundle, Locale},
presentation::handlers::check_ssrf_url,
presentation::handlers::response_builder::{
error_response, json_rejection_response, success_response,
},
presentation::handlers::task_queries::wait_for_tasks_completion,
presentation::helpers::rate_limit_helper::check_rate_limit,
presentation::middleware::auth_middleware::AuthState,
};
#[allow(clippy::too_many_arguments)] pub async fn search(
Extension(search_service): Extension<Arc<dyn SearchServiceTrait>>,
Extension(task_repo): Extension<Arc<dyn TaskRepository>>,
Extension(rate_limiting_service): Extension<Arc<dyn RateLimitingService>>,
Extension(geo_restriction_repo): Extension<
Option<
Arc<
dyn crate::domain::repositories::geo_restriction_repository::GeoRestrictionRepository,
>,
>,
>,
Extension(auth_state): Extension<AuthState>,
Extension(locale): Extension<Locale>,
Extension(bundle): Extension<Arc<I18nBundle>>,
payload: Result<Json<SearchRequestDto>, axum::extract::rejection::JsonRejection>,
) -> impl IntoResponse {
let Json(payload) = match payload {
Ok(parsed) => parsed,
Err(ref rej) => return json_rejection_response(rej),
};
let team_id = auth_state.team_id;
let api_key_id = auth_state.api_key_id;
if let Err(response) =
check_rate_limit(rate_limiting_service.as_ref(), api_key_id, "/v1/search").await
{
return response;
}
let sync_wait_ms = payload
.sync_wait_ms
.unwrap_or(crawl_task::DEFAULT_TIMEOUT_MS as u32);
let mut search_query = into_search_query(payload);
if search_query.crawl_results == Some(true) {
let config = search_query.crawl_config.get_or_insert_with(
crate::domain::services::search_service::SearchCrawlConfig::default,
);
if config.max_depth > crate::domain::services::search_service::MAX_SEARCH_CRAWL_DEPTH {
return error_response(
StatusCode::BAD_REQUEST,
format!(
"crawl_config.max_depth must be <= {}",
crate::domain::services::search_service::MAX_SEARCH_CRAWL_DEPTH
),
);
}
if let Some(repo) = geo_restriction_repo.as_ref() {
match repo.get_team_restrictions(team_id).await {
Ok(restrictions) => match restrictions.effective_domain_blacklist() {
Ok(list) => config.domain_blacklist = list,
Err(message) => {
error!("Invalid team domain blacklist: {}", message);
return error_response(StatusCode::BAD_REQUEST, &message);
}
},
Err(e) => {
error!("Failed to load geo restrictions for search crawl: {}", e);
return error_response(
StatusCode::INTERNAL_SERVER_ERROR,
"Internal server error",
);
}
}
}
}
if let Some(response) = check_search_proxy_ssrf(&search_query, team_id, api_key_id).await {
return response;
}
match execute_search(
search_service.as_ref(),
task_repo.as_ref(),
team_id,
api_key_id,
search_query,
sync_wait_ms,
)
.await
{
Ok(response_dto) => success_response(StatusCode::OK, response_dto),
Err(e) => search_error_response(e, &locale, &bundle),
}
}
async fn execute_search(
search_service: &dyn SearchServiceTrait,
task_repo: &dyn TaskRepository,
team_id: crate::domain::id::Id,
api_key_id: crate::domain::id::Id,
search_query: SearchQuery,
sync_wait_ms: u32,
) -> Result<SearchResponseDto, SearchServiceError> {
let response = search_service
.search(team_id, api_key_id, search_query)
.await?;
await_search_crawl_tasks(task_repo, response.crawl_id, team_id, sync_wait_ms).await;
Ok(into_search_response_dto(response))
}
fn into_search_query(payload: SearchRequestDto) -> SearchQuery {
SearchQuery {
query: payload.query,
limit: payload.limit,
lang: payload.lang,
country: payload.country,
engine: payload.engine,
sources: payload.sources,
crawl_results: payload.crawl_results,
crawl_config: payload.crawl_config.map(|c| {
crate::domain::services::search_service::SearchCrawlConfig {
max_depth: c.max_depth,
include_patterns: c.include_patterns,
exclude_patterns: c.exclude_patterns,
strategy: c.strategy.unwrap_or_else(|| "bfs".to_string()),
crawl_delay_ms: c.crawl_delay_ms,
max_concurrency: c.max_concurrency.unwrap_or(10),
headers: c.headers,
proxy: c.proxy,
extraction_rules: c.extraction_rules,
domain_blacklist: Vec::new(),
}
}),
}
}
async fn check_search_proxy_ssrf(
search_query: &SearchQuery,
team_id: crate::domain::id::Id,
api_key_id: crate::domain::id::Id,
) -> Option<axum::response::Response> {
if let Some(ref config) = search_query.crawl_config {
if let Some(ref proxy_url) = config.proxy {
if let Some(response) = check_ssrf_url(proxy_url, team_id, api_key_id).await {
return Some(response);
}
}
}
None
}
async fn await_search_crawl_tasks(
task_repo: &dyn TaskRepository,
crawl_id: Option<crate::domain::id::Id>,
team_id: crate::domain::id::Id,
sync_wait_ms: u32,
) {
if sync_wait_ms == 0 {
return;
}
let Some(crawl_id) = crawl_id else {
return;
};
match task_repo.find_by_crawl_id(crawl_id).await {
Ok(tasks) => {
if !tasks.is_empty() {
let task_ids: Vec<crate::domain::id::Id> =
tasks.iter().map(|task| task.id).collect();
match wait_for_tasks_completion(
task_repo,
&task_ids,
team_id,
sync_wait_ms,
crawl_task::BASE_POLL_INTERVAL_MS,
)
.await
{
Ok(_) => {
}
Err(e) => {
error!("Failed to wait for task completion: {:?}", e);
}
}
}
}
Err(e) => {
error!("Failed to find tasks for crawl {}: {:?}", crawl_id, e);
}
}
}
fn into_search_response_dto(response: SearchResponse) -> SearchResponseDto {
SearchResponseDto {
query: response.query,
results: response
.results
.into_iter()
.map(|r| SearchResultDto {
title: r.title,
url: r.url,
description: r.description,
engine: Some(r.engine),
score: r.score,
})
.collect(),
crawl_id: response.crawl_id,
credits_used: response.credits_used,
}
}
fn search_error_response(
e: SearchServiceError,
locale: &Locale,
bundle: &Arc<I18nBundle>,
) -> axum::response::Response {
match e {
SearchServiceError::UnknownEngine(name) => {
let msg = crate::i18n::t_with_args(
locale,
bundle,
"search-error-unknown-engine",
&[("name", name.as_str().to_string())],
);
error_response(StatusCode::BAD_REQUEST, msg)
}
SearchServiceError::SmartSearchFailed(detail) => {
let msg = crate::i18n::t_with_args(
locale,
bundle,
"search-error-smart-search",
&[("message", detail.as_str().to_string())],
);
error_response(StatusCode::INTERNAL_SERVER_ERROR, msg)
}
other => {
let (status, msg): (StatusCode, String) = other.into();
error_response(status, msg)
}
}
}
impl From<SearchServiceError> for (StatusCode, String) {
fn from(err: SearchServiceError) -> Self {
match err {
SearchServiceError::ValidationError(details) => (StatusCode::BAD_REQUEST, details),
SearchServiceError::Repository(e) => (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()),
SearchServiceError::CreditsRepository(e) => {
(StatusCode::INTERNAL_SERVER_ERROR, e.to_string())
}
SearchServiceError::InsufficientCredits {
available,
required,
} => {
let details = format!(
"Insufficient credits: available {}, required {}",
available, required
);
(StatusCode::PAYMENT_REQUIRED, details)
}
SearchServiceError::SearchEngine(e) => (StatusCode::INTERNAL_SERVER_ERROR, e),
SearchServiceError::UnknownEngine(name) => (
StatusCode::BAD_REQUEST,
format!("unknown search engine: {name}"),
),
SearchServiceError::SmartSearchFailed(detail) => (
StatusCode::INTERNAL_SERVER_ERROR,
format!("smart search: {detail}"),
),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::domain::repositories::credits_repository::CreditsRepositoryError;
use crate::domain::repositories::task_repository::RepositoryError;
#[test]
fn test_validation_error_maps_to_bad_request() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = SearchServiceError::ValidationError("invalid query".to_string());
let (status, msg) = <(StatusCode, String)>::from(err);
assert_eq!(status, StatusCode::BAD_REQUEST);
assert_eq!(msg, "invalid query");
}
#[test]
fn test_repository_error_maps_to_internal_server_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = SearchServiceError::Repository(RepositoryError::Database(anyhow::anyhow!(
"db connection failed"
)));
let (status, msg) = <(StatusCode, String)>::from(err);
assert_eq!(status, StatusCode::INTERNAL_SERVER_ERROR);
assert!(msg.contains("db connection failed"));
}
#[test]
fn test_repository_not_found_maps_to_internal_server_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = SearchServiceError::Repository(RepositoryError::NotFound);
let (status, _msg) = <(StatusCode, String)>::from(err);
assert_eq!(status, StatusCode::INTERNAL_SERVER_ERROR);
}
#[test]
fn test_credits_repository_error_maps_to_internal_server_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = SearchServiceError::CreditsRepository(CreditsRepositoryError::DatabaseError(
"credits db error".to_string(),
));
let (status, msg) = <(StatusCode, String)>::from(err);
assert_eq!(status, StatusCode::INTERNAL_SERVER_ERROR);
assert!(msg.contains("credits db error"));
}
#[test]
fn test_credits_not_found_maps_to_internal_server_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let team_id = crate::domain::id::Id::generate();
let err =
SearchServiceError::CreditsRepository(CreditsRepositoryError::CreditsNotFound(team_id));
let (status, _msg) = <(StatusCode, String)>::from(err);
assert_eq!(status, StatusCode::INTERNAL_SERVER_ERROR);
}
#[test]
fn test_insufficient_credits_maps_to_payment_required() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = SearchServiceError::InsufficientCredits {
available: 5,
required: 10,
};
let (status, msg) = <(StatusCode, String)>::from(err);
assert_eq!(status, StatusCode::PAYMENT_REQUIRED);
assert!(msg.contains("Insufficient credits"));
assert!(msg.contains("available 5"));
assert!(msg.contains("required 10"));
}
#[test]
fn test_insufficient_credits_zero_available() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = SearchServiceError::InsufficientCredits {
available: 0,
required: 1,
};
let (status, msg) = <(StatusCode, String)>::from(err);
assert_eq!(status, StatusCode::PAYMENT_REQUIRED);
assert!(msg.contains("available 0"));
}
#[test]
fn test_search_engine_error_maps_to_internal_server_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = SearchServiceError::SearchEngine("rate limited by Google".to_string());
let (status, msg) = <(StatusCode, String)>::from(err);
assert_eq!(status, StatusCode::INTERNAL_SERVER_ERROR);
assert_eq!(msg, "rate limited by Google");
}
#[test]
fn test_search_request_dto_minimal() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let json = r#"{"query":"rust web scraping"}"#;
let dto: SearchRequestDto = serde_json::from_str(json).unwrap();
assert_eq!(dto.query, "rust web scraping");
assert!(dto.engine.is_none());
assert!(dto.sources.is_none());
assert!(dto.limit.is_none());
assert!(dto.lang.is_none());
assert!(dto.country.is_none());
assert!(dto.crawl_config.is_none());
assert!(dto.crawl_results.is_none());
assert!(dto.sync_wait_ms.is_none());
}
#[test]
fn test_search_request_dto_full() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let json = r#"{
"query": "rust async",
"engine": "google",
"sources": ["google", "bing"],
"limit": 10,
"lang": "en",
"country": "US",
"crawl_results": true,
"sync_wait_ms": 5000,
"crawl_config": {
"max_depth": 2,
"include_patterns": ["/blog/*"],
"exclude_patterns": ["/admin/*"],
"strategy": "bfs",
"crawl_delay_ms": 1000,
"max_concurrency": 5,
"proxy": "http://proxy:8080",
"headers": {"X-Custom": "value"}
}
}"#;
let dto: SearchRequestDto = serde_json::from_str(json).unwrap();
assert_eq!(dto.query, "rust async");
assert_eq!(dto.engine.as_deref(), Some("google"));
assert!(dto.sources.is_some());
assert_eq!(dto.sources.as_ref().unwrap().len(), 2);
assert_eq!(dto.limit, Some(10));
assert_eq!(dto.lang.as_deref(), Some("en"));
assert_eq!(dto.country.as_deref(), Some("US"));
assert_eq!(dto.crawl_results, Some(true));
assert_eq!(dto.sync_wait_ms, Some(5000));
assert!(dto.crawl_config.is_some());
}
#[test]
fn test_search_request_dto_deny_unknown_fields() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let json = r#"{"query":"test","unknown_field":42}"#;
let result: Result<SearchRequestDto, _> = serde_json::from_str(json);
assert!(result.is_err(), "unknown fields should be rejected");
}
#[test]
fn test_search_request_dto_with_sources_alias() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let json = r#"{"query":"test","sources":["google","bing","baidu"]}"#;
let dto: SearchRequestDto = serde_json::from_str(json).unwrap();
assert_eq!(dto.sources.as_ref().unwrap().len(), 3);
}
#[test]
fn test_search_request_dto_with_crawl_results_false() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let json = r#"{"query":"test","crawl_results":false}"#;
let dto: SearchRequestDto = serde_json::from_str(json).unwrap();
assert_eq!(dto.crawl_results, Some(false));
}
#[test]
fn test_search_request_dto_with_crawl_config_minimal() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let json = r#"{"query":"test","crawl_config":{"max_depth":1}}"#;
let dto: SearchRequestDto = serde_json::from_str(json).unwrap();
let config = dto.crawl_config.unwrap();
assert_eq!(config.max_depth, 1);
assert!(config.strategy.is_none());
assert!(config.max_concurrency.is_none());
}
#[test]
fn test_search_response_dto_construction() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let response = SearchResponseDto {
query: "test query".to_string(),
results: vec![],
crawl_id: None,
credits_used: 5,
};
let json = serde_json::to_string(&response).unwrap();
let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
assert_eq!(parsed["query"], "test query");
assert_eq!(parsed["results"].as_array().unwrap().len(), 0);
assert!(parsed["crawl_id"].is_null());
assert_eq!(parsed["credits_used"], 5);
}
#[test]
fn test_search_response_dto_with_results() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let response = SearchResponseDto {
query: "rust".to_string(),
results: vec![
SearchResultDto {
title: "Rust Programming".to_string(),
url: "https://rust-lang.org".to_string(),
description: Some("Official site".to_string()),
engine: Some("google".to_string()),
score: None,
},
SearchResultDto {
title: "Learn Rust".to_string(),
url: "https://doc.rust-lang.org".to_string(),
description: None,
engine: Some("bing".to_string()),
score: None,
},
],
crawl_id: Some(crate::domain::id::Id::generate()),
credits_used: 1,
};
let json = serde_json::to_string(&response).unwrap();
let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
assert_eq!(parsed["results"].as_array().unwrap().len(), 2);
assert_eq!(parsed["results"][0]["title"], "Rust Programming");
assert!(parsed["results"][1]["description"].is_null());
}
#[test]
fn test_search_result_dto_serialization() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let result = SearchResultDto {
title: "Test".to_string(),
url: "https://example.com".to_string(),
description: Some("A test result".to_string()),
engine: Some("google".to_string()),
score: None,
};
let json = serde_json::to_string(&result).unwrap();
let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
assert_eq!(parsed["title"], "Test");
assert_eq!(parsed["url"], "https://example.com");
assert_eq!(parsed["description"], "A test result");
assert_eq!(parsed["engine"], "google");
}
#[test]
fn test_search_result_dto_clone() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let result = SearchResultDto {
title: "Test".to_string(),
url: "https://example.com".to_string(),
description: None,
engine: None,
score: None,
};
let cloned = result.clone();
assert_eq!(result.title, cloned.title);
assert_eq!(result.url, cloned.url);
assert_eq!(result.description, cloned.description);
assert_eq!(result.engine, cloned.engine);
}
#[test]
fn test_search_result_dto_debug() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let result = SearchResultDto {
title: "Debug Test".to_string(),
url: "https://debug.com".to_string(),
description: Some("debugging".to_string()),
engine: Some("baidu".to_string()),
score: None,
};
let debug = format!("{:?}", result);
assert!(debug.contains("SearchResultDto"));
assert!(debug.contains("Debug Test"));
assert!(debug.contains("https://debug.com"));
}
#[test]
fn test_search_result_dto_deserialization() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let json = r#"{"title":"Test","url":"https://example.com","description":"desc","engine":"google"}"#;
let result: SearchResultDto = serde_json::from_str(json).unwrap();
assert_eq!(result.title, "Test");
assert_eq!(result.url, "https://example.com");
assert_eq!(result.description.as_deref(), Some("desc"));
assert_eq!(result.engine.as_deref(), Some("google"));
}
#[test]
fn test_search_result_dto_deserialization_without_optional_fields() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let json = r#"{"title":"Test","url":"https://example.com"}"#;
let result: SearchResultDto = serde_json::from_str(json).unwrap();
assert_eq!(result.title, "Test");
assert!(result.description.is_none());
assert!(result.engine.is_none());
}
#[test]
fn test_search_query_from_dto_no_crawl_config() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let dto = SearchRequestDto {
query: "test".to_string(),
engine: Some("google".to_string()),
sources: Some(vec!["google".to_string()]),
limit: Some(10),
lang: Some("en".to_string()),
country: Some("US".to_string()),
crawl_config: None,
crawl_results: Some(true),
sync_wait_ms: Some(5000),
};
let search_query = SearchQuery {
query: dto.query,
limit: dto.limit,
lang: dto.lang,
country: dto.country,
engine: dto.engine,
sources: dto.sources,
crawl_results: dto.crawl_results,
crawl_config: dto.crawl_config.map(|c| {
crate::domain::services::search_service::SearchCrawlConfig {
max_depth: c.max_depth,
include_patterns: c.include_patterns,
exclude_patterns: c.exclude_patterns,
strategy: c.strategy.unwrap_or_else(|| "bfs".to_string()),
crawl_delay_ms: c.crawl_delay_ms,
max_concurrency: c.max_concurrency.unwrap_or(10),
headers: c.headers,
proxy: c.proxy,
extraction_rules: c.extraction_rules,
domain_blacklist: Vec::new(),
}
}),
};
assert_eq!(search_query.query, "test");
assert!(search_query.crawl_config.is_none());
}
#[test]
fn test_search_query_from_dto_with_crawl_config_defaults() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let dto = SearchRequestDto {
query: "test".to_string(),
engine: None,
sources: None,
limit: None,
lang: None,
country: None,
crawl_config: Some(crate::application::dto::crawl_request::CrawlConfigDto {
max_depth: 3,
include_patterns: None,
exclude_patterns: None,
strategy: None, crawl_delay_ms: None,
max_concurrency: None, max_pages: None,
proxy: None,
headers: None,
extraction_rules: None,
extraction_prompt: None,
extraction_schema: None,
}),
crawl_results: None,
sync_wait_ms: None,
};
let search_query = SearchQuery {
query: dto.query,
limit: dto.limit,
lang: dto.lang,
country: dto.country,
engine: dto.engine,
sources: dto.sources,
crawl_results: dto.crawl_results,
crawl_config: dto.crawl_config.map(|c| {
crate::domain::services::search_service::SearchCrawlConfig {
max_depth: c.max_depth,
include_patterns: c.include_patterns,
exclude_patterns: c.exclude_patterns,
strategy: c.strategy.unwrap_or_else(|| "bfs".to_string()),
crawl_delay_ms: c.crawl_delay_ms,
max_concurrency: c.max_concurrency.unwrap_or(10),
headers: c.headers,
proxy: c.proxy,
extraction_rules: c.extraction_rules,
domain_blacklist: Vec::new(),
}
}),
};
let config = search_query.crawl_config.unwrap();
assert_eq!(config.max_depth, 3);
assert_eq!(config.strategy, "bfs"); assert_eq!(config.max_concurrency, 10); }
#[test]
fn test_search_query_from_dto_with_crawl_config_explicit_values() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let dto = SearchRequestDto {
query: "test".to_string(),
engine: None,
sources: None,
limit: None,
lang: None,
country: None,
crawl_config: Some(crate::application::dto::crawl_request::CrawlConfigDto {
max_depth: 5,
include_patterns: Some(vec!["/api/*".to_string()]),
exclude_patterns: Some(vec!["/admin/*".to_string()]),
strategy: Some("dfs".to_string()),
crawl_delay_ms: Some(2000),
max_concurrency: Some(20),
max_pages: None,
proxy: Some("http://proxy:8080".to_string()),
headers: Some(serde_json::json!({"Accept": "text/html"})),
extraction_rules: None,
extraction_prompt: None,
extraction_schema: None,
}),
crawl_results: None,
sync_wait_ms: None,
};
let search_query = SearchQuery {
query: dto.query,
limit: dto.limit,
lang: dto.lang,
country: dto.country,
engine: dto.engine,
sources: dto.sources,
crawl_results: dto.crawl_results,
crawl_config: dto.crawl_config.map(|c| {
crate::domain::services::search_service::SearchCrawlConfig {
max_depth: c.max_depth,
include_patterns: c.include_patterns,
exclude_patterns: c.exclude_patterns,
strategy: c.strategy.unwrap_or_else(|| "bfs".to_string()),
crawl_delay_ms: c.crawl_delay_ms,
max_concurrency: c.max_concurrency.unwrap_or(10),
headers: c.headers,
proxy: c.proxy,
extraction_rules: c.extraction_rules,
domain_blacklist: Vec::new(),
}
}),
};
let config = search_query.crawl_config.unwrap();
assert_eq!(config.max_depth, 5);
assert_eq!(config.strategy, "dfs"); assert_eq!(config.max_concurrency, 20); assert_eq!(config.crawl_delay_ms, Some(2000));
assert!(config.include_patterns.is_some());
assert!(config.exclude_patterns.is_some());
assert!(config.proxy.is_some());
assert!(config.headers.is_some());
}
#[test]
fn test_validation_error_empty_message() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = SearchServiceError::ValidationError(String::new());
let (status, msg) = <(StatusCode, String)>::from(err);
assert_eq!(status, StatusCode::BAD_REQUEST);
assert!(msg.is_empty());
}
#[test]
fn test_insufficient_credits_large_numbers() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = SearchServiceError::InsufficientCredits {
available: 999999,
required: 1000000,
};
let (status, msg) = <(StatusCode, String)>::from(err);
assert_eq!(status, StatusCode::PAYMENT_REQUIRED);
assert!(msg.contains("999999"));
assert!(msg.contains("1000000"));
}
#[test]
fn test_insufficient_credits_negative_available() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = SearchServiceError::InsufficientCredits {
available: -5,
required: 10,
};
let (status, msg) = <(StatusCode, String)>::from(err);
assert_eq!(status, StatusCode::PAYMENT_REQUIRED);
assert!(msg.contains("-5"));
}
#[test]
fn test_search_engine_error_empty_string() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = SearchServiceError::SearchEngine(String::new());
let (status, msg) = <(StatusCode, String)>::from(err);
assert_eq!(status, StatusCode::INTERNAL_SERVER_ERROR);
assert!(msg.is_empty());
}
#[test]
fn test_repository_error_not_found_variant() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = SearchServiceError::Repository(RepositoryError::NotFound);
let (status, _msg) = <(StatusCode, String)>::from(err);
assert_eq!(status, StatusCode::INTERNAL_SERVER_ERROR);
}
#[test]
fn test_credits_repository_insufficient_credits_variant() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let team_id = crate::domain::id::Id::generate();
let err =
SearchServiceError::CreditsRepository(CreditsRepositoryError::InsufficientCredits {
available: 0,
required: 10,
});
let (status, _msg) = <(StatusCode, String)>::from(err);
assert_eq!(status, StatusCode::INTERNAL_SERVER_ERROR);
let _ = team_id; }
#[test]
fn test_sync_wait_ms_default_when_none() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let dto = SearchRequestDto {
query: "test".to_string(),
engine: None,
sources: None,
limit: None,
lang: None,
country: None,
crawl_config: None,
crawl_results: None,
sync_wait_ms: None,
};
let sync_wait_ms = dto
.sync_wait_ms
.unwrap_or(crawl_task::DEFAULT_TIMEOUT_MS as u32);
assert_eq!(sync_wait_ms, 5000);
}
#[test]
fn test_sync_wait_ms_custom_when_some() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let dto = SearchRequestDto {
query: "test".to_string(),
engine: None,
sources: None,
limit: None,
lang: None,
country: None,
crawl_config: None,
crawl_results: None,
sync_wait_ms: Some(10000),
};
let sync_wait_ms = dto
.sync_wait_ms
.unwrap_or(crawl_task::DEFAULT_TIMEOUT_MS as u32);
assert_eq!(sync_wait_ms, 10000);
}
#[test]
fn test_sync_wait_ms_zero() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let dto = SearchRequestDto {
query: "test".to_string(),
engine: None,
sources: None,
limit: None,
lang: None,
country: None,
crawl_config: None,
crawl_results: None,
sync_wait_ms: Some(0),
};
let sync_wait_ms = dto
.sync_wait_ms
.unwrap_or(crawl_task::DEFAULT_TIMEOUT_MS as u32);
assert_eq!(sync_wait_ms, 0);
}
#[test]
fn test_search_response_dto_deserialization() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let json = r#"{"query":"test","results":[],"crawl_id":null,"credits_used":0}"#.to_string();
let dto: SearchResponseDto = serde_json::from_str(&json).unwrap();
assert_eq!(dto.query, "test");
assert!(dto.results.is_empty());
assert!(dto.crawl_id.is_none());
assert_eq!(dto.credits_used, 0);
}
#[test]
fn test_search_response_dto_with_crawl_id() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let crawl_id = crate::domain::id::Id::generate();
let json = format!(
r#"{{"query":"test","results":[],"crawl_id":"{}","credits_used":3}}"#,
crawl_id
);
let dto: SearchResponseDto = serde_json::from_str(&json).unwrap();
assert_eq!(dto.crawl_id, Some(crawl_id));
assert_eq!(dto.credits_used, 3);
}
#[test]
fn test_search_response_dto_with_results_deserialization() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let json = r#"{
"query": "rust",
"results": [
{"title":"Result 1","url":"https://1.com","description":"desc 1","engine":"google"},
{"title":"Result 2","url":"https://2.com","description":null,"engine":"bing"}
],
"crawl_id": null,
"credits_used": 2
}"#;
let dto: SearchResponseDto = serde_json::from_str(json).unwrap();
assert_eq!(dto.query, "rust");
assert_eq!(dto.results.len(), 2);
assert_eq!(dto.results[0].title, "Result 1");
assert_eq!(dto.results[1].description, None);
}
#[test]
fn test_search_response_dto_serialization_roundtrip() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let original = SearchResponseDto {
query: "roundtrip test".to_string(),
results: vec![SearchResultDto {
title: "Title".to_string(),
url: "https://example.com".to_string(),
description: Some("Desc".to_string()),
engine: Some("google".to_string()),
score: None,
}],
crawl_id: Some(crate::domain::id::Id::generate()),
credits_used: 7,
};
let json = serde_json::to_string(&original).unwrap();
let deserialized: SearchResponseDto = serde_json::from_str(&json).unwrap();
assert_eq!(deserialized.query, original.query);
assert_eq!(deserialized.results.len(), 1);
assert_eq!(deserialized.results[0].title, "Title");
assert_eq!(deserialized.credits_used, 7);
}
#[test]
fn test_search_service_error_validation_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = SearchServiceError::ValidationError("bad query".to_string());
let display = format!("{}", err);
assert!(display.contains("bad query"));
}
#[test]
fn test_search_service_error_insufficient_credits_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = SearchServiceError::InsufficientCredits {
available: 5,
required: 10,
};
let display = format!("{}", err);
assert!(display.contains("5") || display.contains("10") || display.contains("credit"));
}
#[test]
fn test_search_service_error_search_engine_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = SearchServiceError::SearchEngine("engine timeout".to_string());
let display = format!("{}", err);
assert!(display.contains("engine timeout"));
}
#[test]
fn test_search_request_dto_empty_query() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let json = r#"{"query":""}"#;
let dto: SearchRequestDto = serde_json::from_str(json).unwrap();
assert_eq!(dto.query, "");
}
#[test]
fn test_search_request_dto_long_query() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let long_query = "a".repeat(1000);
let json = serde_json::json!({ "query": long_query }).to_string();
let dto: SearchRequestDto = serde_json::from_str(&json).unwrap();
assert_eq!(dto.query.len(), 1000);
}
#[test]
fn test_search_request_dto_with_unicode_query() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let json = r#"{"query":"中文搜索 日本語 한국어"}"#;
let dto: SearchRequestDto = serde_json::from_str(json).unwrap();
assert!(dto.query.contains("中文"));
assert!(dto.query.contains("日本語"));
}
#[test]
fn test_search_request_dto_with_special_chars_query() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let json = r#"{"query":"test \"quotes\" & <html>"}"#;
let dto: SearchRequestDto = serde_json::from_str(json).unwrap();
assert!(dto.query.contains("quotes"));
assert!(dto.query.contains("<html>"));
}
#[test]
fn test_search_request_dto_with_limit_zero() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let json = r#"{"query":"test","limit":0}"#;
let dto: SearchRequestDto = serde_json::from_str(json).unwrap();
assert_eq!(dto.limit, Some(0));
}
#[test]
fn test_search_request_dto_with_large_limit() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let json = r#"{"query":"test","limit":4294967295}"#;
let dto: SearchRequestDto = serde_json::from_str(json).unwrap();
assert_eq!(dto.limit, Some(u32::MAX));
}
#[test]
fn test_search_query_all_none() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let search_query = SearchQuery {
query: "minimal".to_string(),
limit: None,
lang: None,
country: None,
engine: None,
sources: None,
crawl_results: None,
crawl_config: None,
};
assert_eq!(search_query.query, "minimal");
assert!(search_query.limit.is_none());
assert!(search_query.crawl_config.is_none());
}
#[test]
fn test_search_query_from_dto_with_crawl_config_extraction_rules() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let dto = SearchRequestDto {
query: "test".to_string(),
engine: None,
sources: None,
limit: None,
lang: None,
country: None,
crawl_config: Some(crate::application::dto::crawl_request::CrawlConfigDto {
max_depth: 2,
include_patterns: None,
exclude_patterns: None,
strategy: None,
crawl_delay_ms: None,
max_concurrency: None,
max_pages: None,
proxy: None,
headers: None,
extraction_rules: Some(std::collections::HashMap::new()),
extraction_prompt: None,
extraction_schema: None,
}),
crawl_results: None,
sync_wait_ms: None,
};
let search_query = SearchQuery {
query: dto.query,
limit: dto.limit,
lang: dto.lang,
country: dto.country,
engine: dto.engine,
sources: dto.sources,
crawl_results: dto.crawl_results,
crawl_config: dto.crawl_config.map(|c| {
crate::domain::services::search_service::SearchCrawlConfig {
max_depth: c.max_depth,
include_patterns: c.include_patterns,
exclude_patterns: c.exclude_patterns,
strategy: c.strategy.unwrap_or_else(|| "bfs".to_string()),
crawl_delay_ms: c.crawl_delay_ms,
max_concurrency: c.max_concurrency.unwrap_or(10),
headers: c.headers,
proxy: c.proxy,
extraction_rules: c.extraction_rules,
domain_blacklist: Vec::new(),
}
}),
};
let config = search_query.crawl_config.unwrap();
assert_eq!(config.max_depth, 2);
assert_eq!(config.strategy, "bfs"); assert_eq!(config.max_concurrency, 10); assert!(config.extraction_rules.is_some());
}
#[test]
fn test_search_request_dto_with_multiple_sources() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let json = r#"{
"query": "test",
"sources": ["google", "bing", "baidu", "sogou"]
}"#;
let dto: SearchRequestDto = serde_json::from_str(json).unwrap();
assert_eq!(dto.sources.as_ref().unwrap().len(), 4);
}
#[test]
fn test_search_request_dto_crawl_results_false_no_crawl_config() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let json = r#"{"query":"test","crawl_results":false}"#;
let dto: SearchRequestDto = serde_json::from_str(json).unwrap();
assert_eq!(dto.crawl_results, Some(false));
assert!(dto.crawl_config.is_none());
}
#[test]
fn test_validation_error_with_special_characters() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = SearchServiceError::ValidationError("error with <>&\"".to_string());
let (status, msg) = <(StatusCode, String)>::from(err);
assert_eq!(status, StatusCode::BAD_REQUEST);
assert!(msg.contains("<"));
assert!(msg.contains(">"));
}
#[test]
fn test_search_engine_error_with_url() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err =
SearchServiceError::SearchEngine("failed to fetch https://google.com".to_string());
let (status, msg) = <(StatusCode, String)>::from(err);
assert_eq!(status, StatusCode::INTERNAL_SERVER_ERROR);
assert!(msg.contains("https://google.com"));
}
#[test]
fn test_search_response_dto_empty_results() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let response = SearchResponseDto {
query: "empty".to_string(),
results: vec![],
crawl_id: None,
credits_used: 0,
};
let json = serde_json::to_string(&response).unwrap();
let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
assert_eq!(parsed["results"].as_array().unwrap().len(), 0);
}
#[test]
fn test_search_request_dto_serialization() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let dto = SearchRequestDto {
query: "serialize test".to_string(),
engine: Some("google".to_string()),
sources: Some(vec!["google".to_string()]),
limit: Some(10),
lang: Some("en".to_string()),
country: Some("US".to_string()),
crawl_config: None,
crawl_results: Some(true),
sync_wait_ms: Some(3000),
};
let json = serde_json::to_string(&dto).unwrap();
let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
assert_eq!(parsed["query"], "serialize test");
assert_eq!(parsed["engine"], "google");
assert_eq!(parsed["limit"], 10);
assert_eq!(parsed["crawl_results"], true);
assert_eq!(parsed["sync_wait_ms"], 3000);
}
use crate::domain::auth::ApiKeyScope;
use crate::domain::models::{CreditsTransactionType, Task, TaskStatus, TaskType};
use crate::domain::repositories::task_repository::{TaskQueryParams, TaskRepository};
use crate::domain::services::rate_limiting_service::{
BacklogService, ConcurrencyConfig, ConcurrencyControlService, ConcurrencyResult,
QuotaService, RateLimitConfig, RateLimitResult, RateLimitService, RateLimitingError,
RateLimitingService,
};
use crate::domain::services::search_service::{
SearchResponse as DomainSearchResponse, SearchResult as DomainSearchResult,
SearchServiceTrait,
};
use async_trait::async_trait;
use dbnexus::DbPool;
use std::collections::HashSet;
use std::sync::Mutex;
fn make_test_db_pool() -> Arc<DbPool> {
crate::common::test_helpers::create_test_db_pool()
}
fn make_test_auth_state() -> AuthState {
AuthState::new(
make_test_db_pool(),
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
ApiKeyScope::default(),
)
}
fn test_locale() -> Locale {
"en-US".parse().unwrap()
}
fn test_bundle() -> Arc<I18nBundle> {
Arc::new(I18nBundle::load("en-US", &["en-US", "zh-CN"]).unwrap())
}
fn make_search_response(crawl_id: Option<crate::domain::id::Id>) -> DomainSearchResponse {
DomainSearchResponse {
query: "test query".to_string(),
results: vec![DomainSearchResult {
title: "Test Result".to_string(),
url: "https://example.com".to_string(),
description: Some("Test description".to_string()),
engine: "google".to_string(),
score: None,
}],
crawl_id,
credits_used: 1,
}
}
fn make_search_request_dto(sync_wait_ms: Option<u32>) -> SearchRequestDto {
SearchRequestDto {
query: "test query".to_string(),
engine: None,
sources: None,
limit: None,
lang: None,
country: None,
crawl_config: None,
crawl_results: None,
sync_wait_ms,
}
}
fn make_test_task(team_id: crate::domain::id::Id, status: TaskStatus) -> Task {
let now = chrono::Utc::now();
Task {
id: crate::domain::id::Id::generate(),
task_type: TaskType::Scrape,
status,
priority: 0,
team_id,
api_key_id: crate::domain::id::Id::generate(),
url: "https://example.com".to_string(),
payload: serde_json::Value::Null,
retry_count: 0,
attempt_count: 0,
max_retries: 3,
scheduled_at: None,
expires_at: None,
created_at: now,
started_at: None,
completed_at: None,
crawl_id: None,
updated_at: now,
lock_token: None,
lock_expires_at: None,
}
}
struct MockSearchService {
search_result: Mutex<Option<Result<DomainSearchResponse, SearchServiceError>>>,
}
impl MockSearchService {
fn new_success(response: DomainSearchResponse) -> Self {
Self {
search_result: Mutex::new(Some(Ok(response))),
}
}
fn new_error(err: SearchServiceError) -> Self {
Self {
search_result: Mutex::new(Some(Err(err))),
}
}
fn new_unused() -> Self {
Self {
search_result: Mutex::new(None),
}
}
}
#[async_trait]
impl SearchServiceTrait for MockSearchService {
async fn search(
&self,
_team_id: crate::domain::id::Id,
_api_key_id: crate::domain::id::Id,
_query: SearchQuery,
) -> Result<DomainSearchResponse, SearchServiceError> {
self.search_result
.lock()
.unwrap()
.take()
.expect("MockSearchService::search called but no result configured")
}
}
#[allow(clippy::type_complexity)]
struct MockTaskRepository {
find_by_crawl_id_result: Mutex<Option<Result<Vec<Task>, RepositoryError>>>,
query_tasks_result: Mutex<Option<Result<(Vec<Task>, u64), RepositoryError>>>,
}
impl MockTaskRepository {
fn new() -> Self {
Self {
find_by_crawl_id_result: Mutex::new(None),
query_tasks_result: Mutex::new(None),
}
}
fn with_find_by_crawl_id(result: Result<Vec<Task>, RepositoryError>) -> Self {
Self {
find_by_crawl_id_result: Mutex::new(Some(result)),
query_tasks_result: Mutex::new(None),
}
}
#[allow(dead_code)]
fn with_query_tasks(result: Result<(Vec<Task>, u64), RepositoryError>) -> Self {
Self {
find_by_crawl_id_result: Mutex::new(None),
query_tasks_result: Mutex::new(Some(result)),
}
}
fn with_find_and_query(
find_result: Result<Vec<Task>, RepositoryError>,
query_result: Result<(Vec<Task>, u64), RepositoryError>,
) -> Self {
Self {
find_by_crawl_id_result: Mutex::new(Some(find_result)),
query_tasks_result: Mutex::new(Some(query_result)),
}
}
}
#[async_trait]
impl TaskRepository for MockTaskRepository {
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> {
match self.find_by_crawl_id_result.lock().unwrap().take() {
Some(result) => result,
None => Ok(vec![]),
}
}
async fn query_tasks(
&self,
_params: TaskQueryParams,
) -> Result<(Vec<Task>, u64), RepositoryError> {
match self.query_tasks_result.lock().unwrap().take() {
Some(result) => result,
None => 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 MockRateLimitingService {
rate_limit_result: RateLimitResult,
}
impl MockRateLimitingService {
fn new_allowed() -> Self {
Self {
rate_limit_result: RateLimitResult::Allowed,
}
}
fn new_denied(reason: &str) -> Self {
Self {
rate_limit_result: RateLimitResult::Denied {
reason: reason.to_string(),
},
}
}
fn new_retry_after(seconds: u64) -> Self {
Self {
rate_limit_result: RateLimitResult::RetryAfter {
retry_after_seconds: seconds,
},
}
}
}
#[async_trait]
impl RateLimitService for MockRateLimitingService {
async fn check_rate_limit(
&self,
_api_key: &str,
_endpoint: &str,
) -> Result<RateLimitResult, RateLimitingError> {
Ok(self.rate_limit_result.clone())
}
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 MockRateLimitingService {
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 MockRateLimitingService {
async fn process_backlog_tasks(
&self,
_team_id: crate::domain::id::Id,
) -> Result<u32, RateLimitingError> {
Ok(0)
}
}
#[async_trait]
impl QuotaService for MockRateLimitingService {
async fn check_and_deduct_quota(
&self,
_team_id: crate::domain::id::Id,
_amount: i64,
_transaction_type: 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(0)
}
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(())
}
}
impl RateLimitingService for MockRateLimitingService {}
#[tokio::test]
async fn test_search_handler_success_no_crawl_id() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let search_service: Arc<dyn SearchServiceTrait> =
Arc::new(MockSearchService::new_success(make_search_response(None)));
let task_repo: Arc<dyn TaskRepository> = Arc::new(MockTaskRepository::new());
let rate_limit: Arc<dyn RateLimitingService> =
Arc::new(MockRateLimitingService::new_allowed());
let auth = make_test_auth_state();
let response = search(
Extension(search_service),
Extension(task_repo),
Extension(rate_limit),
Extension(None::<
Arc<dyn crate::domain::repositories::geo_restriction_repository::GeoRestrictionRepository>,
>),
Extension(auth),
Extension(test_locale()),
Extension(test_bundle()),
Ok(Json(make_search_request_dto(Some(5000)))),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::OK);
}
#[tokio::test]
async fn test_search_handler_success_sync_wait_zero() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let search_service: Arc<dyn SearchServiceTrait> = Arc::new(MockSearchService::new_success(
make_search_response(Some(crate::domain::id::Id::generate())),
));
let task_repo: Arc<dyn TaskRepository> = Arc::new(MockTaskRepository::new());
let rate_limit: Arc<dyn RateLimitingService> =
Arc::new(MockRateLimitingService::new_allowed());
let auth = make_test_auth_state();
let response = search(
Extension(search_service),
Extension(task_repo),
Extension(rate_limit),
Extension(None::<
Arc<dyn crate::domain::repositories::geo_restriction_repository::GeoRestrictionRepository>,
>),
Extension(auth),
Extension(test_locale()),
Extension(test_bundle()),
Ok(Json(make_search_request_dto(Some(0)))),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::OK);
}
#[tokio::test]
async fn test_search_handler_success_crawl_id_empty_tasks() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let crawl_id = crate::domain::id::Id::generate();
let search_service: Arc<dyn SearchServiceTrait> = Arc::new(MockSearchService::new_success(
make_search_response(Some(crawl_id)),
));
let task_repo: Arc<dyn TaskRepository> = Arc::new(MockTaskRepository::new());
let rate_limit: Arc<dyn RateLimitingService> =
Arc::new(MockRateLimitingService::new_allowed());
let auth = make_test_auth_state();
let response = search(
Extension(search_service),
Extension(task_repo),
Extension(rate_limit),
Extension(None::<
Arc<dyn crate::domain::repositories::geo_restriction_repository::GeoRestrictionRepository>,
>),
Extension(auth),
Extension(test_locale()),
Extension(test_bundle()),
Ok(Json(make_search_request_dto(Some(5000)))),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::OK);
}
#[tokio::test]
async fn test_search_handler_success_crawl_id_with_completed_tasks() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let team_id = crate::domain::id::Id::generate();
let crawl_id = crate::domain::id::Id::generate();
let task = make_test_task(team_id, TaskStatus::Completed);
let search_service: Arc<dyn SearchServiceTrait> = Arc::new(MockSearchService::new_success(
make_search_response(Some(crawl_id)),
));
let task_repo: Arc<dyn TaskRepository> = Arc::new(MockTaskRepository::with_find_and_query(
Ok(vec![task.clone()]),
Ok((vec![task], 1)),
));
let rate_limit: Arc<dyn RateLimitingService> =
Arc::new(MockRateLimitingService::new_allowed());
let auth = make_test_auth_state();
let response = search(
Extension(search_service),
Extension(task_repo),
Extension(rate_limit),
Extension(None::<
Arc<dyn crate::domain::repositories::geo_restriction_repository::GeoRestrictionRepository>,
>),
Extension(auth),
Extension(test_locale()),
Extension(test_bundle()),
Ok(Json(make_search_request_dto(Some(5000)))),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::OK);
}
#[tokio::test]
async fn test_search_handler_success_find_by_crawl_id_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let crawl_id = crate::domain::id::Id::generate();
let search_service: Arc<dyn SearchServiceTrait> = Arc::new(MockSearchService::new_success(
make_search_response(Some(crawl_id)),
));
let task_repo: Arc<dyn TaskRepository> =
Arc::new(MockTaskRepository::with_find_by_crawl_id(Err(
RepositoryError::Database(anyhow::anyhow!("find_by_crawl_id failed")),
)));
let rate_limit: Arc<dyn RateLimitingService> =
Arc::new(MockRateLimitingService::new_allowed());
let auth = make_test_auth_state();
let response = search(
Extension(search_service),
Extension(task_repo),
Extension(rate_limit),
Extension(None::<
Arc<dyn crate::domain::repositories::geo_restriction_repository::GeoRestrictionRepository>,
>),
Extension(auth),
Extension(test_locale()),
Extension(test_bundle()),
Ok(Json(make_search_request_dto(Some(5000)))),
)
.await
.into_response();
assert_eq!(
response.status(),
StatusCode::OK,
"find_by_crawl_id error should be logged but not fail the request"
);
}
#[tokio::test]
async fn test_search_handler_success_wait_for_tasks_completion_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let team_id = crate::domain::id::Id::generate();
let crawl_id = crate::domain::id::Id::generate();
let task = make_test_task(team_id, TaskStatus::Queued);
let search_service: Arc<dyn SearchServiceTrait> = Arc::new(MockSearchService::new_success(
make_search_response(Some(crawl_id)),
));
let task_repo: Arc<dyn TaskRepository> = Arc::new(MockTaskRepository::with_find_and_query(
Ok(vec![task]),
Err(RepositoryError::Database(anyhow::anyhow!(
"query_tasks failed"
))),
));
let rate_limit: Arc<dyn RateLimitingService> =
Arc::new(MockRateLimitingService::new_allowed());
let auth = make_test_auth_state();
let response = search(
Extension(search_service),
Extension(task_repo),
Extension(rate_limit),
Extension(None::<
Arc<dyn crate::domain::repositories::geo_restriction_repository::GeoRestrictionRepository>,
>),
Extension(auth),
Extension(test_locale()),
Extension(test_bundle()),
Ok(Json(make_search_request_dto(Some(5000)))),
)
.await
.into_response();
assert_eq!(
response.status(),
StatusCode::OK,
"wait_for_tasks_completion error should be logged but not fail the request"
);
}
#[tokio::test]
async fn test_search_handler_success_default_sync_wait_ms() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let search_service: Arc<dyn SearchServiceTrait> =
Arc::new(MockSearchService::new_success(make_search_response(None)));
let task_repo: Arc<dyn TaskRepository> = Arc::new(MockTaskRepository::new());
let rate_limit: Arc<dyn RateLimitingService> =
Arc::new(MockRateLimitingService::new_allowed());
let auth = make_test_auth_state();
let response = search(
Extension(search_service),
Extension(task_repo),
Extension(rate_limit),
Extension(None::<
Arc<dyn crate::domain::repositories::geo_restriction_repository::GeoRestrictionRepository>,
>),
Extension(auth),
Extension(test_locale()),
Extension(test_bundle()),
Ok(Json(make_search_request_dto(None))),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::OK);
}
#[tokio::test]
async fn test_search_handler_rate_limited_denied() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let search_service: Arc<dyn SearchServiceTrait> = Arc::new(MockSearchService::new_unused());
let task_repo: Arc<dyn TaskRepository> = Arc::new(MockTaskRepository::new());
let rate_limit: Arc<dyn RateLimitingService> =
Arc::new(MockRateLimitingService::new_denied("too many requests"));
let auth = make_test_auth_state();
let response = search(
Extension(search_service),
Extension(task_repo),
Extension(rate_limit),
Extension(None::<
Arc<dyn crate::domain::repositories::geo_restriction_repository::GeoRestrictionRepository>,
>),
Extension(auth),
Extension(test_locale()),
Extension(test_bundle()),
Ok(Json(make_search_request_dto(Some(5000)))),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::TOO_MANY_REQUESTS);
}
#[tokio::test]
async fn test_search_handler_rate_limited_retry_after() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let search_service: Arc<dyn SearchServiceTrait> = Arc::new(MockSearchService::new_unused());
let task_repo: Arc<dyn TaskRepository> = Arc::new(MockTaskRepository::new());
let rate_limit: Arc<dyn RateLimitingService> =
Arc::new(MockRateLimitingService::new_retry_after(30));
let auth = make_test_auth_state();
let response = search(
Extension(search_service),
Extension(task_repo),
Extension(rate_limit),
Extension(None::<
Arc<dyn crate::domain::repositories::geo_restriction_repository::GeoRestrictionRepository>,
>),
Extension(auth),
Extension(test_locale()),
Extension(test_bundle()),
Ok(Json(make_search_request_dto(Some(5000)))),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::TOO_MANY_REQUESTS);
}
#[tokio::test]
async fn test_search_handler_validation_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let search_service: Arc<dyn SearchServiceTrait> = Arc::new(MockSearchService::new_error(
SearchServiceError::ValidationError("invalid query".to_string()),
));
let task_repo: Arc<dyn TaskRepository> = Arc::new(MockTaskRepository::new());
let rate_limit: Arc<dyn RateLimitingService> =
Arc::new(MockRateLimitingService::new_allowed());
let auth = make_test_auth_state();
let response = search(
Extension(search_service),
Extension(task_repo),
Extension(rate_limit),
Extension(None::<
Arc<dyn crate::domain::repositories::geo_restriction_repository::GeoRestrictionRepository>,
>),
Extension(auth),
Extension(test_locale()),
Extension(test_bundle()),
Ok(Json(make_search_request_dto(Some(5000)))),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
}
#[tokio::test]
async fn test_search_handler_insufficient_credits() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let search_service: Arc<dyn SearchServiceTrait> = Arc::new(MockSearchService::new_error(
SearchServiceError::InsufficientCredits {
available: 0,
required: 1,
},
));
let task_repo: Arc<dyn TaskRepository> = Arc::new(MockTaskRepository::new());
let rate_limit: Arc<dyn RateLimitingService> =
Arc::new(MockRateLimitingService::new_allowed());
let auth = make_test_auth_state();
let response = search(
Extension(search_service),
Extension(task_repo),
Extension(rate_limit),
Extension(None::<
Arc<dyn crate::domain::repositories::geo_restriction_repository::GeoRestrictionRepository>,
>),
Extension(auth),
Extension(test_locale()),
Extension(test_bundle()),
Ok(Json(make_search_request_dto(Some(5000)))),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::PAYMENT_REQUIRED);
}
#[tokio::test]
async fn test_search_handler_search_engine_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let search_service: Arc<dyn SearchServiceTrait> = Arc::new(MockSearchService::new_error(
SearchServiceError::SearchEngine("engine timeout".to_string()),
));
let task_repo: Arc<dyn TaskRepository> = Arc::new(MockTaskRepository::new());
let rate_limit: Arc<dyn RateLimitingService> =
Arc::new(MockRateLimitingService::new_allowed());
let auth = make_test_auth_state();
let response = search(
Extension(search_service),
Extension(task_repo),
Extension(rate_limit),
Extension(None::<
Arc<dyn crate::domain::repositories::geo_restriction_repository::GeoRestrictionRepository>,
>),
Extension(auth),
Extension(test_locale()),
Extension(test_bundle()),
Ok(Json(make_search_request_dto(Some(5000)))),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
}
#[tokio::test]
async fn test_search_handler_repository_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let search_service: Arc<dyn SearchServiceTrait> = Arc::new(MockSearchService::new_error(
SearchServiceError::Repository(RepositoryError::Database(anyhow::anyhow!(
"db connection failed"
))),
));
let task_repo: Arc<dyn TaskRepository> = Arc::new(MockTaskRepository::new());
let rate_limit: Arc<dyn RateLimitingService> =
Arc::new(MockRateLimitingService::new_allowed());
let auth = make_test_auth_state();
let response = search(
Extension(search_service),
Extension(task_repo),
Extension(rate_limit),
Extension(None::<
Arc<dyn crate::domain::repositories::geo_restriction_repository::GeoRestrictionRepository>,
>),
Extension(auth),
Extension(test_locale()),
Extension(test_bundle()),
Ok(Json(make_search_request_dto(Some(5000)))),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
}
#[tokio::test]
async fn test_search_handler_credits_repository_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let search_service: Arc<dyn SearchServiceTrait> = Arc::new(MockSearchService::new_error(
SearchServiceError::CreditsRepository(CreditsRepositoryError::DatabaseError(
"credits db error".to_string(),
)),
));
let task_repo: Arc<dyn TaskRepository> = Arc::new(MockTaskRepository::new());
let rate_limit: Arc<dyn RateLimitingService> =
Arc::new(MockRateLimitingService::new_allowed());
let auth = make_test_auth_state();
let response = search(
Extension(search_service),
Extension(task_repo),
Extension(rate_limit),
Extension(None::<
Arc<dyn crate::domain::repositories::geo_restriction_repository::GeoRestrictionRepository>,
>),
Extension(auth),
Extension(test_locale()),
Extension(test_bundle()),
Ok(Json(make_search_request_dto(Some(5000)))),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
}
#[tokio::test]
async fn test_search_handler_repository_not_found_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let search_service: Arc<dyn SearchServiceTrait> = Arc::new(MockSearchService::new_error(
SearchServiceError::Repository(RepositoryError::NotFound),
));
let task_repo: Arc<dyn TaskRepository> = Arc::new(MockTaskRepository::new());
let rate_limit: Arc<dyn RateLimitingService> =
Arc::new(MockRateLimitingService::new_allowed());
let auth = make_test_auth_state();
let response = search(
Extension(search_service),
Extension(task_repo),
Extension(rate_limit),
Extension(None::<
Arc<dyn crate::domain::repositories::geo_restriction_repository::GeoRestrictionRepository>,
>),
Extension(auth),
Extension(test_locale()),
Extension(test_bundle()),
Ok(Json(make_search_request_dto(Some(5000)))),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
}
#[tokio::test]
async fn test_search_handler_credits_not_found_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let team_id = crate::domain::id::Id::generate();
let search_service: Arc<dyn SearchServiceTrait> = Arc::new(MockSearchService::new_error(
SearchServiceError::CreditsRepository(CreditsRepositoryError::CreditsNotFound(team_id)),
));
let task_repo: Arc<dyn TaskRepository> = Arc::new(MockTaskRepository::new());
let rate_limit: Arc<dyn RateLimitingService> =
Arc::new(MockRateLimitingService::new_allowed());
let auth = make_test_auth_state();
let response = search(
Extension(search_service),
Extension(task_repo),
Extension(rate_limit),
Extension(None::<
Arc<dyn crate::domain::repositories::geo_restriction_repository::GeoRestrictionRepository>,
>),
Extension(auth),
Extension(test_locale()),
Extension(test_bundle()),
Ok(Json(make_search_request_dto(Some(5000)))),
)
.await
.into_response();
assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
}
}