use crate::config::settings::Settings;
use crate::di::{CrawlRsState, CrawlRsStateExt};
#[cfg(feature = "teams")]
use crate::domain::repositories::geo_restriction_repository::GeoRestrictionRepository;
#[cfg(feature = "teams")]
use crate::domain::services::team_service::TeamService;
#[cfg(feature = "teams")]
use crate::infrastructure::database::repositories::database_geo_restriction_repo::DatabaseGeoRestrictionRepository;
use crate::common::constants::server_config::CORS_MAX_AGE_SECS;
use crate::infrastructure::database::repositories::scrape_result_repo_impl::ScrapeResultRepositoryImpl;
use crate::infrastructure::database::repositories::task_repo_impl::TaskRepositoryImpl;
#[cfg(feature = "webhook")]
use crate::infrastructure::database::repositories::webhook_repo_impl::WebhookRepoImpl;
use crate::infrastructure::events::event_bus::EventBus;
use crate::presentation::handlers::metrics_handler;
#[cfg(not(feature = "auth"))]
use crate::presentation::middleware::auth_types::AuthState;
use crate::presentation::middleware::rate_limit_middleware::RateLimitMiddleware;
use crate::presentation::middleware::team_semaphore_middleware::team_semaphore_middleware;
use crate::presentation::routes;
use crate::presentation::routes::task::{task_routes, TaskWsGuard};
use crate::presentation::state::CrawlHandlerState;
use axum::{routing::get, Extension, Router};
use std::sync::Arc;
use tower_http::cors::{Any, CorsLayer};
#[cfg(not(feature = "auth"))]
use crate::common::constants::default_identity::{DEFAULT_API_KEY_ID, DEFAULT_TEAM_ID};
#[cfg(not(feature = "auth"))]
use crate::domain::auth::ApiKeyScope;
use crate::bootstrap::route_groups::{
crawl_routes, management_routes, scrape_routes, search_routes,
};
#[cfg(feature = "sitemap")]
use crate::bootstrap::route_groups::map_routes;
fn create_cors_layer(settings: &Settings) -> CorsLayer {
let allowed_origins = settings.cors.allowed_origins_list();
if allowed_origins.is_empty() || allowed_origins.iter().any(|o| o == "*") {
wildcard_cors_layer()
} else {
restricted_cors_layer(&allowed_origins)
}
}
fn wildcard_cors_layer() -> CorsLayer {
log::warn!("{}", crate::i18n::tr_log("boot-cors-wildcard"));
let env = std::env::var(crate::common::constants::env_vars::ENV)
.or_else(|_| std::env::var(crate::common::constants::env_vars::APP_ENVIRONMENT))
.unwrap_or_else(|_| "development".to_string());
let is_test_env = env.to_lowercase() == "test"
|| std::env::var("CRAWLRS__TEST_MODE").unwrap_or_default() == "true";
if !is_test_env {
log::warn!("CORS allows all origins in production");
}
CorsLayer::new()
.allow_origin(Any)
.allow_methods(Any)
.allow_headers(Any)
}
fn restricted_cors_layer(allowed_origins: &[String]) -> CorsLayer {
let origins: Vec<axum::http::HeaderValue> = allowed_origins
.iter()
.filter_map(|origin| origin.parse().ok())
.collect();
if origins.is_empty() {
log::warn!("{}", crate::i18n::tr_log("boot-cors-invalid-fallback"));
CorsLayer::new()
.allow_origin(Any)
.allow_methods(Any)
.allow_headers(Any)
} else {
CorsLayer::new()
.allow_origin(origins)
.allow_methods([
axum::http::Method::GET,
axum::http::Method::POST,
axum::http::Method::PUT,
axum::http::Method::DELETE,
axum::http::Method::PATCH,
axum::http::Method::HEAD,
axum::http::Method::OPTIONS,
])
.allow_headers([
axum::http::HeaderName::from_static("authorization"),
axum::http::HeaderName::from_static("content-type"),
axum::http::HeaderName::from_static("x-api-key"),
axum::http::HeaderName::from_static("x-request-id"),
])
.expose_headers([axum::http::HeaderName::from_static("x-request-id")])
.max_age(std::time::Duration::from_secs(CORS_MAX_AGE_SECS))
}
}
pub fn create_public_routes(state: &CrawlRsState) -> Router {
let ready_routes = Router::new()
.route("/ready", get(routes::readiness_check))
.layer(Extension(state.db_pool.clone()))
.layer(Extension(state.cache_service.clone()));
#[cfg_attr(not(feature = "auth"), allow(unused_mut))]
let mut router = Router::new()
.route("/health", get(routes::health_check))
.merge(ready_routes)
.route("/metrics", get(metrics_handler::metrics))
.route("/v1/version", get(routes::version))
.with_state(Arc::new(state.clone()));
#[cfg(feature = "auth")]
{
router = router.merge(garrison::health::axum_routes::health_routes(
state.engine_client.health_registry(),
));
}
router
}
#[cfg(not(feature = "auth"))]
fn build_default_identity_template(state: &CrawlRsState) -> AuthState {
static WARN_ONCE: std::sync::OnceLock<()> = std::sync::OnceLock::new();
WARN_ONCE.get_or_init(|| {
log::warn!(
"auth feature disabled — running in single-tenant degraded mode; \
protected routes default-denied (401) unless \
allow_unauthenticated_protected() is called. \
DO NOT expose to public networks."
);
});
AuthState::new(
state.db_pool.clone(),
DEFAULT_TEAM_ID,
DEFAULT_API_KEY_ID,
ApiKeyScope::denied(),
)
}
fn protected_route_groups() -> Router {
let app: Router = scrape_routes::register_scrape_routes()
.merge(crawl_routes::register_crawl_routes())
.merge(search_routes::register_search_routes())
.merge(management_routes::register_webhook_routes())
.merge(management_routes::register_extract_routes())
.merge(management_routes::register_teams_routes())
.merge(management_routes::register_audit_routes())
.merge(management_routes::register_searxng_routes())
.merge(management_routes::register_admin_routes());
#[cfg(feature = "sitemap")]
let app = app.merge(map_routes::register_map_routes());
app
}
fn apply_auth_layers(app: Router, state: &CrawlRsState) -> Router {
#[cfg(feature = "auth")]
let app = app.layer(axum::middleware::from_fn_with_state(
state.db_pool.clone(),
crate::presentation::middleware::auth_middleware::auth_middleware_inner,
));
#[cfg(not(feature = "auth"))]
let app = {
let template = build_default_identity_template(state);
app.layer(axum::middleware::from_fn_with_state(
template,
crate::presentation::middleware::auth_middleware::default_identity_middleware,
))
};
#[cfg(feature = "auth")]
let app = app.layer(axum::middleware::from_fn(
crate::presentation::middleware::auth_middleware::garrison_ip_context_middleware,
));
app
}
#[cfg(feature = "teams")]
fn apply_teams_extension_layers(app: Router, state: &CrawlRsState) -> Router {
let geo_restriction_repo_impl: Arc<DatabaseGeoRestrictionRepository> =
Arc::new(DatabaseGeoRestrictionRepository::new(state.db_pool.clone()));
let geo_restriction_repo: Arc<dyn GeoRestrictionRepository> = geo_restriction_repo_impl.clone();
let geo_location_service = state.geo_location_service();
let team_service = state.team_service.clone();
app.layer(Extension(geo_restriction_repo.clone()))
.layer(Extension(geo_location_service))
.layer(Extension(team_service.clone()))
.layer(Extension(geo_restriction_repo_impl))
.layer(Extension(
Some(geo_restriction_repo) as Option<Arc<dyn GeoRestrictionRepository>>
))
.layer(Extension(Some(team_service) as Option<Arc<TeamService>>))
}
#[cfg(not(feature = "teams"))]
fn apply_teams_extension_layers(app: Router, _state: &CrawlRsState) -> Router {
app.layer(Extension(
None::<Arc<dyn crate::domain::repositories::geo_restriction_repository::GeoRestrictionRepository>>,
))
.layer(Extension(
None::<Arc<crate::domain::services::team_service::TeamService>>,
))
}
#[cfg(feature = "webhook")]
fn apply_webhook_extension_layers(app: Router, state: &CrawlRsState) -> Router {
let webhook_repo_impl: Arc<WebhookRepoImpl> =
Arc::new(WebhookRepoImpl::new(state.db_pool.clone()));
app.layer(Extension(state.webhook_repo.clone()))
.layer(Extension(state.webhook_event_repo()))
.layer(Extension(webhook_repo_impl))
}
#[cfg(not(feature = "webhook"))]
fn apply_webhook_extension_layers(app: Router, _state: &CrawlRsState) -> Router {
app
}
fn build_sdk_router_with_auth(state: &CrawlRsState) -> Router {
apply_auth_layers(crate::presentation::sdk::build_sdk_router(), state)
}
fn apply_global_api_layers(
app: Router,
sdk_router: Router,
state: &CrawlRsState,
settings: Arc<Settings>,
cors_layer: CorsLayer,
) -> Router {
let rate_limiting_service = state.rate_limiting_service.clone();
let rate_limit_middleware = RateLimitMiddleware::new(rate_limiting_service.clone());
let rate_limit_config = std::sync::Arc::new(
crate::presentation::middleware::rate_limit_middleware::RateLimitRuntimeConfig::from_settings(
settings.as_ref(),
),
);
let search_engine_service = state.search_client();
let queue = state.task_queue.clone();
let credits_repo = state.credits_repo();
let crawl_repo = state.crawl_repo.clone();
#[cfg(feature = "webhook")]
let webhook_event_repo = state.webhook_event_repo();
#[cfg(feature = "webhook")]
let webhook_repo = state.webhook_repo();
#[cfg(feature = "teams")]
let geo_restriction_repo = state.geo_restriction_repo();
#[cfg(feature = "teams")]
let geo_restriction_repo_opt: Option<
Arc<dyn crate::domain::repositories::geo_restriction_repository::GeoRestrictionRepository>,
> = Some(state.geo_restriction_repo());
#[cfg(not(feature = "teams"))]
let geo_restriction_repo_opt: Option<
Arc<dyn crate::domain::repositories::geo_restriction_repository::GeoRestrictionRepository>,
> = None;
let rate_limiting_service_opt: Option<
Arc<dyn crate::domain::services::rate_limiting_service::RateLimitingService>,
> = Some(rate_limiting_service.clone());
let app = app
.merge(sdk_router)
.layer(Extension(state.search_service.clone()))
.layer(Extension(state.task_queue.clone()))
.layer(Extension(state.crawl_repo.clone()))
.layer(Extension(geo_restriction_repo_opt))
.layer(Extension(rate_limiting_service_opt));
let app = app.layer(cors_layer)
.layer(axum::middleware::from_fn(
crate::i18n::i18n_middleware,
))
.layer(Extension(state.i18n_bundle.clone()))
.layer(axum::middleware::from_fn(
crate::presentation::middleware::security_headers_middleware::security_headers_middleware,
))
.layer(axum::extract::DefaultBodyLimit::max(10 * 1024 * 1024)) .layer(axum::middleware::from_fn_with_state(
rate_limit_config,
crate::presentation::middleware::rate_limit_middleware::rate_limit_layer,
))
.layer(Extension(state.team_semaphore.clone()))
.layer(Extension(queue))
.layer(Extension(state.task_repo.clone()))
.layer(Extension(state.result_repo.clone()))
.layer(Extension(crawl_repo))
.layer(Extension(rate_limit_middleware))
.layer(Extension(credits_repo))
.layer(Extension(settings))
.layer(Extension(search_engine_service))
.layer(Extension(rate_limiting_service.clone()))
.layer(Extension(state.audit_service()));
#[cfg(feature = "webhook")]
let app = app
.layer(Extension(webhook_event_repo))
.layer(Extension(webhook_repo.clone()));
#[cfg(feature = "teams")]
let app = app.layer(Extension(geo_restriction_repo));
app
}
pub fn create_protected_routes_with_state(state: &CrawlRsState, settings: Arc<Settings>) -> Router {
let team_semaphore = state.team_semaphore.clone();
let queue = state.task_queue.clone();
let task_repo = state.task_repo.clone();
let result_repo = state.result_repo.clone();
let rate_limiting_service = state.rate_limiting_service.clone();
let rate_limit_middleware = RateLimitMiddleware::new(rate_limiting_service.clone());
let crawl_repo = state.crawl_repo.clone();
let search_engine_service = state.search_client();
let searxng_instances = state.searxng_instances();
let credits_repo = state.credits_repo();
let app_state_arc = Arc::new(state.clone());
let crawl_handler_state = Arc::new(CrawlHandlerState::from_app_state(&app_state_arc));
let app = protected_route_groups();
let app = apply_auth_layers(app, state);
let app = apply_teams_extension_layers(app, state);
let app = apply_webhook_extension_layers(app, state);
let app = app
.layer(Extension(team_semaphore))
.layer(Extension(queue))
.layer(Extension(task_repo))
.layer(Extension(result_repo))
.layer(Extension(rate_limit_middleware))
.layer(Extension(settings))
.layer(Extension(rate_limiting_service))
.layer(Extension(crawl_repo))
.layer(Extension(search_engine_service))
.layer(Extension(state.search_service.clone()))
.layer(Extension(crawl_handler_state)) .layer(Extension(credits_repo))
.layer(Extension(searxng_instances));
#[cfg(feature = "sitemap")]
let app = app.layer(Extension(state.map_use_case.clone()));
app
}
pub fn create_v2_routes_with_state(state: &CrawlRsState, settings: Arc<Settings>) -> Router {
let crawl_repo = state.crawl_repo.clone();
#[cfg(feature = "webhook")]
let webhook_repo = state.webhook_repo.clone();
#[cfg(feature = "webhook")]
let webhook_event_repo = state.webhook_event_repo();
let team_semaphore = state.team_semaphore.clone();
let task_repo_impl: Arc<TaskRepositoryImpl> = Arc::new(TaskRepositoryImpl::new(
state.db_pool.clone(),
chrono::Duration::seconds(
settings
.concurrency
.task_lock_duration_seconds
.try_into()
.expect("task_lock_duration_seconds exceeds i64 range"),
),
));
let result_repo_impl: Arc<ScrapeResultRepositoryImpl> =
Arc::new(ScrapeResultRepositoryImpl::new(state.db_pool.clone()));
let app = task_routes()
.layer(Extension(task_repo_impl.clone()))
.layer(Extension(result_repo_impl.clone()))
.layer(Extension(Arc::clone(&state.event_bus) as Arc<dyn EventBus>))
.layer(Extension(Arc::new(TaskWsGuard::new(
settings.websocket.max_connections,
std::time::Duration::from_secs(settings.websocket.idle_timeout_secs),
))));
let app = app
.layer(axum::middleware::from_fn(team_semaphore_middleware))
.layer(Extension(team_semaphore))
.layer(Extension(task_repo_impl.clone()))
.layer(Extension(result_repo_impl.clone()))
.layer(Extension(crawl_repo.clone()));
#[cfg(feature = "webhook")]
let app = app
.layer(Extension(webhook_repo.clone()))
.layer(Extension(webhook_event_repo.clone()));
apply_auth_layers(app, state)
}
pub fn build_api_app_with_state(state: &CrawlRsState, settings: Arc<Settings>) -> Router {
#[cfg(feature = "auth")]
crate::presentation::middleware::auth_middleware::configure_trusted_proxies(&settings);
let public_routes = create_public_routes(state);
let protected_routes = create_protected_routes_with_state(state, settings.clone());
let v2_routes = create_v2_routes_with_state(state, settings.clone());
let cors_layer = create_cors_layer(&settings);
let app = Router::new()
.merge(public_routes)
.merge(protected_routes)
.merge(v2_routes);
let sdk_router = build_sdk_router_with_auth(state);
apply_global_api_layers(app, sdk_router, state, settings, cors_layer)
}
#[cfg(test)]
mod tests {
use super::*;
use axum::body::Body;
use axum::http::{HeaderValue, Method, Request, StatusCode};
use axum::routing::any;
use tower::ServiceExt;
use crate::common::test_support::testcontainers_fixtures as tcf;
use crate::di::modules::{
CacheModule, DatabaseModule, EngineModule, HttpModule, IdModule, InfrastructureModule,
RepositoryModule, ServiceModule, SettingsModule,
};
use trait_kit::AsyncKit;
fn cors_test_app(layer: CorsLayer) -> axum::Router {
axum::Router::new()
.route("/ping", any(|| async { "pong" }))
.layer(layer)
}
fn make_settings(origins: &str) -> Settings {
let mut settings =
crate::bootstrap::config::load_settings().expect("Failed to load settings");
settings.cors.allowed_origins = origins.to_string();
settings
}
#[tokio::test]
async fn test_cors_wildcard_adds_allow_origin_star() {
let settings = crate::bootstrap::config::load_settings().expect("Failed to load settings");
let app = cors_test_app(create_cors_layer(&settings));
let response = app
.oneshot(
Request::builder()
.method(Method::GET)
.uri("/ping")
.header("origin", "https://example.com")
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(response.status(), StatusCode::OK);
let allow_origin = response
.headers()
.get("access-control-allow-origin")
.expect("CORS wildcard should set access-control-allow-origin");
assert_eq!(allow_origin, "*", "wildcard config should allow origin *");
}
#[tokio::test]
async fn test_cors_empty_origins_falls_back_to_wildcard() {
let settings = make_settings("");
let app = cors_test_app(create_cors_layer(&settings));
let response = app
.oneshot(
Request::builder()
.method(Method::GET)
.uri("/ping")
.header("origin", "https://example.com")
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(
response.headers().get("access-control-allow-origin"),
Some(&HeaderValue::from_static("*")),
"empty origins should fall back to wildcard"
);
}
#[tokio::test]
async fn test_cors_specific_origin_reflected_for_matching_request() {
let settings = make_settings("https://example.com");
let app = cors_test_app(create_cors_layer(&settings));
let response = app
.oneshot(
Request::builder()
.method(Method::GET)
.uri("/ping")
.header("origin", "https://example.com")
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(response.status(), StatusCode::OK);
let allow_origin = response
.headers()
.get("access-control-allow-origin")
.expect("matching origin should get access-control-allow-origin header");
assert_eq!(
allow_origin, "https://example.com",
"specific origin config should reflect the request origin"
);
}
#[tokio::test]
async fn test_cors_specific_origin_not_set_for_non_matching_request() {
let settings = make_settings("https://example.com");
let app = cors_test_app(create_cors_layer(&settings));
let response = app
.oneshot(
Request::builder()
.method(Method::GET)
.uri("/ping")
.header("origin", "https://evil.com")
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(response.status(), StatusCode::OK);
assert!(
response
.headers()
.get("access-control-allow-origin")
.is_none(),
"non-matching origin should NOT get CORS allow-origin header"
);
}
#[tokio::test]
async fn test_cors_multiple_specific_origins_match_one() {
let settings = make_settings("https://example.com,https://api.example.com");
let app = cors_test_app(create_cors_layer(&settings));
let response = app
.oneshot(
Request::builder()
.method(Method::GET)
.uri("/ping")
.header("origin", "https://api.example.com")
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(
response.headers().get("access-control-allow-origin"),
Some(&HeaderValue::from_static("https://api.example.com")),
"second origin in list should be allowed"
);
}
#[tokio::test]
async fn test_cors_whitespace_origins_are_trimmed() {
let settings = make_settings(" https://example.com , https://api.example.com ");
let app = cors_test_app(create_cors_layer(&settings));
let response = app
.oneshot(
Request::builder()
.method(Method::GET)
.uri("/ping")
.header("origin", "https://example.com")
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(
response.headers().get("access-control-allow-origin"),
Some(&HeaderValue::from_static("https://example.com")),
"whitespace-padded origins should be trimmed and still match"
);
}
#[tokio::test]
async fn test_cors_preflight_specific_origin_returns_allow_methods() {
let settings = make_settings("https://example.com");
let app = cors_test_app(create_cors_layer(&settings));
let response = app
.oneshot(
Request::builder()
.method(Method::OPTIONS)
.uri("/ping")
.header("origin", "https://example.com")
.header("access-control-request-method", "GET")
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(response.status(), StatusCode::OK);
let allow_methods = response
.headers()
.get("access-control-allow-methods")
.expect("preflight should return access-control-allow-methods");
let methods_str = allow_methods.to_str().expect("methods header is ASCII");
assert!(
methods_str.contains("GET"),
"allow-methods should include GET, got: {}",
methods_str
);
assert!(
methods_str.contains("POST"),
"allow-methods should include POST, got: {}",
methods_str
);
}
#[tokio::test]
async fn test_cors_preflight_specific_origin_returns_allow_headers() {
let settings = make_settings("https://example.com");
let app = cors_test_app(create_cors_layer(&settings));
let response = app
.oneshot(
Request::builder()
.method(Method::OPTIONS)
.uri("/ping")
.header("origin", "https://example.com")
.header("access-control-request-method", "POST")
.header("access-control-request-headers", "content-type")
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(response.status(), StatusCode::OK);
let allow_headers = response
.headers()
.get("access-control-allow-headers")
.expect("preflight should return access-control-allow-headers");
let headers_str = allow_headers.to_str().expect("headers header is ASCII");
assert!(
headers_str.contains("authorization"),
"allow-headers should include authorization, got: {}",
headers_str
);
assert!(
headers_str.contains("content-type"),
"allow-headers should include content-type, got: {}",
headers_str
);
}
#[tokio::test]
async fn test_cors_preflight_returns_max_age() {
let settings = make_settings("https://example.com");
let app = cors_test_app(create_cors_layer(&settings));
let response = app
.oneshot(
Request::builder()
.method(Method::OPTIONS)
.uri("/ping")
.header("origin", "https://example.com")
.header("access-control-request-method", "GET")
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(response.status(), StatusCode::OK);
let max_age = response
.headers()
.get("access-control-max-age")
.expect("preflight should return access-control-max-age");
let max_age_str = max_age.to_str().expect("max-age is ASCII");
let max_age_secs: u64 = max_age_str.parse().expect("max-age should be a number");
assert_eq!(
max_age_secs, CORS_MAX_AGE_SECS,
"max-age should match CORS_MAX_AGE_SECS constant"
);
}
#[tokio::test]
async fn test_cors_preflight_exposes_request_id_header() {
let settings = make_settings("https://example.com");
let app = cors_test_app(create_cors_layer(&settings));
let response = app
.oneshot(
Request::builder()
.method(Method::GET)
.uri("/ping")
.header("origin", "https://example.com")
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(response.status(), StatusCode::OK);
let expose = response
.headers()
.get("access-control-expose-headers")
.expect("response should include access-control-expose-headers");
let expose_str = expose.to_str().expect("expose-headers is ASCII");
assert!(
expose_str.contains("x-request-id"),
"expose-headers should include x-request-id, got: {}",
expose_str
);
}
#[tokio::test]
async fn test_cors_unparsable_origin_falls_back_to_wildcard() {
let invalid = format!("https://{}.example.com", '\0');
let settings = make_settings(&invalid);
let app = cors_test_app(create_cors_layer(&settings));
let response = app
.oneshot(
Request::builder()
.method(Method::GET)
.uri("/ping")
.header("origin", "https://example.com")
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(
response.headers().get("access-control-allow-origin"),
Some(&HeaderValue::from_static("*")),
"unparsable origin config should fall back to wildcard"
);
}
#[tokio::test]
async fn test_cors_origin_with_spaces_is_valid_header_value() {
let settings = make_settings("invalid origin with spaces");
let app = cors_test_app(create_cors_layer(&settings));
let response = app
.oneshot(
Request::builder()
.method(Method::GET)
.uri("/ping")
.header("origin", "https://example.com")
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(response.status(), StatusCode::OK);
assert!(
response
.headers()
.get("access-control-allow-origin")
.is_none(),
"request origin 'https://example.com' should not match the configured 'invalid origin with spaces'"
);
}
#[tokio::test]
async fn test_cors_no_origin_header_no_cors_headers() {
let settings = make_settings("https://example.com");
let app = cors_test_app(create_cors_layer(&settings));
let response = app
.oneshot(
Request::builder()
.method(Method::GET)
.uri("/ping")
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(response.status(), StatusCode::OK);
assert!(
response
.headers()
.get("access-control-allow-origin")
.is_none(),
"request without Origin should not get CORS headers"
);
}
#[tokio::test]
async fn test_cors_wildcard_among_specific_origins_uses_wildcard() {
let settings = make_settings("https://example.com,*,https://api.example.com");
let app = cors_test_app(create_cors_layer(&settings));
let response = app
.oneshot(
Request::builder()
.method(Method::GET)
.uri("/ping")
.header("origin", "https://random-site.com")
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(
response.headers().get("access-control-allow-origin"),
Some(&HeaderValue::from_static("*")),
"when '*' is in the list, wildcard should be used"
);
}
#[tokio::test]
async fn test_cors_only_wildcard_origin() {
let settings = make_settings("*");
let app = cors_test_app(create_cors_layer(&settings));
let response = app
.oneshot(
Request::builder()
.method(Method::GET)
.uri("/ping")
.header("origin", "https://any-origin.com")
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(
response.headers().get("access-control-allow-origin"),
Some(&HeaderValue::from_static("*"))
);
}
#[tokio::test]
async fn test_cors_multiple_origins_first_matches() {
let settings = make_settings("https://example.com,https://api.example.com");
let app = cors_test_app(create_cors_layer(&settings));
let response = app
.oneshot(
Request::builder()
.method(Method::GET)
.uri("/ping")
.header("origin", "https://example.com")
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(
response.headers().get("access-control-allow-origin"),
Some(&HeaderValue::from_static("https://example.com"))
);
}
#[tokio::test]
async fn test_cors_preflight_wildcard_returns_allow_origin_star() {
let settings = crate::bootstrap::config::load_settings().expect("Failed to load settings");
let app = cors_test_app(create_cors_layer(&settings));
let response = app
.oneshot(
Request::builder()
.method(Method::OPTIONS)
.uri("/ping")
.header("origin", "https://example.com")
.header("access-control-request-method", "POST")
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(
response.headers().get("access-control-allow-origin"),
Some(&HeaderValue::from_static("*")),
"preflight with wildcard config should return *"
);
}
#[tokio::test]
async fn test_cors_preflight_non_matching_origin_no_allow_methods() {
let settings = make_settings("https://example.com");
let app = cors_test_app(create_cors_layer(&settings));
let response = app
.oneshot(
Request::builder()
.method(Method::OPTIONS)
.uri("/ping")
.header("origin", "https://evil.com")
.header("access-control-request-method", "GET")
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(response.status(), StatusCode::OK);
assert!(
response
.headers()
.get("access-control-allow-origin")
.is_none(),
"non-matching origin should not get CORS headers in preflight"
);
}
#[tokio::test]
async fn test_cors_specific_origin_post_request() {
let settings = make_settings("https://example.com");
let app = cors_test_app(create_cors_layer(&settings));
let response = app
.oneshot(
Request::builder()
.method(Method::POST)
.uri("/ping")
.header("origin", "https://example.com")
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(
response.headers().get("access-control-allow-origin"),
Some(&HeaderValue::from_static("https://example.com")),
"POST request with matching origin should get CORS header"
);
}
#[tokio::test]
async fn test_cors_specific_origin_delete_request() {
let settings = make_settings("https://example.com");
let app = cors_test_app(create_cors_layer(&settings));
let response = app
.oneshot(
Request::builder()
.method(Method::DELETE)
.uri("/ping")
.header("origin", "https://example.com")
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(
response.headers().get("access-control-allow-origin"),
Some(&HeaderValue::from_static("https://example.com"))
);
}
#[tokio::test]
async fn test_cors_specific_origin_expose_headers_on_get() {
let settings = make_settings("https://example.com");
let app = cors_test_app(create_cors_layer(&settings));
let response = app
.oneshot(
Request::builder()
.method(Method::GET)
.uri("/ping")
.header("origin", "https://example.com")
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(response.status(), StatusCode::OK);
let expose = response
.headers()
.get("access-control-expose-headers")
.expect("GET response should include expose-headers");
assert!(expose.to_str().unwrap().contains("x-request-id"));
}
#[tokio::test]
async fn test_cors_preflight_includes_all_methods() {
let settings = make_settings("https://example.com");
let app = cors_test_app(create_cors_layer(&settings));
let response = app
.oneshot(
Request::builder()
.method(Method::OPTIONS)
.uri("/ping")
.header("origin", "https://example.com")
.header("access-control-request-method", "PUT")
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(response.status(), StatusCode::OK);
let allow_methods = response
.headers()
.get("access-control-allow-methods")
.expect("preflight should return allow-methods");
let methods_str = allow_methods.to_str().unwrap();
assert!(methods_str.contains("GET"));
assert!(methods_str.contains("POST"));
assert!(methods_str.contains("PUT"));
assert!(methods_str.contains("DELETE"));
assert!(methods_str.contains("PATCH"));
assert!(methods_str.contains("HEAD"));
assert!(methods_str.contains("OPTIONS"));
}
#[tokio::test]
async fn test_cors_preflight_includes_all_allowed_headers() {
let settings = make_settings("https://example.com");
let app = cors_test_app(create_cors_layer(&settings));
let response = app
.oneshot(
Request::builder()
.method(Method::OPTIONS)
.uri("/ping")
.header("origin", "https://example.com")
.header("access-control-request-method", "POST")
.header(
"access-control-request-headers",
"authorization, content-type",
)
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(response.status(), StatusCode::OK);
let allow_headers = response
.headers()
.get("access-control-allow-headers")
.expect("preflight should return allow-headers");
let headers_str = allow_headers.to_str().unwrap();
assert!(headers_str.contains("authorization"));
assert!(headers_str.contains("content-type"));
assert!(headers_str.contains("x-api-key"));
assert!(headers_str.contains("x-request-id"));
}
#[tokio::test]
async fn test_cors_trailing_comma_in_origins() {
let settings = make_settings("https://example.com,");
let app = cors_test_app(create_cors_layer(&settings));
let response = app
.oneshot(
Request::builder()
.method(Method::GET)
.uri("/ping")
.header("origin", "https://example.com")
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(
response.headers().get("access-control-allow-origin"),
Some(&HeaderValue::from_static("https://example.com")),
"trailing comma should be handled correctly"
);
}
#[tokio::test]
async fn test_cors_origins_only_commas_falls_back_to_wildcard() {
let settings = make_settings(",,,");
let app = cors_test_app(create_cors_layer(&settings));
let response = app
.oneshot(
Request::builder()
.method(Method::GET)
.uri("/ping")
.header("origin", "https://example.com")
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(
response.headers().get("access-control-allow-origin"),
Some(&HeaderValue::from_static("*")),
"origins with only commas should fall back to wildcard"
);
}
async fn build_test_state() -> anyhow::Result<CrawlRsState> {
let db_url = crate::common::test_helpers::resolve_test_database_url().ok_or_else(|| {
anyhow::anyhow!(
"No test database available: set TEST_DATABASE_URL or ensure Docker is running"
)
})?;
let settings = Arc::new(tcf::settings_with_urls(&db_url)?);
let mut kit = AsyncKit::new();
kit.set_config(settings);
kit.register::<SettingsModule>()
.map_err(|e| anyhow::anyhow!("register SettingsModule: {e}"))?;
kit.register::<DatabaseModule>()
.map_err(|e| anyhow::anyhow!("register DatabaseModule: {e}"))?;
kit.register::<HttpModule>()
.map_err(|e| anyhow::anyhow!("register HttpModule: {e}"))?;
kit.register::<CacheModule>()
.map_err(|e| anyhow::anyhow!("register CacheModule: {e}"))?;
kit.register::<RepositoryModule>()
.map_err(|e| anyhow::anyhow!("register RepositoryModule: {e}"))?;
kit.register::<EngineModule>()
.map_err(|e| anyhow::anyhow!("register EngineModule: {e}"))?;
kit.register::<InfrastructureModule>()
.map_err(|e| anyhow::anyhow!("register InfrastructureModule: {e}"))?;
kit.register::<ServiceModule>()
.map_err(|e| anyhow::anyhow!("register ServiceModule: {e}"))?;
kit.register::<IdModule>().map_err(|e| {
anyhow::anyhow!(
"{}: {e}",
crate::i18n::tr_log("boot-register-id-module-failed")
)
})?;
let kit = kit
.build()
.await
.map_err(|e| anyhow::anyhow!("Failed to build kit: {e}"))?;
let state = CrawlRsState::from_kit(&kit)?;
Ok(state)
}
fn skip_if_no_test_db() -> bool {
crate::common::test_helpers::skip_if_no_test_db()
}
fn load_test_settings() -> Settings {
crate::bootstrap::config::load_settings().expect("Failed to load settings")
}
#[tokio::test]
async fn test_create_public_routes_handles_health_check() {
if skip_if_no_test_db() {
return;
}
let _garrison_guard = crate::common::test_helpers::acquire_garrison_global_state().await;
let state = match build_test_state().await {
Ok(s) => s,
Err(e) => {
eprintln!("[skip] failed to build CrawlRsState: {e}");
return;
}
};
let router = create_public_routes(&state);
let response = router
.oneshot(
Request::builder()
.method(Method::GET)
.uri("/health")
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(
response.status(),
StatusCode::OK,
"public /health endpoint should return 200 OK"
);
}
#[tokio::test]
async fn test_create_protected_routes_constructs_without_panic() {
if skip_if_no_test_db() {
return;
}
let _garrison_guard = crate::common::test_helpers::acquire_garrison_global_state().await;
let state = match build_test_state().await {
Ok(s) => s,
Err(e) => {
eprintln!("[skip] failed to build CrawlRsState: {e}");
return;
}
};
let settings = Arc::new(load_test_settings());
let router = create_protected_routes_with_state(&state, settings);
drop(router);
}
#[tokio::test]
async fn test_create_v2_routes_constructs_without_panic() {
if skip_if_no_test_db() {
return;
}
let _garrison_guard = crate::common::test_helpers::acquire_garrison_global_state().await;
let state = match build_test_state().await {
Ok(s) => s,
Err(e) => {
eprintln!("[skip] failed to build CrawlRsState: {e}");
return;
}
};
let settings = Arc::new(load_test_settings());
let router = create_v2_routes_with_state(&state, settings);
drop(router);
}
#[tokio::test]
async fn test_build_api_app_serves_public_health() {
if skip_if_no_test_db() {
return;
}
let _garrison_guard = crate::common::test_helpers::acquire_garrison_global_state().await;
let state = match build_test_state().await {
Ok(s) => s,
Err(e) => {
eprintln!("[skip] failed to build CrawlRsState: {e}");
return;
}
};
let settings = Arc::new(load_test_settings());
let router = build_api_app_with_state(&state, settings);
let response = router
.oneshot(
Request::builder()
.method(Method::GET)
.uri("/health")
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(
response.status(),
StatusCode::OK,
"merged app router should serve /health from public routes"
);
}
#[tokio::test]
async fn test_build_api_app_applies_cors_layer() {
if skip_if_no_test_db() {
return;
}
let _garrison_guard = crate::common::test_helpers::acquire_garrison_global_state().await;
let state = match build_test_state().await {
Ok(s) => s,
Err(e) => {
eprintln!("[skip] failed to build CrawlRsState: {e}");
return;
}
};
let settings = Arc::new(load_test_settings());
let router = build_api_app_with_state(&state, settings);
let response = router
.oneshot(
Request::builder()
.method(Method::GET)
.uri("/health")
.header("origin", "https://example.com")
.body(Body::empty())
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(response.status(), StatusCode::OK);
assert!(
response
.headers()
.get("access-control-allow-origin")
.is_some(),
"merged app router should apply CORS layer"
);
}
#[cfg(feature = "auth")]
#[tokio::test]
async fn test_admin_api_keys_endpoint_registered_when_auth_on() {
if skip_if_no_test_db() {
return;
}
let _garrison_guard = crate::common::test_helpers::acquire_garrison_global_state().await;
let state = match build_test_state().await {
Ok(s) => s,
Err(e) => {
eprintln!("[skip] failed to build CrawlRsState: {e}");
return;
}
};
let settings = Arc::new(load_test_settings());
let router = create_protected_routes_with_state(&state, settings);
let response = router
.oneshot(
Request::builder()
.method(Method::POST)
.uri("/v1/admin/api-keys")
.header("content-type", "application/json")
.body(Body::from("{}"))
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_ne!(
response.status(),
StatusCode::NOT_FOUND,
"POST /v1/admin/api-keys must be registered when auth feature is on (got {})",
response.status()
);
}
#[cfg(not(feature = "auth"))]
#[tokio::test]
async fn test_admin_api_keys_endpoint_not_registered_when_auth_off() {
if skip_if_no_test_db() {
return;
}
let state = match build_test_state().await {
Ok(s) => s,
Err(e) => {
eprintln!("[skip] failed to build CrawlRsState: {e}");
return;
}
};
let settings = Arc::new(load_test_settings());
let router = create_protected_routes_with_state(&state, settings);
let response = router
.oneshot(
Request::builder()
.method(Method::POST)
.uri("/v1/admin/api-keys")
.header("content-type", "application/json")
.body(Body::from("{}"))
.expect("Failed to build request"),
)
.await
.expect("Failed to get response");
assert_eq!(
response.status(),
StatusCode::NOT_FOUND,
"POST /v1/admin/api-keys must NOT be registered when auth feature is off"
);
}
}