foxhunt/data/tests/benzinga_streaming_tests.rs

//! Benzinga News Provider Streaming and Integration Tests
//!
//! Comprehensive tests for Benzinga news feed covering:
//! - News article processing and parsing
//! - Earnings events and analyst ratings
//! - Economic calendar events
//! - Rate limiting and throttling
//! - Real-time streaming
//! - News sentiment analysis integration

#![allow(unused_crate_dependencies)]

use chrono::{Duration, Utc};
use data::error::DataError;
use data::providers::common::NewsEvent;
use std::collections::HashMap;

// ============================================================================
// News Article Processing Tests
// ============================================================================

#[test]
fn test_benzinga_news_article_structure() {
    let article = NewsEvent {
        event_id: "news_123".to_string(),
        timestamp: Utc::now(),
        event_type: "news_article".to_string(),
        symbols: vec!["AAPL".to_string()],
        title: "Apple Announces New Product".to_string(),
        content: Some("Apple Inc. announced...".to_string()),
        source: "Benzinga".to_string(),
        tags: vec!["technology".to_string(), "earnings".to_string()],
        metadata: HashMap::new(),
    };

    assert_eq!(article.source, "Benzinga");
    assert!(!article.symbols.is_empty());
    assert!(!article.title.is_empty());
}

#[test]
fn test_benzinga_news_empty_fields() {
    let article = NewsEvent {
        event_id: "news_123".to_string(),
        timestamp: Utc::now(),
        event_type: "news_article".to_string(),
        symbols: vec![],
        title: "".to_string(),
        content: None,
        source: "Benzinga".to_string(),
        tags: vec![],
        metadata: HashMap::new(),
    };

    assert!(article.symbols.is_empty());
    assert!(article.title.is_empty());
    assert!(article.content.is_none());
}

#[test]
fn test_benzinga_news_multiple_symbols() {
    let article = NewsEvent {
        event_id: "news_456".to_string(),
        timestamp: Utc::now(),
        event_type: "merger_announcement".to_string(),
        symbols: vec!["AAPL".to_string(), "MSFT".to_string(), "GOOGL".to_string()],
        title: "Tech Giants Partnership".to_string(),
        content: Some("Major tech companies announce partnership...".to_string()),
        source: "Benzinga".to_string(),
        tags: vec!["partnerships".to_string()],
        metadata: HashMap::new(),
    };

    assert_eq!(article.symbols.len(), 3);
    assert!(article.symbols.contains(&"AAPL".to_string()));
}

// ============================================================================
// Earnings Event Tests
// ============================================================================

#[test]
fn test_benzinga_earnings_event() {
    let mut metadata = HashMap::new();
    metadata.insert("eps_estimate".to_string(), "2.50".to_string());
    metadata.insert("eps_actual".to_string(), "2.75".to_string());
    metadata.insert("revenue_estimate".to_string(), "100B".to_string());

    let earnings = NewsEvent {
        event_id: "earnings_123".to_string(),
        timestamp: Utc::now(),
        event_type: "earnings_release".to_string(),
        symbols: vec!["AAPL".to_string()],
        title: "Apple Q4 Earnings Beat Estimates".to_string(),
        content: Some("Apple reports strong Q4...".to_string()),
        source: "Benzinga".to_string(),
        tags: vec!["earnings".to_string(), "quarterly_results".to_string()],
        metadata,
    };

    assert_eq!(earnings.event_type, "earnings_release");
    assert!(earnings.metadata.contains_key("eps_estimate"));
    assert!(earnings.metadata.contains_key("eps_actual"));
}

#[test]
fn test_benzinga_earnings_surprise() {
    let mut metadata = HashMap::new();
    metadata.insert("eps_estimate".to_string(), "1.50".to_string());
    metadata.insert("eps_actual".to_string(), "2.00".to_string());

    let estimate: f64 = metadata["eps_estimate"].parse().unwrap();
    let actual: f64 = metadata["eps_actual"].parse().unwrap();
    let surprise = ((actual - estimate) / estimate) * 100.0;

    assert!(surprise > 0.0); // Positive surprise
    assert_eq!(surprise.round(), 33.0); // 33% surprise
}

// ============================================================================
// Analyst Rating Tests
// ============================================================================

#[test]
fn test_benzinga_analyst_rating_upgrade() {
    let mut metadata = HashMap::new();
    metadata.insert("rating_type".to_string(), "upgrade".to_string());
    metadata.insert("old_rating".to_string(), "hold".to_string());
    metadata.insert("new_rating".to_string(), "buy".to_string());
    metadata.insert("analyst_firm".to_string(), "Goldman Sachs".to_string());

    let rating = NewsEvent {
        event_id: "rating_123".to_string(),
        timestamp: Utc::now(),
        event_type: "analyst_rating".to_string(),
        symbols: vec!["TSLA".to_string()],
        title: "Goldman Sachs Upgrades Tesla".to_string(),
        content: None,
        source: "Benzinga".to_string(),
        tags: vec!["analyst_rating".to_string(), "upgrade".to_string()],
        metadata,
    };

    assert_eq!(rating.event_type, "analyst_rating");
    assert_eq!(rating.metadata["rating_type"], "upgrade");
}

#[test]
fn test_benzinga_analyst_rating_downgrade() {
    let mut metadata = HashMap::new();
    metadata.insert("rating_type".to_string(), "downgrade".to_string());
    metadata.insert("old_rating".to_string(), "buy".to_string());
    metadata.insert("new_rating".to_string(), "sell".to_string());

    let rating = NewsEvent {
        event_id: "rating_456".to_string(),
        timestamp: Utc::now(),
        event_type: "analyst_rating".to_string(),
        symbols: vec!["NFLX".to_string()],
        title: "Netflix Downgraded on Subscriber Concerns".to_string(),
        content: None,
        source: "Benzinga".to_string(),
        tags: vec!["analyst_rating".to_string(), "downgrade".to_string()],
        metadata,
    };

    assert_eq!(rating.metadata["rating_type"], "downgrade");
}

// ============================================================================
// Economic Event Tests
// ============================================================================

#[test]
fn test_benzinga_economic_calendar_event() {
    let mut metadata = HashMap::new();
    metadata.insert("event_name".to_string(), "FOMC Meeting".to_string());
    metadata.insert("importance".to_string(), "high".to_string());
    metadata.insert("country".to_string(), "USA".to_string());

    let economic = NewsEvent {
        event_id: "econ_123".to_string(),
        timestamp: Utc::now(),
        event_type: "economic_event".to_string(),
        symbols: vec![],
        title: "Federal Reserve FOMC Meeting".to_string(),
        content: Some("Federal Reserve to announce interest rate decision...".to_string()),
        source: "Benzinga".to_string(),
        tags: vec!["economics".to_string(), "fed".to_string()],
        metadata,
    };

    assert_eq!(economic.event_type, "economic_event");
    assert_eq!(economic.metadata["importance"], "high");
}

#[test]
fn test_benzinga_economic_data_release() {
    let mut metadata = HashMap::new();
    metadata.insert("indicator".to_string(), "CPI".to_string());
    metadata.insert("expected".to_string(), "3.5".to_string());
    metadata.insert("actual".to_string(), "3.8".to_string());

    let data = NewsEvent {
        event_id: "econ_456".to_string(),
        timestamp: Utc::now(),
        event_type: "economic_data".to_string(),
        symbols: vec![],
        title: "Consumer Price Index Exceeds Expectations".to_string(),
        content: None,
        source: "Benzinga".to_string(),
        tags: vec!["inflation".to_string(), "cpi".to_string()],
        metadata,
    };

    assert_eq!(data.metadata["indicator"], "CPI");
}

// ============================================================================
// Rate Limiting Tests
// ============================================================================

#[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_rate_limit_throttling() {
    let requests_per_minute = 60;
    let current_requests = 55;

    let remaining = requests_per_minute - current_requests;
    let should_throttle = remaining <= 5;

    assert!(should_throttle);
}

#[test]
fn test_benzinga_rate_limit_backoff() {
    let base_delay_ms = 1000;
    let attempts = vec![0, 1, 2, 3, 4];

    for attempt in attempts {
        let delay = base_delay_ms * 2_u64.pow(attempt);
        let capped_delay = delay.min(60_000);

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

// ============================================================================
// API Error Handling Tests
// ============================================================================

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

    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_authentication_error() {
    let auth_err = DataError::authentication("Invalid API token");
    assert!(matches!(auth_err, DataError::Authentication { .. }));
    assert_eq!(auth_err.severity(), data::error::ErrorSeverity::Critical);
}

// ============================================================================
// Symbol Validation Tests
// ============================================================================

#[test]
fn test_benzinga_symbol_validation() {
    let invalid_symbols = vec![
        "",
        " ",
        "\n",
        &"TOOLONG".repeat(100),
        "!@#$%",
        "symbol with spaces",
    ];

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

        assert!(!is_valid);
    }
}

#[test]
fn test_benzinga_symbol_normalization() {
    let symbols = vec![
        ("aapl", "AAPL"),
        ("tsla", "TSLA"),
        ("brk.b", "BRK.B"),
    ];

    for (input, expected) in symbols {
        let normalized = input.to_uppercase();
        assert_eq!(normalized, expected);
    }
}

// ============================================================================
// News Filtering Tests
// ============================================================================

#[test]
fn test_benzinga_news_category_filtering() {
    let categories = vec!["earnings", "analyst_rating", "merger", "ipo"];

    let article = NewsEvent {
        event_id: "news_123".to_string(),
        timestamp: Utc::now(),
        event_type: "earnings_release".to_string(),
        symbols: vec!["AAPL".to_string()],
        title: "Test".to_string(),
        content: None,
        source: "Benzinga".to_string(),
        tags: vec!["earnings".to_string()],
        metadata: HashMap::new(),
    };

    let should_include = categories.contains(&"earnings");
    assert!(should_include);
}

#[test]
fn test_benzinga_news_importance_filtering() {
    let min_importance = 0.7;

    let mut metadata = HashMap::new();
    metadata.insert("importance".to_string(), "0.8".to_string());

    let article_importance: f64 = metadata["importance"].parse().unwrap();
    let should_include = article_importance >= min_importance;

    assert!(should_include);
}

// ============================================================================
// News Deduplication Tests
// ============================================================================

#[test]
fn test_benzinga_news_deduplication() {
    let mut seen_ids: std::collections::HashSet<String> = std::collections::HashSet::new();

    let event_ids = vec![
        "news_1", "news_2", "news_3", "news_2", "news_4", "news_3",
    ];

    let mut unique_count = 0;
    for id in event_ids {
        if seen_ids.insert(id.to_string()) {
            unique_count += 1;
        }
    }

    assert_eq!(unique_count, 4); // Only 4 unique IDs
}

// ============================================================================
// Timestamp Validation Tests
// ============================================================================

#[test]
fn test_benzinga_news_timestamp_validation() {
    let now = Utc::now();
    let old_news = now - Duration::hours(24);
    let future_news = now + Duration::hours(1);

    let max_age = Duration::hours(6);

    let is_old = (now - old_news) > max_age;
    let is_future = future_news > now;

    assert!(is_old);
    assert!(is_future);
}

#[test]
fn test_benzinga_news_timestamp_ordering() {
    let events = vec![
        Utc::now() - Duration::hours(3),
        Utc::now() - Duration::hours(2),
        Utc::now() - Duration::hours(1),
        Utc::now(),
    ];

    for i in 1..events.len() {
        assert!(events[i] > events[i - 1]);
    }
}

// ============================================================================
// Content Processing Tests
// ============================================================================

#[test]
fn test_benzinga_news_content_sanitization() {
    let raw_content = "Apple <b>announces</b> new product!\n\nStock up 5%";
    let sanitized = raw_content.replace("<b>", "").replace("</b>", "");

    assert!(!sanitized.contains("<b>"));
    assert!(!sanitized.contains("</b>"));
}

#[test]
fn test_benzinga_news_content_truncation() {
    let long_content = "a".repeat(10000);
    let max_length = 5000;

    let truncated = if long_content.len() > max_length {
        &long_content[..max_length]
    } else {
        &long_content
    };

    assert_eq!(truncated.len(), max_length);
}

// ============================================================================
// Streaming Integration Tests
// ============================================================================

#[tokio::test]
async fn test_benzinga_streaming_event_processing() {
    use tokio::task;

    let handles: Vec<_> = (0..10)
        .map(|i| {
            task::spawn(async move {
                let event = NewsEvent {
                    event_id: format!("news_{}", i),
                    timestamp: Utc::now(),
                    event_type: "news_article".to_string(),
                    symbols: vec!["AAPL".to_string()],
                    title: format!("Test Article {}", i),
                    content: None,
                    source: "Benzinga".to_string(),
                    tags: vec![],
                    metadata: HashMap::new(),
                };
                event
            })
        })
        .collect();

    for handle in handles {
        let event = handle.await.unwrap();
        assert!(!event.event_id.is_empty());
    }
}

// ============================================================================
// Metadata Extraction Tests
// ============================================================================

#[test]
fn test_benzinga_metadata_parsing() {
    let mut metadata = HashMap::new();
    metadata.insert("sentiment_score".to_string(), "0.75".to_string());
    metadata.insert("impact_score".to_string(), "0.85".to_string());
    metadata.insert("relevance".to_string(), "high".to_string());

    let sentiment: f64 = metadata["sentiment_score"].parse().unwrap();
    let impact: f64 = metadata["impact_score"].parse().unwrap();

    assert!(sentiment > 0.0 && sentiment <= 1.0);
    assert!(impact > 0.0 && impact <= 1.0);
}

#[test]
fn test_benzinga_metadata_missing_fields() {
    let metadata: HashMap<String, String> = HashMap::new();

    let sentiment = metadata
        .get("sentiment_score")
        .and_then(|s| s.parse::<f64>().ok())
        .unwrap_or(0.0);

    assert_eq!(sentiment, 0.0);
}

// ============================================================================
// Tag Processing Tests
// ============================================================================

#[test]
fn test_benzinga_tag_extraction() {
    let tags = vec![
        "earnings",
        "technology",
        "ai",
        "quarterly_results",
        "revenue_growth",
    ];

    let relevant_tags: Vec<&str> = tags
        .iter()
        .filter(|t| {
            t.contains("earnings") || t.contains("revenue") || t.contains("growth")
        })
        .copied()
        .collect();

    assert_eq!(relevant_tags.len(), 2); // earnings and revenue_growth
}

// ============================================================================
// Error Recovery Tests
// ============================================================================

#[test]
fn test_benzinga_error_recovery() {
    let mut attempt = 0;
    let max_attempts = 3;

    let result = loop {
        attempt += 1;
        let err = DataError::network("Connection timeout");

        if err.is_retryable() && attempt < max_attempts {
            continue;
        }

        break if attempt < max_attempts {
            Ok(())
        } else {
            Err(err)
        };
    };

    assert!(result.is_err());
}

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

#[test]
fn test_benzinga_config_validation() {
    let config = HashMap::from([
        ("api_token", "valid_token_12345"),
        ("max_events_per_request", "100"),
        ("update_interval_seconds", "60"),
    ]);

    assert!(!config["api_token"].is_empty());
    assert!(config["max_events_per_request"].parse::<u32>().is_ok());
}

// ============================================================================
// Serialization Tests
// ============================================================================

#[test]
fn test_benzinga_news_event_serialization() {
    use serde_json;

    let event = NewsEvent {
        event_id: "news_123".to_string(),
        timestamp: Utc::now(),
        event_type: "news_article".to_string(),
        symbols: vec!["AAPL".to_string()],
        title: "Test".to_string(),
        content: None,
        source: "Benzinga".to_string(),
        tags: vec![],
        metadata: HashMap::new(),
    };

    let json = serde_json::to_string(&event).unwrap();
    let deserialized: NewsEvent = serde_json::from_str(&json).unwrap();

    assert_eq!(event.event_id, deserialized.event_id);
    assert_eq!(event.title, deserialized.title);
}