use super::*;
use crate::common::test_helpers::create_test_db_pool;
use crate::domain::retention_policy::RetentionBatchPolicy;
use chrono::Duration;
static RETENTION_TEST_LOCK: std::sync::OnceLock<tokio::sync::Mutex<()>> =
std::sync::OnceLock::new();
fn retention_lock() -> &'static tokio::sync::Mutex<()> {
RETENTION_TEST_LOCK.get_or_init(|| tokio::sync::Mutex::new(()))
}
fn sample_result_with_age(days_ago: i64) -> ScrapeResult {
ScrapeResult {
id: crate::domain::id::Id::generate(),
task_id: crate::domain::id::Id::generate(),
url: "https://example.com/retention".to_string(),
status_code: 200,
content: "<html>retention test</html>".to_string(),
content_type: "text/html".to_string(),
headers: serde_json::json!({}),
meta_data: serde_json::json!({}),
screenshot: None,
response_time_ms: 100,
created_at: chrono::Utc::now() - Duration::days(days_ago),
}
}
#[tokio::test]
async fn cleanup_expired_deletes_old_keeps_recent() {
let _guard = retention_lock().lock().await;
let repo = ScrapeResultRepositoryImpl::new(create_test_db_pool());
let old = sample_result_with_age(40);
let recent = sample_result_with_age(1);
repo.save(old.clone()).await.expect("save old failed");
repo.save(recent.clone()).await.expect("save recent failed");
let deleted = repo
.cleanup_expired(30, &RetentionBatchPolicy::default())
.await
.expect("cleanup_expired failed");
assert!(
deleted >= 1,
"deleted count should include our old row: {deleted}"
);
assert!(
repo.find_by_task_id(old.task_id)
.await
.expect("query failed")
.is_none(),
"40-day-old row should be deleted"
);
let found = repo
.find_by_task_id(recent.task_id)
.await
.expect("query failed");
assert!(found.is_some(), "1-day-old row should be kept");
}
#[tokio::test]
async fn cleanup_expired_with_zero_retention_removes_fresh_rows() {
let _guard = retention_lock().lock().await;
let repo = ScrapeResultRepositoryImpl::new(create_test_db_pool());
let fresh = sample_result_with_age(0);
repo.save(fresh.clone()).await.expect("save failed");
let deleted = repo
.cleanup_expired(0, &RetentionBatchPolicy::default())
.await
.expect("cleanup_expired failed");
assert!(
deleted >= 1,
"fresh row should be removable with 0 retention: {deleted}"
);
assert!(
repo.find_by_task_id(fresh.task_id)
.await
.expect("query failed")
.is_none(),
"row should be deleted with 0-day retention"
);
}
#[tokio::test]
async fn cleanup_expired_batches_until_drained() {
let _guard = retention_lock().lock().await;
let repo = ScrapeResultRepositoryImpl::new(create_test_db_pool());
let mut old_tasks = Vec::new();
for _ in 0..5 {
let r = sample_result_with_age(40);
old_tasks.push(r.task_id);
repo.save(r).await.expect("save old failed");
}
let recent = sample_result_with_age(1);
repo.save(recent.clone()).await.expect("save recent failed");
let policy = RetentionBatchPolicy {
batch_size: 2,
max_rows_per_cycle: 100_000,
statement_timeout_ms: 60_000,
};
let deleted = repo
.cleanup_expired(30, &policy)
.await
.expect("cleanup_expired failed");
assert_eq!(deleted, 5, "all 5 old rows must be deleted across batches");
for task_id in old_tasks {
assert!(
repo.find_by_task_id(task_id)
.await
.expect("query failed")
.is_none(),
"old row should be deleted"
);
}
assert!(
repo.find_by_task_id(recent.task_id)
.await
.expect("query failed")
.is_some(),
"recent row must survive"
);
}
#[tokio::test]
async fn cleanup_expired_caps_at_max_rows_per_cycle() {
let _guard = retention_lock().lock().await;
let repo = ScrapeResultRepositoryImpl::new(create_test_db_pool());
for _ in 0..5 {
repo.save(sample_result_with_age(40))
.await
.expect("save old failed");
}
let policy = RetentionBatchPolicy {
batch_size: 2,
max_rows_per_cycle: 3,
statement_timeout_ms: 60_000,
};
let deleted = repo
.cleanup_expired(30, &policy)
.await
.expect("cleanup_expired failed");
assert_eq!(
deleted, 3,
"deletion must stop once max_rows_per_cycle is reached"
);
}