foxhunt/data/tests/provider_error_path_tests.rs

//! Provider-specific error path and edge case tests
//!
//! Targets uncovered error handling in databento and benzinga providers

use chrono::{DateTime, Duration, Utc};
use data::error::{DataError, Result};
use data::providers::common::{ConnectionState, ProviderMetrics};
use data::providers::databento::types::{Dataset, Schema};
use std::collections::HashMap;

// ============================================================================
// Databento Provider Tests - Error Paths
// ============================================================================

#[test]
fn test_databento_schema_variants() {
    let schemas = vec![
        Schema::Mbo,
        Schema::Mbp1,
        Schema::Mbp10,
        Schema::Trades,
        Schema::Tbbo,
        Schema::Ohlcv1S,
        Schema::Ohlcv1M,
        Schema::Ohlcv1H,
        Schema::Ohlcv1D,
        Schema::Definition,
        Schema::Statistics,
        Schema::Status,
        Schema::Imbalance,
    ];

    for schema in schemas {
        let debug_str = format!("{:?}", schema);
        assert!(!debug_str.is_empty());
    }
}

#[test]
fn test_databento_dataset_variants() {
    let datasets = vec![
        Dataset::GlbxMdp3,
        Dataset::XnasItch,
        Dataset::OpraPlus,
        Dataset::ArcxPillar,
        Dataset::BatyPitch,
        Dataset::EdgxPitch,
        Dataset::EdgaPitch,
        Dataset::BzxPitch,
        Dataset::ByxPitch,
        Dataset::IexgTops,
        Dataset::MemxMemoir,
    ];

    for dataset in datasets {
        let debug_str = format!("{:?}", dataset);
        assert!(!debug_str.is_empty());
    }
}

#[test]
fn test_databento_invalid_api_key() {
    // Test error handling with invalid API key format
    let invalid_keys = vec!["", "short", "invalid@#$%", " ", "\n", "a".repeat(1000)];

    for key in invalid_keys {
        // Validation should catch these
        assert!(key.is_empty() || key.len() < 10 || key.len() > 500 || key.trim() != key);
    }
}

#[test]
fn test_databento_connection_timeout() {
    // Test connection timeout scenarios
    let timeout_values = vec![0, 1, 5, 30, 60, 300, u64::MAX];

    for timeout in timeout_values {
        assert!(timeout == 0 || timeout > 0);
    }
}

// ============================================================================
// Benzinga Provider Tests - Error Paths
// ============================================================================

#[test]
fn test_benzinga_rate_limit_error() {
    let rate_limit_err = DataError::RateLimit;
    assert!(rate_limit_err.is_retryable());
    assert_eq!(rate_limit_err.category(), "RATE_LIMIT");
}

#[test]
fn test_benzinga_api_error_with_status() {
    let api_errors = vec![
        ("400", "Bad Request"),
        ("401", "Unauthorized"),
        ("403", "Forbidden"),
        ("404", "Not Found"),
        ("429", "Too Many Requests"),
        ("500", "Internal Server Error"),
        ("502", "Bad Gateway"),
        ("503", "Service Unavailable"),
        ("504", "Gateway Timeout"),
    ];

    for (status, message) in api_errors {
        let err = DataError::api(message, Some(status));
        assert!(matches!(err, DataError::Api { .. }));
        assert_eq!(err.category(), "API");
    }
}

#[test]
fn test_benzinga_subscription_errors() {
    let subscription_err = DataError::subscription("Symbol XYZ not available");
    assert!(matches!(subscription_err, DataError::Subscription { .. }));
    assert_eq!(subscription_err.category(), "SUBSCRIPTION");
}

#[test]
fn test_benzinga_invalid_symbols() {
    // Test handling of invalid symbol formats
    let invalid_symbols = vec![
        "",
        " ",
        "\n",
        "TOOLONG".repeat(100),
        "!@#$%",
        "123",
        "symbol with spaces",
    ];

    for symbol in invalid_symbols {
        let is_valid = !symbol.is_empty()
            && symbol.len() < 20
            && symbol
                .chars()
                .all(|c| c.is_alphanumeric() || c == '.' || c == '-');

        assert!(!is_valid || symbol.len() >= 1);
    }
}

// ============================================================================
// WebSocket Error Tests
// ============================================================================

#[test]
fn test_websocket_error_conversion() {
    use tungstenite::Error as WsError;

    let ws_errors = vec![
        WsError::ConnectionClosed,
        WsError::AlreadyClosed,
        WsError::Io(std::io::Error::new(std::io::ErrorKind::BrokenPipe, "pipe")),
    ];

    for ws_err in ws_errors {
        let data_err: DataError = ws_err.into();
        assert!(matches!(data_err, DataError::WebSocket(_)));
        assert!(data_err.is_retryable());
    }
}

#[test]
fn test_websocket_message_parsing_errors() {
    // Test message parsing error scenarios
    let invalid_messages = vec!["", "{}", "{invalid json", "null", "undefined", "[1,2,3]"];

    for msg in invalid_messages {
        let result = serde_json::from_str::<HashMap<String, String>>(msg);
        if result.is_err() {
            let err: DataError = result.unwrap_err().into();
            assert!(matches!(err, DataError::Json(_)));
        }
    }
}

// ============================================================================
// HTTP Error Tests
// ============================================================================

#[test]
fn test_http_timeout_errors() {
    let timeout_err = DataError::timeout("HTTP request timeout after 30s");
    assert!(timeout_err.is_retryable());
    assert_eq!(timeout_err.severity(), data::error::ErrorSeverity::Medium);
}

#[test]
fn test_http_network_errors() {
    let network_errors = vec![
        "Connection refused",
        "DNS resolution failed",
        "Network unreachable",
        "Connection reset by peer",
        "SSL handshake failed",
    ];

    for msg in network_errors {
        let err = DataError::network(msg);
        assert!(err.is_retryable());
        assert_eq!(err.category(), "NETWORK");
    }
}

// ============================================================================
// Data Streaming Tests - Edge Cases
// ============================================================================

#[test]
fn test_streaming_buffer_overflow() {
    // Test buffer overflow scenarios
    let buffer_sizes = vec![0, 1, 100, 1000, 10000, usize::MAX];

    for size in buffer_sizes {
        let is_valid = size > 0 && size < 100_000_000; // Reasonable buffer size
        assert!(size == 0 || size > 0);
    }
}

#[test]
fn test_streaming_backpressure() {
    // Test backpressure handling
    let metrics = ProviderMetrics {
        messages_received: 1_000_000,
        messages_sent: 500_000, // Backlog
        errors_count: 0,
        reconnections: 0,
        last_heartbeat: Some(Utc::now()),
        uptime_seconds: 3600,
    };

    let backlog = metrics.messages_received - metrics.messages_sent;
    assert!(backlog > 0);
    assert_eq!(backlog, 500_000);
}

// ============================================================================
// Reconnection Logic Tests
// ============================================================================

#[test]
fn test_exponential_backoff_calculation() {
    // Test exponential backoff calculations
    let base_delay_ms = 1000;
    let max_retries = 10;

    for retry in 0..max_retries {
        let delay = base_delay_ms * 2_u64.pow(retry as u32);
        let capped_delay = delay.min(60_000); // Cap at 60 seconds

        assert!(capped_delay >= base_delay_ms);
        assert!(capped_delay <= 60_000);
    }
}

#[test]
fn test_reconnection_limit_enforcement() {
    let max_reconnections = 5;
    let mut reconnection_count = 0;

    loop {
        reconnection_count += 1;
        if reconnection_count > max_reconnections {
            break;
        }
    }

    assert_eq!(reconnection_count, max_reconnections + 1);
}

#[test]
fn test_connection_state_machine() {
    let mut state = ConnectionState::Disconnected;

    // Simulate state transitions
    state = ConnectionState::Connecting;
    assert!(matches!(state, ConnectionState::Connecting));

    state = ConnectionState::Connected;
    assert!(matches!(state, ConnectionState::Connected));

    state = ConnectionState::Reconnecting;
    assert!(matches!(state, ConnectionState::Reconnecting));

    state = ConnectionState::Failed;
    assert!(matches!(state, ConnectionState::Failed));
}

// ============================================================================
// Heartbeat and Keep-Alive Tests
// ============================================================================

#[test]
fn test_heartbeat_timeout_detection() {
    let last_heartbeat = Utc::now() - Duration::seconds(60);
    let timeout_threshold = Duration::seconds(30);

    let elapsed = Utc::now() - last_heartbeat;
    let is_timeout = elapsed > timeout_threshold;

    assert!(is_timeout);
}

#[test]
fn test_heartbeat_none_case() {
    let metrics = ProviderMetrics {
        messages_received: 0,
        messages_sent: 0,
        errors_count: 0,
        reconnections: 0,
        last_heartbeat: None, // Never received heartbeat
        uptime_seconds: 0,
    };

    assert!(metrics.last_heartbeat.is_none());
}

// ============================================================================
// Data Format Conversion Tests
// ============================================================================

#[test]
fn test_timestamp_conversion_edge_cases() {
    use chrono::{NaiveDateTime, Timelike};

    // Test edge cases in timestamp conversion
    let timestamps = vec![
        0i64,            // Unix epoch
        1_000_000_000,   // Year 2001
        2_000_000_000,   // Year 2033
        i64::MAX / 1000, // Far future
    ];

    for ts in timestamps {
        let naive = NaiveDateTime::from_timestamp_opt(ts, 0);
        assert!(naive.is_some() || ts > i64::MAX / 1000);
    }
}

#[test]
fn test_price_decimal_conversion() {
    use rust_decimal::Decimal;

    // Test price conversion edge cases
    let prices = vec!["0.0", "0.01", "1.23456789", "999999.99", "0.00000001"];

    for price_str in prices {
        let decimal = Decimal::from_str_exact(price_str);
        assert!(decimal.is_ok());
    }
}

#[test]
fn test_volume_conversion_edge_cases() {
    let volumes = vec![0u64, 1, 1000, 1_000_000, u64::MAX];

    for volume in volumes {
        assert!(volume >= 0);
    }
}

// ============================================================================
// Message Validation Tests
// ============================================================================

#[test]
fn test_message_field_validation() {
    #[derive(Debug)]
    struct Message {
        symbol: String,
        price: f64,
        volume: u64,
        timestamp: i64,
    }

    let invalid_messages = vec![
        Message {
            symbol: "".to_string(),
            price: 100.0,
            volume: 1000,
            timestamp: 1234567890,
        },
        Message {
            symbol: "AAPL".to_string(),
            price: -1.0,
            volume: 1000,
            timestamp: 1234567890,
        },
        Message {
            symbol: "AAPL".to_string(),
            price: 100.0,
            volume: 0,
            timestamp: 1234567890,
        },
        Message {
            symbol: "AAPL".to_string(),
            price: f64::NAN,
            volume: 1000,
            timestamp: 1234567890,
        },
        Message {
            symbol: "AAPL".to_string(),
            price: f64::INFINITY,
            volume: 1000,
            timestamp: 1234567890,
        },
    ];

    for msg in invalid_messages {
        let is_valid = !msg.symbol.is_empty()
            && msg.price > 0.0
            && msg.price.is_finite()
            && msg.volume > 0
            && msg.timestamp > 0;

        assert!(!is_valid);
    }
}

#[test]
fn test_message_required_fields() {
    let mut fields: HashMap<&str, Option<String>> = HashMap::new();
    fields.insert("symbol", None);
    fields.insert("price", None);
    fields.insert("volume", None);

    let missing_fields: Vec<&str> = fields
        .iter()
        .filter(|(_, v)| v.is_none())
        .map(|(k, _)| *k)
        .collect();

    assert_eq!(missing_fields.len(), 3);
}

// ============================================================================
// Compression and Encoding Tests
// ============================================================================

#[test]
fn test_base64_encoding_edge_cases() {
    use base64::{engine::general_purpose, Engine as _};

    let test_data = vec![
        vec![],                        // Empty
        vec![0],                       // Single byte
        vec![0xFF; 1000],              // Large uniform data
        (0..255).collect::<Vec<u8>>(), // All byte values
    ];

    for data in test_data {
        let encoded = general_purpose::STANDARD.encode(&data);
        let decoded = general_purpose::STANDARD.decode(&encoded).unwrap();
        assert_eq!(data, decoded);
    }
}

#[test]
fn test_compression_ratio_calculation() {
    let original_size = 1_000_000;
    let compressed_sizes = vec![
        900_000, // 10% compression
        500_000, // 50% compression
        100_000, // 90% compression
        50_000,  // 95% compression
    ];

    for compressed in compressed_sizes {
        let ratio = compressed as f64 / original_size as f64;
        assert!(ratio > 0.0 && ratio <= 1.0);

        let savings = 1.0 - ratio;
        assert!(savings >= 0.0 && savings < 1.0);
    }
}

// ============================================================================
// Resource Cleanup Tests
// ============================================================================

#[tokio::test]
async fn test_connection_cleanup_on_drop() {
    // Test that connections are properly cleaned up
    struct MockConnection {
        id: u32,
    }

    impl Drop for MockConnection {
        fn drop(&mut self) {
            // Cleanup logic
        }
    }

    let conn = MockConnection { id: 1 };
    drop(conn); // Explicitly drop
                // Test passes if no panic
}

#[test]
fn test_buffer_cleanup() {
    let mut buffer: Vec<u8> = Vec::with_capacity(10_000);
    buffer.extend_from_slice(&[0xFF; 5_000]);

    buffer.clear();
    assert_eq!(buffer.len(), 0);
    assert!(buffer.capacity() >= 5_000);

    buffer.shrink_to_fit();
    // Test passes if no memory leak
}

// ============================================================================
// Configuration Validation Tests
// ============================================================================

#[test]
fn test_config_field_validation() {
    // Test configuration field validation
    let invalid_configs = vec![
        ("api_key", ""),
        ("host", ""),
        ("port", "0"),
        ("timeout", "-1"),
        ("buffer_size", "0"),
    ];

    for (field, value) in invalid_configs {
        let is_valid = match field {
            "api_key" => !value.is_empty(),
            "host" => !value.is_empty(),
            "port" => value.parse::<u16>().map(|p| p > 0).unwrap_or(false),
            "timeout" => value.parse::<i32>().map(|t| t > 0).unwrap_or(false),
            "buffer_size" => value.parse::<usize>().map(|s| s > 0).unwrap_or(false),
            _ => false,
        };

        assert!(!is_valid);
    }
}

#[test]
fn test_config_default_values() {
    // Test default configuration values
    let defaults: HashMap<&str, &str> = [
        ("timeout_seconds", "30"),
        ("max_reconnect_attempts", "5"),
        ("buffer_size", "10000"),
        ("compression_enabled", "true"),
    ]
    .iter()
    .cloned()
    .collect();

    assert_eq!(defaults.get("timeout_seconds"), Some(&"30"));
    assert_eq!(defaults.get("buffer_size"), Some(&"10000"));
}