pub(crate) use super::task_commands::cancel_tasks;
pub(crate) use super::task_queries::{query_tasks, wait_for_tasks_completion};
#[cfg(test)]
mod tests {
use super::super::task_queries::{
handle_sync_wait_and_get_status, SyncWaitResult, TaskQueryResponseMeta,
};
use super::*;
use super::super::task_queries::{
apply_defaults, build_scrape_result_json, build_task_infos, calculate_completion_rate,
calculate_next_interval, execute_task_query, fetch_scrape_results, handle_sync_wait,
poll_count_exceeded, query_tasks_for_poll, validate_request,
};
use crate::application::dto::task_query_request::{TaskCancelRequestDto, TaskQueryRequestDto};
use crate::common::constants::crawl_task;
use crate::common::constants::server_config;
use crate::domain::auth::ApiKeyScope;
use crate::domain::models::{Task, TaskStatus, TaskType};
use crate::domain::repositories::task_repository::RepositoryError;
use crate::domain::repositories::task_repository::{TaskQueryParams, TaskRepository};
use crate::infrastructure::repositories::scrape_result_repo_impl::ScrapeResultRepositoryImpl;
use crate::presentation::errors::CrawlRsError;
use crate::presentation::middleware::auth_middleware::AuthState;
use async_trait::async_trait;
use axum::{extract::Extension, Json};
use dbnexus::DbPool;
use std::sync::{Arc, Mutex};
fn make_test_task(id: crate::domain::id::Id, status: TaskStatus) -> Task {
let now = chrono::Utc::now();
Task {
id,
task_type: TaskType::Scrape,
status,
priority: 0,
team_id: crate::domain::id::Id::generate(),
api_key_id: crate::domain::id::Id::generate(),
url: "https://example.com".to_string(),
payload: serde_json::json!({}),
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,
}
}
#[test]
fn test_poll_count_exceeded_true_when_count_equals_max() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
assert!(poll_count_exceeded(60, 60));
}
#[test]
fn test_poll_count_exceeded_true_when_count_exceeds_max() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
assert!(poll_count_exceeded(100, 60));
}
#[test]
fn test_poll_count_exceeded_false_when_count_below_max() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
assert!(!poll_count_exceeded(59, 60));
}
#[test]
fn test_poll_count_exceeded_false_when_count_zero() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
assert!(!poll_count_exceeded(0, 60));
}
#[test]
fn test_poll_count_exceeded_with_max_one() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
assert!(poll_count_exceeded(1, 1));
assert!(!poll_count_exceeded(0, 1));
}
#[test]
fn test_completion_rate_empty_task_ids_returns_one() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let tasks = vec![];
let task_ids: Vec<crate::domain::id::Id> = vec![];
assert_eq!(calculate_completion_rate(&tasks, &task_ids), 1.0);
}
#[test]
fn test_completion_rate_all_completed() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let id1 = crate::domain::id::Id::generate();
let id2 = crate::domain::id::Id::generate();
let tasks = vec![
make_test_task(id1, TaskStatus::Completed),
make_test_task(id2, TaskStatus::Completed),
];
let task_ids = vec![id1, id2];
assert_eq!(calculate_completion_rate(&tasks, &task_ids), 1.0);
}
#[test]
fn test_completion_rate_none_completed() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let id1 = crate::domain::id::Id::generate();
let id2 = crate::domain::id::Id::generate();
let tasks = vec![
make_test_task(id1, TaskStatus::Queued),
make_test_task(id2, TaskStatus::Active),
];
let task_ids = vec![id1, id2];
assert_eq!(calculate_completion_rate(&tasks, &task_ids), 0.0);
}
#[test]
fn test_completion_rate_half_completed() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let id1 = crate::domain::id::Id::generate();
let id2 = crate::domain::id::Id::generate();
let tasks = vec![
make_test_task(id1, TaskStatus::Completed),
make_test_task(id2, TaskStatus::Active),
];
let task_ids = vec![id1, id2];
assert_eq!(calculate_completion_rate(&tasks, &task_ids), 0.5);
}
#[test]
fn test_completion_rate_counts_failed_as_completed() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let id1 = crate::domain::id::Id::generate();
let tasks = vec![make_test_task(id1, TaskStatus::Failed)];
let task_ids = vec![id1];
assert_eq!(calculate_completion_rate(&tasks, &task_ids), 1.0);
}
#[test]
fn test_completion_rate_counts_cancelled_as_completed() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let id1 = crate::domain::id::Id::generate();
let tasks = vec![make_test_task(id1, TaskStatus::Cancelled)];
let task_ids = vec![id1];
assert_eq!(calculate_completion_rate(&tasks, &task_ids), 1.0);
}
#[test]
fn test_completion_rate_mixed_statuses() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let id1 = crate::domain::id::Id::generate();
let id2 = crate::domain::id::Id::generate();
let id3 = crate::domain::id::Id::generate();
let id4 = crate::domain::id::Id::generate();
let tasks = vec![
make_test_task(id1, TaskStatus::Completed),
make_test_task(id2, TaskStatus::Failed),
make_test_task(id3, TaskStatus::Cancelled),
make_test_task(id4, TaskStatus::Active),
];
let task_ids = vec![id1, id2, id3, id4];
assert_eq!(calculate_completion_rate(&tasks, &task_ids), 0.75);
}
#[test]
fn test_next_interval_no_progress_uses_rate_based() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let interval = calculate_next_interval(0.5, 0.5, 1000, 500, 2000);
assert_eq!(interval, 1250);
}
#[test]
fn test_next_interval_positive_progress_increases() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let interval = calculate_next_interval(0.6, 0.5, 1000, 500, 2000);
assert!(interval >= 1000);
assert!(interval <= 2000);
}
#[test]
fn test_next_interval_negative_progress_decreases() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let interval = calculate_next_interval(0.4, 0.5, 1500, 500, 2000);
assert!(interval <= 1500);
assert!(interval >= 500);
}
#[test]
fn test_next_interval_clamped_to_min() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let interval = calculate_next_interval(0.0, 0.0, 500, 500, 2000);
assert!(interval >= 500);
}
#[test]
fn test_next_interval_clamped_to_max() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let interval = calculate_next_interval(1.0, 1.0, 2000, 500, 2000);
assert!(interval <= 2000);
}
#[test]
fn test_next_interval_full_completion() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let interval = calculate_next_interval(1.0, 0.0, 500, 500, 2000);
assert_eq!(interval, 2000);
}
#[test]
fn test_apply_defaults_all_none() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let request = TaskQueryRequestDto {
task_ids: None,
task_types: None,
statuses: None,
created_after: None,
created_before: None,
crawl_id: None,
limit: None,
offset: None,
include_results: None,
sync_wait_ms: None,
};
let (limit, offset, include_results, sync_wait_ms) = apply_defaults(&request);
assert_eq!(limit, server_config::DEFAULT_PAGE_LIMIT);
assert_eq!(offset, 0);
assert!(!include_results);
assert_eq!(sync_wait_ms, crawl_task::DEFAULT_TIMEOUT_MS as u32);
}
#[test]
fn test_apply_defaults_with_values() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let request = TaskQueryRequestDto {
task_ids: None,
task_types: None,
statuses: None,
created_after: None,
created_before: None,
crawl_id: None,
limit: Some(50),
offset: Some(100),
include_results: Some(true),
sync_wait_ms: Some(10000),
};
let (limit, offset, include_results, sync_wait_ms) = apply_defaults(&request);
assert_eq!(limit, 50);
assert_eq!(offset, 100);
assert!(include_results);
assert_eq!(sync_wait_ms, 10000);
}
#[test]
fn test_apply_defaults_limit_capped_at_max() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let request = TaskQueryRequestDto {
task_ids: None,
task_types: None,
statuses: None,
created_after: None,
created_before: None,
crawl_id: None,
limit: Some(5000),
offset: None,
include_results: None,
sync_wait_ms: None,
};
let (limit, _, _, _) = apply_defaults(&request);
assert_eq!(limit, server_config::MAX_PAGE_LIMIT);
}
#[test]
fn test_build_task_infos_empty() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let tasks: Vec<Task> = vec![];
let result = build_task_infos(&tasks, None);
assert!(result.is_empty());
}
#[test]
fn test_build_task_infos_single_task_no_results() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let id = crate::domain::id::Id::generate();
let tasks = vec![make_test_task(id, TaskStatus::Completed)];
let result = build_task_infos(&tasks, None);
assert_eq!(result.len(), 1);
assert_eq!(result[0].id, id);
assert_eq!(result[0].status, TaskStatus::Completed);
assert_eq!(result[0].url, "https://example.com");
assert!(result[0].result.is_none());
}
#[test]
fn test_build_task_infos_multiple_tasks() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let id1 = crate::domain::id::Id::generate();
let id2 = crate::domain::id::Id::generate();
let tasks = vec![
make_test_task(id1, TaskStatus::Queued),
make_test_task(id2, TaskStatus::Failed),
];
let result = build_task_infos(&tasks, None);
assert_eq!(result.len(), 2);
assert_eq!(result[0].id, id1);
assert_eq!(result[1].id, id2);
}
#[test]
fn test_build_task_infos_preserves_task_type() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let id = crate::domain::id::Id::generate();
let mut task = make_test_task(id, TaskStatus::Queued);
task.task_type = TaskType::Crawl;
let result = build_task_infos(&[task], None);
assert_eq!(result[0].task_type, TaskType::Crawl);
}
#[test]
fn test_sync_wait_result_no_wait() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let result = SyncWaitResult {
waited_time_ms: 0,
is_timeout: false,
};
assert_eq!(result.waited_time_ms, 0);
assert!(!result.is_timeout);
}
#[test]
fn test_sync_wait_result_timeout() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let result = SyncWaitResult {
waited_time_ms: 5000,
is_timeout: true,
};
assert_eq!(result.waited_time_ms, 5000);
assert!(result.is_timeout);
}
#[test]
fn test_sync_wait_result_completed_before_timeout() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let result = SyncWaitResult {
waited_time_ms: 3000,
is_timeout: false,
};
assert_eq!(result.waited_time_ms, 3000);
assert!(!result.is_timeout);
}
#[test]
fn test_task_query_response_meta_serialization() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let meta = TaskQueryResponseMeta {
status: "sync_completed".to_string(),
credits_used: 5,
response_time_ms: 1234,
};
let json = serde_json::to_string(&meta).unwrap();
let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
assert_eq!(parsed["status"], "sync_completed");
assert_eq!(parsed["credits_used"], 5);
assert_eq!(parsed["response_time_ms"], 1234);
}
#[test]
fn test_task_query_response_meta_async_status() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let meta = TaskQueryResponseMeta {
status: "async".to_string(),
credits_used: 0,
response_time_ms: 0,
};
let json = serde_json::to_string(&meta).unwrap();
let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
assert_eq!(parsed["status"], "async");
}
#[test]
fn test_task_query_response_meta_timeout_status() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let meta = TaskQueryResponseMeta {
status: "sync_timeout".to_string(),
credits_used: 10,
response_time_ms: 30000,
};
let json = serde_json::to_string(&meta).unwrap();
let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
assert_eq!(parsed["status"], "sync_timeout");
}
#[test]
fn test_validate_request_valid() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let request = TaskQueryRequestDto::default();
assert!(validate_request(&request).is_ok());
}
#[test]
fn test_validate_request_limit_too_small() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let request = TaskQueryRequestDto {
limit: Some(0),
..TaskQueryRequestDto::default()
};
assert!(validate_request(&request).is_err());
}
#[test]
fn test_validate_request_limit_too_large() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let request = TaskQueryRequestDto {
limit: Some(1001),
..TaskQueryRequestDto::default()
};
assert!(validate_request(&request).is_err());
}
#[test]
fn test_validate_request_sync_wait_ms_exceeds_max() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let request = TaskQueryRequestDto {
sync_wait_ms: Some(30001),
..TaskQueryRequestDto::default()
};
assert!(validate_request(&request).is_err());
}
#[test]
fn test_validate_request_sync_wait_ms_zero_ok() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let request = TaskQueryRequestDto {
sync_wait_ms: Some(0),
..TaskQueryRequestDto::default()
};
assert!(validate_request(&request).is_ok());
}
#[test]
fn test_validate_request_sync_wait_ms_at_max_ok() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let request = TaskQueryRequestDto {
sync_wait_ms: Some(30000),
..TaskQueryRequestDto::default()
};
assert!(validate_request(&request).is_ok());
}
#[tokio::test]
async fn test_handle_sync_wait_zero_ms_returns_immediately() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
struct DummyRepo;
#[async_trait::async_trait]
impl TaskRepository for DummyRepo {
async fn create(
&self,
_task: &Task,
) -> Result<Task, crate::domain::repositories::task_repository::RepositoryError>
{
unreachable!("should not be called")
}
async fn find_by_id(
&self,
_id: crate::domain::id::Id,
) -> Result<Option<Task>, crate::domain::repositories::task_repository::RepositoryError>
{
unreachable!("should not be called")
}
async fn update(
&self,
_task: &Task,
) -> Result<Task, crate::domain::repositories::task_repository::RepositoryError>
{
unreachable!("should not be called")
}
async fn acquire_next(
&self,
_worker_id: crate::domain::id::Id,
) -> Result<Option<Task>, crate::domain::repositories::task_repository::RepositoryError>
{
unreachable!("should not be called")
}
async fn mark_completed(
&self,
_id: crate::domain::id::Id,
_lock_token: Option<crate::domain::id::Id>,
) -> Result<u64, crate::domain::repositories::task_repository::RepositoryError>
{
unreachable!("should not be called")
}
async fn mark_failed(
&self,
_id: crate::domain::id::Id,
_lock_token: Option<crate::domain::id::Id>,
) -> Result<u64, crate::domain::repositories::task_repository::RepositoryError>
{
unreachable!("should not be called")
}
async fn mark_cancelled(
&self,
_id: crate::domain::id::Id,
) -> Result<u64, crate::domain::repositories::task_repository::RepositoryError>
{
unreachable!("should not be called")
}
async fn exists_by_url(
&self,
_url: &str,
) -> Result<bool, crate::domain::repositories::task_repository::RepositoryError>
{
unreachable!("should not be called")
}
async fn find_existing_urls(
&self,
_urls: &[String],
) -> Result<
std::collections::HashSet<String>,
crate::domain::repositories::task_repository::RepositoryError,
> {
unreachable!("should not be called")
}
async fn reset_stuck_tasks(
&self,
_timeout: chrono::Duration,
) -> Result<u64, crate::domain::repositories::task_repository::RepositoryError>
{
unreachable!("should not be called")
}
async fn cancel_tasks_by_crawl_id(
&self,
_crawl_id: crate::domain::id::Id,
) -> Result<u64, crate::domain::repositories::task_repository::RepositoryError>
{
unreachable!("should not be called")
}
async fn expire_tasks(
&self,
) -> Result<u64, crate::domain::repositories::task_repository::RepositoryError>
{
unreachable!("should not be called")
}
async fn find_by_crawl_id(
&self,
_crawl_id: crate::domain::id::Id,
) -> Result<Vec<Task>, crate::domain::repositories::task_repository::RepositoryError>
{
unreachable!("should not be called")
}
async fn query_tasks(
&self,
_params: crate::domain::repositories::task_repository::TaskQueryParams,
) -> Result<
(Vec<Task>, u64),
crate::domain::repositories::task_repository::RepositoryError,
> {
unreachable!("should not be called")
}
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)>,
),
crate::domain::repositories::task_repository::RepositoryError,
> {
unreachable!("should not be called")
}
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)
}
}
let result =
handle_sync_wait_and_get_status(&DummyRepo, &[], crate::domain::id::Id::nil(), 0).await;
assert!(result.is_ok());
let result = result.unwrap();
assert_eq!(result.waited_time_ms, 0);
assert!(!result.is_timeout);
}
#[tokio::test]
async fn test_handle_sync_wait_empty_task_ids_returns_immediately() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
struct DummyRepo;
#[async_trait::async_trait]
impl TaskRepository for DummyRepo {
async fn create(
&self,
_task: &Task,
) -> Result<Task, crate::domain::repositories::task_repository::RepositoryError>
{
unreachable!("should not be called")
}
async fn find_by_id(
&self,
_id: crate::domain::id::Id,
) -> Result<Option<Task>, crate::domain::repositories::task_repository::RepositoryError>
{
unreachable!("should not be called")
}
async fn update(
&self,
_task: &Task,
) -> Result<Task, crate::domain::repositories::task_repository::RepositoryError>
{
unreachable!("should not be called")
}
async fn acquire_next(
&self,
_worker_id: crate::domain::id::Id,
) -> Result<Option<Task>, crate::domain::repositories::task_repository::RepositoryError>
{
unreachable!("should not be called")
}
async fn mark_completed(
&self,
_id: crate::domain::id::Id,
_lock_token: Option<crate::domain::id::Id>,
) -> Result<u64, crate::domain::repositories::task_repository::RepositoryError>
{
unreachable!("should not be called")
}
async fn mark_failed(
&self,
_id: crate::domain::id::Id,
_lock_token: Option<crate::domain::id::Id>,
) -> Result<u64, crate::domain::repositories::task_repository::RepositoryError>
{
unreachable!("should not be called")
}
async fn mark_cancelled(
&self,
_id: crate::domain::id::Id,
) -> Result<u64, crate::domain::repositories::task_repository::RepositoryError>
{
unreachable!("should not be called")
}
async fn exists_by_url(
&self,
_url: &str,
) -> Result<bool, crate::domain::repositories::task_repository::RepositoryError>
{
unreachable!("should not be called")
}
async fn find_existing_urls(
&self,
_urls: &[String],
) -> Result<
std::collections::HashSet<String>,
crate::domain::repositories::task_repository::RepositoryError,
> {
unreachable!("should not be called")
}
async fn reset_stuck_tasks(
&self,
_timeout: chrono::Duration,
) -> Result<u64, crate::domain::repositories::task_repository::RepositoryError>
{
unreachable!("should not be called")
}
async fn cancel_tasks_by_crawl_id(
&self,
_crawl_id: crate::domain::id::Id,
) -> Result<u64, crate::domain::repositories::task_repository::RepositoryError>
{
unreachable!("should not be called")
}
async fn expire_tasks(
&self,
) -> Result<u64, crate::domain::repositories::task_repository::RepositoryError>
{
unreachable!("should not be called")
}
async fn find_by_crawl_id(
&self,
_crawl_id: crate::domain::id::Id,
) -> Result<Vec<Task>, crate::domain::repositories::task_repository::RepositoryError>
{
unreachable!("should not be called")
}
async fn query_tasks(
&self,
_params: crate::domain::repositories::task_repository::TaskQueryParams,
) -> Result<
(Vec<Task>, u64),
crate::domain::repositories::task_repository::RepositoryError,
> {
unreachable!("should not be called")
}
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)>,
),
crate::domain::repositories::task_repository::RepositoryError,
> {
unreachable!("should not be called")
}
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)
}
}
let result =
handle_sync_wait_and_get_status(&DummyRepo, &[], crate::domain::id::Id::nil(), 5000)
.await;
assert!(result.is_ok());
let result = result.unwrap();
assert_eq!(result.waited_time_ms, 0);
assert!(!result.is_timeout);
}
fn make_test_scrape_result(
task_id: crate::domain::id::Id,
) -> crate::domain::models::ScrapeResult {
crate::domain::models::ScrapeResult {
id: crate::domain::id::Id::generate(),
task_id,
url: "https://example.com".to_string(),
status_code: 200,
content: "<html><body>Hello</body></html>".to_string(),
content_type: "text/html".to_string(),
headers: serde_json::json!({"content-length": "100"}),
meta_data: serde_json::json!({"key": "value"}),
screenshot: None,
response_time_ms: 150,
created_at: chrono::Utc::now(),
}
}
#[test]
fn test_build_scrape_result_json_maps_basic_fields() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task_id = crate::domain::id::Id::generate();
let result = make_test_scrape_result(task_id);
let dto = build_scrape_result_json(&result);
assert_eq!(dto.id, result.id);
assert_eq!(dto.status_code, 200);
assert_eq!(
dto.content,
"<html><body>Hello</body></html>"
);
}
#[test]
fn test_build_scrape_result_json_escapes_html_special_chars() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task_id = crate::domain::id::Id::generate();
let mut result = make_test_scrape_result(task_id);
result.content = "<script>alert('xss')</script>".to_string();
let dto = build_scrape_result_json(&result);
assert!(dto.content.contains("<script>"));
assert!(!dto.content.contains("<script>"));
}
#[test]
fn test_build_scrape_result_json_escapes_ampersand() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task_id = crate::domain::id::Id::generate();
let mut result = make_test_scrape_result(task_id);
result.content = "Tom & Jerry".to_string();
let dto = build_scrape_result_json(&result);
assert!(dto.content.contains("&"));
assert!(!dto.content.contains(" & "));
}
#[test]
fn test_build_scrape_result_json_clones_metadata() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task_id = crate::domain::id::Id::generate();
let result = make_test_scrape_result(task_id);
let dto = build_scrape_result_json(&result);
assert!(dto.metadata.is_some());
let metadata = dto.metadata.unwrap();
assert_eq!(metadata["key"], "value");
}
#[test]
fn test_build_scrape_result_json_status_code_404() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task_id = crate::domain::id::Id::generate();
let mut result = make_test_scrape_result(task_id);
result.status_code = 404;
let dto = build_scrape_result_json(&result);
assert_eq!(dto.status_code, 404);
}
#[test]
fn test_build_scrape_result_json_empty_content() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task_id = crate::domain::id::Id::generate();
let mut result = make_test_scrape_result(task_id);
result.content = String::new();
let dto = build_scrape_result_json(&result);
assert!(dto.content.is_empty());
}
#[test]
fn test_build_scrape_result_json_null_metadata() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task_id = crate::domain::id::Id::generate();
let mut result = make_test_scrape_result(task_id);
result.meta_data = serde_json::Value::Null;
let dto = build_scrape_result_json(&result);
assert!(dto.metadata.is_some());
assert!(dto.metadata.unwrap().is_null());
}
#[test]
fn test_build_task_infos_with_matching_result() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task_id = crate::domain::id::Id::generate();
let task = make_test_task(task_id, TaskStatus::Completed);
let scrape_result = make_test_scrape_result(task_id);
let mut results_map = std::collections::HashMap::new();
results_map.insert(task_id, scrape_result.clone());
let infos = build_task_infos(&[task], Some(&results_map));
assert_eq!(infos.len(), 1);
assert!(infos[0].result.is_some());
let result_dto = infos[0].result.as_ref().unwrap();
assert_eq!(result_dto.id, scrape_result.id);
assert_eq!(result_dto.status_code, 200);
}
#[test]
fn test_build_task_infos_with_results_map_no_match() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task_id = crate::domain::id::Id::generate();
let other_id = crate::domain::id::Id::generate();
let task = make_test_task(task_id, TaskStatus::Completed);
let scrape_result = make_test_scrape_result(other_id);
let mut results_map = std::collections::HashMap::new();
results_map.insert(other_id, scrape_result);
let infos = build_task_infos(&[task], Some(&results_map));
assert_eq!(infos.len(), 1);
assert!(infos[0].result.is_none());
}
#[test]
fn test_build_task_infos_mixed_with_and_without_results() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task1_id = crate::domain::id::Id::generate();
let task2_id = crate::domain::id::Id::generate();
let tasks = vec![
make_test_task(task1_id, TaskStatus::Completed),
make_test_task(task2_id, TaskStatus::Queued),
];
let scrape_result = make_test_scrape_result(task1_id);
let mut results_map = std::collections::HashMap::new();
results_map.insert(task1_id, scrape_result);
let infos = build_task_infos(&tasks, Some(&results_map));
assert_eq!(infos.len(), 2);
assert!(infos[0].result.is_some());
assert!(infos[1].result.is_none());
}
#[test]
fn test_build_task_infos_empty_map_returns_none_for_all() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task1_id = crate::domain::id::Id::generate();
let task2_id = crate::domain::id::Id::generate();
let tasks = vec![
make_test_task(task1_id, TaskStatus::Completed),
make_test_task(task2_id, TaskStatus::Failed),
];
let results_map: std::collections::HashMap<
crate::domain::id::Id,
crate::domain::models::ScrapeResult,
> = std::collections::HashMap::new();
let infos = build_task_infos(&tasks, Some(&results_map));
assert_eq!(infos.len(), 2);
assert!(infos[0].result.is_none());
assert!(infos[1].result.is_none());
}
#[test]
fn test_build_task_infos_result_html_escaped_in_dto() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task_id = crate::domain::id::Id::generate();
let task = make_test_task(task_id, TaskStatus::Completed);
let mut scrape_result = make_test_scrape_result(task_id);
scrape_result.content = "<b>bold</b>".to_string();
let mut results_map = std::collections::HashMap::new();
results_map.insert(task_id, scrape_result);
let infos = build_task_infos(&[task], Some(&results_map));
let result_dto = infos[0].result.as_ref().expect("result should exist");
assert!(result_dto.content.contains("<b>"));
assert!(!result_dto.content.contains("<b>"));
}
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 make_test_scrape_result_repo() -> Arc<ScrapeResultRepositoryImpl> {
Arc::new(ScrapeResultRepositoryImpl::new(make_test_db_pool()))
}
#[allow(clippy::type_complexity)]
struct MockTaskRepository {
query_error: Mutex<Option<RepositoryError>>,
query_tasks_data: Mutex<Vec<Task>>,
query_total: u64,
batch_cancel_result: Mutex<
Option<
Result<
(
Vec<crate::domain::id::Id>,
Vec<(crate::domain::id::Id, String)>,
),
RepositoryError,
>,
>,
>,
}
#[allow(clippy::type_complexity)]
impl MockTaskRepository {
fn new() -> Self {
Self {
query_error: Mutex::new(None),
query_tasks_data: Mutex::new(Vec::new()),
query_total: 0,
batch_cancel_result: Mutex::new(None),
}
}
fn with_query_data(tasks: Vec<Task>, total: u64) -> Self {
Self {
query_error: Mutex::new(None),
query_tasks_data: Mutex::new(tasks),
query_total: total,
batch_cancel_result: Mutex::new(None),
}
}
fn with_query_error(err: RepositoryError) -> Self {
Self {
query_error: Mutex::new(Some(err)),
query_tasks_data: Mutex::new(Vec::new()),
query_total: 0,
batch_cancel_result: Mutex::new(None),
}
}
fn with_batch_cancel_result(
result: Result<
(
Vec<crate::domain::id::Id>,
Vec<(crate::domain::id::Id, String)>,
),
RepositoryError,
>,
) -> Self {
Self {
query_error: Mutex::new(None),
query_tasks_data: Mutex::new(Vec::new()),
query_total: 0,
batch_cancel_result: Mutex::new(Some(result)),
}
}
fn with_batch_cancel_result_and_query_data(
result: Result<
(
Vec<crate::domain::id::Id>,
Vec<(crate::domain::id::Id, String)>,
),
RepositoryError,
>,
query_tasks: Vec<Task>,
) -> Self {
Self {
query_error: Mutex::new(None),
query_tasks_data: Mutex::new(query_tasks),
query_total: 1,
batch_cancel_result: Mutex::new(Some(result)),
}
}
}
#[async_trait]
impl TaskRepository for MockTaskRepository {
async fn create(&self, _task: &Task) -> Result<Task, RepositoryError> {
unreachable!("create not expected in task_handler tests")
}
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> {
unreachable!("update not expected in task_handler tests")
}
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<std::collections::HashSet<String>, RepositoryError> {
Ok(std::collections::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::new())
}
async fn query_tasks(
&self,
_params: TaskQueryParams,
) -> Result<(Vec<Task>, u64), RepositoryError> {
if let Some(err) = self.query_error.lock().unwrap().take() {
return Err(err);
}
Ok((
self.query_tasks_data.lock().unwrap().clone(),
self.query_total,
))
}
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,
> {
match self.batch_cancel_result.lock().unwrap().take() {
Some(result) => result,
None => Ok((Vec::new(), Vec::new())),
}
}
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)
}
}
#[tokio::test]
async fn test_query_tasks_handler_success() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task_id = crate::domain::id::Id::generate();
let task = make_test_task(task_id, TaskStatus::Completed);
let repo = Arc::new(MockTaskRepository::with_query_data(vec![task], 1));
let auth = make_test_auth_state();
let scrape_repo = make_test_scrape_result_repo();
let request = TaskQueryRequestDto {
sync_wait_ms: Some(0),
..TaskQueryRequestDto::default()
};
let result = query_tasks::<MockTaskRepository>(
Extension(auth),
Extension(repo),
Extension(scrape_repo),
Ok(Json(request)),
)
.await;
assert!(result.is_ok(), "query_tasks should succeed");
let response = result.unwrap();
let data = response
.data
.as_ref()
.expect("response data should be present");
assert_eq!(data.tasks.len(), 1);
assert_eq!(data.total, 1);
assert!(!data.has_more);
}
#[tokio::test]
async fn test_query_tasks_handler_empty_result() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = Arc::new(MockTaskRepository::new());
let auth = make_test_auth_state();
let scrape_repo = make_test_scrape_result_repo();
let request = TaskQueryRequestDto {
sync_wait_ms: Some(0),
..TaskQueryRequestDto::default()
};
let result = query_tasks::<MockTaskRepository>(
Extension(auth),
Extension(repo),
Extension(scrape_repo),
Ok(Json(request)),
)
.await;
assert!(
result.is_ok(),
"query_tasks should succeed with empty results"
);
let response = result.unwrap();
let data = response
.data
.as_ref()
.expect("response data should be present");
assert_eq!(data.tasks.len(), 0);
assert_eq!(data.total, 0);
assert!(!data.has_more);
}
#[tokio::test]
async fn test_query_tasks_handler_has_more() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task1 = make_test_task(crate::domain::id::Id::generate(), TaskStatus::Completed);
let task2 = make_test_task(crate::domain::id::Id::generate(), TaskStatus::Completed);
let repo = Arc::new(MockTaskRepository::with_query_data(vec![task1, task2], 10));
let auth = make_test_auth_state();
let scrape_repo = make_test_scrape_result_repo();
let request = TaskQueryRequestDto {
limit: Some(2),
offset: Some(0),
sync_wait_ms: Some(0),
..TaskQueryRequestDto::default()
};
let result = query_tasks::<MockTaskRepository>(
Extension(auth),
Extension(repo),
Extension(scrape_repo),
Ok(Json(request)),
)
.await;
assert!(result.is_ok());
let response = result.unwrap();
let data = response
.data
.as_ref()
.expect("response data should be present");
assert_eq!(data.tasks.len(), 2);
assert_eq!(data.total, 10);
assert!(
data.has_more,
"has_more should be true when total > offset+limit"
);
}
#[tokio::test]
async fn test_query_tasks_handler_validation_error_limit() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = Arc::new(MockTaskRepository::new());
let auth = make_test_auth_state();
let scrape_repo = make_test_scrape_result_repo();
let request = TaskQueryRequestDto {
limit: Some(0),
sync_wait_ms: Some(0),
..TaskQueryRequestDto::default()
};
let result = query_tasks::<MockTaskRepository>(
Extension(auth),
Extension(repo),
Extension(scrape_repo),
Ok(Json(request)),
)
.await;
assert!(result.is_err(), "limit=0 should fail validation");
}
#[tokio::test]
async fn test_query_tasks_handler_validation_error_sync_wait() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = Arc::new(MockTaskRepository::new());
let auth = make_test_auth_state();
let scrape_repo = make_test_scrape_result_repo();
let request = TaskQueryRequestDto {
sync_wait_ms: Some(30001),
..TaskQueryRequestDto::default()
};
let result = query_tasks::<MockTaskRepository>(
Extension(auth),
Extension(repo),
Extension(scrape_repo),
Ok(Json(request)),
)
.await;
assert!(result.is_err(), "sync_wait_ms=30001 should fail validation");
}
#[tokio::test]
async fn test_query_tasks_handler_repo_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = Arc::new(MockTaskRepository::with_query_error(
RepositoryError::Database(anyhow::anyhow!("query failed")),
));
let auth = make_test_auth_state();
let scrape_repo = make_test_scrape_result_repo();
let request = TaskQueryRequestDto {
sync_wait_ms: Some(0),
..TaskQueryRequestDto::default()
};
let result = query_tasks::<MockTaskRepository>(
Extension(auth),
Extension(repo),
Extension(scrape_repo),
Ok(Json(request)),
)
.await;
assert!(result.is_err(), "repo error should propagate");
match result.unwrap_err() {
CrawlRsError::Other(msg) => assert!(msg.contains("Query failed")),
other => panic!("expected CrawlRsError::Other, got {:?}", other),
}
}
#[tokio::test]
async fn test_query_tasks_handler_sync_wait_completed() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task_id = crate::domain::id::Id::generate();
let task = make_test_task(task_id, TaskStatus::Completed);
let repo = Arc::new(MockTaskRepository::with_query_data(vec![task], 1));
let auth = make_test_auth_state();
let scrape_repo = make_test_scrape_result_repo();
let request = TaskQueryRequestDto {
sync_wait_ms: Some(100),
..TaskQueryRequestDto::default()
};
let result = query_tasks::<MockTaskRepository>(
Extension(auth),
Extension(repo),
Extension(scrape_repo),
Ok(Json(request)),
)
.await;
assert!(
result.is_ok(),
"sync wait with completed tasks should succeed"
);
let response = result.unwrap();
let data = response
.data
.as_ref()
.expect("response data should be present");
assert_eq!(data.tasks.len(), 1);
}
#[tokio::test]
async fn test_query_tasks_handler_include_results_no_match_returns_success() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task_id = crate::domain::id::Id::generate();
let task = make_test_task(task_id, TaskStatus::Completed);
let repo = Arc::new(MockTaskRepository::with_query_data(vec![task], 1));
let auth = make_test_auth_state();
let scrape_repo = make_test_scrape_result_repo();
let request = TaskQueryRequestDto {
include_results: Some(true),
sync_wait_ms: Some(0),
..TaskQueryRequestDto::default()
};
let result = query_tasks::<MockTaskRepository>(
Extension(auth),
Extension(repo),
Extension(scrape_repo),
Ok(Json(request)),
)
.await;
assert!(
result.is_ok(),
"include_results with no matching scrape results should succeed"
);
let response = result.unwrap();
let data = response
.data
.as_ref()
.expect("response data should be present");
assert_eq!(data.tasks.len(), 1);
assert!(data.tasks[0].result.is_none());
}
#[tokio::test]
async fn test_cancel_tasks_handler_success() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task_id = crate::domain::id::Id::generate();
let repo = Arc::new(MockTaskRepository::with_batch_cancel_result(Ok((
vec![task_id],
vec![],
))));
let auth = make_test_auth_state();
let request = TaskCancelRequestDto {
task_ids: vec![task_id],
force: Some(false),
sync_wait_ms: Some(0),
};
let result =
cancel_tasks::<MockTaskRepository>(Extension(auth), Extension(repo), Ok(Json(request)))
.await;
assert!(result.is_ok(), "cancel_tasks should succeed");
let response = result.unwrap();
let data = response
.data
.as_ref()
.expect("response data should be present");
assert_eq!(data.total_cancelled, 1);
assert_eq!(data.total_failed, 0);
assert_eq!(data.cancelled_tasks.len(), 1);
assert_eq!(data.cancelled_tasks[0].task_id, task_id);
}
#[tokio::test]
async fn test_cancel_tasks_handler_empty_task_ids() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = Arc::new(MockTaskRepository::new());
let auth = make_test_auth_state();
let request = TaskCancelRequestDto {
task_ids: vec![],
force: Some(false),
sync_wait_ms: Some(0),
};
let result =
cancel_tasks::<MockTaskRepository>(Extension(auth), Extension(repo), Ok(Json(request)))
.await;
assert!(result.is_err(), "empty task_ids should fail");
match result.unwrap_err() {
CrawlRsError::Validation(msg) => {
assert!(msg.contains("Task IDs cannot be empty"), "got: {}", msg);
}
other => panic!("expected CrawlRsError::Validation, got {:?}", other),
}
}
#[tokio::test]
async fn test_cancel_tasks_handler_validation_error_sync_wait() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = Arc::new(MockTaskRepository::new());
let auth = make_test_auth_state();
let request = TaskCancelRequestDto {
task_ids: vec![crate::domain::id::Id::generate()],
force: Some(false),
sync_wait_ms: Some(30001),
};
let result =
cancel_tasks::<MockTaskRepository>(Extension(auth), Extension(repo), Ok(Json(request)))
.await;
assert!(result.is_err(), "sync_wait_ms=30001 should fail validation");
}
#[tokio::test]
async fn test_cancel_tasks_handler_repo_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = Arc::new(MockTaskRepository::with_batch_cancel_result(Err(
RepositoryError::Database(anyhow::anyhow!("batch_cancel failed")),
)));
let auth = make_test_auth_state();
let request = TaskCancelRequestDto {
task_ids: vec![crate::domain::id::Id::generate()],
force: Some(false),
sync_wait_ms: Some(0),
};
let result =
cancel_tasks::<MockTaskRepository>(Extension(auth), Extension(repo), Ok(Json(request)))
.await;
assert!(result.is_err(), "repo error should propagate");
}
#[tokio::test]
async fn test_cancel_tasks_handler_with_failed_tasks() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task_id1 = crate::domain::id::Id::generate();
let task_id2 = crate::domain::id::Id::generate();
let repo = Arc::new(MockTaskRepository::with_batch_cancel_result(Ok((
vec![task_id1],
vec![(task_id2, "Already completed".to_string())],
))));
let auth = make_test_auth_state();
let request = TaskCancelRequestDto {
task_ids: vec![task_id1, task_id2],
force: Some(false),
sync_wait_ms: Some(0),
};
let result =
cancel_tasks::<MockTaskRepository>(Extension(auth), Extension(repo), Ok(Json(request)))
.await;
assert!(result.is_ok());
let response = result.unwrap();
let data = response
.data
.as_ref()
.expect("response data should be present");
assert_eq!(data.total_cancelled, 1);
assert_eq!(data.total_failed, 1);
assert_eq!(data.failed_tasks[0].task_id, task_id2);
assert_eq!(data.failed_tasks[0].reason, "Already completed");
}
#[tokio::test]
async fn test_cancel_tasks_handler_sync_wait() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task_id = crate::domain::id::Id::generate();
let cancelled_task = make_test_task(task_id, TaskStatus::Cancelled);
let repo = Arc::new(MockTaskRepository::with_batch_cancel_result_and_query_data(
Ok((vec![task_id], vec![])),
vec![cancelled_task],
));
let auth = make_test_auth_state();
let request = TaskCancelRequestDto {
task_ids: vec![task_id],
force: Some(false),
sync_wait_ms: Some(100),
};
let result =
cancel_tasks::<MockTaskRepository>(Extension(auth), Extension(repo), Ok(Json(request)))
.await;
assert!(result.is_ok(), "cancel with sync wait should succeed");
let response = result.unwrap();
let data = response
.data
.as_ref()
.expect("response data should be present");
assert_eq!(data.total_cancelled, 1);
}
#[tokio::test]
async fn test_wait_for_tasks_completion_already_completed() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task_id = crate::domain::id::Id::generate();
let task = make_test_task(task_id, TaskStatus::Completed);
let repo = MockTaskRepository::with_query_data(vec![task], 1);
let result =
wait_for_tasks_completion(&repo, &[task_id], crate::domain::id::Id::nil(), 100, 500)
.await;
assert!(
result.is_ok(),
"should complete immediately when tasks are done"
);
}
#[tokio::test]
async fn test_wait_for_tasks_completion_timeout() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task_id = crate::domain::id::Id::generate();
let task = make_test_task(task_id, TaskStatus::Active);
let repo = MockTaskRepository::with_query_data(vec![task], 1);
let result =
wait_for_tasks_completion(&repo, &[task_id], crate::domain::id::Id::nil(), 50, 500)
.await;
assert!(result.is_ok(), "should return Ok on timeout");
}
#[tokio::test]
async fn test_wait_for_tasks_completion_query_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task_id = crate::domain::id::Id::generate();
let repo = MockTaskRepository::with_query_error(RepositoryError::Database(
anyhow::anyhow!("poll query failed"),
));
let result =
wait_for_tasks_completion(&repo, &[task_id], crate::domain::id::Id::nil(), 100, 500)
.await;
assert!(result.is_err(), "query error should propagate");
}
#[tokio::test]
async fn test_handle_sync_wait_and_get_status_success() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task_id = crate::domain::id::Id::generate();
let task = make_test_task(task_id, TaskStatus::Completed);
let repo = MockTaskRepository::with_query_data(vec![task], 1);
let result =
handle_sync_wait_and_get_status(&repo, &[task_id], crate::domain::id::Id::nil(), 200)
.await;
assert!(result.is_ok());
let sync_result = result.unwrap();
assert!(!sync_result.is_timeout, "should complete before timeout");
}
#[tokio::test]
async fn test_handle_sync_wait_and_get_status_error_continues() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task_id = crate::domain::id::Id::generate();
let repo = MockTaskRepository::with_query_error(RepositoryError::Database(
anyhow::anyhow!("poll failed"),
));
let result =
handle_sync_wait_and_get_status(&repo, &[task_id], crate::domain::id::Id::nil(), 200)
.await;
assert!(result.is_ok(), "should return Ok even on wait error");
}
#[tokio::test]
async fn test_query_tasks_for_poll_success() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task_id = crate::domain::id::Id::generate();
let task = make_test_task(task_id, TaskStatus::Completed);
let repo = MockTaskRepository::with_query_data(vec![task], 1);
let result = query_tasks_for_poll(&repo, crate::domain::id::Id::nil(), &[task_id]).await;
assert!(result.is_ok());
assert_eq!(result.unwrap().len(), 1);
}
#[tokio::test]
async fn test_query_tasks_for_poll_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task_id = crate::domain::id::Id::generate();
let repo = MockTaskRepository::with_query_error(RepositoryError::Database(
anyhow::anyhow!("poll failed"),
));
let result = query_tasks_for_poll(&repo, crate::domain::id::Id::nil(), &[task_id]).await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_execute_task_query_success() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task_id = crate::domain::id::Id::generate();
let task = make_test_task(task_id, TaskStatus::Completed);
let repo = MockTaskRepository::with_query_data(vec![task], 1);
let request = TaskQueryRequestDto::default();
let result =
execute_task_query(&repo, crate::domain::id::Id::nil(), &request, 100, 0).await;
assert!(result.is_ok());
let (tasks, total) = result.unwrap();
assert_eq!(tasks.len(), 1);
assert_eq!(total, 1);
}
#[tokio::test]
async fn test_execute_task_query_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = MockTaskRepository::with_query_error(RepositoryError::Database(
anyhow::anyhow!("exec failed"),
));
let request = TaskQueryRequestDto::default();
let result =
execute_task_query(&repo, crate::domain::id::Id::nil(), &request, 100, 0).await;
assert!(result.is_err());
match result.unwrap_err() {
CrawlRsError::Other(msg) => assert!(msg.contains("Query failed")),
other => panic!("expected CrawlRsError::Other, got {:?}", other),
}
}
#[tokio::test]
async fn test_handle_sync_wait_direct() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task_id = crate::domain::id::Id::generate();
let task = make_test_task(task_id, TaskStatus::Completed);
let repo = MockTaskRepository::with_query_data(vec![task.clone()], 1);
let result = handle_sync_wait(&repo, &[task], crate::domain::id::Id::nil(), 100).await;
assert!(result.is_ok());
let waited = result.unwrap();
assert!(
waited < 1000,
"waited_time_ms should be small, got {}",
waited
);
}
#[tokio::test]
async fn test_fetch_scrape_results_empty_tasks() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = make_test_scrape_result_repo();
let tasks: Vec<Task> = vec![];
let result = fetch_scrape_results(repo.as_ref(), &tasks).await;
assert!(result.is_ok());
let map = result.unwrap();
assert!(map.is_some());
assert!(map.unwrap().is_empty());
}
#[tokio::test]
async fn test_fetch_scrape_results_non_empty_tasks_returns_result_map() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = make_test_scrape_result_repo();
let task_id = crate::domain::id::Id::generate();
let tasks = vec![make_test_task(task_id, TaskStatus::Completed)];
let result = fetch_scrape_results(repo.as_ref(), &tasks).await;
let map = result.expect("fetch_scrape_results should succeed against a real DB");
let map = map.expect("non-empty tasks should produce a result map");
assert!(
!map.contains_key(&task_id),
"freshly generated task id must have no stored results"
);
}
#[tokio::test]
async fn test_query_tasks_handler_include_results_with_empty_tasks_skips_fetch() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = Arc::new(MockTaskRepository::new());
let auth = make_test_auth_state();
let scrape_repo = make_test_scrape_result_repo();
let request = TaskQueryRequestDto {
include_results: Some(true),
sync_wait_ms: Some(0),
..TaskQueryRequestDto::default()
};
let result = query_tasks::<MockTaskRepository>(
Extension(auth),
Extension(repo),
Extension(scrape_repo),
Ok(Json(request)),
)
.await;
assert!(
result.is_ok(),
"should succeed when tasks empty even with include_results"
);
let binding = result.unwrap();
let data = binding.data.as_ref().expect("data present");
assert!(data.tasks.is_empty());
}
#[tokio::test]
async fn test_cancel_tasks_handler_force_true_succeeds() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task_id = crate::domain::id::Id::generate();
let repo = Arc::new(MockTaskRepository::with_batch_cancel_result(Ok((
vec![task_id],
vec![],
))));
let auth = make_test_auth_state();
let request = TaskCancelRequestDto {
task_ids: vec![task_id],
force: Some(true),
sync_wait_ms: Some(0),
};
let result =
cancel_tasks::<MockTaskRepository>(Extension(auth), Extension(repo), Ok(Json(request)))
.await;
assert!(result.is_ok(), "force=true should succeed");
let binding = result.unwrap();
let data = binding.data.as_ref().expect("data present");
assert_eq!(data.total_cancelled, 1);
}
#[tokio::test]
async fn test_cancel_tasks_handler_force_none_uses_default_false() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task_id = crate::domain::id::Id::generate();
let repo = Arc::new(MockTaskRepository::with_batch_cancel_result(Ok((
vec![task_id],
vec![],
))));
let auth = make_test_auth_state();
let request = TaskCancelRequestDto {
task_ids: vec![task_id],
force: None,
sync_wait_ms: Some(0),
};
let result =
cancel_tasks::<MockTaskRepository>(Extension(auth), Extension(repo), Ok(Json(request)))
.await;
assert!(result.is_ok(), "force=None should default to false");
}
use crate::test_utils::ensure_debug_logger;
#[test]
fn test_poll_count_exceeded_logs_debug_with_logger() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
ensure_debug_logger();
assert!(poll_count_exceeded(60, 60));
assert!(poll_count_exceeded(100, 60));
}
#[tokio::test]
async fn test_handle_sync_wait_error_logs_error_with_logger() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
ensure_debug_logger();
let task_id = crate::domain::id::Id::generate();
let repo = MockTaskRepository::with_query_error(RepositoryError::Database(
anyhow::anyhow!("poll failed for logging test"),
));
let result =
handle_sync_wait_and_get_status(&repo, &[task_id], crate::domain::id::Id::nil(), 200)
.await;
assert!(result.is_ok(), "should return Ok even on wait error");
}
#[tokio::test]
async fn test_wait_for_tasks_completion_logs_debug_poll_count_with_logger() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
ensure_debug_logger();
let task_id = crate::domain::id::Id::generate();
let task = make_test_task(task_id, TaskStatus::Active);
let repo = MockTaskRepository::with_query_data(vec![task], 1);
let result =
wait_for_tasks_completion(&repo, &[task_id], crate::domain::id::Id::nil(), 50, 500)
.await;
assert!(result.is_ok(), "should return Ok on timeout");
}
}