use super::*;
use crate::common::test_helpers::acquire_next_test_mutex;
use crate::common::test_helpers::create_test_db_pool;
use crate::domain::models::{Task, TaskType};
use chrono::Duration;
use serde_json::json;
fn make_test_task() -> Task {
Task::new(
crate::domain::id::Id::generate(),
TaskType::Scrape,
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
"http://example.com".to_string(),
json!({}),
)
}
fn make_test_task_with_unique_url() -> Task {
let mut task = make_test_task();
task.url = format!("http://example.com/{}", crate::domain::id::Id::generate());
task
}
#[test]
fn test_new_creates_repository_instance() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let repo = TaskRepositoryImpl::new(pool, Duration::minutes(5));
let _ = repo;
}
#[tokio::test]
async fn test_create_with_real_db_succeeds() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let _guard = acquire_next_test_mutex().lock().await;
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let task = make_test_task();
let result = repo.create(&task).await;
assert!(result.is_ok(), "create failed: {:?}", result.err());
let returned = result.unwrap();
assert_eq!(returned.id, task.id);
assert_eq!(returned.url, task.url);
assert_eq!(returned.team_id, task.team_id);
let found = repo.find_by_id(task.id).await.expect("find_by_id failed");
assert!(found.is_some(), "task should be found after create");
let found_task = found.unwrap();
assert_eq!(found_task.id, task.id);
assert_eq!(found_task.url, task.url);
assert_eq!(found_task.task_type, task.task_type);
assert_eq!(found_task.team_id, task.team_id);
assert_eq!(found_task.status, task.status);
}
#[tokio::test]
async fn test_find_by_id_with_real_db_returns_none_for_unknown() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let result = repo.find_by_id(crate::domain::id::Id::generate()).await;
assert!(result.is_ok(), "find_by_id failed: {:?}", result.err());
assert!(result.unwrap().is_none(), "unknown UUID should return None");
}
#[tokio::test]
async fn test_update_with_real_db_succeeds() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let mut task = make_test_task();
repo.create(&task).await.expect("create failed");
task.url = format!("http://updated.com/{}", crate::domain::id::Id::generate());
task.priority = 7;
task.payload = json!({"updated": true});
let result = repo.update(&task).await;
assert!(result.is_ok(), "update failed: {:?}", result.err());
let found = repo
.find_by_id(task.id)
.await
.expect("find_by_id failed")
.expect("task should exist");
assert_eq!(found.url, task.url);
assert_eq!(found.priority, 7);
assert_eq!(found.payload, json!({"updated": true}));
}
#[tokio::test]
async fn test_acquire_next_with_real_db_returns_ok_when_backlog_empty() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let _guard = acquire_next_test_mutex().lock().await;
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let result = repo.acquire_next(crate::domain::id::Id::generate()).await;
assert!(result.is_ok(), "acquire_next failed: {:?}", result.err());
let _ = result.unwrap();
}
#[tokio::test]
async fn test_acquire_next_with_real_db_acquires_created_task() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let _guard = acquire_next_test_mutex().lock().await;
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let mut task = make_test_task();
task.priority = 0;
repo.create(&task).await.expect("create failed");
let worker = crate::domain::id::Id::generate();
let result = repo.acquire_next(worker).await;
assert!(result.is_ok(), "acquire_next failed: {:?}", result.err());
let acquired = result.unwrap();
assert!(acquired.is_some(), "should acquire the queued task");
let acquired_task = acquired.unwrap();
assert_eq!(acquired_task.status, TaskStatus::Active);
assert_eq!(acquired_task.lock_token, Some(worker));
assert!(acquired_task.lock_expires_at.is_some());
assert!(acquired_task.started_at.is_some());
}
#[tokio::test]
async fn test_mark_completed_with_real_db_succeeds() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let task = make_test_task();
repo.create(&task).await.expect("create failed");
let result = repo.mark_completed(task.id, None).await;
assert!(result.is_ok(), "mark_completed failed: {:?}", result.err());
let found = repo
.find_by_id(task.id)
.await
.expect("find_by_id failed")
.expect("task should exist");
assert_eq!(found.status, TaskStatus::Completed);
assert!(found.completed_at.is_some());
}
#[tokio::test]
async fn test_mark_failed_with_real_db_succeeds() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let task = make_test_task();
repo.create(&task).await.expect("create failed");
let result = repo.mark_failed(task.id, None).await;
assert!(result.is_ok(), "mark_failed failed: {:?}", result.err());
let found = repo
.find_by_id(task.id)
.await
.expect("find_by_id failed")
.expect("task should exist");
assert_eq!(found.status, TaskStatus::Failed);
assert!(found.completed_at.is_some());
}
#[tokio::test]
async fn test_mark_cancelled_with_real_db_succeeds() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let task = make_test_task();
repo.create(&task).await.expect("create failed");
let result = repo.mark_cancelled(task.id).await;
assert!(result.is_ok(), "mark_cancelled failed: {:?}", result.err());
let found = repo
.find_by_id(task.id)
.await
.expect("find_by_id failed")
.expect("task should exist");
assert_eq!(found.status, TaskStatus::Cancelled);
assert!(found.completed_at.is_some());
}
#[tokio::test]
async fn test_exists_by_url_with_real_db_returns_false_for_unknown() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let unknown_url = format!(
"http://nonexistent-{}.com",
crate::domain::id::Id::generate()
);
let result = repo.exists_by_url(&unknown_url).await;
assert!(result.is_ok(), "exists_by_url failed: {:?}", result.err());
assert!(!result.unwrap(), "unknown URL should return false");
}
#[tokio::test]
async fn test_exists_by_url_with_real_db_returns_true_for_existing() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let task = make_test_task_with_unique_url();
repo.create(&task).await.expect("create failed");
let result = repo.exists_by_url(&task.url).await;
assert!(result.is_ok(), "exists_by_url failed: {:?}", result.err());
assert!(result.unwrap(), "existing URL should return true");
}
#[tokio::test]
async fn test_find_existing_urls_returns_empty_for_empty_input() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let result = repo.find_existing_urls(&[]).await;
assert!(result.is_ok());
assert!(result.unwrap().is_empty());
}
#[tokio::test]
async fn test_find_existing_urls_with_real_db_returns_empty_for_unknown() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let urls = vec![format!(
"http://nonexistent-{}.com",
crate::domain::id::Id::generate()
)];
let result = repo.find_existing_urls(&urls).await;
assert!(
result.is_ok(),
"find_existing_urls failed: {:?}",
result.err()
);
assert!(
result.unwrap().is_empty(),
"unknown URLs should return empty set"
);
}
#[tokio::test]
async fn test_find_existing_urls_with_real_db_returns_matching_urls() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let task1 = make_test_task_with_unique_url();
let task2 = make_test_task_with_unique_url();
repo.create(&task1).await.expect("create task1 failed");
repo.create(&task2).await.expect("create task2 failed");
let unknown_url = format!(
"http://nonexistent-{}.com",
crate::domain::id::Id::generate()
);
let urls = vec![task1.url.clone(), task2.url.clone(), unknown_url.clone()];
let result = repo.find_existing_urls(&urls).await;
assert!(
result.is_ok(),
"find_existing_urls failed: {:?}",
result.err()
);
let existing = result.unwrap();
assert_eq!(existing.len(), 2, "should find both created URLs");
assert!(existing.contains(&task1.url));
assert!(existing.contains(&task2.url));
assert!(!existing.contains(&unknown_url));
}
#[tokio::test]
async fn test_reset_stuck_tasks_with_real_db_returns_zero_when_none_stuck() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let result = repo.reset_stuck_tasks(Duration::minutes(30)).await;
assert!(
result.is_ok(),
"reset_stuck_tasks failed: {:?}",
result.err()
);
let _count = result.unwrap();
}
#[tokio::test]
async fn test_reset_stuck_tasks_with_real_db_resets_stuck_task() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let mut task = make_test_task();
task.status = TaskStatus::Active;
task.started_at = Some(Utc::now() - Duration::hours(2));
task.updated_at = Utc::now() - Duration::hours(2);
repo.create(&task).await.expect("create failed");
let result = repo.reset_stuck_tasks(Duration::minutes(30)).await;
assert!(
result.is_ok(),
"reset_stuck_tasks failed: {:?}",
result.err()
);
let _count = result.unwrap();
let found = repo.find_by_id(task.id).await.expect("find_by_id failed");
let found_task = found.expect("stuck task must still exist");
{
assert_eq!(
found_task.status,
TaskStatus::Queued,
"stuck task should be reset to Queued"
);
assert!(found_task.started_at.is_none());
assert!(found_task.lock_token.is_none());
assert!(found_task.lock_expires_at.is_none());
}
}
#[tokio::test]
async fn test_cancel_tasks_by_crawl_id_with_real_db_returns_zero_for_unknown() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let result = repo
.cancel_tasks_by_crawl_id(crate::domain::id::Id::generate())
.await;
assert!(
result.is_ok(),
"cancel_tasks_by_crawl_id failed: {:?}",
result.err()
);
assert_eq!(result.unwrap(), 0, "unknown crawl_id should cancel 0 tasks");
}
#[tokio::test]
async fn test_cancel_tasks_by_crawl_id_with_real_db_cancels_matching() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let crawl_id = crate::domain::id::Id::generate();
let mut task1 = make_test_task();
task1.crawl_id = Some(crawl_id);
let mut task2 = make_test_task();
task2.crawl_id = Some(crawl_id);
task2.url = format!("{}/task2", task2.url);
let mut task3 = make_test_task();
task3.crawl_id = Some(crawl_id);
task3.url = format!("{}/task3", task3.url);
task3.status = TaskStatus::Completed; repo.create(&task1).await.expect("create task1 failed");
repo.create(&task2).await.expect("create task2 failed");
repo.create(&task3).await.expect("create task3 failed");
let result = repo.cancel_tasks_by_crawl_id(crawl_id).await;
assert!(result.is_ok(), "cancel_tasks_by_crawl_id failed");
let count = result.unwrap();
assert_eq!(count, 2, "should cancel 2 queued/active tasks");
let found1 = repo
.find_by_id(task1.id)
.await
.expect("find_by_id failed")
.expect("task1 should exist");
assert_eq!(found1.status, TaskStatus::Cancelled);
assert!(
found1.completed_at.is_some(),
"cancelled 行必须写 completed_at"
);
assert!(found1.lock_token.is_none(), "cancelled 行必须清锁");
assert!(
found1.lock_expires_at.is_none(),
"cancelled 行必须清锁过期时间"
);
let found2 = repo
.find_by_id(task2.id)
.await
.expect("find_by_id failed")
.expect("task2 should exist");
assert_eq!(found2.status, TaskStatus::Cancelled);
let found3 = repo
.find_by_id(task3.id)
.await
.expect("find_by_id failed")
.expect("task3 should exist");
assert_eq!(
found3.status,
TaskStatus::Completed,
"completed task should not be cancelled"
);
}
#[tokio::test]
async fn test_expire_tasks_with_real_db_returns_zero_when_none_expired() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let _guard = acquire_next_test_mutex().lock().await;
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let task = make_test_task_with_unique_url();
repo.create(&task).await.expect("create failed");
let result = repo.expire_tasks().await;
assert!(result.is_ok(), "expire_tasks failed: {:?}", result.err());
let _count = result.unwrap();
}
#[tokio::test]
async fn test_expire_tasks_with_real_db_expires_past_expires_at() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let _guard = acquire_next_test_mutex().lock().await;
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let mut task = make_test_task();
task.expires_at = Some(Utc::now() - Duration::minutes(5));
task.lock_token = Some(crate::domain::id::Id::generate());
task.lock_expires_at = Some(Utc::now() - Duration::minutes(1));
repo.create(&task).await.expect("create failed");
let result = repo.expire_tasks().await;
assert!(result.is_ok(), "expire_tasks failed");
let count = result.unwrap();
assert!(count >= 1, "at least one task should be expired");
let found = repo.find_by_id(task.id).await.expect("find_by_id failed");
let found_task = found.expect("expired task must still exist");
{
assert_eq!(
found_task.status,
TaskStatus::Failed,
"expired task should be marked Failed"
);
assert!(
found_task.completed_at.is_some(),
"expired task must get completed_at"
);
assert!(
found_task.lock_token.is_none(),
"expired task must clear lock_token"
);
assert!(
found_task.lock_expires_at.is_none(),
"expired task must clear lock_expires_at"
);
}
}
#[tokio::test]
async fn test_expire_tasks_reconciles_crawl_counters_and_status() {
use crate::domain::models::crawl_model::{Crawl, CrawlStatus};
use crate::domain::repositories::crawl_repository::CrawlRepository;
use crate::infrastructure::database::repositories::crawl_repo_impl::CrawlRepositoryImpl;
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let _guard = acquire_next_test_mutex().lock().await;
let pool = create_test_db_pool();
let crawl_repo = CrawlRepositoryImpl::new(pool.clone());
let crawl_id = crate::domain::id::Id::generate();
let now = Utc::now();
let crawl = Crawl::with_all_fields(
crawl_id,
crate::domain::id::Id::generate(),
"expire-reconcile".to_string(),
"https://example.com/".to_string(),
"https://example.com/".to_string(),
CrawlStatus::Queued,
json!({}),
1,
0,
0,
now,
now,
None,
);
crawl_repo
.create(&crawl)
.await
.expect("crawl create failed");
let repo = TaskRepositoryImpl::new(pool.clone(), Duration::minutes(5));
let mut task = make_test_task();
task.crawl_id = Some(crawl_id);
task.expires_at = Some(Utc::now() - Duration::minutes(5));
repo.create(&task).await.expect("task create failed");
repo.expire_tasks().await.expect("expire_tasks failed");
let crawl = crawl_repo
.find_by_id(crawl_id)
.await
.expect("find crawl failed")
.expect("crawl must exist");
assert_eq!(crawl.total_tasks(), 1, "total recomputed from tasks");
assert_eq!(crawl.failed_tasks(), 1, "expired task counted as failed");
assert_eq!(crawl.completed_tasks(), 0);
assert_eq!(
crawl.status,
CrawlStatus::Failed,
"all-failed crawl must be terminal Failed"
);
assert!(
crawl.completed_at.is_some(),
"terminal crawl gets completed_at"
);
}
#[tokio::test]
async fn test_expire_tasks_recovers_stuck_crawl_progress_from_tasks() {
use crate::domain::models::crawl_model::{Crawl, CrawlStatus};
use crate::domain::repositories::crawl_repository::CrawlRepository;
use crate::infrastructure::database::repositories::crawl_repo_impl::CrawlRepositoryImpl;
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let _guard = acquire_next_test_mutex().lock().await;
let pool = create_test_db_pool();
let crawl_repo = CrawlRepositoryImpl::new(pool.clone());
let crawl_id = crate::domain::id::Id::generate();
let now = Utc::now();
let stale = now - Duration::hours(1);
let crawl = Crawl::with_all_fields(
crawl_id,
crate::domain::id::Id::generate(),
"stuck-progress".to_string(),
"https://example.com/".to_string(),
"https://example.com/".to_string(),
CrawlStatus::Queued,
json!({}),
2,
0,
0,
stale,
stale,
None,
);
crawl_repo
.create(&crawl)
.await
.expect("crawl create failed");
let repo = TaskRepositoryImpl::new(pool.clone(), Duration::minutes(5));
for _ in 0..2 {
let mut task = make_test_task_with_unique_url();
task.crawl_id = Some(crawl_id);
task.status = TaskStatus::Completed;
task.updated_at = stale;
repo.create(&task).await.expect("task create failed");
}
repo.expire_tasks().await.expect("expire_tasks failed");
let crawl = crawl_repo
.find_by_id(crawl_id)
.await
.expect("find crawl failed")
.expect("crawl must exist");
assert_eq!(crawl.status, CrawlStatus::Completed);
assert_eq!(crawl.total_tasks(), 2);
assert_eq!(crawl.completed_tasks(), 2);
assert_eq!(crawl.failed_tasks(), 0);
assert!(crawl.completed_at.is_some());
}
#[tokio::test]
async fn test_expire_tasks_recovers_skips_recent_task_activity() {
use crate::domain::models::crawl_model::{Crawl, CrawlStatus};
use crate::domain::repositories::crawl_repository::CrawlRepository;
use crate::infrastructure::database::repositories::crawl_repo_impl::CrawlRepositoryImpl;
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let _guard = acquire_next_test_mutex().lock().await;
let pool = create_test_db_pool();
let crawl_repo = CrawlRepositoryImpl::new(pool.clone());
let crawl_id = crate::domain::id::Id::generate();
let now = Utc::now();
let stale = now - Duration::hours(1);
let crawl = Crawl::with_all_fields(
crawl_id,
crate::domain::id::Id::generate(),
"recent-activity".to_string(),
"https://example.com/".to_string(),
"https://example.com/".to_string(),
CrawlStatus::Queued,
json!({}),
2,
0,
0,
stale,
stale,
None,
);
crawl_repo
.create(&crawl)
.await
.expect("crawl create failed");
let repo = TaskRepositoryImpl::new(pool.clone(), Duration::minutes(5));
let mut task = make_test_task_with_unique_url();
task.crawl_id = Some(crawl_id);
task.status = TaskStatus::Completed;
repo.create(&task).await.expect("task create failed");
repo.expire_tasks().await.expect("expire_tasks failed");
let crawl = crawl_repo
.find_by_id(crawl_id)
.await
.expect("find crawl failed")
.expect("crawl must exist");
assert_eq!(
crawl.status,
CrawlStatus::Queued,
"recent task activity must prevent recovery"
);
assert_eq!(crawl.completed_tasks(), 0);
}
#[tokio::test]
async fn test_expire_tasks_recovers_crawl_without_task_rows() {
use crate::domain::models::crawl_model::{Crawl, CrawlStatus};
use crate::domain::repositories::crawl_repository::CrawlRepository;
use crate::infrastructure::database::repositories::crawl_repo_impl::CrawlRepositoryImpl;
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let _guard = acquire_next_test_mutex().lock().await;
let pool = create_test_db_pool();
let crawl_repo = CrawlRepositoryImpl::new(pool.clone());
let crawl_id = crate::domain::id::Id::generate();
let now = Utc::now();
let stale = now - Duration::hours(1);
let crawl = Crawl::with_all_fields(
crawl_id,
crate::domain::id::Id::generate(),
"no-task-rows".to_string(),
"https://example.com/".to_string(),
"https://example.com/".to_string(),
CrawlStatus::Queued,
json!({}),
3,
0,
0,
stale,
stale,
None,
);
crawl_repo
.create(&crawl)
.await
.expect("crawl create failed");
let repo = TaskRepositoryImpl::new(pool.clone(), Duration::minutes(5));
repo.expire_tasks().await.expect("expire_tasks failed");
let crawl = crawl_repo
.find_by_id(crawl_id)
.await
.expect("find crawl failed")
.expect("crawl must exist");
assert_eq!(crawl.status, CrawlStatus::Failed);
assert_eq!(crawl.total_tasks(), 3);
assert_eq!(crawl.failed_tasks(), 3);
assert_eq!(crawl.completed_tasks(), 0);
}
#[tokio::test]
async fn test_find_by_crawl_id_with_real_db_returns_empty_for_unknown() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let result = repo
.find_by_crawl_id(crate::domain::id::Id::generate())
.await;
assert!(
result.is_ok(),
"find_by_crawl_id failed: {:?}",
result.err()
);
assert!(
result.unwrap().is_empty(),
"unknown crawl_id should return empty vec"
);
}
#[tokio::test]
async fn test_find_by_crawl_id_with_real_db_returns_matching_tasks() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let crawl_id = crate::domain::id::Id::generate();
let mut task1 = make_test_task();
task1.crawl_id = Some(crawl_id);
let mut task2 = make_test_task();
task2.crawl_id = Some(crawl_id);
task2.url = format!("{}/task2", task2.url);
let unrelated = make_test_task();
repo.create(&task1).await.expect("create task1 failed");
repo.create(&task2).await.expect("create task2 failed");
repo.create(&unrelated)
.await
.expect("create unrelated failed");
let result = repo.find_by_crawl_id(crawl_id).await;
assert!(result.is_ok(), "find_by_crawl_id failed");
let tasks = result.unwrap();
assert_eq!(tasks.len(), 2, "should find 2 tasks for crawl_id");
let ids: HashSet<crate::domain::id::Id> = tasks.iter().map(|t| t.id).collect();
assert!(ids.contains(&task1.id));
assert!(ids.contains(&task2.id));
assert!(!ids.contains(&unrelated.id));
}
#[tokio::test]
async fn test_query_tasks_with_real_db_returns_empty_for_unknown_team() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let params = TaskQueryParams {
team_id: crate::domain::id::Id::generate(),
..Default::default()
};
let result = repo.query_tasks(params).await;
assert!(result.is_ok(), "query_tasks failed: {:?}", result.err());
let (tasks, total) = result.unwrap();
assert!(
tasks.is_empty(),
"unknown team_id should return empty tasks"
);
assert_eq!(total, 0, "unknown team_id should return total=0");
}
#[tokio::test]
async fn test_query_tasks_with_real_db_returns_matching_tasks() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let team_id = crate::domain::id::Id::generate();
let mut task1 = make_test_task();
task1.team_id = team_id;
task1.task_type = TaskType::Scrape;
let mut task2 = make_test_task();
task2.team_id = team_id;
task2.task_type = TaskType::Crawl;
repo.create(&task1).await.expect("create task1 failed");
repo.create(&task2).await.expect("create task2 failed");
let params = TaskQueryParams {
team_id,
limit: 100,
..Default::default()
};
let result = repo.query_tasks(params).await;
assert!(result.is_ok(), "query_tasks failed");
let (tasks, total) = result.unwrap();
assert_eq!(total, 2, "should find 2 tasks for team_id");
assert_eq!(tasks.len(), 2);
}
#[tokio::test]
async fn test_batch_cancel_returns_empty_for_empty_input() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let result = repo
.batch_cancel(Vec::new(), crate::domain::id::Id::generate(), false)
.await;
assert!(result.is_ok());
let (cancelled, errors) = result.unwrap();
assert!(cancelled.is_empty());
assert!(errors.is_empty());
}
#[tokio::test]
async fn test_batch_cancel_with_real_db_returns_errors_for_unknown_ids() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let unknown_id = crate::domain::id::Id::generate();
let task_ids = vec![unknown_id];
let result = repo
.batch_cancel(task_ids, crate::domain::id::Id::generate(), false)
.await;
assert!(
result.is_ok(),
"batch_cancel should succeed even with unknown IDs"
);
let (cancelled, errors) = result.unwrap();
assert!(cancelled.is_empty(), "no tasks should be cancelled");
assert_eq!(errors.len(), 1, "should report 1 error");
assert_eq!(errors[0].0, unknown_id);
assert!(errors[0].1.contains("not found"));
}
#[tokio::test]
async fn test_batch_cancel_with_real_db_cancels_owned_tasks() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let team_id = crate::domain::id::Id::generate();
let mut task1 = make_test_task();
task1.team_id = team_id;
let mut task2 = make_test_task();
task2.team_id = team_id;
repo.create(&task1).await.expect("create task1 failed");
repo.create(&task2).await.expect("create task2 failed");
let result = repo
.batch_cancel(vec![task1.id, task2.id], team_id, false)
.await;
assert!(result.is_ok(), "batch_cancel failed");
let (cancelled, errors) = result.unwrap();
assert_eq!(cancelled.len(), 2, "both tasks should be cancelled");
assert!(errors.is_empty(), "no errors expected");
let found1 = repo
.find_by_id(task1.id)
.await
.expect("find_by_id failed")
.expect("task1 should exist");
assert_eq!(found1.status, TaskStatus::Cancelled);
assert!(
found1.completed_at.is_some(),
"cancelled 行必须写 completed_at"
);
assert!(found1.lock_token.is_none(), "cancelled 行必须清锁");
assert!(
found1.lock_expires_at.is_none(),
"cancelled 行必须清锁过期时间"
);
let found2 = repo
.find_by_id(task2.id)
.await
.expect("find_by_id failed")
.expect("task2 should exist");
assert_eq!(found2.status, TaskStatus::Cancelled);
}
#[test]
fn test_error_database_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = RepositoryError::Database(anyhow::anyhow!("conn refused"));
assert!(err.to_string().contains("Database error"));
assert!(err.to_string().contains("conn refused"));
}
#[test]
fn test_error_not_found_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = RepositoryError::NotFound;
assert!(err.to_string().contains("Record not found"));
}
#[test]
fn test_from_dberr_to_repository_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::sea_orm::DbErr::Custom("query failed".to_string());
let repo_err: RepositoryError = db_err.into();
assert!(matches!(repo_err, RepositoryError::Database(_)));
assert!(repo_err.to_string().contains("query failed"));
}
#[test]
fn test_pool_accessor_returns_reference_to_same_pool() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let repo = TaskRepositoryImpl::new(pool.clone(), Duration::minutes(5));
let pool_ref = repo.pool();
assert!(Arc::ptr_eq(pool_ref, &pool));
}
#[test]
fn test_new_with_zero_lock_duration() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let repo = TaskRepositoryImpl::new(pool, Duration::zero());
let _ = repo;
}
#[test]
fn test_new_with_large_lock_duration() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let repo = TaskRepositoryImpl::new(pool, Duration::days(7));
let _ = repo;
}
#[test]
fn test_make_test_task_construction() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let task = make_test_task();
assert_eq!(task.task_type, TaskType::Scrape);
assert_eq!(task.url, "http://example.com");
assert_eq!(task.status, TaskStatus::Queued);
}
#[test]
fn test_task_query_params_default() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let params = TaskQueryParams::default();
assert_eq!(params.team_id, crate::domain::id::Id::nil());
assert!(params.crawl_id.is_none());
assert!(params.statuses.is_none());
assert!(params.task_types.is_none());
assert_eq!(params.limit, 0);
assert_eq!(params.offset, 0);
}
#[tokio::test]
async fn test_query_tasks_with_crawl_id_returns_empty() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let params = TaskQueryParams {
team_id: crate::domain::id::Id::generate(),
crawl_id: Some(crate::domain::id::Id::generate()),
..Default::default()
};
let result = repo.query_tasks(params).await;
assert!(result.is_ok(), "query_tasks failed: {:?}", result.err());
let (tasks, total) = result.unwrap();
assert!(tasks.is_empty());
assert_eq!(total, 0);
}
#[tokio::test]
async fn test_query_tasks_with_statuses_returns_empty() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let params = TaskQueryParams {
team_id: crate::domain::id::Id::generate(),
statuses: Some(vec![TaskStatus::Queued, TaskStatus::Active]),
..Default::default()
};
let result = repo.query_tasks(params).await;
assert!(result.is_ok(), "query_tasks failed: {:?}", result.err());
let (tasks, total) = result.unwrap();
assert!(tasks.is_empty());
assert_eq!(total, 0);
}
#[tokio::test]
async fn test_query_tasks_with_task_types_returns_empty() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let params = TaskQueryParams {
team_id: crate::domain::id::Id::generate(),
task_types: Some(vec![TaskType::Scrape, TaskType::Crawl, TaskType::Extract]),
..Default::default()
};
let result = repo.query_tasks(params).await;
assert!(result.is_ok(), "query_tasks failed: {:?}", result.err());
let (tasks, total) = result.unwrap();
assert!(tasks.is_empty());
assert_eq!(total, 0);
}
#[tokio::test]
async fn test_query_tasks_with_all_optional_filters_returns_empty() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let params = TaskQueryParams {
team_id: crate::domain::id::Id::generate(),
crawl_id: Some(crate::domain::id::Id::generate()),
statuses: Some(vec![TaskStatus::Completed, TaskStatus::Failed]),
task_types: Some(vec![TaskType::Scrape]),
limit: 50,
offset: 10,
..Default::default()
};
let result = repo.query_tasks(params).await;
assert!(result.is_ok(), "query_tasks failed: {:?}", result.err());
let (tasks, total) = result.unwrap();
assert!(tasks.is_empty());
assert_eq!(total, 0);
}
#[tokio::test]
async fn test_find_existing_urls_with_multiple_urls_returns_empty_for_unknown() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let urls = vec![
format!(
"http://nonexistent-{}.com",
crate::domain::id::Id::generate()
),
format!(
"http://nonexistent-{}.com",
crate::domain::id::Id::generate()
),
format!(
"http://nonexistent-{}.com",
crate::domain::id::Id::generate()
),
];
let result = repo.find_existing_urls(&urls).await;
assert!(result.is_ok(), "find_existing_urls failed");
assert!(result.unwrap().is_empty());
}
#[tokio::test]
async fn test_batch_cancel_with_multiple_ids_returns_errors_for_unknown() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let id1 = crate::domain::id::Id::generate();
let id2 = crate::domain::id::Id::generate();
let id3 = crate::domain::id::Id::generate();
let task_ids = vec![id1, id2, id3];
let result = repo
.batch_cancel(task_ids, crate::domain::id::Id::generate(), false)
.await;
assert!(result.is_ok(), "batch_cancel should succeed");
let (cancelled, errors) = result.unwrap();
assert!(cancelled.is_empty());
assert_eq!(errors.len(), 3, "all 3 IDs should be reported as not found");
let error_ids: HashSet<crate::domain::id::Id> = errors.iter().map(|(id, _)| *id).collect();
assert!(error_ids.contains(&id1));
assert!(error_ids.contains(&id2));
assert!(error_ids.contains(&id3));
}
#[tokio::test]
async fn test_batch_cancel_with_force_true_returns_errors_for_unknown() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let task_ids = vec![crate::domain::id::Id::generate()];
let result = repo
.batch_cancel(task_ids, crate::domain::id::Id::generate(), true)
.await;
assert!(result.is_ok(), "batch_cancel should succeed");
let (cancelled, errors) = result.unwrap();
assert!(cancelled.is_empty());
assert_eq!(errors.len(), 1);
}
#[tokio::test]
async fn test_reset_stuck_tasks_with_zero_duration_returns_zero_or_more() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let result = repo.reset_stuck_tasks(Duration::zero()).await;
assert!(
result.is_ok(),
"reset_stuck_tasks failed: {:?}",
result.err()
);
let _count = result.unwrap();
}
#[tokio::test]
async fn test_reset_stuck_tasks_with_negative_duration_returns_zero_or_more() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let result = repo.reset_stuck_tasks(Duration::minutes(-30)).await;
assert!(
result.is_ok(),
"reset_stuck_tasks failed: {:?}",
result.err()
);
let _count = result.unwrap();
}
#[tokio::test]
async fn test_exists_by_url_with_empty_string_returns_false() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let result = repo.exists_by_url("").await;
assert!(result.is_ok(), "exists_by_url failed: {:?}", result.err());
let _exists = result.unwrap();
}
#[test]
fn test_from_dberr_record_not_found_to_repository_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::sea_orm::DbErr::RecordNotFound("task missing".to_string());
let repo_err: RepositoryError = db_err.into();
assert!(matches!(repo_err, RepositoryError::Database(_)));
assert!(repo_err.to_string().contains("task missing"));
}
#[test]
fn test_from_dberr_connection_acquire_to_repository_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err =
dbnexus::sea_orm::DbErr::ConnectionAcquire(dbnexus::sea_orm::ConnAcquireErr::Timeout);
let repo_err: RepositoryError = db_err.into();
assert!(matches!(repo_err, RepositoryError::Database(_)));
}
#[test]
fn test_from_dberr_record_not_inserted_to_repository_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::sea_orm::DbErr::RecordNotInserted;
let repo_err: RepositoryError = db_err.into();
assert!(matches!(repo_err, RepositoryError::Database(_)));
}
#[test]
fn test_from_dberr_query_runtime_to_repository_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::sea_orm::DbErr::Query(dbnexus::sea_orm::RuntimeErr::Internal(
"syntax error".to_string(),
));
let repo_err: RepositoryError = db_err.into();
assert!(matches!(repo_err, RepositoryError::Database(_)));
assert!(repo_err.to_string().contains("syntax error"));
}
#[test]
fn test_task_type_scrape_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
assert_eq!(format!("{}", TaskType::Scrape), "scrape");
}
#[test]
fn test_task_type_crawl_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
assert_eq!(format!("{}", TaskType::Crawl), "crawl");
}
#[test]
fn test_task_type_extract_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
assert_eq!(format!("{}", TaskType::Extract), "extract");
}
#[test]
fn test_task_status_queued_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
assert_eq!(format!("{}", TaskStatus::Queued), "queued");
}
#[test]
fn test_task_status_active_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
assert_eq!(format!("{}", TaskStatus::Active), "active");
}
#[test]
fn test_task_status_completed_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
assert_eq!(format!("{}", TaskStatus::Completed), "completed");
}
#[test]
fn test_task_status_failed_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
assert_eq!(format!("{}", TaskStatus::Failed), "failed");
}
#[test]
fn test_task_status_cancelled_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
assert_eq!(format!("{}", TaskStatus::Cancelled), "cancelled");
}
#[test]
fn test_from_dberr_connection_acquire_closed_to_repository_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::sea_orm::DbErr::ConnectionAcquire(
dbnexus::sea_orm::ConnAcquireErr::ConnectionClosed,
);
let repo_err: RepositoryError = db_err.into();
assert!(matches!(repo_err, RepositoryError::Database(_)));
}
#[test]
fn test_from_dberr_record_not_updated_to_repository_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::sea_orm::DbErr::RecordNotUpdated;
let repo_err: RepositoryError = db_err.into();
assert!(matches!(repo_err, RepositoryError::Database(_)));
}
#[test]
fn test_from_dberr_query_sqlx_error_to_repository_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let inner = dbnexus::sea_orm::sqlx::Error::RowNotFound;
let db_err = dbnexus::sea_orm::DbErr::Query(dbnexus::sea_orm::RuntimeErr::SqlxError(
std::sync::Arc::new(inner),
));
let repo_err: RepositoryError = db_err.into();
assert!(matches!(repo_err, RepositoryError::Database(_)));
}
#[test]
fn test_from_dberr_conn_runtime_to_repository_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::sea_orm::DbErr::Conn(dbnexus::sea_orm::RuntimeErr::Internal(
"conn lost".to_string(),
));
let repo_err: RepositoryError = db_err.into();
assert!(matches!(repo_err, RepositoryError::Database(_)));
assert!(repo_err.to_string().contains("conn lost"));
}
#[test]
fn test_from_dberr_exec_runtime_to_repository_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::sea_orm::DbErr::Exec(dbnexus::sea_orm::RuntimeErr::Internal(
"exec failed".to_string(),
));
let repo_err: RepositoryError = db_err.into();
assert!(matches!(repo_err, RepositoryError::Database(_)));
assert!(repo_err.to_string().contains("exec failed"));
}
#[test]
fn test_from_dberr_type_to_repository_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::sea_orm::DbErr::Type("invalid type".to_string());
let repo_err: RepositoryError = db_err.into();
assert!(matches!(repo_err, RepositoryError::Database(_)));
assert!(repo_err.to_string().contains("invalid type"));
}
#[test]
fn test_from_dberr_json_to_repository_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::sea_orm::DbErr::Json("parse error".to_string());
let repo_err: RepositoryError = db_err.into();
assert!(matches!(repo_err, RepositoryError::Database(_)));
assert!(repo_err.to_string().contains("parse error"));
}
#[test]
fn test_from_dberr_attr_not_set_to_repository_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::sea_orm::DbErr::AttrNotSet("name".to_string());
let repo_err: RepositoryError = db_err.into();
assert!(matches!(repo_err, RepositoryError::Database(_)));
assert!(repo_err.to_string().contains("name"));
}
#[test]
fn test_from_dberr_convert_from_u64_to_repository_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::sea_orm::DbErr::ConvertFromU64("String");
let repo_err: RepositoryError = db_err.into();
assert!(matches!(repo_err, RepositoryError::Database(_)));
}
#[test]
fn test_from_dberr_unpack_insert_id_to_repository_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::sea_orm::DbErr::UnpackInsertId;
let repo_err: RepositoryError = db_err.into();
assert!(matches!(repo_err, RepositoryError::Database(_)));
}
#[test]
fn test_from_dberr_update_get_primary_key_to_repository_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::sea_orm::DbErr::UpdateGetPrimaryKey;
let repo_err: RepositoryError = db_err.into();
assert!(matches!(repo_err, RepositoryError::Database(_)));
}
#[test]
fn test_from_dberr_migration_to_repository_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::sea_orm::DbErr::Migration("schema mismatch".to_string());
let repo_err: RepositoryError = db_err.into();
assert!(matches!(repo_err, RepositoryError::Database(_)));
assert!(repo_err.to_string().contains("schema mismatch"));
}
#[test]
fn test_from_dberr_mutex_poison_error_to_repository_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::sea_orm::DbErr::MutexPoisonError;
let repo_err: RepositoryError = db_err.into();
assert!(matches!(repo_err, RepositoryError::Database(_)));
}
#[test]
fn test_from_dberr_rbac_error_to_repository_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::sea_orm::DbErr::RbacError("forbidden".to_string());
let repo_err: RepositoryError = db_err.into();
assert!(matches!(repo_err, RepositoryError::Database(_)));
assert!(repo_err.to_string().contains("forbidden"));
}
#[test]
fn test_from_dberr_access_denied_to_repository_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::sea_orm::DbErr::AccessDenied {
permission: "write".to_string(),
resource: "task".to_string(),
};
let repo_err: RepositoryError = db_err.into();
assert!(matches!(repo_err, RepositoryError::Database(_)));
assert!(repo_err.to_string().contains("write"));
assert!(repo_err.to_string().contains("task"));
}
#[test]
fn test_from_dberr_backend_not_supported_to_repository_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::sea_orm::DbErr::BackendNotSupported {
db: "mysql",
ctx: "not configured",
};
let repo_err: RepositoryError = db_err.into();
assert!(matches!(repo_err, RepositoryError::Database(_)));
}
#[test]
fn test_from_dberr_try_into_err_to_repository_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let source_err: std::sync::Arc<dyn std::error::Error + Send + Sync> = std::sync::Arc::new(
std::io::Error::new(std::io::ErrorKind::InvalidData, "bad value"),
);
let db_err = dbnexus::sea_orm::DbErr::TryIntoErr {
from: "String",
into: "i32",
source: source_err,
};
let repo_err: RepositoryError = db_err.into();
assert!(matches!(repo_err, RepositoryError::Database(_)));
}
#[test]
fn test_from_dberr_key_arity_mismatch_to_repository_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::sea_orm::DbErr::KeyArityMismatch {
expected: 2,
received: 1,
};
let repo_err: RepositoryError = db_err.into();
assert!(matches!(repo_err, RepositoryError::Database(_)));
}
#[test]
fn test_from_dberr_primary_key_not_set_to_repository_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = dbnexus::sea_orm::DbErr::PrimaryKeyNotSet { ctx: "update" };
let repo_err: RepositoryError = db_err.into();
assert!(matches!(repo_err, RepositoryError::Database(_)));
}
#[test]
fn test_repository_error_database_display_exact() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = RepositoryError::Database(anyhow::anyhow!("connection refused"));
let msg = err.to_string();
assert!(msg.contains("Database error"));
assert!(msg.contains("connection refused"));
}
#[test]
fn test_repository_error_database_display_with_empty_message() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = RepositoryError::Database(anyhow::anyhow!(""));
let msg = err.to_string();
assert!(msg.contains("Database error"));
}
#[test]
fn test_repository_error_not_found_display_exact() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = RepositoryError::NotFound;
assert_eq!(err.to_string(), "Record not found");
}
#[test]
fn test_repository_error_implements_debug() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err1 = RepositoryError::Database(anyhow::anyhow!("e"));
let err2 = RepositoryError::NotFound;
let debug1 = format!("{:?}", err1);
let debug2 = format!("{:?}", err2);
assert!(!debug1.is_empty());
assert!(!debug2.is_empty());
}
#[tokio::test]
async fn test_exists_by_url_with_unicode_returns_false_for_unknown() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let result = repo.exists_by_url("http://例子.com/测试").await;
assert!(result.is_ok(), "exists_by_url failed: {:?}", result.err());
let _exists = result.unwrap();
}
#[tokio::test]
async fn test_exists_by_url_with_long_url_returns_false_for_unknown() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let long_url = format!(
"http://nonexistent-{}.com/{}",
crate::domain::id::Id::generate(),
"a".repeat(2000)
);
let result = repo.exists_by_url(&long_url).await;
assert!(result.is_ok(), "exists_by_url failed: {:?}", result.err());
assert!(!result.unwrap(), "long unknown URL should return false");
}
#[tokio::test]
async fn test_find_existing_urls_with_unicode_urls_returns_empty_for_unknown() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let urls = vec![
format!("http://例子-{}.com", crate::domain::id::Id::generate()),
format!("http://example-{}.org", crate::domain::id::Id::generate()),
];
let result = repo.find_existing_urls(&urls).await;
assert!(result.is_ok(), "find_existing_urls failed");
assert!(result.unwrap().is_empty());
}
#[tokio::test]
async fn test_find_existing_urls_with_empty_string_in_list_returns_empty() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let urls = vec!["".to_string()];
let result = repo.find_existing_urls(&urls).await;
assert!(result.is_ok(), "find_existing_urls failed");
let _existing = result.unwrap();
}
#[tokio::test]
async fn test_find_existing_urls_with_mixed_empty_and_nonempty_returns_only_matches() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let task = make_test_task_with_unique_url();
repo.create(&task).await.expect("create failed");
let urls = vec!["".to_string(), task.url.clone()];
let result = repo.find_existing_urls(&urls).await;
assert!(result.is_ok(), "find_existing_urls failed");
let existing = result.unwrap();
assert!(
existing.contains(&task.url),
"should find the created task URL"
);
}
#[tokio::test]
async fn test_find_by_id_with_nil_uuid_returns_none() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let result = repo.find_by_id(crate::domain::id::Id::nil()).await;
assert!(result.is_ok(), "find_by_id failed: {:?}", result.err());
let _found = result.unwrap();
}
#[tokio::test]
async fn test_mark_completed_with_nil_uuid_succeeds_silently() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let result = repo
.mark_completed(crate::domain::id::Id::nil(), None)
.await;
assert!(result.is_ok(), "mark_completed failed: {:?}", result.err());
}
#[tokio::test]
async fn test_mark_failed_with_nil_uuid_succeeds_silently() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let result = repo.mark_failed(crate::domain::id::Id::nil(), None).await;
assert!(result.is_ok(), "mark_failed failed: {:?}", result.err());
}
#[tokio::test]
async fn test_mark_cancelled_with_nil_uuid_succeeds_silently() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let result = repo.mark_cancelled(crate::domain::id::Id::nil()).await;
assert!(result.is_ok(), "mark_cancelled failed: {:?}", result.err());
}
#[tokio::test]
async fn test_acquire_next_with_nil_worker_id_returns_ok() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let _guard = acquire_next_test_mutex().lock().await;
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let result = repo.acquire_next(crate::domain::id::Id::nil()).await;
assert!(result.is_ok(), "acquire_next failed: {:?}", result.err());
let _acquired = result.unwrap();
}
#[tokio::test]
async fn test_cancel_tasks_by_crawl_id_with_nil_uuid_returns_zero() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let result = repo
.cancel_tasks_by_crawl_id(crate::domain::id::Id::nil())
.await;
assert!(
result.is_ok(),
"cancel_tasks_by_crawl_id failed: {:?}",
result.err()
);
let _count = result.unwrap();
}
#[tokio::test]
async fn test_find_by_crawl_id_with_nil_uuid_returns_empty() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let result = repo.find_by_crawl_id(crate::domain::id::Id::nil()).await;
assert!(
result.is_ok(),
"find_by_crawl_id failed: {:?}",
result.err()
);
let _tasks = result.unwrap();
}
#[tokio::test]
async fn test_batch_cancel_with_nil_uuids_returns_errors() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let task_ids = vec![crate::domain::id::Id::nil()];
let result = repo
.batch_cancel(task_ids, crate::domain::id::Id::nil(), false)
.await;
assert!(result.is_ok(), "batch_cancel should succeed");
let (cancelled, errors) = result.unwrap();
assert!(
cancelled.is_empty(),
"nil UUID task should not be cancelled"
);
assert_eq!(
errors.len(),
1,
"nil UUID task should be reported as not found"
);
}
#[tokio::test]
async fn test_query_tasks_with_zero_limit_offset_returns_empty() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let params = TaskQueryParams {
team_id: crate::domain::id::Id::generate(),
limit: 0,
offset: 0,
..Default::default()
};
let result = repo.query_tasks(params).await;
assert!(result.is_ok(), "query_tasks failed: {:?}", result.err());
let (tasks, total) = result.unwrap();
assert!(tasks.is_empty());
assert_eq!(total, 0);
}
#[tokio::test]
async fn test_query_tasks_with_max_limit_returns_empty() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let params = TaskQueryParams {
team_id: crate::domain::id::Id::generate(),
limit: u32::MAX,
offset: 0,
..Default::default()
};
let result = repo.query_tasks(params).await;
assert!(result.is_ok(), "query_tasks failed: {:?}", result.err());
let (tasks, total) = result.unwrap();
assert!(tasks.is_empty());
assert_eq!(total, 0);
}
#[tokio::test]
async fn test_query_tasks_with_nil_team_id_returns_empty() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let params = TaskQueryParams {
team_id: crate::domain::id::Id::nil(),
..Default::default()
};
let result = repo.query_tasks(params).await;
assert!(result.is_ok(), "query_tasks failed: {:?}", result.err());
let (tasks, _total) = result.unwrap();
assert!(tasks.is_empty());
}
#[tokio::test]
async fn test_query_tasks_with_empty_statuses_vec_returns_empty() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let params = TaskQueryParams {
team_id: crate::domain::id::Id::generate(),
statuses: Some(Vec::new()),
..Default::default()
};
let result = repo.query_tasks(params).await;
assert!(result.is_ok(), "query_tasks failed: {:?}", result.err());
let (tasks, total) = result.unwrap();
assert!(tasks.is_empty());
assert_eq!(total, 0);
}
#[tokio::test]
async fn test_query_tasks_with_empty_task_types_vec_returns_empty() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = TaskRepositoryImpl::new(create_test_db_pool(), Duration::minutes(5));
let params = TaskQueryParams {
team_id: crate::domain::id::Id::generate(),
task_types: Some(Vec::new()),
..Default::default()
};
let result = repo.query_tasks(params).await;
assert!(result.is_ok(), "query_tasks failed: {:?}", result.err());
let (tasks, total) = result.unwrap();
assert!(tasks.is_empty());
assert_eq!(total, 0);
}
#[test]
fn test_repository_clone_preserves_pool_identity() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let repo = TaskRepositoryImpl::new(pool.clone(), Duration::minutes(5));
let cloned = repo.clone();
assert!(Arc::ptr_eq(&repo.pool, &cloned.pool));
}
#[test]
fn test_new_with_distinct_pools_do_not_share_identity() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool1 = crate::common::test_helpers::build_independent_test_db_pool();
let pool2 = crate::common::test_helpers::build_independent_test_db_pool();
let repo1 = TaskRepositoryImpl::new(pool1, Duration::minutes(5));
let repo2 = TaskRepositoryImpl::new(pool2, Duration::minutes(5));
assert!(!Arc::ptr_eq(&repo1.pool, &repo2.pool));
}