use crate::domain::models::ScrapeResult;
use crate::domain::repositories::scrape_result_repository::ScrapeResultRepository;
use crate::infrastructure::database::entities::scrape_result as db_entity;
use async_trait::async_trait;
use dbnexus::sea_orm::{
ActiveModelTrait, ColumnTrait, ConnectionTrait, DatabaseBackend, EntityTrait, PaginatorTrait,
QueryFilter, QueryOrder, QueryResult, QuerySelect, Set, Statement,
};
use dbnexus::DbPool;
use std::sync::Arc;
pub struct ScrapeResultRepositoryImpl {
pool: Arc<DbPool>,
}
impl ScrapeResultRepositoryImpl {
pub fn new(pool: Arc<DbPool>) -> Self {
Self { pool }
}
pub fn pool(&self) -> &Arc<DbPool> {
&self.pool
}
fn to_active_model(result: &ScrapeResult) -> db_entity::ActiveModel {
use chrono::FixedOffset;
db_entity::ActiveModel {
id: Set(result.id.into()),
task_id: Set(result.task_id.into()),
url: Set(result.url.clone()),
status_code: Set(result.status_code),
content: Set(result.content.clone()),
content_type: Set(result.content_type.clone()),
headers: Set(Some(result.headers.clone())),
meta_data: Set(Some(result.meta_data.clone())),
screenshot: Set(result.screenshot.clone()),
response_time_ms: Set(result.response_time_ms),
created_at: Set(result
.created_at
.with_timezone(&FixedOffset::east_opt(0).unwrap())),
}
}
fn to_domain(model: db_entity::Model) -> ScrapeResult {
ScrapeResult {
id: model.id.into(),
task_id: model.task_id.into(),
url: model.url,
status_code: model.status_code,
content: model.content,
content_type: model.content_type,
headers: model.headers.unwrap_or(serde_json::json!({})),
meta_data: model.meta_data.unwrap_or(serde_json::json!({})),
screenshot: model.screenshot,
response_time_ms: model.response_time_ms,
created_at: model.created_at.with_timezone(&chrono::Utc),
}
}
}
#[async_trait]
impl ScrapeResultRepository for ScrapeResultRepositoryImpl {
async fn has_result_for_task(&self, task_id: crate::domain::id::Id) -> anyhow::Result<bool> {
let session = self
.pool
.get_session("admin")
.await
.map_err(|e| anyhow::anyhow!("Failed to get session: {}", e))?;
let conn = session
.connection()
.map_err(|e| anyhow::anyhow!("Failed to get connection: {}", e))?;
let count = db_entity::Entity::find()
.filter(db_entity::Column::TaskId.eq(task_id))
.count(conn)
.await
.map_err(|e| anyhow::anyhow!("Failed to count results: {}", e))?;
Ok(count > 0)
}
async fn save(&self, result: ScrapeResult) -> anyhow::Result<()> {
let session = self
.pool
.get_session("admin")
.await
.map_err(|e| anyhow::anyhow!("Failed to get session: {}", e))?;
let conn = session
.connection()
.map_err(|e| anyhow::anyhow!("Failed to get connection: {}", e))?;
let active_model = Self::to_active_model(&result);
active_model
.insert(conn)
.await
.map_err(|e| anyhow::anyhow!("Failed to insert: {}", e))?;
Ok(())
}
async fn find_by_task_id(
&self,
task_id: crate::domain::id::Id,
) -> anyhow::Result<Option<ScrapeResult>> {
let session = self
.pool
.get_session("admin")
.await
.map_err(|e| anyhow::anyhow!("Failed to get session: {}", e))?;
let conn = session
.connection()
.map_err(|e| anyhow::anyhow!("Failed to get connection: {}", e))?;
let result = db_entity::Entity::find()
.filter(db_entity::Column::TaskId.eq(task_id))
.one(conn)
.await
.map_err(|e| anyhow::anyhow!("Failed to find: {}", e))?;
Ok(result.map(Self::to_domain))
}
async fn find_by_task_ids(
&self,
task_ids: &[crate::domain::id::Id],
) -> anyhow::Result<Vec<ScrapeResult>> {
if task_ids.is_empty() {
return Ok(Vec::new());
}
let session = self
.pool
.get_session("admin")
.await
.map_err(|e| anyhow::anyhow!("Failed to get session: {}", e))?;
let conn = session
.connection()
.map_err(|e| anyhow::anyhow!("Failed to get connection: {}", e))?;
let results = db_entity::Entity::find()
.filter(db_entity::Column::TaskId.is_in(task_ids.to_vec()))
.all(conn)
.await
.map_err(|e| anyhow::anyhow!("Failed to find: {}", e))?;
Ok(results.into_iter().map(Self::to_domain).collect())
}
async fn get_team_avg_response_time(
&self,
team_id: crate::domain::id::Id,
) -> anyhow::Result<f64> {
let session = self
.pool
.get_session("admin")
.await
.map_err(|e| anyhow::anyhow!("Failed to get session: {}", e))?;
let conn = session
.connection()
.map_err(|e| anyhow::anyhow!("Failed to get connection: {}", e))?;
let stmt = Statement::from_sql_and_values(
DatabaseBackend::Postgres,
r#"SELECT COALESCE(AVG(sr.response_time_ms), 0)::DOUBLE PRECISION AS avg_ms
FROM scrape_results sr
JOIN tasks t ON sr.task_id = t.id
WHERE t.team_id = $1
AND sr.created_at >= NOW() - INTERVAL '30 days'"#,
[team_id.into()],
);
let row: Option<QueryResult> = conn
.query_one_raw(stmt)
.await
.map_err(|e| anyhow::anyhow!("Failed to query avg response time: {}", e))?;
let avg = row
.and_then(|r| r.try_get::<f64>("", "avg_ms").ok())
.unwrap_or(0.0);
Ok(avg)
}
async fn cleanup_expired(&self, retention_days: i64) -> anyhow::Result<u64> {
if retention_days <= 0 {
return Ok(0);
}
let delta = chrono::TimeDelta::try_days(retention_days)
.ok_or_else(|| anyhow::anyhow!("retention_days out of range: {}", retention_days))?;
let cutoff = chrono::Utc::now() - delta;
let cutoff = cutoff.with_timezone(&chrono::FixedOffset::east_opt(0).unwrap());
let session = self
.pool
.get_session("admin")
.await
.map_err(|e| anyhow::anyhow!("Failed to get session: {}", e))?;
let conn = session
.connection()
.map_err(|e| anyhow::anyhow!("Failed to get connection: {}", e))?;
let result = db_entity::Entity::delete_many()
.filter(db_entity::Column::CreatedAt.lt(cutoff))
.exec(conn)
.await
.map_err(|e| anyhow::anyhow!("Failed to cleanup expired results: {}", e))?;
Ok(result.rows_affected)
}
async fn list_distinct_urls(
&self,
limit: u32,
after_url: Option<String>,
) -> anyhow::Result<Vec<String>> {
let session = self
.pool
.get_session("admin")
.await
.map_err(|e| anyhow::anyhow!("Failed to get session: {}", e))?;
let conn = session
.connection()
.map_err(|e| anyhow::anyhow!("Failed to get connection: {}", e))?;
let mut query = db_entity::Entity::find()
.select_only()
.column(db_entity::Column::Url)
.distinct()
.order_by_asc(db_entity::Column::Url)
.limit(u64::from(limit));
if let Some(after) = after_url {
query = query.filter(db_entity::Column::Url.gt(after));
}
let urls = query
.into_tuple::<String>()
.all(conn)
.await
.map_err(|e| anyhow::anyhow!("Failed to list distinct urls: {}", e))?;
Ok(urls)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::common::test_helpers::create_test_db_pool;
use chrono::{FixedOffset, TimeZone};
fn sample_scrape_result() -> ScrapeResult {
ScrapeResult {
id: crate::domain::id::Id::generate(),
task_id: crate::domain::id::Id::generate(),
url: "https://example.com/page".to_string(),
status_code: 200,
content: "<html>hello</html>".to_string(),
content_type: "text/html".to_string(),
headers: serde_json::json!({"content-type": "text/html"}),
meta_data: serde_json::json!({"lang": "en"}),
screenshot: Some("base64screenshot".to_string()),
response_time_ms: 150,
created_at: chrono::DateTime::from_timestamp(1_700_000_000, 0)
.expect("valid timestamp"),
}
}
fn sample_db_model() -> db_entity::Model {
db_entity::Model {
id: crate::domain::id::Id::generate().into(),
task_id: crate::domain::id::Id::generate().into(),
url: "https://example.com/page".to_string(),
status_code: 404,
content: "not found".to_string(),
content_type: "text/plain".to_string(),
response_time_ms: 42,
created_at: FixedOffset::east_opt(0).unwrap().from_utc_datetime(
&chrono::DateTime::from_timestamp(1_700_000_000, 0)
.expect("valid timestamp")
.naive_utc(),
),
headers: Some(serde_json::json!({"x-custom": "value"})),
meta_data: Some(serde_json::json!({"source": "test"})),
screenshot: None,
}
}
#[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 = ScrapeResultRepositoryImpl::new(pool);
let pool_ref = repo.pool();
assert!(Arc::strong_count(pool_ref) >= 1);
}
#[test]
fn test_to_active_model_converts_all_fields() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let result = sample_scrape_result();
let active = ScrapeResultRepositoryImpl::to_active_model(&result);
assert_eq!(result.id, active.id.unwrap());
assert_eq!(result.task_id, active.task_id.unwrap());
assert_eq!(active.url.unwrap(), result.url);
assert_eq!(active.status_code.unwrap(), result.status_code);
assert_eq!(active.content.unwrap(), result.content);
assert_eq!(active.content_type.unwrap(), result.content_type);
assert_eq!(active.response_time_ms.unwrap(), result.response_time_ms);
assert_eq!(active.screenshot.unwrap(), result.screenshot);
assert_eq!(active.headers.unwrap(), Some(result.headers.clone()));
assert_eq!(active.meta_data.unwrap(), Some(result.meta_data.clone()));
}
#[test]
fn test_to_active_model_with_none_screenshot() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let mut result = sample_scrape_result();
result.screenshot = None;
let active = ScrapeResultRepositoryImpl::to_active_model(&result);
assert_eq!(active.screenshot.unwrap(), None);
}
#[test]
fn test_to_domain_converts_all_fields() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let model = sample_db_model();
let domain = ScrapeResultRepositoryImpl::to_domain(model.clone());
assert_eq!(domain.id, model.id);
assert_eq!(domain.task_id, model.task_id);
assert_eq!(domain.url, model.url);
assert_eq!(domain.status_code, model.status_code);
assert_eq!(domain.content, model.content);
assert_eq!(domain.content_type, model.content_type);
assert_eq!(domain.response_time_ms, model.response_time_ms);
assert_eq!(domain.screenshot, model.screenshot);
assert_eq!(domain.headers, model.headers.unwrap());
assert_eq!(domain.meta_data, model.meta_data.unwrap());
}
#[test]
fn test_to_domain_with_null_headers_uses_default_object() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let mut model = sample_db_model();
model.headers = None;
let domain = ScrapeResultRepositoryImpl::to_domain(model);
assert_eq!(domain.headers, serde_json::json!({}));
}
#[test]
fn test_to_domain_with_null_meta_data_uses_default_object() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let mut model = sample_db_model();
model.meta_data = None;
let domain = ScrapeResultRepositoryImpl::to_domain(model);
assert_eq!(domain.meta_data, serde_json::json!({}));
}
#[test]
fn test_to_domain_roundtrip_preserves_core_fields() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let original = sample_scrape_result();
let active = ScrapeResultRepositoryImpl::to_active_model(&original);
let model = db_entity::Model {
id: active.id.unwrap(),
task_id: active.task_id.unwrap(),
url: active.url.unwrap(),
status_code: active.status_code.unwrap(),
content: active.content.unwrap(),
content_type: active.content_type.unwrap(),
response_time_ms: active.response_time_ms.unwrap(),
created_at: active.created_at.unwrap(),
headers: active.headers.unwrap(),
meta_data: active.meta_data.unwrap(),
screenshot: active.screenshot.unwrap(),
};
let roundtrip = ScrapeResultRepositoryImpl::to_domain(model);
assert_eq!(roundtrip.id, original.id);
assert_eq!(roundtrip.url, original.url);
assert_eq!(roundtrip.content, original.content);
assert_eq!(roundtrip.headers, original.headers);
assert_eq!(roundtrip.meta_data, original.meta_data);
}
#[tokio::test]
async fn test_save_creates_record() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = ScrapeResultRepositoryImpl::new(create_test_db_pool());
let mut result = sample_scrape_result();
result.id = crate::domain::id::Id::generate();
result.task_id = crate::domain::id::Id::generate();
let saved = repo.save(result.clone()).await;
assert!(saved.is_ok(), "save failed: {:?}", saved.err());
let found = repo
.find_by_task_id(result.task_id)
.await
.expect("find_by_task_id failed")
.expect("record should exist after save");
assert_eq!(found.id, result.id);
assert_eq!(found.task_id, result.task_id);
assert_eq!(found.url, result.url);
assert_eq!(found.status_code, result.status_code);
assert_eq!(found.content, result.content);
assert_eq!(found.content_type, result.content_type);
assert_eq!(found.response_time_ms, result.response_time_ms);
}
#[tokio::test]
async fn test_find_by_task_id_returns_none_for_unknown() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = ScrapeResultRepositoryImpl::new(create_test_db_pool());
let result = repo
.find_by_task_id(crate::domain::id::Id::generate())
.await;
assert!(result.is_ok(), "find_by_task_id failed: {:?}", result.err());
assert!(
result.unwrap().is_none(),
"unknown task_id should return None"
);
}
#[tokio::test]
async fn test_find_by_task_ids_returns_empty_for_unknown() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = ScrapeResultRepositoryImpl::new(create_test_db_pool());
let result = repo
.find_by_task_ids(&[
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
])
.await;
assert!(
result.is_ok(),
"find_by_task_ids failed: {:?}",
result.err()
);
assert!(
result.unwrap().is_empty(),
"unknown task_ids should return empty vec"
);
}
#[tokio::test]
async fn test_find_by_task_ids_with_empty_slice_returns_empty_vec() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = ScrapeResultRepositoryImpl::new(create_test_db_pool());
let result = repo.find_by_task_ids(&[]).await;
assert!(
result.is_ok(),
"empty slice should short-circuit without DB"
);
assert!(result.unwrap().is_empty());
}
#[tokio::test]
async fn test_get_team_avg_response_time_returns_zero_for_unknown_team() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = ScrapeResultRepositoryImpl::new(create_test_db_pool());
let result = repo
.get_team_avg_response_time(crate::domain::id::Id::generate())
.await;
assert!(
result.is_ok(),
"get_team_avg_response_time failed: {:?}",
result.err()
);
assert_eq!(result.unwrap(), 0.0);
}
#[tokio::test]
async fn test_find_by_task_ids_with_single_id_returns_empty_for_unknown() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = ScrapeResultRepositoryImpl::new(create_test_db_pool());
let result = repo
.find_by_task_ids(&[crate::domain::id::Id::generate()])
.await;
assert!(
result.is_ok(),
"find_by_task_ids failed: {:?}",
result.err()
);
assert!(
result.unwrap().is_empty(),
"unknown single id should return empty vec"
);
}
#[tokio::test]
async fn test_find_by_task_ids_with_many_ids_returns_empty_for_unknown() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = ScrapeResultRepositoryImpl::new(create_test_db_pool());
let ids: Vec<crate::domain::id::Id> = (0..100)
.map(|_| crate::domain::id::Id::generate())
.collect();
let result = repo.find_by_task_ids(&ids).await;
assert!(
result.is_ok(),
"find_by_task_ids failed: {:?}",
result.err()
);
assert!(
result.unwrap().is_empty(),
"unknown ids should return empty vec"
);
}
#[tokio::test]
async fn test_find_by_task_id_with_nil_uuid_returns_none() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = ScrapeResultRepositoryImpl::new(create_test_db_pool());
let result = repo
.find_by_task_id(crate::domain::id::Id::generate())
.await;
assert!(result.is_ok(), "find_by_task_id failed: {:?}", result.err());
assert!(
result.unwrap().is_none(),
"unknown task_id should return None"
);
}
#[tokio::test]
async fn test_save_with_nil_task_id_succeeds() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = ScrapeResultRepositoryImpl::new(create_test_db_pool());
let mut result = sample_scrape_result();
result.id = crate::domain::id::Id::generate();
result.task_id = crate::domain::id::Id::nil();
let res = repo.save(result).await;
assert!(res.is_ok(), "save with nil task_id failed: {:?}", res.err());
}
#[tokio::test]
async fn test_get_team_avg_response_time_with_nil_uuid_returns_zero() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = ScrapeResultRepositoryImpl::new(create_test_db_pool());
let result = repo
.get_team_avg_response_time(crate::domain::id::Id::nil())
.await;
assert!(result.is_ok());
assert_eq!(result.unwrap(), 0.0);
}
async fn save_results_with_urls(repo: &ScrapeResultRepositoryImpl, urls: &[&str]) {
for url in urls {
let mut result = sample_scrape_result();
result.id = crate::domain::id::Id::generate();
result.task_id = crate::domain::id::Id::generate();
result.url = url.to_string();
repo.save(result).await.expect("save failed");
}
}
#[tokio::test]
async fn test_list_distinct_urls_returns_distinct_sorted() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = ScrapeResultRepositoryImpl::new(create_test_db_pool());
let prefix = format!(
"https://listdistinct-{}.example.com",
crate::domain::id::Id::generate()
);
let a = format!("{prefix}/a");
let b = format!("{prefix}/b");
save_results_with_urls(&repo, &[&b, &a, &b]).await;
let urls = repo
.list_distinct_urls(100, Some(prefix.clone()))
.await
.expect("list_distinct_urls failed");
let own: Vec<String> = urls
.into_iter()
.filter(|u| u.starts_with(&prefix))
.collect();
assert_eq!(own, vec![a, b], "distinct + url 升序");
}
#[tokio::test]
async fn test_list_distinct_urls_keyset_strictly_greater_than_after() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = ScrapeResultRepositoryImpl::new(create_test_db_pool());
let prefix = format!(
"https://keyset-{}.example.com",
crate::domain::id::Id::generate()
);
let a = format!("{prefix}/a");
let b = format!("{prefix}/b");
let c = format!("{prefix}/c");
save_results_with_urls(&repo, &[&a, &b, &c]).await;
let urls = repo
.list_distinct_urls(100, Some(b.clone()))
.await
.expect("keyset page failed");
let own: Vec<String> = urls
.into_iter()
.filter(|u| u.starts_with(&prefix))
.collect();
assert_eq!(own, vec![c], "after_url 语义必须为严格大于");
let urls = repo
.list_distinct_urls(1, None)
.await
.expect("limit page failed");
assert_eq!(urls.len(), 1, "limit=1 必须只返回一页一条");
}
#[tokio::test]
async fn test_cleanup_expired_disabled_returns_zero() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = ScrapeResultRepositoryImpl::new(create_test_db_pool());
let result = repo.cleanup_expired(0).await;
assert!(
result.is_ok(),
"cleanup_expired(0) failed: {:?}",
result.err()
);
assert_eq!(result.unwrap(), 0);
let result = repo.cleanup_expired(-5).await;
assert!(
result.is_ok(),
"cleanup_expired(-5) failed: {:?}",
result.err()
);
assert_eq!(result.unwrap(), 0);
}
#[tokio::test]
async fn test_cleanup_expired_with_overflow_days_returns_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = ScrapeResultRepositoryImpl::new(create_test_db_pool());
let result = repo.cleanup_expired(i64::MAX).await;
assert!(
result.is_err(),
"overflow retention_days should be an error"
);
}
#[tokio::test]
async fn test_cleanup_expired_deletes_only_ancient_rows() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = ScrapeResultRepositoryImpl::new(create_test_db_pool());
let mut ancient = sample_scrape_result();
ancient.id = crate::domain::id::Id::generate();
ancient.task_id = crate::domain::id::Id::generate();
ancient.created_at = chrono::DateTime::from_timestamp(1_000, 0).expect("valid timestamp");
repo.save(ancient.clone())
.await
.expect("save ancient failed");
let mut recent = sample_scrape_result();
recent.id = crate::domain::id::Id::generate();
recent.task_id = crate::domain::id::Id::generate();
repo.save(recent.clone()).await.expect("save recent failed");
let deleted = repo.cleanup_expired(20_000).await.expect("cleanup failed");
assert!(deleted >= 1, "at least the ancient row should be deleted");
let ancient_gone = repo
.find_by_task_id(ancient.task_id)
.await
.expect("find ancient failed");
assert!(ancient_gone.is_none(), "ancient row must be deleted");
let recent_alive = repo
.find_by_task_id(recent.task_id)
.await
.expect("find recent failed");
assert!(recent_alive.is_some(), "recent row must survive cleanup");
}
#[test]
fn test_to_active_model_with_empty_content() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let mut result = sample_scrape_result();
result.content = "".to_string();
let active = ScrapeResultRepositoryImpl::to_active_model(&result);
assert_eq!(active.content.unwrap(), "");
}
#[test]
fn test_to_active_model_with_empty_url() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let mut result = sample_scrape_result();
result.url = "".to_string();
let active = ScrapeResultRepositoryImpl::to_active_model(&result);
assert_eq!(active.url.unwrap(), "");
}
#[test]
fn test_to_active_model_with_zero_status_code() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let mut result = sample_scrape_result();
result.status_code = 0;
let active = ScrapeResultRepositoryImpl::to_active_model(&result);
assert_eq!(active.status_code.unwrap(), 0);
}
#[test]
fn test_to_active_model_with_large_status_code() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let mut result = sample_scrape_result();
result.status_code = 599;
let active = ScrapeResultRepositoryImpl::to_active_model(&result);
assert_eq!(active.status_code.unwrap(), 599);
}
#[test]
fn test_to_active_model_with_zero_response_time() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let mut result = sample_scrape_result();
result.response_time_ms = 0;
let active = ScrapeResultRepositoryImpl::to_active_model(&result);
assert_eq!(active.response_time_ms.unwrap(), 0);
}
#[test]
fn test_to_active_model_with_empty_headers_and_metadata() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let mut result = sample_scrape_result();
result.headers = serde_json::json!({});
result.meta_data = serde_json::json!({});
let active = ScrapeResultRepositoryImpl::to_active_model(&result);
assert_eq!(active.headers.unwrap(), Some(serde_json::json!({})));
assert_eq!(active.meta_data.unwrap(), Some(serde_json::json!({})));
}
#[test]
fn test_to_active_model_with_complex_headers() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let mut result = sample_scrape_result();
result.headers = serde_json::json!({
"content-type": "application/json",
"x-custom-header": "value-with-unicode-🔑",
"x-numbers": [1, 2, 3],
"x-nested": {"key": "value"}
});
let active = ScrapeResultRepositoryImpl::to_active_model(&result);
let headers = active.headers.unwrap().unwrap();
assert_eq!(headers["content-type"], "application/json");
assert_eq!(headers["x-custom-header"], "value-with-unicode-🔑");
assert_eq!(headers["x-numbers"][2], 3);
assert_eq!(headers["x-nested"]["key"], "value");
}
#[test]
fn test_to_domain_with_zero_response_time() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let mut model = sample_db_model();
model.response_time_ms = 0;
let domain = ScrapeResultRepositoryImpl::to_domain(model);
assert_eq!(domain.response_time_ms, 0);
}
#[test]
fn test_to_domain_with_empty_strings() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let mut model = sample_db_model();
model.url = "".to_string();
model.content = "".to_string();
model.content_type = "".to_string();
let domain = ScrapeResultRepositoryImpl::to_domain(model);
assert_eq!(domain.url, "");
assert_eq!(domain.content, "");
assert_eq!(domain.content_type, "");
}
#[test]
fn test_to_domain_with_both_headers_and_metadata_null() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let mut model = sample_db_model();
model.headers = None;
model.meta_data = None;
let domain = ScrapeResultRepositoryImpl::to_domain(model);
assert_eq!(domain.headers, serde_json::json!({}));
assert_eq!(domain.meta_data, serde_json::json!({}));
}
#[test]
fn test_to_domain_with_screenshot_present() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let mut model = sample_db_model();
model.screenshot = Some("base64data".to_string());
let domain = ScrapeResultRepositoryImpl::to_domain(model);
assert_eq!(domain.screenshot, Some("base64data".to_string()));
}
#[test]
fn test_sample_scrape_result_construction_values() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let result = sample_scrape_result();
assert_eq!(result.status_code, 200);
assert_eq!(result.content_type, "text/html");
assert_eq!(result.response_time_ms, 150);
assert!(result.screenshot.is_some());
assert_eq!(result.screenshot.as_ref().unwrap(), "base64screenshot");
assert_eq!(result.url, "https://example.com/page");
}
#[test]
fn test_sample_db_model_construction_values() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let model = sample_db_model();
assert_eq!(model.status_code, 404);
assert_eq!(model.content_type, "text/plain");
assert_eq!(model.response_time_ms, 42);
assert!(model.screenshot.is_none());
assert!(model.headers.is_some());
assert!(model.meta_data.is_some());
}
}