foxhunt/config/tests/validation_edge_cases_tests.rs

//! Validation edge cases tests for config package
//!
//! This test suite covers edge cases in validation logic for:
//! - Invalid configuration values
//! - Schema validation errors
//! - Environment override edge cases
//! - Configuration reload scenarios

use config::{
    database::DatabaseConfig,
    runtime::{
        CacheRuntimeConfig, DatabaseRuntimeConfig, Environment, LimitsConfig, RuntimeConfig,
        TimeoutConfig,
    },
    schemas::{AssetClassificationSchema, S3Config},
    symbol_config::{AssetClassification, SymbolConfig},
    vault::VaultConfig,
};
use std::time::Duration;

// ============================================================================
// Test Helper Functions
// ============================================================================

fn create_test_symbol_config() -> SymbolConfig {
    SymbolConfig::new("TEST".to_string(), AssetClassification::Equity)
}

// ============================================================================
// Invalid Configuration Tests
// ============================================================================

#[test]
fn test_s3config_validate_empty_bucket_name_error() {
    let config = S3Config {
        bucket_name: String::new(),
        region: "us-east-1".to_string(),
        ..S3Config::default()
    };

    let result = config.validate();
    assert!(result.is_err());
    assert_eq!(result.unwrap_err(), "S3 bucket name cannot be empty");
}

#[test]
fn test_s3config_validate_empty_region_error() {
    let config = S3Config {
        bucket_name: "my-bucket".to_string(),
        region: String::new(),
        ..S3Config::default()
    };

    let result = config.validate();
    assert!(result.is_err());
    assert_eq!(result.unwrap_err(), "S3 region cannot be empty");
}

#[test]
fn test_s3config_validate_both_empty() {
    let config = S3Config {
        bucket_name: String::new(),
        region: String::new(),
        ..S3Config::default()
    };

    let result = config.validate();
    assert!(result.is_err());
    // Should fail on bucket name first
    assert!(result.unwrap_err().contains("bucket name"));
}

#[test]
fn test_s3config_whitespace_only_bucket() {
    let config = S3Config {
        bucket_name: "   ".to_string(),
        region: "us-east-1".to_string(),
        ..S3Config::default()
    };

    // Should still pass validation (only checks empty, not whitespace)
    assert!(config.validate().is_ok());
}

#[test]
fn test_s3config_negative_timeout() {
    let config = S3Config {
        timeout: Duration::from_secs(0),
        ..S3Config::default()
    };

    // Zero timeout is technically valid
    assert!(config.validate().is_ok());
}

#[test]
fn test_s3config_zero_max_retry_attempts() {
    let config = S3Config {
        max_retry_attempts: 0,
        ..S3Config::default()
    };

    // Zero retries is valid (no retries)
    assert!(config.validate().is_ok());
}

#[test]
fn test_s3config_very_large_retry_attempts() {
    let config = S3Config {
        max_retry_attempts: u32::MAX,
        ..S3Config::default()
    };

    assert!(config.validate().is_ok());
}

#[test]
fn test_database_config_validate_empty_url() {
    let config = DatabaseConfig {
        url: String::new(),
        ..DatabaseConfig::default()
    };

    let result = config.validate();
    assert!(result.is_err());
    assert_eq!(result.unwrap_err(), "Database URL cannot be empty");
}

#[test]
fn test_database_config_validate_whitespace_url() {
    let config = DatabaseConfig {
        url: "   ".to_string(),
        ..DatabaseConfig::default()
    };

    // Whitespace-only URL passes validation (only checks empty)
    assert!(config.validate().is_ok());
}

#[test]
fn test_database_config_zero_max_connections() {
    let config = DatabaseConfig {
        max_connections: 0,
        ..DatabaseConfig::default()
    };

    // Zero connections is technically valid in struct
    assert!(config.validate().is_ok());
}

#[test]
fn test_database_config_min_greater_than_max() {
    let config = DatabaseConfig {
        min_connections: 100,
        max_connections: 10,
        ..DatabaseConfig::default()
    };

    // This logical error isn't caught by current validation
    assert!(config.validate().is_ok());
}

#[test]
fn test_vault_config_validate_empty_url() {
    let config = VaultConfig::new(
        String::new(),
        "test-token".to_string(),
        "secret".to_string(),
    );

    let result = config.validate();
    assert!(result.is_err());
    assert_eq!(result.unwrap_err(), "Vault URL cannot be empty");
}

#[test]
fn test_vault_config_validate_empty_token() {
    let config = VaultConfig::new(
        "http://localhost:8200".to_string(),
        String::new(),
        "secret".to_string(),
    );

    let result = config.validate();
    assert!(result.is_err());
    assert_eq!(result.unwrap_err(), "Vault token cannot be empty");
}

#[test]
fn test_vault_config_validate_empty_mount_path() {
    let config = VaultConfig::new(
        "http://localhost:8200".to_string(),
        "test-token".to_string(),
        String::new(),
    );

    let result = config.validate();
    assert!(result.is_err());
    assert_eq!(result.unwrap_err(), "Vault mount path cannot be empty");
}

#[test]
fn test_vault_config_validate_all_empty() {
    let config = VaultConfig::new(String::new(), String::new(), String::new());

    let result = config.validate();
    assert!(result.is_err());
    // Should fail on URL first
    assert!(result.unwrap_err().contains("URL"));
}

#[test]
fn test_symbol_config_validate_empty_symbol() {
    let mut config = create_test_symbol_config();
    config.symbol = String::new();

    let result = config.validate();
    assert!(result.is_err());
    assert_eq!(result.unwrap_err(), "Symbol cannot be empty");
}

#[test]
fn test_symbol_config_validate_zero_tick_size() {
    let mut config = create_test_symbol_config();
    config.symbol = "BTCUSD".to_string();
    config.tick_size = 0.0;

    let result = config.validate();
    assert!(result.is_err());
    assert!(result.unwrap_err().contains("Tick size must be positive"));
}

#[test]
fn test_symbol_config_validate_negative_tick_size() {
    let mut config = create_test_symbol_config();
    config.symbol = "BTCUSD".to_string();
    config.tick_size = -0.01;

    let result = config.validate();
    assert!(result.is_err());
    assert!(result.unwrap_err().contains("Tick size must be positive"));
}

#[test]
fn test_symbol_config_validate_zero_lot_size() {
    let mut config = create_test_symbol_config();
    config.symbol = "BTCUSD".to_string();
    config.lot_size = 0.0;

    let result = config.validate();
    assert!(result.is_err());
    assert!(result.unwrap_err().contains("Lot size must be positive"));
}

#[test]
fn test_symbol_config_validate_negative_lot_size() {
    let mut config = create_test_symbol_config();
    config.symbol = "BTCUSD".to_string();
    config.lot_size = -1.0;

    let result = config.validate();
    assert!(result.is_err());
    assert!(result.unwrap_err().contains("Lot size must be positive"));
}

#[test]
fn test_symbol_config_validate_multiple_errors() {
    let mut config = create_test_symbol_config();
    config.symbol = String::new();
    config.tick_size = -0.01;
    config.lot_size = -1.0;

    let result = config.validate();
    assert!(result.is_err());
    // Should fail on first error (empty symbol)
    assert!(result.unwrap_err().contains("Symbol cannot be empty"));
}

// ============================================================================
// Runtime Config Validation Tests
// ============================================================================

#[test]
fn test_database_runtime_config_zero_query_timeout() {
    let config = DatabaseRuntimeConfig {
        query_timeout: Duration::from_millis(0),
        ..DatabaseRuntimeConfig::with_defaults(Environment::Development)
    };

    let result = config.validate();
    assert!(result.is_err());
    assert!(result
        .unwrap_err()
        .to_string()
        .contains("Query timeout must be positive"));
}

#[test]
fn test_database_runtime_config_zero_pool_size() {
    let config = DatabaseRuntimeConfig {
        pool_size: 0,
        ..DatabaseRuntimeConfig::with_defaults(Environment::Development)
    };

    let result = config.validate();
    assert!(result.is_err());
    assert!(result
        .unwrap_err()
        .to_string()
        .contains("Pool size must be positive"));
}

#[test]
fn test_database_runtime_config_pool_exceeds_max() {
    let config = DatabaseRuntimeConfig {
        pool_size: 100,
        max_pool_size: 50,
        ..DatabaseRuntimeConfig::with_defaults(Environment::Development)
    };

    let result = config.validate();
    assert!(result.is_err());
    assert!(result
        .unwrap_err()
        .to_string()
        .contains("Pool size cannot exceed max pool size"));
}

#[test]
fn test_database_runtime_config_pool_equals_max() {
    let config = DatabaseRuntimeConfig {
        pool_size: 50,
        max_pool_size: 50,
        ..DatabaseRuntimeConfig::with_defaults(Environment::Development)
    };

    // Equal values should be valid
    assert!(config.validate().is_ok());
}

#[test]
fn test_cache_runtime_config_zero_ttl() {
    let config = CacheRuntimeConfig {
        position_ttl: Duration::from_secs(0),
        ..CacheRuntimeConfig::with_defaults(Environment::Development)
    };

    let result = config.validate();
    assert!(result.is_err());
    assert!(result
        .unwrap_err()
        .to_string()
        .contains("Position TTL must be positive"));
}

#[test]
fn test_cache_runtime_config_zero_var_ttl() {
    let config = CacheRuntimeConfig {
        var_ttl: Duration::from_secs(0),
        ..CacheRuntimeConfig::with_defaults(Environment::Development)
    };

    let result = config.validate();
    assert!(result.is_err());
    assert!(result
        .unwrap_err()
        .to_string()
        .contains("VaR TTL must be positive"));
}

#[test]
fn test_timeout_config_zero_grpc_timeout() {
    let config = TimeoutConfig {
        grpc_connect_timeout: Duration::from_secs(0),
        ..TimeoutConfig::with_defaults(Environment::Development)
    };

    let result = config.validate();
    assert!(result.is_err());
    assert!(result
        .unwrap_err()
        .to_string()
        .contains("gRPC connect timeout must be positive"));
}

#[test]
fn test_timeout_config_zero_max_connections() {
    let config = TimeoutConfig {
        max_concurrent_connections: 0,
        ..TimeoutConfig::with_defaults(Environment::Development)
    };

    let result = config.validate();
    assert!(result.is_err());
    assert!(result
        .unwrap_err()
        .to_string()
        .contains("Max concurrent connections must be positive"));
}

#[test]
fn test_limits_config_zero_retry_attempts() {
    let config = LimitsConfig {
        retry_max_attempts: 0,
        ..LimitsConfig::with_defaults(Environment::Development)
    };

    let result = config.validate();
    assert!(result.is_err());
    assert!(result
        .unwrap_err()
        .to_string()
        .contains("Retry max attempts must be positive"));
}

#[test]
fn test_limits_config_invalid_backoff_multiplier() {
    let config = LimitsConfig {
        retry_backoff_multiplier: 1.0,
        ..LimitsConfig::with_defaults(Environment::Development)
    };

    let result = config.validate();
    assert!(result.is_err());
    assert!(result
        .unwrap_err()
        .to_string()
        .contains("Backoff multiplier must be > 1.0"));
}

#[test]
fn test_limits_config_backoff_multiplier_less_than_one() {
    let config = LimitsConfig {
        retry_backoff_multiplier: 0.5,
        ..LimitsConfig::with_defaults(Environment::Development)
    };

    let result = config.validate();
    assert!(result.is_err());
    assert!(result
        .unwrap_err()
        .to_string()
        .contains("Backoff multiplier must be > 1.0"));
}

#[test]
fn test_limits_config_zero_ml_batch_size() {
    let config = LimitsConfig {
        ml_max_batch_size: 0,
        ..LimitsConfig::with_defaults(Environment::Development)
    };

    let result = config.validate();
    assert!(result.is_err());
    assert!(result
        .unwrap_err()
        .to_string()
        .contains("ML max batch size must be positive"));
}

#[test]
fn test_limits_config_var_confidence_negative() {
    let config = LimitsConfig {
        risk_var_confidence: -0.1,
        ..LimitsConfig::with_defaults(Environment::Development)
    };

    let result = config.validate();
    assert!(result.is_err());
    assert!(result
        .unwrap_err()
        .to_string()
        .contains("VaR confidence must be between 0.0 and 1.0"));
}

#[test]
fn test_limits_config_var_confidence_greater_than_one() {
    let config = LimitsConfig {
        risk_var_confidence: 1.5,
        ..LimitsConfig::with_defaults(Environment::Development)
    };

    let result = config.validate();
    assert!(result.is_err());
    assert!(result
        .unwrap_err()
        .to_string()
        .contains("VaR confidence must be between 0.0 and 1.0"));
}

#[test]
fn test_limits_config_var_confidence_zero() {
    let config = LimitsConfig {
        risk_var_confidence: 0.0,
        ..LimitsConfig::with_defaults(Environment::Development)
    };

    // 0.0 is actually valid based on the validation logic (>= 0.0 && <= 1.0)
    assert!(config.validate().is_ok());
}

#[test]
fn test_limits_config_var_confidence_one() {
    let config = LimitsConfig {
        risk_var_confidence: 1.0,
        ..LimitsConfig::with_defaults(Environment::Development)
    };

    // 1.0 is actually valid based on the validation logic (>= 0.0 && <= 1.0)
    assert!(config.validate().is_ok());
}

#[test]
fn test_limits_config_var_confidence_edge_valid() {
    let config = LimitsConfig {
        risk_var_confidence: 0.99,
        ..LimitsConfig::with_defaults(Environment::Development)
    };

    assert!(config.validate().is_ok());
}

#[test]
fn test_runtime_config_validates_all_subconfigs() {
    let mut config = RuntimeConfig::with_defaults(Environment::Development);

    // Break database config
    config.database.pool_size = 0;

    let result = config.validate();
    assert!(result.is_err());
    assert!(result
        .unwrap_err()
        .to_string()
        .contains("Pool size must be positive"));
}

// ============================================================================
// Schema Validation Tests
// ============================================================================

#[test]
fn test_asset_classification_empty_patterns() {
    let schema = AssetClassificationSchema {
        asset_type_rules: Default::default(),
        default_sectors: Default::default(),
        currency_patterns: Vec::new(),
        crypto_patterns: Vec::new(),
    };

    // With no patterns, should fall back to default
    let result = schema.classify_sector("BTCUSD", None);
    assert_eq!(result, "Other");
}

#[test]
fn test_asset_classification_invalid_regex_pattern() {
    let schema = AssetClassificationSchema {
        asset_type_rules: Default::default(),
        default_sectors: Default::default(),
        currency_patterns: vec!["[invalid".to_string()], // Invalid regex
        crypto_patterns: Vec::new(),
    };

    // Should not panic, should fallback to default
    let result = schema.classify_sector("USDUSD", None);
    assert_eq!(result, "Other");
}

#[test]
fn test_asset_classification_empty_instrument_id() {
    let schema = AssetClassificationSchema::new();
    let result = schema.classify_sector("", None);
    assert_eq!(result, "Other");
}

#[test]
fn test_asset_classification_unknown_asset_type() {
    let schema = AssetClassificationSchema::new();
    let result = schema.classify_sector("UNKNOWN", Some("UNKNOWN_TYPE"));
    assert_eq!(result, "Other");
}

#[test]
fn test_asset_classification_null_asset_type() {
    let schema = AssetClassificationSchema::new();
    let result = schema.classify_sector("BTCUSD", None);
    // BTCUSD matches "USD" currency pattern first before checking crypto patterns
    assert_eq!(result, "Currencies");
}

// ============================================================================
// Environment Override Tests
// ============================================================================

// Note: Environment detection tests are skipped because they modify global
// environment state which can interfere with other tests. The detect() logic
// is straightforward and tested in the runtime module's tests.

#[test]
#[ignore = "Skipped due to env var interference"]
fn test_environment_detect_production_variants() {
    // These tests would need serial_test to run safely
    // For now, we test the enum methods instead
}

#[test]
#[ignore = "Skipped due to env var interference"]
fn test_environment_detect_staging_variants() {
    // These tests would need serial_test to run safely
}

#[test]
#[ignore = "Skipped due to env var interference"]
fn test_environment_detect_development_default() {
    // These tests would need serial_test to run safely
}

#[test]
#[ignore = "Skipped due to env var interference"]
fn test_environment_detect_empty_string() {
    // These tests would need serial_test to run safely
}

#[test]
fn test_environment_is_production() {
    assert!(Environment::Production.is_production());
    assert!(!Environment::Staging.is_production());
    assert!(!Environment::Development.is_production());
}

#[test]
fn test_environment_is_development() {
    assert!(Environment::Development.is_development());
    assert!(!Environment::Staging.is_development());
    assert!(!Environment::Production.is_development());
}

// ============================================================================
// Configuration Value Edge Cases
// ============================================================================

#[test]
fn test_s3config_extremely_long_bucket_name() {
    let long_name = "a".repeat(1000);
    let config = S3Config {
        bucket_name: long_name,
        ..S3Config::default()
    };

    // Should pass validation (no length limit enforced)
    assert!(config.validate().is_ok());
}

#[test]
fn test_s3config_special_characters_bucket_name() {
    let config = S3Config {
        bucket_name: "my-bucket_123.test".to_string(),
        ..S3Config::default()
    };

    assert!(config.validate().is_ok());
}

#[test]
fn test_s3config_unicode_bucket_name() {
    let config = S3Config {
        bucket_name: "测试-bucket".to_string(),
        ..S3Config::default()
    };

    // Should pass (validation doesn't check character set)
    assert!(config.validate().is_ok());
}

#[test]
fn test_database_config_max_connections_u32_max() {
    let config = DatabaseConfig {
        max_connections: u32::MAX,
        ..DatabaseConfig::default()
    };

    assert!(config.validate().is_ok());
}

#[test]
fn test_database_config_very_long_url() {
    let long_url = format!("postgresql://user:pass@{}/db", "a".repeat(1000));
    let config = DatabaseConfig {
        url: long_url,
        ..DatabaseConfig::default()
    };

    assert!(config.validate().is_ok());
}

#[test]
fn test_symbol_config_very_small_tick_size() {
    let mut config = create_test_symbol_config();
    config.symbol = "BTCUSD".to_string();
    config.tick_size = f64::MIN_POSITIVE;

    assert!(config.validate().is_ok());
}

#[test]
fn test_symbol_config_very_large_tick_size() {
    let mut config = create_test_symbol_config();
    config.symbol = "BTCUSD".to_string();
    config.tick_size = f64::MAX;

    assert!(config.validate().is_ok());
}

#[test]
fn test_runtime_config_development_defaults() {
    let config = RuntimeConfig::with_defaults(Environment::Development);
    assert!(config.validate().is_ok());
}

#[test]
fn test_runtime_config_staging_defaults() {
    let config = RuntimeConfig::with_defaults(Environment::Staging);
    assert!(config.validate().is_ok());
}

#[test]
fn test_runtime_config_production_defaults() {
    let config = RuntimeConfig::with_defaults(Environment::Production);
    assert!(config.validate().is_ok());
}

#[test]
fn test_runtime_config_serialization_roundtrip() {
    let config = RuntimeConfig::with_defaults(Environment::Development);
    let json = serde_json::to_string(&config).unwrap();
    let deserialized: RuntimeConfig = serde_json::from_str(&json).unwrap();

    assert!(deserialized.validate().is_ok());
}