use super::config_loader::{detect_available_port, load_settings};
use crate::config::settings::Settings;
use crate::infrastructure::security::env_var_security::{EnvVarSecurityMonitor, EnvVarValidator};
use anyhow::Result;
#[cfg(feature = "auth")]
use confers::security::rules::JwtSecretValidator;
use confers::security::rules::{CorsValidator, SecurityValidatorRegistry, ViolationSeverity};
use confers::types::{AnnotatedValue, ConfigValue, SourceId};
use confers::ConfigProvider;
use log::{debug, error, info, warn};
use std::collections::HashMap;
struct SettingsSecurityProvider {
values: HashMap<String, AnnotatedValue>,
}
impl SettingsSecurityProvider {
fn new(settings: &Settings) -> Self {
let mut values = HashMap::new();
#[cfg(feature = "auth")]
values.insert(
"jwt.secret".to_string(),
AnnotatedValue::new(
ConfigValue::from(settings.auth.jwt_secret().to_string()),
SourceId::default(),
"jwt.secret",
),
);
values.insert(
"cors.allowed_origins".to_string(),
AnnotatedValue::new(
ConfigValue::from(settings.cors.allowed_origins.clone()),
SourceId::default(),
"cors.allowed_origins",
),
);
values.insert(
"cors.allowed_methods".to_string(),
AnnotatedValue::new(
ConfigValue::from("GET,POST,PUT,DELETE,PATCH,HEAD,OPTIONS".to_string()),
SourceId::default(),
"cors.allowed_methods",
),
);
Self { values }
}
}
impl ConfigProvider for SettingsSecurityProvider {
fn get_raw(&self, key: &str) -> Option<&AnnotatedValue> {
self.values.get(key)
}
fn keys(&self) -> Vec<String> {
self.values.keys().cloned().collect()
}
}
pub fn validate_security(settings: &Settings, is_production: bool) -> Result<()> {
debug!("Running security rule validators (confers security-rules)");
let provider = SettingsSecurityProvider::new(settings);
let mut registry = SecurityValidatorRegistry::new();
#[cfg(feature = "auth")]
registry.register(Box::new(JwtSecretValidator::new()));
registry.register(Box::new(CorsValidator::new()));
let report = registry.validate_all(&provider);
for violation in &report.violations {
match violation.severity {
ViolationSeverity::Critical => error!("Security violation: {}", violation),
ViolationSeverity::Warning => warn!("Security warning: {}", violation),
}
}
info!(
"Security rules validation complete: {} validator(s) passed, {} critical, {} warning(s)",
report.passed.len(),
report.critical_count(),
report.warning_count()
);
if report.is_ok(false) {
return Ok(());
}
let details = report
.violations
.iter()
.map(|v| v.to_string())
.collect::<Vec<_>>()
.join("; ");
let msg = format!("Configuration security validation failed: {}", details);
if is_production {
error!("CRITICAL: {}", msg);
return Err(anyhow::anyhow!("{}", msg));
}
warn!(
"Security violations present in non-production environment (not blocking): {}",
msg
);
Ok(())
}
pub fn validate_environment(is_production: bool) -> Result<()> {
info!("Starting environment variable security validation...");
let monitor = EnvVarSecurityMonitor::default();
let validator = EnvVarValidator::new(monitor.clone(), vec!["APP_ENVIRONMENT", "DATABASE_URL"]);
monitor.log_security_warnings();
check_required_variables(&validator, is_production)?;
let report = monitor.generate_security_report();
let (env, is_test, is_dev) = detect_runtime_environment();
warn_if_ssrf_protection_disabled(&env, is_dev);
check_forbidden_variables(&report.forbidden_variables, is_test)?;
check_security_score(report.security_score, is_production)?;
info!(
"Environment variable validation complete. Security score: {}/100",
report.security_score
);
Ok(())
}
fn check_required_variables(validator: &EnvVarValidator, is_production: bool) -> Result<()> {
if let Err(missing) = validator.validate_required() {
let error_msg = format!(
"Missing required environment variables: {}",
missing.join(", ")
);
if is_production {
error!("CRITICAL: {}", error_msg);
return Err(anyhow::anyhow!("{}", error_msg));
} else {
warn!(
"Missing required environment variables in non-production: {}",
missing.join(", ")
);
}
}
Ok(())
}
fn detect_runtime_environment() -> (String, bool, bool) {
let env = std::env::var("CRAWLRS_ENV")
.or_else(|_| std::env::var("APP_ENVIRONMENT"))
.unwrap_or_else(|_| "development".to_string());
let env_lower = env.to_lowercase();
let is_test =
env_lower == "test" || std::env::var("CRAWLRS__TEST_MODE").unwrap_or_default() == "true";
let is_dev = env_lower == "development" || env_lower == "dev" || is_test;
(env, is_test, is_dev)
}
fn warn_if_ssrf_protection_disabled(env: &str, is_dev: bool) {
if std::env::var(crate::common::constants::env_vars::DISABLE_SSRF_PROTECTION).is_ok() && !is_dev
{
warn!(
"SSRF protection disabled via CRAWLRS_DISABLE_SSRF_PROTECTION! \
This switch is for development/testing only; disabling it in production \
enables internal network probing. Current environment: {}. \
For production deployment, remove this env var and configure trusted_proxies.",
env
);
}
}
fn check_forbidden_variables(forbidden_variables: &[String], is_test: bool) -> Result<()> {
if !forbidden_variables.is_empty() && !is_test {
let error_msg = format!(
"Forbidden environment variables detected: {}",
forbidden_variables.join(", ")
);
error!("CRITICAL: {}", error_msg);
return Err(anyhow::anyhow!("{}", error_msg));
} else if !forbidden_variables.is_empty() && is_test {
warn!(
"Test mode: Skipping forbidden environment variable check: {}",
forbidden_variables.join(", ")
);
}
Ok(())
}
fn check_security_score(security_score: u8, is_production: bool) -> Result<()> {
if security_score < 70 {
let msg = format!(
"Security score {} is below acceptable level (70). Review warnings above.",
security_score
);
if is_production {
error!("CRITICAL: {}", msg);
return Err(anyhow::anyhow!("{}", msg));
} else {
warn!("{}", msg);
}
}
Ok(())
}
pub fn load_and_configure(is_production: bool) -> Result<(Settings, u16)> {
debug!("Starting application configuration...");
debug!("Step 1/4: Validating environment variables...");
validate_environment(is_production)?;
debug!("Step 2/4: Loading configuration settings...");
let mut settings = load_settings()?;
debug!("Step 3/4: Validating configuration security...");
validate_security(&settings, is_production)?;
debug!("Step 4/4: Detecting available port...");
let port = detect_available_port(&mut settings)?;
validate_webhook_secret_fail_fast(is_production, &settings.webhook.secret)?;
info!("Application configuration completed successfully");
Ok((settings, port))
}
#[cfg(feature = "webhook")]
fn validate_webhook_secret_fail_fast(is_production: bool, secret: &str) -> Result<()> {
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 env_lower = env.to_lowercase();
let is_test_env =
env_lower == "test" || std::env::var("CRAWLRS__TEST_MODE").unwrap_or_default() == "true";
if is_production && !is_test_env && secret.is_empty() {
error!(
"CRITICAL: webhook.secret must not be empty in production (webhook feature enabled)"
);
return Err(anyhow::anyhow!(
"webhook.secret must not be empty in production (webhook feature enabled)"
));
}
if is_production && !is_test_env && secret == "default-webhook-secret" {
error!(
"CRITICAL: webhook.secret must not be the removed hardcoded default \
'default-webhook-secret' in production"
);
return Err(anyhow::anyhow!(
"webhook.secret must not be the hardcoded default 'default-webhook-secret' \
in production"
));
}
Ok(())
}
#[cfg(not(feature = "webhook"))]
fn validate_webhook_secret_fail_fast(_is_production: bool, _secret: &str) -> Result<()> {
Ok(())
}
#[cfg(test)]
mod tests {
use super::super::config_loader::load_settings;
use super::*;
use crate::common::test_support::ENV_MUTEX;
#[test]
fn test_validate_security_returns_ok_for_non_production() {
let settings = load_settings().expect("Failed to load settings");
let result = validate_security(&settings, false);
assert!(result.is_ok());
}
#[test]
fn test_validate_security_returns_ok_for_production() {
let settings = load_settings().expect("Failed to load settings");
let mut settings = settings;
settings.auth.jwt_secret = "a-very-strong-jwt-secret-that-is-32-chars!!".to_string();
let result = validate_security(&settings, true);
assert!(
result.is_ok(),
"production with strong jwt secret should pass, got: {:?}",
result.err()
);
}
#[test]
#[cfg(feature = "auth")]
fn test_validate_security_empty_jwt_secret_blocks_production() {
let settings = load_settings().expect("Failed to load settings");
let mut settings = settings;
settings.auth.jwt_secret = String::new();
let result = validate_security(&settings, true);
assert!(
result.is_err(),
"production with empty jwt secret must fail security validation"
);
let err_msg = result.unwrap_err().to_string();
assert!(
err_msg.contains("JWT secret"),
"error should mention JWT secret, got: {}",
err_msg
);
}
#[test]
#[cfg(feature = "auth")]
fn test_validate_security_weak_jwt_secret_blocks_production() {
let settings = load_settings().expect("Failed to load settings");
let mut settings = settings;
settings.auth.jwt_secret = "changeme".to_string();
let result = validate_security(&settings, true);
assert!(
result.is_err(),
"production with weak jwt secret must fail security validation"
);
}
#[test]
#[cfg(feature = "auth")]
fn test_validate_security_weak_jwt_secret_warns_only_in_non_production() {
let settings = load_settings().expect("Failed to load settings");
let mut settings = settings;
settings.auth.jwt_secret = "changeme".to_string();
let result = validate_security(&settings, false);
assert!(
result.is_ok(),
"non-production with weak jwt secret should not block startup, got: {:?}",
result.err()
);
}
#[test]
fn test_validate_security_cors_wildcard_warns_but_does_not_block() {
let settings = load_settings().expect("Failed to load settings");
assert!(settings.cors.allowed_origins.contains('*'));
let mut settings = settings;
settings.auth.jwt_secret = "a-very-strong-jwt-secret-that-is-32-chars!!".to_string();
let result = validate_security(&settings, true);
assert!(
result.is_ok(),
"cors wildcard is a warning, must not block production startup, got: {:?}",
result.err()
);
}
#[test]
fn test_validate_security_does_not_modify_settings() {
let settings1 = load_settings().expect("Failed to load settings");
let settings2 = settings1.clone();
let _ = validate_security(&settings1, false);
assert_eq!(settings1.server.port, settings2.server.port);
assert_eq!(settings1.server.host, settings2.server.host);
}
#[test]
fn test_validate_security_preserves_cors_settings() {
let settings1 = load_settings().expect("Failed to load settings");
let settings2 = settings1.clone();
let _ = validate_security(&settings1, true);
assert_eq!(
settings1.cors.allowed_origins,
settings2.cors.allowed_origins
);
}
#[test]
fn test_validate_security_preserves_database_settings() {
let settings1 = load_settings().expect("Failed to load settings");
let settings2 = settings1.clone();
let _ = validate_security(&settings1, false);
assert_eq!(
settings1.database.max_connections,
settings2.database.max_connections
);
}
#[test]
fn test_validate_security_preserves_rate_limiting_settings() {
let settings1 = load_settings().expect("Failed to load settings");
let settings2 = settings1.clone();
let _ = validate_security(&settings1, true);
assert_eq!(
settings1.rate_limiting.enabled,
settings2.rate_limiting.enabled
);
assert_eq!(
settings1.rate_limiting.default_rpm,
settings2.rate_limiting.default_rpm
);
}
#[test]
fn test_settings_clone_is_equal() {
let settings1 = load_settings().expect("Failed to load settings");
let settings2 = settings1.clone();
assert_eq!(settings1.server.port, settings2.server.port);
assert_eq!(settings1.server.host, settings2.server.host);
assert_eq!(
settings1.cors.allowed_origins,
settings2.cors.allowed_origins
);
}
#[test]
fn test_validate_environment_non_production_returns_ok() {
let _guard = ENV_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
let saved_test_mode = std::env::var("CRAWLRS__TEST_MODE").ok();
std::env::set_var("CRAWLRS__TEST_MODE", "true");
let result = validate_environment(false);
if let Some(v) = saved_test_mode {
std::env::set_var("CRAWLRS__TEST_MODE", v);
} else {
std::env::remove_var("CRAWLRS__TEST_MODE");
}
assert!(result.is_ok());
}
#[test]
fn test_validate_environment_production_missing_required_returns_error() {
let _guard = ENV_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
let saved_app_env = std::env::var("APP_ENVIRONMENT").ok();
let saved_db_url = std::env::var("DATABASE_URL").ok();
let saved_test_mode = std::env::var("CRAWLRS__TEST_MODE").ok();
std::env::remove_var("APP_ENVIRONMENT");
std::env::remove_var("DATABASE_URL");
std::env::set_var("CRAWLRS__TEST_MODE", "true");
let result = validate_environment(true);
if let Some(v) = saved_app_env {
std::env::set_var("APP_ENVIRONMENT", v);
}
if let Some(v) = saved_db_url {
std::env::set_var("DATABASE_URL", v);
}
if let Some(v) = saved_test_mode {
std::env::set_var("CRAWLRS__TEST_MODE", v);
} else {
std::env::remove_var("CRAWLRS__TEST_MODE");
}
assert!(
result.is_err(),
"validate_environment in production mode should error when required env vars are missing"
);
let err_msg = result.unwrap_err().to_string();
assert!(
err_msg.contains("Missing required environment variables"),
"Error should mention missing required env vars, got: {}",
err_msg
);
}
#[test]
fn test_validate_environment_production_with_required_vars_succeeds() {
let _guard = ENV_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
let saved_app_env = std::env::var("APP_ENVIRONMENT").ok();
let saved_db_url = std::env::var("DATABASE_URL").ok();
let saved_test_mode = std::env::var("CRAWLRS__TEST_MODE").ok();
std::env::set_var("APP_ENVIRONMENT", "production");
std::env::set_var("DATABASE_URL", "postgresql://test:test@localhost/test");
std::env::set_var("CRAWLRS__TEST_MODE", "true");
let result = validate_environment(true);
if let Some(v) = saved_app_env {
std::env::set_var("APP_ENVIRONMENT", v);
} else {
std::env::remove_var("APP_ENVIRONMENT");
}
if let Some(v) = saved_db_url {
std::env::set_var("DATABASE_URL", v);
} else {
std::env::remove_var("DATABASE_URL");
}
if let Some(v) = saved_test_mode {
std::env::set_var("CRAWLRS__TEST_MODE", v);
} else {
std::env::remove_var("CRAWLRS__TEST_MODE");
}
assert!(
result.is_ok(),
"validate_environment in production mode should succeed when required vars are set and test mode skips forbidden check, got err: {:?}",
result.err()
);
}
#[test]
fn test_validate_environment_test_mode_skips_forbidden_check() {
let _guard = ENV_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
let saved_app_env = std::env::var("APP_ENVIRONMENT").ok();
let saved_db_url = std::env::var("DATABASE_URL").ok();
let saved_test_mode = std::env::var("CRAWLRS__TEST_MODE").ok();
let saved_crawlrs_env = std::env::var("CRAWLRS_ENV").ok();
std::env::set_var("APP_ENVIRONMENT", "test");
std::env::set_var("DATABASE_URL", "postgresql://test:test@localhost/test");
std::env::set_var("CRAWLRS__TEST_MODE", "true");
std::env::remove_var("CRAWLRS_ENV");
let result = validate_environment(false);
if let Some(v) = saved_app_env {
std::env::set_var("APP_ENVIRONMENT", v);
} else {
std::env::remove_var("APP_ENVIRONMENT");
}
if let Some(v) = saved_db_url {
std::env::set_var("DATABASE_URL", v);
} else {
std::env::remove_var("DATABASE_URL");
}
if let Some(v) = saved_test_mode {
std::env::set_var("CRAWLRS__TEST_MODE", v);
} else {
std::env::remove_var("CRAWLRS__TEST_MODE");
}
if let Some(v) = saved_crawlrs_env {
std::env::set_var("CRAWLRS_ENV", v);
}
assert!(
result.is_ok(),
"validate_environment in test mode should succeed, got err: {:?}",
result.err()
);
}
#[test]
fn test_validate_environment_crawlrs_env_test_mode() {
let _guard = ENV_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
let saved_crawlrs_env = std::env::var("CRAWLRS_ENV").ok();
let saved_app_env = std::env::var("APP_ENVIRONMENT").ok();
let saved_db_url = std::env::var("DATABASE_URL").ok();
let saved_test_mode = std::env::var("CRAWLRS__TEST_MODE").ok();
std::env::set_var("CRAWLRS_ENV", "test");
std::env::set_var("APP_ENVIRONMENT", "production");
std::env::set_var("DATABASE_URL", "postgresql://test:test@localhost/test");
std::env::remove_var("CRAWLRS__TEST_MODE");
let result = validate_environment(false);
if let Some(v) = saved_crawlrs_env {
std::env::set_var("CRAWLRS_ENV", v);
} else {
std::env::remove_var("CRAWLRS_ENV");
}
if let Some(v) = saved_app_env {
std::env::set_var("APP_ENVIRONMENT", v);
} else {
std::env::remove_var("APP_ENVIRONMENT");
}
if let Some(v) = saved_db_url {
std::env::set_var("DATABASE_URL", v);
} else {
std::env::remove_var("DATABASE_URL");
}
if let Some(v) = saved_test_mode {
std::env::set_var("CRAWLRS__TEST_MODE", v);
} else {
std::env::remove_var("CRAWLRS__TEST_MODE");
}
assert!(
result.is_ok(),
"validate_environment with CRAWLRS_ENV=test should succeed"
);
}
#[test]
fn test_validate_environment_non_production_with_required_vars_succeeds() {
let _guard = ENV_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
let saved_app_env = std::env::var("APP_ENVIRONMENT").ok();
let saved_db_url = std::env::var("DATABASE_URL").ok();
let saved_test_mode = std::env::var("CRAWLRS__TEST_MODE").ok();
std::env::set_var("APP_ENVIRONMENT", "development");
std::env::set_var("DATABASE_URL", "postgresql://test:test@localhost/test");
std::env::set_var("CRAWLRS__TEST_MODE", "true");
let result = validate_environment(false);
if let Some(v) = saved_app_env {
std::env::set_var("APP_ENVIRONMENT", v);
} else {
std::env::remove_var("APP_ENVIRONMENT");
}
if let Some(v) = saved_db_url {
std::env::set_var("DATABASE_URL", v);
} else {
std::env::remove_var("DATABASE_URL");
}
if let Some(v) = saved_test_mode {
std::env::set_var("CRAWLRS__TEST_MODE", v);
} else {
std::env::remove_var("CRAWLRS__TEST_MODE");
}
assert!(
result.is_ok(),
"validate_environment in non-production with required vars should succeed"
);
}
#[test]
fn test_validate_environment_forbidden_vars_in_non_test_mode_returns_error() {
let _guard = ENV_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
let saved_app_env = std::env::var("APP_ENVIRONMENT").ok();
let saved_db_url = std::env::var("DATABASE_URL").ok();
let saved_test_mode = std::env::var("CRAWLRS__TEST_MODE").ok();
let saved_crawlrs_env = std::env::var("CRAWLRS_ENV").ok();
let saved_ld_preload = std::env::var("LD_PRELOAD").ok();
std::env::set_var("LD_PRELOAD", "/tmp/fake_lib.so");
std::env::set_var("APP_ENVIRONMENT", "development");
std::env::set_var("DATABASE_URL", "postgresql://test:test@localhost/test");
std::env::remove_var("CRAWLRS__TEST_MODE");
std::env::remove_var("CRAWLRS_ENV");
let result = validate_environment(false);
if let Some(v) = saved_app_env {
std::env::set_var("APP_ENVIRONMENT", v);
} else {
std::env::remove_var("APP_ENVIRONMENT");
}
if let Some(v) = saved_db_url {
std::env::set_var("DATABASE_URL", v);
} else {
std::env::remove_var("DATABASE_URL");
}
if let Some(v) = saved_test_mode {
std::env::set_var("CRAWLRS__TEST_MODE", v);
} else {
std::env::remove_var("CRAWLRS__TEST_MODE");
}
if let Some(v) = saved_crawlrs_env {
std::env::set_var("CRAWLRS_ENV", v);
} else {
std::env::remove_var("CRAWLRS_ENV");
}
if let Some(v) = saved_ld_preload {
std::env::set_var("LD_PRELOAD", v);
} else {
std::env::remove_var("LD_PRELOAD");
}
assert!(
result.is_err(),
"validate_environment should return error when forbidden vars detected in non-test mode, got: {:?}",
result.ok()
);
let err_msg = result.unwrap_err().to_string();
assert!(
err_msg.contains("Forbidden"),
"Error should mention forbidden variables, got: {}",
err_msg
);
}
#[test]
fn test_validate_environment_forbidden_vars_in_test_mode_warns_only() {
let _guard = ENV_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
let saved_app_env = std::env::var("APP_ENVIRONMENT").ok();
let saved_db_url = std::env::var("DATABASE_URL").ok();
let saved_test_mode = std::env::var("CRAWLRS__TEST_MODE").ok();
let saved_crawlrs_env = std::env::var("CRAWLRS_ENV").ok();
let saved_ld_preload = std::env::var("LD_PRELOAD").ok();
std::env::set_var("LD_PRELOAD", "/tmp/fake_lib.so");
std::env::set_var("APP_ENVIRONMENT", "development");
std::env::set_var("DATABASE_URL", "postgresql://test:test@localhost/test");
std::env::set_var("CRAWLRS__TEST_MODE", "true");
std::env::remove_var("CRAWLRS_ENV");
let result = validate_environment(false);
if let Some(v) = saved_app_env {
std::env::set_var("APP_ENVIRONMENT", v);
} else {
std::env::remove_var("APP_ENVIRONMENT");
}
if let Some(v) = saved_db_url {
std::env::set_var("DATABASE_URL", v);
} else {
std::env::remove_var("DATABASE_URL");
}
if let Some(v) = saved_test_mode {
std::env::set_var("CRAWLRS__TEST_MODE", v);
} else {
std::env::remove_var("CRAWLRS__TEST_MODE");
}
if let Some(v) = saved_crawlrs_env {
std::env::set_var("CRAWLRS_ENV", v);
} else {
std::env::remove_var("CRAWLRS_ENV");
}
if let Some(v) = saved_ld_preload {
std::env::set_var("LD_PRELOAD", v);
} else {
std::env::remove_var("LD_PRELOAD");
}
assert!(
result.is_ok(),
"validate_environment in test mode should succeed even with forbidden vars (warn only), got err: {:?}",
result.err()
);
}
#[test]
fn test_validate_environment_crawlrs_env_test_mode_with_forbidden_vars() {
let _guard = ENV_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
let saved_app_env = std::env::var("APP_ENVIRONMENT").ok();
let saved_db_url = std::env::var("DATABASE_URL").ok();
let saved_test_mode = std::env::var("CRAWLRS__TEST_MODE").ok();
let saved_crawlrs_env = std::env::var("CRAWLRS_ENV").ok();
let saved_ld_preload = std::env::var("LD_PRELOAD").ok();
std::env::set_var("LD_PRELOAD", "/tmp/fake_lib.so");
std::env::set_var("CRAWLRS_ENV", "test");
std::env::set_var("APP_ENVIRONMENT", "development");
std::env::set_var("DATABASE_URL", "postgresql://test:test@localhost/test");
std::env::remove_var("CRAWLRS__TEST_MODE");
let result = validate_environment(false);
if let Some(v) = saved_app_env {
std::env::set_var("APP_ENVIRONMENT", v);
} else {
std::env::remove_var("APP_ENVIRONMENT");
}
if let Some(v) = saved_db_url {
std::env::set_var("DATABASE_URL", v);
} else {
std::env::remove_var("DATABASE_URL");
}
if let Some(v) = saved_test_mode {
std::env::set_var("CRAWLRS__TEST_MODE", v);
} else {
std::env::remove_var("CRAWLRS__TEST_MODE");
}
if let Some(v) = saved_crawlrs_env {
std::env::set_var("CRAWLRS_ENV", v);
} else {
std::env::remove_var("CRAWLRS_ENV");
}
if let Some(v) = saved_ld_preload {
std::env::set_var("LD_PRELOAD", v);
} else {
std::env::remove_var("LD_PRELOAD");
}
assert!(
result.is_ok(),
"validate_environment with CRAWLRS_ENV=test should succeed even with forbidden vars"
);
}
#[test]
fn test_validate_environment_warns_when_ssrf_disabled_in_non_dev_env() {
let _guard = ENV_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
let saved_app_env = std::env::var("APP_ENVIRONMENT").ok();
let saved_db_url = std::env::var("DATABASE_URL").ok();
let saved_test_mode = std::env::var("CRAWLRS__TEST_MODE").ok();
let saved_crawlrs_env = std::env::var("CRAWLRS_ENV").ok();
let saved_ssrf = std::env::var("CRAWLRS_DISABLE_SSRF_PROTECTION").ok();
std::env::set_var("APP_ENVIRONMENT", "production");
std::env::set_var("DATABASE_URL", "postgresql://test:test@localhost/test");
std::env::set_var("CRAWLRS__TEST_MODE", "true");
std::env::remove_var("CRAWLRS_ENV");
std::env::set_var("CRAWLRS_DISABLE_SSRF_PROTECTION", "true");
let result = validate_environment(false);
if let Some(v) = saved_app_env {
std::env::set_var("APP_ENVIRONMENT", v);
} else {
std::env::remove_var("APP_ENVIRONMENT");
}
if let Some(v) = saved_db_url {
std::env::set_var("DATABASE_URL", v);
} else {
std::env::remove_var("DATABASE_URL");
}
if let Some(v) = saved_test_mode {
std::env::set_var("CRAWLRS__TEST_MODE", v);
} else {
std::env::remove_var("CRAWLRS__TEST_MODE");
}
if let Some(v) = saved_crawlrs_env {
std::env::set_var("CRAWLRS_ENV", v);
} else {
std::env::remove_var("CRAWLRS_ENV");
}
if let Some(v) = saved_ssrf {
std::env::set_var("CRAWLRS_DISABLE_SSRF_PROTECTION", v);
} else {
std::env::remove_var("CRAWLRS_DISABLE_SSRF_PROTECTION");
}
assert!(
result.is_ok(),
"validate_environment should succeed with SSRF disabled (warn only), got err: {:?}",
result.err()
);
}
#[test]
fn test_validate_environment_no_warn_when_ssrf_disabled_in_dev_env() {
let _guard = ENV_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
let saved_app_env = std::env::var("APP_ENVIRONMENT").ok();
let saved_db_url = std::env::var("DATABASE_URL").ok();
let saved_test_mode = std::env::var("CRAWLRS__TEST_MODE").ok();
let saved_crawlrs_env = std::env::var("CRAWLRS_ENV").ok();
let saved_ssrf = std::env::var("CRAWLRS_DISABLE_SSRF_PROTECTION").ok();
std::env::set_var("APP_ENVIRONMENT", "development");
std::env::set_var("DATABASE_URL", "postgresql://test:test@localhost/test");
std::env::set_var("CRAWLRS__TEST_MODE", "true");
std::env::remove_var("CRAWLRS_ENV");
std::env::set_var("CRAWLRS_DISABLE_SSRF_PROTECTION", "true");
let result = validate_environment(false);
if let Some(v) = saved_app_env {
std::env::set_var("APP_ENVIRONMENT", v);
} else {
std::env::remove_var("APP_ENVIRONMENT");
}
if let Some(v) = saved_db_url {
std::env::set_var("DATABASE_URL", v);
} else {
std::env::remove_var("DATABASE_URL");
}
if let Some(v) = saved_test_mode {
std::env::set_var("CRAWLRS__TEST_MODE", v);
} else {
std::env::remove_var("CRAWLRS__TEST_MODE");
}
if let Some(v) = saved_crawlrs_env {
std::env::set_var("CRAWLRS_ENV", v);
} else {
std::env::remove_var("CRAWLRS_ENV");
}
if let Some(v) = saved_ssrf {
std::env::set_var("CRAWLRS_DISABLE_SSRF_PROTECTION", v);
} else {
std::env::remove_var("CRAWLRS_DISABLE_SSRF_PROTECTION");
}
assert!(result.is_ok());
}
#[test]
fn test_load_and_configure_non_production_succeeds() {
let _guard = ENV_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
let saved_test_mode = std::env::var("CRAWLRS__TEST_MODE").ok();
std::env::set_var("CRAWLRS__TEST_MODE", "true");
let result = load_and_configure(false);
if let Some(v) = saved_test_mode {
std::env::set_var("CRAWLRS__TEST_MODE", v);
} else {
std::env::remove_var("CRAWLRS__TEST_MODE");
}
assert!(
result.is_ok(),
"load_and_configure in non-production mode should succeed, got err: {:?}",
result.err()
);
let (settings, port) = result.expect("load_and_configure should succeed");
assert!(port > 0, "Detected port should be greater than 0");
assert_eq!(
settings.server.port, port,
"settings.server.port should match the detected port"
);
}
#[test]
fn test_load_and_configure_returns_valid_settings() {
let _guard = ENV_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
let saved_test_mode = std::env::var("CRAWLRS__TEST_MODE").ok();
std::env::set_var("CRAWLRS__TEST_MODE", "true");
let result = load_and_configure(false);
if let Some(v) = saved_test_mode {
std::env::set_var("CRAWLRS__TEST_MODE", v);
} else {
std::env::remove_var("CRAWLRS__TEST_MODE");
}
assert!(result.is_ok());
let (settings, _port) = result.unwrap();
assert_eq!(settings.server.host, "0.0.0.0");
}
#[test]
#[cfg(feature = "webhook")]
fn test_webhook_secret_empty_in_production_errors() {
let _guard = ENV_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
let saved_env = std::env::var("CRAWLRS_ENV").ok();
let saved_test_mode = std::env::var("CRAWLRS__TEST_MODE").ok();
std::env::set_var("CRAWLRS_ENV", "production");
std::env::remove_var("CRAWLRS__TEST_MODE");
let result = validate_webhook_secret_fail_fast(true, "");
match saved_env {
Some(v) => std::env::set_var("CRAWLRS_ENV", v),
None => std::env::remove_var("CRAWLRS_ENV"),
}
match saved_test_mode {
Some(v) => std::env::set_var("CRAWLRS__TEST_MODE", v),
None => std::env::remove_var("CRAWLRS__TEST_MODE"),
}
assert!(
result.is_err(),
"empty webhook secret in production must fail, got: {:?}",
result
);
}
#[test]
#[cfg(feature = "webhook")]
fn test_webhook_secret_empty_in_test_env_passes() {
let _guard = ENV_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
let saved_env = std::env::var("CRAWLRS_ENV").ok();
let saved_test_mode = std::env::var("CRAWLRS__TEST_MODE").ok();
std::env::set_var("CRAWLRS_ENV", "test");
std::env::remove_var("CRAWLRS__TEST_MODE");
let result = validate_webhook_secret_fail_fast(true, "");
match saved_env {
Some(v) => std::env::set_var("CRAWLRS_ENV", v),
None => std::env::remove_var("CRAWLRS_ENV"),
}
match saved_test_mode {
Some(v) => std::env::set_var("CRAWLRS__TEST_MODE", v),
None => std::env::remove_var("CRAWLRS__TEST_MODE"),
}
assert!(
result.is_ok(),
"empty webhook secret in test env should pass, got err: {:?}",
result.err()
);
}
#[test]
#[cfg(feature = "webhook")]
fn test_webhook_secret_non_empty_in_production_passes() {
let _guard = ENV_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
let saved_env = std::env::var("CRAWLRS_ENV").ok();
let saved_test_mode = std::env::var("CRAWLRS__TEST_MODE").ok();
std::env::set_var("CRAWLRS_ENV", "production");
std::env::remove_var("CRAWLRS__TEST_MODE");
let result = validate_webhook_secret_fail_fast(true, "non-empty-secret");
match saved_env {
Some(v) => std::env::set_var("CRAWLRS_ENV", v),
None => std::env::remove_var("CRAWLRS_ENV"),
}
match saved_test_mode {
Some(v) => std::env::set_var("CRAWLRS__TEST_MODE", v),
None => std::env::remove_var("CRAWLRS__TEST_MODE"),
}
assert!(
result.is_ok(),
"non-empty webhook secret in production should pass, got err: {:?}",
result.err()
);
}
#[test]
#[cfg(feature = "webhook")]
fn test_webhook_secret_hardcoded_default_in_production_errors() {
let _guard = ENV_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
let saved_env = std::env::var("CRAWLRS_ENV").ok();
let saved_test_mode = std::env::var("CRAWLRS__TEST_MODE").ok();
std::env::set_var("CRAWLRS_ENV", "production");
std::env::remove_var("CRAWLRS__TEST_MODE");
let result = validate_webhook_secret_fail_fast(true, "default-webhook-secret");
match saved_env {
Some(v) => std::env::set_var("CRAWLRS_ENV", v),
None => std::env::remove_var("CRAWLRS_ENV"),
}
match saved_test_mode {
Some(v) => std::env::set_var("CRAWLRS__TEST_MODE", v),
None => std::env::remove_var("CRAWLRS__TEST_MODE"),
}
assert!(
result.is_err(),
"hardcoded default webhook secret in production must fail, got: {:?}",
result
);
let err_msg = result.unwrap_err().to_string();
assert!(
err_msg.contains("hardcoded default"),
"error should mention hardcoded default, got: {}",
err_msg
);
}
}