use super::crawl_link_processor::{persist_crawl_with_initial_task, PersistCrawlError};
use super::crawl_state_machine;
use crate::{
application::dto::crawl_request::CrawlRequestDto,
domain::{
models::{Crawl, CrawlStatus, ScrapeResult},
repositories::{
crawl_repository::CrawlRepository,
scrape_result_repository::ScrapeResultRepository,
task_repository::{RepositoryError, TaskRepository},
},
},
};
#[cfg(feature = "teams")]
use crate::domain::repositories::geo_restriction_repository::GeoRestrictionRepository;
#[cfg(feature = "teams")]
use crate::domain::services::team_service::TeamService;
use chrono::Utc;
#[cfg(feature = "teams")]
use log::error;
use std::sync::Arc;
use thiserror::Error;
#[derive(Error, Debug)]
pub enum CrawlUseCaseError {
#[error("Validation failed: {0}")]
ValidationError(String),
#[error("Repository error: {0}")]
Repository(#[from] RepositoryError),
#[error("Crawl not found")]
NotFound,
#[error("Anyhow error: {0}")]
Anyhow(#[from] anyhow::Error),
}
pub struct CrawlUseCase {
crawl_repo: Arc<dyn CrawlRepository>,
task_repo: Arc<dyn TaskRepository>,
scrape_result_repo: Arc<dyn ScrapeResultRepository>,
#[cfg(feature = "teams")]
geo_restriction_repo: Arc<dyn GeoRestrictionRepository>,
#[cfg(feature = "teams")]
team_service: Arc<TeamService>,
}
impl CrawlUseCase {
pub fn new(
crawl_repo: Arc<dyn CrawlRepository>,
task_repo: Arc<dyn TaskRepository>,
scrape_result_repo: Arc<dyn ScrapeResultRepository>,
#[cfg(feature = "teams")] geo_restriction_repo: Arc<dyn GeoRestrictionRepository>,
#[cfg(feature = "teams")] team_service: Arc<TeamService>,
) -> Self {
Self {
crawl_repo,
task_repo,
scrape_result_repo,
#[cfg(feature = "teams")]
geo_restriction_repo,
#[cfg(feature = "teams")]
team_service,
}
}
pub async fn get_crawl_results(
&self,
crawl_id: crate::domain::id::Id,
team_id: crate::domain::id::Id,
) -> Result<Vec<ScrapeResult>, CrawlUseCaseError> {
match self.crawl_repo.find_by_id(crawl_id).await? {
Some(crawl) => {
if crawl.team_id != team_id {
return Err(CrawlUseCaseError::NotFound);
}
}
None => return Err(CrawlUseCaseError::NotFound),
}
let tasks = self.task_repo.find_by_crawl_id(crawl_id).await?;
let task_ids: Vec<crate::domain::id::Id> = tasks.iter().map(|t| t.id).collect();
let results = self.scrape_result_repo.find_by_task_ids(&task_ids).await?;
Ok(results)
}
pub async fn create_crawl(
&self,
team_id: crate::domain::id::Id,
api_key_id: crate::domain::id::Id,
dto: CrawlRequestDto,
client_ip: &str,
) -> Result<Crawl, CrawlUseCaseError> {
if let Err(reason) = crawl_state_machine::validate_crawl_config(
dto.config.max_depth,
dto.config.max_concurrency,
) {
return Err(CrawlUseCaseError::ValidationError(reason));
}
let restrictions = self
.check_request_restrictions(team_id, client_ip, &dto.url)
.await?;
let now = Utc::now();
let domain_blacklist = restrictions
.effective_domain_blacklist()
.map_err(CrawlUseCaseError::ValidationError)?;
persist_crawl_with_initial_task(
self.crawl_repo.as_ref(),
team_id,
api_key_id,
&dto,
&dto.url,
domain_blacklist,
now,
|task| {
let repo = self.task_repo.clone();
async move { repo.create(&task).await }
},
)
.await
.map_err(|e| match e {
PersistCrawlError::Repository(err) => CrawlUseCaseError::Repository(err),
PersistCrawlError::Enqueue(err) => CrawlUseCaseError::Repository(err),
})
}
async fn check_request_restrictions(
&self,
team_id: crate::domain::id::Id,
client_ip: &str,
seed_url: &str,
) -> Result<crate::domain::services::team_service::TeamGeoRestrictions, CrawlUseCaseError> {
#[cfg(feature = "teams")]
let restrictions = self.resolve_geo_restrictions(team_id, client_ip).await?;
#[cfg(not(feature = "teams"))]
let restrictions = crate::domain::services::team_service::TeamGeoRestrictions::default();
#[cfg(not(feature = "teams"))]
let _ = (team_id, client_ip, seed_url);
#[cfg(feature = "teams")]
self.validate_seed_domain(seed_url, &restrictions).await?;
Ok(restrictions)
}
#[cfg(feature = "teams")]
async fn resolve_geo_restrictions(
&self,
team_id: crate::domain::id::Id,
client_ip: &str,
) -> Result<crate::domain::services::team_service::TeamGeoRestrictions, CrawlUseCaseError> {
let r = self
.geo_restriction_repo
.get_team_restrictions(team_id)
.await
.map_err(|e| {
CrawlUseCaseError::Anyhow(anyhow::anyhow!("Failed to get team restrictions: {}", e))
})?;
match self
.team_service
.validate_geographic_restriction(team_id, client_ip, &r)
.await
{
Ok(crate::domain::services::team_service::GeoRestrictionResult::Allowed) => {
if let Err(e) = self
.geo_restriction_repo
.log_geo_restriction_action(
team_id,
client_ip,
"",
"ALLOWED",
"Geographic restriction check passed",
)
.await
{
error!("Failed to log geographic restriction action: {}", e);
}
}
Ok(crate::domain::services::team_service::GeoRestrictionResult::Denied(reason)) => {
if let Err(e) = self
.geo_restriction_repo
.log_geo_restriction_action(team_id, client_ip, "", "DENIED", &reason)
.await
{
error!("Failed to log geographic restriction action: {}", e);
}
return Err(CrawlUseCaseError::ValidationError(format!(
"Geographic restriction check failed: {}",
reason
)));
}
Err(e) => {
error!("Geographic restriction validation error: {}", e);
return Err(CrawlUseCaseError::Anyhow(anyhow::anyhow!(
"Geographic restriction validation failed: {}",
e
)));
}
}
Ok(r)
}
#[cfg(feature = "teams")]
async fn validate_seed_domain(
&self,
seed_url: &str,
restrictions: &crate::domain::services::team_service::TeamGeoRestrictions,
) -> Result<(), CrawlUseCaseError> {
match self
.team_service
.validate_domain_blacklist(seed_url, restrictions)
{
Ok(crate::domain::services::team_service::GeoRestrictionResult::Allowed) => Ok(()),
Ok(crate::domain::services::team_service::GeoRestrictionResult::Denied(reason)) => {
error!(
"Crawl seed URL {} denied by domain blacklist: {}",
seed_url, reason
);
Err(CrawlUseCaseError::ValidationError(reason))
}
Err(e) => {
error!("Domain blacklist validation error: {}", e);
Err(CrawlUseCaseError::Anyhow(anyhow::anyhow!(
"Domain blacklist validation failed: {}",
e
)))
}
}
}
pub async fn get_crawl(
&self,
crawl_id: crate::domain::id::Id,
team_id: crate::domain::id::Id,
) -> Result<Option<Crawl>, CrawlUseCaseError> {
match self.crawl_repo.find_by_id(crawl_id).await? {
Some(crawl) => {
if crawl.team_id != team_id {
return Ok(None); }
Ok(Some(crawl))
}
None => Ok(None),
}
}
pub async fn cancel_crawl(
&self,
id: crate::domain::id::Id,
team_id: crate::domain::id::Id,
) -> Result<(), CrawlUseCaseError> {
let crawl = self.crawl_repo.find_by_id(id).await?;
match crawl {
Some(c) => {
if c.team_id != team_id {
return Err(CrawlUseCaseError::NotFound); }
if !crawl_state_machine::can_cancel(&c.status) {
return Ok(()); }
if !self
.crawl_repo
.update_status_guarded(id, CrawlStatus::Cancelled)
.await?
{
return Ok(());
}
self.task_repo.cancel_tasks_by_crawl_id(id).await?;
Ok(())
}
None => Err(CrawlUseCaseError::NotFound), }
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::domain::models::{ScrapeResult, Task, TaskType};
use serde_json::json;
#[cfg(feature = "teams")]
use crate::domain::repositories::geo_restriction_repository::GeoRestrictionRepositoryError;
#[cfg(feature = "teams")]
use crate::domain::services::geo_location::{GeoLocation, GeoLocationService};
#[cfg(feature = "teams")]
use crate::domain::services::team_service::TeamGeoRestrictions;
#[cfg(feature = "webhook")]
use crate::domain::repositories::webhook_repository::WebhookRepository;
use async_trait::async_trait;
#[cfg(feature = "teams")]
use std::net::IpAddr;
use std::sync::atomic::{AtomicU32, Ordering};
use std::sync::Mutex;
struct MockCrawlRepository {
stored_crawl: Mutex<Option<Crawl>>,
updated_crawls: Mutex<Vec<Crawl>>,
created_count: AtomicU32,
should_fail_find: bool,
should_fail_create: bool,
should_fail_update: bool,
}
impl MockCrawlRepository {
fn with_crawl(crawl: Crawl) -> Self {
Self {
stored_crawl: Mutex::new(Some(crawl)),
updated_crawls: Mutex::new(vec![]),
created_count: AtomicU32::new(0),
should_fail_find: false,
should_fail_create: false,
should_fail_update: false,
}
}
fn empty() -> Self {
Self {
stored_crawl: Mutex::new(None),
updated_crawls: Mutex::new(vec![]),
created_count: AtomicU32::new(0),
should_fail_find: false,
should_fail_create: false,
should_fail_update: false,
}
}
fn failing_find() -> Self {
Self {
stored_crawl: Mutex::new(None),
updated_crawls: Mutex::new(vec![]),
created_count: AtomicU32::new(0),
should_fail_find: true,
should_fail_create: false,
should_fail_update: false,
}
}
fn failing_create() -> Self {
let mut m = Self::empty();
m.should_fail_create = true;
m
}
fn failing_update(crawl: Crawl) -> Self {
Self {
stored_crawl: Mutex::new(Some(crawl)),
updated_crawls: Mutex::new(vec![]),
created_count: AtomicU32::new(0),
should_fail_find: false,
should_fail_create: false,
should_fail_update: true,
}
}
fn last_updated_status(&self) -> Option<CrawlStatus> {
self.updated_crawls.lock().unwrap().last().map(|c| c.status)
}
}
#[async_trait]
impl CrawlRepository for MockCrawlRepository {
async fn update_status_guarded(
&self,
id: crate::domain::id::Id,
status: CrawlStatus,
) -> Result<bool, RepositoryError> {
if self.should_fail_update {
return Err(RepositoryError::Database(anyhow::anyhow!(
"crawl repo update down"
)));
}
let mut guard = self.stored_crawl.lock().unwrap();
let Some(crawl) = guard.as_mut() else {
return Ok(false);
};
if matches!(
crawl.status,
CrawlStatus::Completed | CrawlStatus::Failed | CrawlStatus::Cancelled
) {
return Ok(false);
}
crawl.status = status;
crawl.updated_at = Utc::now();
if matches!(
status,
CrawlStatus::Completed | CrawlStatus::Failed | CrawlStatus::Cancelled
) {
crawl.completed_at = Some(Utc::now());
}
let snapshot = crawl.clone();
let _ = id;
drop(guard);
self.updated_crawls.lock().unwrap().push(snapshot);
Ok(true)
}
async fn create(&self, crawl: &Crawl) -> Result<Crawl, RepositoryError> {
if self.should_fail_create {
return Err(RepositoryError::Database(anyhow::anyhow!(
"crawl repo create down"
)));
}
self.created_count.fetch_add(1, Ordering::SeqCst);
Ok(crawl.clone())
}
async fn find_by_id(
&self,
_id: crate::domain::id::Id,
) -> Result<Option<Crawl>, RepositoryError> {
if self.should_fail_find {
return Err(RepositoryError::Database(anyhow::anyhow!(
"crawl repo find down"
)));
}
Ok(self.stored_crawl.lock().unwrap().clone())
}
async fn update(&self, crawl: &Crawl) -> Result<Crawl, RepositoryError> {
if self.should_fail_update {
return Err(RepositoryError::Database(anyhow::anyhow!(
"crawl repo update down"
)));
}
self.updated_crawls.lock().unwrap().push(crawl.clone());
Ok(crawl.clone())
}
async fn increment_completed_tasks(
&self,
_id: crate::domain::id::Id,
) -> Result<(), RepositoryError> {
Ok(())
}
async fn increment_failed_tasks(
&self,
_id: crate::domain::id::Id,
) -> Result<(), RepositoryError> {
Ok(())
}
async fn update_status(
&self,
_id: crate::domain::id::Id,
_status: CrawlStatus,
) -> Result<(), RepositoryError> {
Ok(())
}
async fn increment_total_tasks(
&self,
_id: crate::domain::id::Id,
) -> Result<(), RepositoryError> {
Ok(())
}
async fn find_by_team_id_paginated(
&self,
_team_id: crate::domain::id::Id,
_limit: u32,
_offset: u32,
) -> Result<Vec<Crawl>, RepositoryError> {
Ok(vec![])
}
async fn count_by_team_id(
&self,
_team_id: crate::domain::id::Id,
) -> Result<u64, RepositoryError> {
Ok(0)
}
}
struct MockTaskRepository {
created_count: AtomicU32,
should_fail_create: bool,
should_fail_find_by_crawl: bool,
should_fail_cancel: bool,
stored_tasks: Mutex<Vec<Task>>,
}
impl MockTaskRepository {
fn with_tasks(tasks: Vec<Task>) -> Self {
Self {
created_count: AtomicU32::new(0),
should_fail_create: false,
should_fail_find_by_crawl: false,
should_fail_cancel: false,
stored_tasks: Mutex::new(tasks),
}
}
fn empty() -> Self {
Self {
created_count: AtomicU32::new(0),
should_fail_create: false,
should_fail_find_by_crawl: false,
should_fail_cancel: false,
stored_tasks: Mutex::new(vec![]),
}
}
fn failing_create() -> Self {
Self {
created_count: AtomicU32::new(0),
should_fail_create: true,
should_fail_find_by_crawl: false,
should_fail_cancel: false,
stored_tasks: Mutex::new(vec![]),
}
}
fn failing_cancel() -> Self {
Self {
created_count: AtomicU32::new(0),
should_fail_create: false,
should_fail_find_by_crawl: false,
should_fail_cancel: true,
stored_tasks: Mutex::new(vec![]),
}
}
fn failing_find_by_crawl() -> Self {
Self {
created_count: AtomicU32::new(0),
should_fail_create: false,
should_fail_find_by_crawl: true,
should_fail_cancel: false,
stored_tasks: Mutex::new(vec![]),
}
}
}
#[async_trait]
impl TaskRepository for MockTaskRepository {
async fn create(&self, task: &Task) -> Result<Task, RepositoryError> {
if self.should_fail_create {
return Err(RepositoryError::Database(anyhow::anyhow!(
"task repo create down"
)));
}
self.created_count.fetch_add(1, Ordering::SeqCst);
Ok(task.clone())
}
async fn find_by_id(
&self,
_id: crate::domain::id::Id,
) -> Result<Option<Task>, RepositoryError> {
Ok(None)
}
async fn update(&self, task: &Task) -> Result<Task, RepositoryError> {
Ok(task.clone())
}
async fn acquire_next(
&self,
_worker_id: crate::domain::id::Id,
) -> Result<Option<Task>, RepositoryError> {
Ok(None)
}
async fn mark_completed(
&self,
_id: crate::domain::id::Id,
_lock_token: Option<crate::domain::id::Id>,
) -> Result<u64, RepositoryError> {
Ok(1)
}
async fn mark_failed(
&self,
_id: crate::domain::id::Id,
_lock_token: Option<crate::domain::id::Id>,
) -> Result<u64, RepositoryError> {
Ok(1)
}
async fn mark_cancelled(&self, _id: crate::domain::id::Id) -> Result<u64, RepositoryError> {
Ok(1)
}
async fn exists_by_url(&self, _url: &str) -> Result<bool, RepositoryError> {
Ok(false)
}
async fn find_existing_urls(
&self,
_urls: &[String],
) -> Result<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> {
if self.should_fail_cancel {
return Err(RepositoryError::Database(anyhow::anyhow!(
"cancel tasks down"
)));
}
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> {
if self.should_fail_find_by_crawl {
return Err(RepositoryError::Database(anyhow::anyhow!(
"find_by_crawl_id down"
)));
}
Ok(self.stored_tasks.lock().unwrap().clone())
}
async fn query_tasks(
&self,
_params: crate::domain::repositories::task_repository::TaskQueryParams,
) -> Result<(Vec<Task>, u64), RepositoryError> {
Ok((vec![], 0))
}
async fn batch_cancel(
&self,
_task_ids: Vec<crate::domain::id::Id>,
_team_id: crate::domain::id::Id,
_force: bool,
) -> Result<
(
Vec<crate::domain::id::Id>,
Vec<(crate::domain::id::Id, String)>,
),
RepositoryError,
> {
Ok((vec![], vec![]))
}
async fn renew_lock(
&self,
_task_id: crate::domain::id::Id,
_worker_id: crate::domain::id::Id,
_extend_seconds: i64,
) -> Result<bool, RepositoryError> {
Ok(true)
}
}
#[cfg(feature = "webhook")]
struct MockWebhookRepository;
#[cfg(feature = "webhook")]
#[async_trait]
impl WebhookRepository for MockWebhookRepository {
async fn create(
&self,
webhook: &crate::domain::models::Webhook,
) -> Result<crate::domain::models::Webhook, RepositoryError> {
Ok(webhook.clone())
}
async fn find_by_id(
&self,
_id: crate::domain::id::Id,
) -> Result<Option<crate::domain::models::Webhook>, RepositoryError> {
Ok(None)
}
async fn find_by_team_id(
&self,
_team_id: crate::domain::id::Id,
) -> Result<Vec<crate::domain::models::Webhook>, RepositoryError> {
Ok(vec![])
}
}
struct MockScrapeResultRepository {
stored_results: Mutex<Vec<ScrapeResult>>,
should_fail: bool,
}
impl MockScrapeResultRepository {
fn with_results(results: Vec<ScrapeResult>) -> Self {
Self {
stored_results: Mutex::new(results),
should_fail: false,
}
}
fn empty() -> Self {
Self {
stored_results: Mutex::new(vec![]),
should_fail: false,
}
}
fn failing() -> Self {
Self {
stored_results: Mutex::new(vec![]),
should_fail: true,
}
}
}
#[async_trait]
impl ScrapeResultRepository for MockScrapeResultRepository {
async fn save(&self, _result: ScrapeResult) -> anyhow::Result<()> {
Ok(())
}
async fn find_by_task_id(
&self,
_task_id: crate::domain::id::Id,
) -> anyhow::Result<Option<ScrapeResult>> {
Ok(None)
}
async fn find_by_task_ids(
&self,
_task_ids: &[crate::domain::id::Id],
) -> anyhow::Result<Vec<ScrapeResult>> {
if self.should_fail {
return Err(anyhow::anyhow!("scrape result repo down"));
}
Ok(self.stored_results.lock().unwrap().clone())
}
async fn get_team_avg_response_time(
&self,
_team_id: crate::domain::id::Id,
) -> anyhow::Result<f64> {
Ok(0.0)
}
async fn cleanup_expired(&self, _retention_days: i64) -> anyhow::Result<u64> {
Ok(0)
}
}
#[cfg(feature = "teams")]
struct MockGeoRestrictionRepository {
restrictions: Mutex<TeamGeoRestrictions>,
get_should_fail: bool,
log_should_fail: bool,
log_count: AtomicU32,
}
#[cfg(feature = "teams")]
impl MockGeoRestrictionRepository {
fn with_restrictions(restrictions: TeamGeoRestrictions) -> Self {
Self {
restrictions: Mutex::new(restrictions),
get_should_fail: false,
log_should_fail: false,
log_count: AtomicU32::new(0),
}
}
fn failing_get() -> Self {
Self {
restrictions: Mutex::new(TeamGeoRestrictions::default()),
get_should_fail: true,
log_should_fail: false,
log_count: AtomicU32::new(0),
}
}
fn with_failing_log(restrictions: TeamGeoRestrictions) -> Self {
Self {
restrictions: Mutex::new(restrictions),
get_should_fail: false,
log_should_fail: true,
log_count: AtomicU32::new(0),
}
}
}
#[cfg(feature = "teams")]
#[async_trait]
impl GeoRestrictionRepository for MockGeoRestrictionRepository {
async fn get_team_restrictions(
&self,
_team_id: crate::domain::id::Id,
) -> Result<TeamGeoRestrictions, GeoRestrictionRepositoryError> {
if self.get_should_fail {
return Err(GeoRestrictionRepositoryError::Database(
"geo restriction repo down".to_string(),
));
}
Ok(self.restrictions.lock().unwrap().clone())
}
async fn update_team_restrictions(
&self,
_team_id: crate::domain::id::Id,
_restrictions: &TeamGeoRestrictions,
) -> Result<(), GeoRestrictionRepositoryError> {
Ok(())
}
async fn log_geo_restriction_action(
&self,
_team_id: crate::domain::id::Id,
_ip_address: &str,
_country_code: &str,
_action: &str,
_reason: &str,
) -> Result<(), GeoRestrictionRepositoryError> {
self.log_count.fetch_add(1, Ordering::SeqCst);
if self.log_should_fail {
return Err(GeoRestrictionRepositoryError::Other(
"log action down".to_string(),
));
}
Ok(())
}
}
#[cfg(feature = "teams")]
struct MockGeoLocationService {
should_fail: bool,
}
#[cfg(feature = "teams")]
impl MockGeoLocationService {
fn succeeding() -> Self {
Self { should_fail: false }
}
fn failing() -> Self {
Self { should_fail: true }
}
}
#[cfg(feature = "teams")]
#[async_trait]
impl GeoLocationService for MockGeoLocationService {
async fn get_location(&self, _ip: &IpAddr) -> anyhow::Result<GeoLocation> {
if self.should_fail {
return Err(anyhow::anyhow!("geolocation service down"));
}
Ok(GeoLocation {
country_code: "US".to_string(),
..GeoLocation::default()
})
}
}
fn make_crawl(
id: crate::domain::id::Id,
team_id: crate::domain::id::Id,
status: CrawlStatus,
) -> Crawl {
Crawl::with_all_fields(
id,
team_id,
"Test Crawl".to_string(),
"https://example.com".to_string(),
"https://example.com".to_string(),
status,
json!({}),
1,
0,
0,
Utc::now(),
Utc::now(),
None,
)
}
fn make_crawl_dto() -> CrawlRequestDto {
CrawlRequestDto {
url: "https://example.com".to_string(),
validated_url: None,
name: Some("Test Crawl".to_string()),
config: crate::application::dto::crawl_request::CrawlConfigDto {
max_depth: 3,
include_patterns: None,
exclude_patterns: None,
strategy: None,
crawl_delay_ms: None,
max_concurrency: None,
max_pages: None,
proxy: None,
headers: None,
extraction_rules: None,
extraction_prompt: None,
extraction_schema: None,
},
sync_wait_ms: None,
expires_at: None,
sitemap_seed: None,
sitemap_url: None,
}
}
fn make_scrape_result(task_id: crate::domain::id::Id) -> ScrapeResult {
ScrapeResult {
id: crate::domain::id::Id::generate(),
task_id,
url: "https://example.com".to_string(),
status_code: 200,
content: "<html></html>".to_string(),
content_type: "text/html".to_string(),
headers: json!({}),
meta_data: json!({}),
screenshot: None,
response_time_ms: 100,
created_at: Utc::now(),
}
}
fn build_use_case(
crawl_repo: Arc<MockCrawlRepository>,
task_repo: Arc<MockTaskRepository>,
scrape_result_repo: Arc<MockScrapeResultRepository>,
#[cfg(feature = "teams")] geo_repo: Arc<MockGeoRestrictionRepository>,
#[cfg(feature = "teams")] geo_loc_service: Arc<MockGeoLocationService>,
) -> CrawlUseCase {
#[cfg(feature = "teams")]
let team_service = Arc::new(TeamService::new(
geo_loc_service,
Arc::new(MockGeoRestrictionRepository::with_restrictions(
TeamGeoRestrictions::default(),
)),
));
CrawlUseCase::new(
crawl_repo,
task_repo,
scrape_result_repo,
#[cfg(feature = "teams")]
geo_repo,
#[cfg(feature = "teams")]
team_service,
)
}
fn build_use_case_allowed_geo(
crawl_repo: Arc<MockCrawlRepository>,
task_repo: Arc<MockTaskRepository>,
scrape_result_repo: Arc<MockScrapeResultRepository>,
) -> CrawlUseCase {
build_use_case(
crawl_repo,
task_repo,
scrape_result_repo,
#[cfg(feature = "teams")]
Arc::new(MockGeoRestrictionRepository::with_restrictions(
TeamGeoRestrictions::default(),
)),
#[cfg(feature = "teams")]
Arc::new(MockGeoLocationService::succeeding()),
)
}
#[test]
fn test_new_constructs_without_calling_repos() {
let use_case = build_use_case_allowed_geo(
Arc::new(MockCrawlRepository::empty()),
Arc::new(MockTaskRepository::empty()),
Arc::new(MockScrapeResultRepository::empty()),
);
let _ = &use_case;
}
#[tokio::test]
async fn test_get_crawl_results_success() {
let team_id = crate::domain::id::Id::generate();
let crawl_id = crate::domain::id::Id::generate();
let task_id = crate::domain::id::Id::generate();
let crawl = make_crawl(crawl_id, team_id, CrawlStatus::Completed);
let task = Task::new(
task_id,
TaskType::Crawl,
team_id,
crate::domain::id::Id::nil(),
"https://example.com".to_string(),
json!({}),
);
let result = make_scrape_result(task_id);
let use_case = build_use_case_allowed_geo(
Arc::new(MockCrawlRepository::with_crawl(crawl)),
Arc::new(MockTaskRepository::with_tasks(vec![task])),
Arc::new(MockScrapeResultRepository::with_results(vec![result])),
);
let results = use_case
.get_crawl_results(crawl_id, team_id)
.await
.expect("should succeed");
assert_eq!(results.len(), 1);
assert_eq!(results[0].task_id, task_id);
}
#[tokio::test]
async fn test_get_crawl_results_crawl_not_found() {
let use_case = build_use_case_allowed_geo(
Arc::new(MockCrawlRepository::empty()),
Arc::new(MockTaskRepository::empty()),
Arc::new(MockScrapeResultRepository::empty()),
);
let result = use_case
.get_crawl_results(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
)
.await;
assert!(matches!(result, Err(CrawlUseCaseError::NotFound)));
}
#[tokio::test]
async fn test_get_crawl_results_wrong_team_returns_not_found() {
let crawl_id = crate::domain::id::Id::generate();
let crawl = make_crawl(
crawl_id,
crate::domain::id::Id::generate(),
CrawlStatus::Completed,
);
let use_case = build_use_case_allowed_geo(
Arc::new(MockCrawlRepository::with_crawl(crawl)),
Arc::new(MockTaskRepository::empty()),
Arc::new(MockScrapeResultRepository::empty()),
);
let result = use_case
.get_crawl_results(crawl_id, crate::domain::id::Id::generate())
.await;
assert!(
matches!(result, Err(CrawlUseCaseError::NotFound)),
"wrong team should return NotFound"
);
}
#[tokio::test]
async fn test_get_crawl_results_crawl_repo_error_propagates() {
let use_case = build_use_case_allowed_geo(
Arc::new(MockCrawlRepository::failing_find()),
Arc::new(MockTaskRepository::empty()),
Arc::new(MockScrapeResultRepository::empty()),
);
let result = use_case
.get_crawl_results(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
)
.await;
let err = match result {
Err(CrawlUseCaseError::Repository(e)) => e,
e => panic!("expected Repository error, got: {:?}", e),
};
assert!(err.to_string().contains("find down"));
}
#[tokio::test]
async fn test_get_crawl_results_task_repo_error_propagates() {
let team_id = crate::domain::id::Id::generate();
let crawl_id = crate::domain::id::Id::generate();
let crawl = make_crawl(crawl_id, team_id, CrawlStatus::Completed);
let use_case = build_use_case_allowed_geo(
Arc::new(MockCrawlRepository::with_crawl(crawl)),
Arc::new(MockTaskRepository::failing_find_by_crawl()),
Arc::new(MockScrapeResultRepository::empty()),
);
let result = use_case.get_crawl_results(crawl_id, team_id).await;
let err = match result {
Err(CrawlUseCaseError::Repository(e)) => e,
e => panic!("expected Repository error, got: {:?}", e),
};
assert!(err.to_string().contains("find_by_crawl_id down"));
}
#[tokio::test]
async fn test_get_crawl_results_scrape_result_repo_error_propagates() {
let team_id = crate::domain::id::Id::generate();
let crawl_id = crate::domain::id::Id::generate();
let task_id = crate::domain::id::Id::generate();
let crawl = make_crawl(crawl_id, team_id, CrawlStatus::Completed);
let task = Task::new(
task_id,
TaskType::Crawl,
team_id,
crate::domain::id::Id::nil(),
"https://example.com".to_string(),
json!({}),
);
let use_case = build_use_case_allowed_geo(
Arc::new(MockCrawlRepository::with_crawl(crawl)),
Arc::new(MockTaskRepository::with_tasks(vec![task])),
Arc::new(MockScrapeResultRepository::failing()),
);
let result = use_case.get_crawl_results(crawl_id, team_id).await;
assert!(
matches!(result, Err(CrawlUseCaseError::Anyhow(_))),
"scrape result repo error should map to Anyhow"
);
}
#[tokio::test]
async fn test_get_crawl_results_empty_results_when_no_tasks() {
let team_id = crate::domain::id::Id::generate();
let crawl_id = crate::domain::id::Id::generate();
let crawl = make_crawl(crawl_id, team_id, CrawlStatus::Completed);
let use_case = build_use_case_allowed_geo(
Arc::new(MockCrawlRepository::with_crawl(crawl)),
Arc::new(MockTaskRepository::with_tasks(vec![])),
Arc::new(MockScrapeResultRepository::empty()),
);
let results = use_case
.get_crawl_results(crawl_id, team_id)
.await
.expect("should succeed with empty results");
assert!(results.is_empty());
}
#[tokio::test]
async fn test_create_crawl_success() {
let team_id = crate::domain::id::Id::generate();
let api_key_id = crate::domain::id::Id::generate();
let dto = make_crawl_dto();
let crawl_repo = Arc::new(MockCrawlRepository::empty());
let task_repo = Arc::new(MockTaskRepository::empty());
let use_case = build_use_case_allowed_geo(
crawl_repo.clone(),
task_repo.clone(),
Arc::new(MockScrapeResultRepository::empty()),
);
let crawl = use_case
.create_crawl(team_id, api_key_id, dto, "1.2.3.4")
.await
.expect("create_crawl should succeed");
assert_eq!(crawl.team_id, team_id);
assert_eq!(crawl.status, CrawlStatus::Queued);
assert_eq!(crawl.name, "Test Crawl");
assert_eq!(crawl.root_url, "https://example.com");
assert_eq!(crawl_repo.created_count.load(Ordering::SeqCst), 1);
assert_eq!(task_repo.created_count.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_create_crawl_name_none_uses_default() {
let team_id = crate::domain::id::Id::generate();
let mut dto = make_crawl_dto();
dto.name = None;
let use_case = build_use_case_allowed_geo(
Arc::new(MockCrawlRepository::empty()),
Arc::new(MockTaskRepository::empty()),
Arc::new(MockScrapeResultRepository::empty()),
);
let crawl = use_case
.create_crawl(team_id, crate::domain::id::Id::generate(), dto, "1.2.3.4")
.await
.expect("should succeed");
assert_eq!(crawl.name, "Untitled Crawl");
}
#[tokio::test]
async fn test_create_crawl_max_depth_exceeds_limit() {
let mut dto = make_crawl_dto();
dto.config.max_depth = 6;
let use_case = build_use_case_allowed_geo(
Arc::new(MockCrawlRepository::empty()),
Arc::new(MockTaskRepository::empty()),
Arc::new(MockScrapeResultRepository::empty()),
);
let result = use_case
.create_crawl(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
dto,
"1.2.3.4",
)
.await;
let err = match result {
Err(CrawlUseCaseError::ValidationError(msg)) => msg,
e => panic!("expected ValidationError, got: {:?}", e),
};
assert!(err.contains("max_depth"), "got: {}", err);
}
#[tokio::test]
async fn test_create_crawl_max_depth_at_boundary_5_succeeds() {
let mut dto = make_crawl_dto();
dto.config.max_depth = 5;
let use_case = build_use_case_allowed_geo(
Arc::new(MockCrawlRepository::empty()),
Arc::new(MockTaskRepository::empty()),
Arc::new(MockScrapeResultRepository::empty()),
);
let result = use_case
.create_crawl(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
dto,
"1.2.3.4",
)
.await;
assert!(result.is_ok(), "max_depth=5 should be allowed");
}
#[tokio::test]
async fn test_create_crawl_max_concurrency_exceeds_limit() {
let mut dto = make_crawl_dto();
dto.config.max_concurrency = Some(101);
let use_case = build_use_case_allowed_geo(
Arc::new(MockCrawlRepository::empty()),
Arc::new(MockTaskRepository::empty()),
Arc::new(MockScrapeResultRepository::empty()),
);
let result = use_case
.create_crawl(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
dto,
"1.2.3.4",
)
.await;
let err = match result {
Err(CrawlUseCaseError::ValidationError(msg)) => msg,
e => panic!("expected ValidationError, got: {:?}", e),
};
assert!(err.contains("max_concurrency"), "got: {}", err);
}
#[tokio::test]
async fn test_create_crawl_max_concurrency_at_boundary_50_succeeds() {
let mut dto = make_crawl_dto();
dto.config.max_concurrency = Some(50);
let use_case = build_use_case_allowed_geo(
Arc::new(MockCrawlRepository::empty()),
Arc::new(MockTaskRepository::empty()),
Arc::new(MockScrapeResultRepository::empty()),
);
let result = use_case
.create_crawl(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
dto,
"1.2.3.4",
)
.await;
assert!(result.is_ok(), "max_concurrency=100 should be allowed");
}
#[cfg(feature = "teams")]
#[tokio::test]
async fn test_create_crawl_geo_denied_invalid_ip() {
let restrictions = TeamGeoRestrictions {
enable_geo_restrictions: true,
..Default::default()
};
let use_case = build_use_case(
Arc::new(MockCrawlRepository::empty()),
Arc::new(MockTaskRepository::empty()),
Arc::new(MockScrapeResultRepository::empty()),
Arc::new(MockGeoRestrictionRepository::with_restrictions(
restrictions,
)),
Arc::new(MockGeoLocationService::succeeding()),
);
let result = use_case
.create_crawl(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
make_crawl_dto(),
"not-an-ip",
)
.await;
let err = match result {
Err(CrawlUseCaseError::ValidationError(msg)) => msg,
e => panic!("expected ValidationError, got: {:?}", e),
};
assert!(
err.contains("Geographic restriction check failed"),
"got: {}",
err
);
}
#[cfg(feature = "teams")]
#[tokio::test]
async fn test_create_crawl_geo_validation_error() {
let restrictions = TeamGeoRestrictions {
enable_geo_restrictions: true,
..Default::default()
};
let use_case = build_use_case(
Arc::new(MockCrawlRepository::empty()),
Arc::new(MockTaskRepository::empty()),
Arc::new(MockScrapeResultRepository::empty()),
Arc::new(MockGeoRestrictionRepository::with_restrictions(
restrictions,
)),
Arc::new(MockGeoLocationService::failing()),
);
let result = use_case
.create_crawl(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
make_crawl_dto(),
"8.8.8.8",
)
.await;
let err = match result {
Err(CrawlUseCaseError::Anyhow(msg)) => msg.to_string(),
e => panic!("expected Anyhow error, got: {:?}", e),
};
assert!(
err.contains("Geographic restriction validation failed"),
"got: {}",
err
);
}
#[cfg(feature = "teams")]
#[tokio::test]
async fn test_create_crawl_geo_repo_get_error() {
let use_case = build_use_case(
Arc::new(MockCrawlRepository::empty()),
Arc::new(MockTaskRepository::empty()),
Arc::new(MockScrapeResultRepository::empty()),
Arc::new(MockGeoRestrictionRepository::failing_get()),
Arc::new(MockGeoLocationService::succeeding()),
);
let result = use_case
.create_crawl(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
make_crawl_dto(),
"1.2.3.4",
)
.await;
let err = match result {
Err(CrawlUseCaseError::Anyhow(msg)) => msg.to_string(),
e => panic!("expected Anyhow error, got: {:?}", e),
};
assert!(
err.contains("Failed to get team restrictions"),
"got: {}",
err
);
}
#[cfg(feature = "teams")]
#[tokio::test]
async fn test_create_crawl_log_failure_does_not_block_allowed() {
let restrictions = TeamGeoRestrictions::default(); let geo_repo = Arc::new(MockGeoRestrictionRepository::with_failing_log(restrictions));
let use_case = build_use_case(
Arc::new(MockCrawlRepository::empty()),
Arc::new(MockTaskRepository::empty()),
Arc::new(MockScrapeResultRepository::empty()),
geo_repo,
Arc::new(MockGeoLocationService::succeeding()),
);
let result = use_case
.create_crawl(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
make_crawl_dto(),
"1.2.3.4",
)
.await;
assert!(
result.is_ok(),
"log failure should not block the allowed path"
);
}
#[tokio::test]
async fn test_create_crawl_crawl_repo_create_error() {
let use_case = build_use_case_allowed_geo(
Arc::new(MockCrawlRepository::failing_create()),
Arc::new(MockTaskRepository::empty()),
Arc::new(MockScrapeResultRepository::empty()),
);
let result = use_case
.create_crawl(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
make_crawl_dto(),
"1.2.3.4",
)
.await;
let err = match result {
Err(CrawlUseCaseError::Repository(e)) => e,
e => panic!("expected Repository error, got: {:?}", e),
};
assert!(err.to_string().contains("create down"));
}
#[tokio::test]
async fn test_create_crawl_task_repo_create_error() {
let use_case = build_use_case_allowed_geo(
Arc::new(MockCrawlRepository::empty()),
Arc::new(MockTaskRepository::failing_create()),
Arc::new(MockScrapeResultRepository::empty()),
);
let result = use_case
.create_crawl(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
make_crawl_dto(),
"1.2.3.4",
)
.await;
let err = match result {
Err(CrawlUseCaseError::Repository(e)) => e,
e => panic!("expected Repository error, got: {:?}", e),
};
assert!(err.to_string().contains("create down"));
}
#[tokio::test]
async fn test_get_crawl_found() {
let team_id = crate::domain::id::Id::generate();
let crawl_id = crate::domain::id::Id::generate();
let crawl = make_crawl(crawl_id, team_id, CrawlStatus::Queued);
let use_case = build_use_case_allowed_geo(
Arc::new(MockCrawlRepository::with_crawl(crawl)),
Arc::new(MockTaskRepository::empty()),
Arc::new(MockScrapeResultRepository::empty()),
);
let result = use_case
.get_crawl(crawl_id, team_id)
.await
.expect("should succeed");
let found = result.expect("should find crawl");
assert_eq!(found.id, crawl_id);
assert_eq!(found.team_id, team_id);
}
#[tokio::test]
async fn test_get_crawl_not_found_returns_none() {
let use_case = build_use_case_allowed_geo(
Arc::new(MockCrawlRepository::empty()),
Arc::new(MockTaskRepository::empty()),
Arc::new(MockScrapeResultRepository::empty()),
);
let result = use_case
.get_crawl(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
)
.await
.expect("should succeed");
assert!(result.is_none(), "non-existent crawl should return None");
}
#[tokio::test]
async fn test_get_crawl_wrong_team_returns_none() {
let crawl_id = crate::domain::id::Id::generate();
let crawl = make_crawl(
crawl_id,
crate::domain::id::Id::generate(),
CrawlStatus::Queued,
);
let use_case = build_use_case_allowed_geo(
Arc::new(MockCrawlRepository::with_crawl(crawl)),
Arc::new(MockTaskRepository::empty()),
Arc::new(MockScrapeResultRepository::empty()),
);
let result = use_case
.get_crawl(crawl_id, crate::domain::id::Id::generate())
.await
.expect("should succeed");
assert!(
result.is_none(),
"wrong team should return None to avoid info leak"
);
}
#[tokio::test]
async fn test_get_crawl_repo_error_propagates() {
let use_case = build_use_case_allowed_geo(
Arc::new(MockCrawlRepository::failing_find()),
Arc::new(MockTaskRepository::empty()),
Arc::new(MockScrapeResultRepository::empty()),
);
let result = use_case
.get_crawl(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
)
.await;
assert!(
matches!(result, Err(CrawlUseCaseError::Repository(_))),
"repo error should propagate"
);
}
#[tokio::test]
async fn test_cancel_crawl_success() {
let team_id = crate::domain::id::Id::generate();
let crawl_id = crate::domain::id::Id::generate();
let crawl = make_crawl(crawl_id, team_id, CrawlStatus::Queued);
let crawl_repo = Arc::new(MockCrawlRepository::with_crawl(crawl));
let task_repo = Arc::new(MockTaskRepository::empty());
let use_case = build_use_case_allowed_geo(
crawl_repo.clone(),
task_repo.clone(),
Arc::new(MockScrapeResultRepository::empty()),
);
use_case
.cancel_crawl(crawl_id, team_id)
.await
.expect("should succeed");
assert_eq!(
crawl_repo.last_updated_status(),
Some(CrawlStatus::Cancelled),
"crawl status should be updated to Cancelled"
);
}
#[tokio::test]
async fn test_cancel_crawl_not_found() {
let use_case = build_use_case_allowed_geo(
Arc::new(MockCrawlRepository::empty()),
Arc::new(MockTaskRepository::empty()),
Arc::new(MockScrapeResultRepository::empty()),
);
let result = use_case
.cancel_crawl(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
)
.await;
assert!(matches!(result, Err(CrawlUseCaseError::NotFound)));
}
#[tokio::test]
async fn test_cancel_crawl_wrong_team_returns_not_found() {
let crawl_id = crate::domain::id::Id::generate();
let crawl = make_crawl(
crawl_id,
crate::domain::id::Id::generate(),
CrawlStatus::Queued,
);
let use_case = build_use_case_allowed_geo(
Arc::new(MockCrawlRepository::with_crawl(crawl)),
Arc::new(MockTaskRepository::empty()),
Arc::new(MockScrapeResultRepository::empty()),
);
let result = use_case
.cancel_crawl(crawl_id, crate::domain::id::Id::generate())
.await;
assert!(matches!(result, Err(CrawlUseCaseError::NotFound)));
}
#[tokio::test]
async fn test_cancel_crawl_already_completed_is_noop() {
let team_id = crate::domain::id::Id::generate();
let crawl_id = crate::domain::id::Id::generate();
let crawl = make_crawl(crawl_id, team_id, CrawlStatus::Completed);
let crawl_repo = Arc::new(MockCrawlRepository::with_crawl(crawl));
let use_case = build_use_case_allowed_geo(
crawl_repo.clone(),
Arc::new(MockTaskRepository::empty()),
Arc::new(MockScrapeResultRepository::empty()),
);
use_case
.cancel_crawl(crawl_id, team_id)
.await
.expect("should succeed as no-op");
assert!(
crawl_repo.last_updated_status().is_none(),
"completed crawl should not be updated"
);
}
#[tokio::test]
async fn test_cancel_crawl_already_failed_is_noop() {
let team_id = crate::domain::id::Id::generate();
let crawl_id = crate::domain::id::Id::generate();
let crawl = make_crawl(crawl_id, team_id, CrawlStatus::Failed);
let use_case = build_use_case_allowed_geo(
Arc::new(MockCrawlRepository::with_crawl(crawl)),
Arc::new(MockTaskRepository::empty()),
Arc::new(MockScrapeResultRepository::empty()),
);
use_case
.cancel_crawl(crawl_id, team_id)
.await
.expect("should succeed as no-op");
}
#[tokio::test]
async fn test_cancel_crawl_already_cancelled_is_noop() {
let team_id = crate::domain::id::Id::generate();
let crawl_id = crate::domain::id::Id::generate();
let crawl = make_crawl(crawl_id, team_id, CrawlStatus::Cancelled);
let use_case = build_use_case_allowed_geo(
Arc::new(MockCrawlRepository::with_crawl(crawl)),
Arc::new(MockTaskRepository::empty()),
Arc::new(MockScrapeResultRepository::empty()),
);
use_case
.cancel_crawl(crawl_id, team_id)
.await
.expect("should succeed as no-op");
}
#[tokio::test]
async fn test_cancel_crawl_processing_status_gets_cancelled() {
let team_id = crate::domain::id::Id::generate();
let crawl_id = crate::domain::id::Id::generate();
let crawl = make_crawl(crawl_id, team_id, CrawlStatus::Processing);
let crawl_repo = Arc::new(MockCrawlRepository::with_crawl(crawl));
let use_case = build_use_case_allowed_geo(
crawl_repo.clone(),
Arc::new(MockTaskRepository::empty()),
Arc::new(MockScrapeResultRepository::empty()),
);
use_case
.cancel_crawl(crawl_id, team_id)
.await
.expect("should succeed");
assert_eq!(
crawl_repo.last_updated_status(),
Some(CrawlStatus::Cancelled)
);
}
#[tokio::test]
async fn test_cancel_crawl_update_error_propagates() {
let team_id = crate::domain::id::Id::generate();
let crawl_id = crate::domain::id::Id::generate();
let crawl = make_crawl(crawl_id, team_id, CrawlStatus::Queued);
let use_case = build_use_case_allowed_geo(
Arc::new(MockCrawlRepository::failing_update(crawl)),
Arc::new(MockTaskRepository::empty()),
Arc::new(MockScrapeResultRepository::empty()),
);
let result = use_case.cancel_crawl(crawl_id, team_id).await;
let err = match result {
Err(CrawlUseCaseError::Repository(e)) => e,
e => panic!("expected Repository error, got: {:?}", e),
};
assert!(err.to_string().contains("update down"));
}
#[tokio::test]
async fn test_cancel_crawl_cancel_tasks_error_propagates() {
let team_id = crate::domain::id::Id::generate();
let crawl_id = crate::domain::id::Id::generate();
let crawl = make_crawl(crawl_id, team_id, CrawlStatus::Queued);
let use_case = build_use_case_allowed_geo(
Arc::new(MockCrawlRepository::with_crawl(crawl)),
Arc::new(MockTaskRepository::failing_cancel()),
Arc::new(MockScrapeResultRepository::empty()),
);
let result = use_case.cancel_crawl(crawl_id, team_id).await;
let err = match result {
Err(CrawlUseCaseError::Repository(e)) => e,
e => panic!("expected Repository error, got: {:?}", e),
};
assert!(err.to_string().contains("cancel tasks down"));
}
#[cfg(feature = "teams")]
#[tokio::test]
async fn test_create_crawl_geo_denied_with_failing_log_still_returns_validation_error() {
let restrictions = TeamGeoRestrictions {
enable_geo_restrictions: true,
..Default::default()
};
let geo_repo = Arc::new(MockGeoRestrictionRepository::with_failing_log(restrictions));
let use_case = build_use_case(
Arc::new(MockCrawlRepository::empty()),
Arc::new(MockTaskRepository::empty()),
Arc::new(MockScrapeResultRepository::empty()),
geo_repo,
Arc::new(MockGeoLocationService::succeeding()),
);
let result = use_case
.create_crawl(
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
make_crawl_dto(),
"not-an-ip",
)
.await;
let err = match result {
Err(CrawlUseCaseError::ValidationError(msg)) => msg,
e => panic!("expected ValidationError, got: {:?}", e),
};
assert!(
err.contains("Geographic restriction check failed"),
"got: {}",
err
);
}
#[tokio::test]
async fn test_mock_crawl_repo_remaining_methods_return_defaults() {
let repo = MockCrawlRepository::empty();
let id = crate::domain::id::Id::generate();
repo.increment_completed_tasks(id).await.unwrap();
repo.increment_failed_tasks(id).await.unwrap();
repo.update_status(id, CrawlStatus::Completed)
.await
.unwrap();
repo.increment_total_tasks(id).await.unwrap();
assert!(repo
.find_by_team_id_paginated(id, 10, 0)
.await
.unwrap()
.is_empty());
assert_eq!(repo.count_by_team_id(id).await.unwrap(), 0);
}
#[tokio::test]
async fn test_mock_task_repo_remaining_methods_return_defaults() {
let repo = MockTaskRepository::empty();
let task = Task::new(
crate::domain::id::Id::generate(),
TaskType::Crawl,
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
"https://example.com".to_string(),
json!({}),
);
assert!(repo.find_by_id(task.id).await.unwrap().is_none());
let updated = repo.update(&task).await.unwrap();
assert_eq!(updated.id, task.id);
assert!(repo
.acquire_next(crate::domain::id::Id::generate())
.await
.unwrap()
.is_none());
repo.mark_completed(task.id, None).await.unwrap();
repo.mark_failed(task.id, None).await.unwrap();
repo.mark_cancelled(task.id).await.unwrap();
assert!(!repo.exists_by_url("https://a.com").await.unwrap());
assert!(repo
.find_existing_urls(&["https://a.com".to_string()])
.await
.unwrap()
.is_empty());
assert_eq!(
repo.reset_stuck_tasks(chrono::Duration::minutes(5))
.await
.unwrap(),
0
);
assert_eq!(repo.expire_tasks().await.unwrap(), 0);
let (tasks, count) = repo
.query_tasks(crate::domain::repositories::task_repository::TaskQueryParams::default())
.await
.unwrap();
assert!(tasks.is_empty());
assert_eq!(count, 0);
let (cancelled, failed) = repo
.batch_cancel(
vec![crate::domain::id::Id::generate()],
crate::domain::id::Id::generate(),
false,
)
.await
.unwrap();
assert!(cancelled.is_empty());
assert!(failed.is_empty());
}
#[cfg(feature = "webhook")]
#[tokio::test]
async fn test_mock_webhook_repo_remaining_methods_return_defaults() {
let repo = MockWebhookRepository;
let id = crate::domain::id::Id::generate();
assert!(repo.find_by_id(id).await.unwrap().is_none());
assert!(repo.find_by_team_id(id).await.unwrap().is_empty());
}
#[tokio::test]
async fn test_mock_scrape_result_repo_remaining_methods_return_defaults() {
let repo = MockScrapeResultRepository::empty();
let task_id = crate::domain::id::Id::generate();
repo.save(make_scrape_result(task_id)).await.unwrap();
assert!(repo.find_by_task_id(task_id).await.unwrap().is_none());
assert_eq!(
repo.get_team_avg_response_time(crate::domain::id::Id::generate())
.await
.unwrap(),
0.0
);
}
#[cfg(feature = "teams")]
#[tokio::test]
async fn test_mock_geo_restriction_repo_update_team_restrictions_succeeds() {
let repo = MockGeoRestrictionRepository::with_restrictions(TeamGeoRestrictions::default());
let result = repo
.update_team_restrictions(
crate::domain::id::Id::generate(),
&TeamGeoRestrictions::default(),
)
.await;
assert!(result.is_ok(), "update_team_restrictions should succeed");
}
}