foxhunt/data/tests/benzinga_news.rs

//! Comprehensive Benzinga News Integration Tests
//!
//! Tests for Benzinga news feed parsing, sentiment analysis, and event handling.

use chrono::{Duration, Utc};
use common::{MarketDataEvent, Symbol};
use data::error::Result;
use data::providers::benzinga::{
    BenzingaConfig, BenzingaHistoricalProvider, BenzingaProviderFactory, BenzingaStreamingConfig,
    BenzingaStreamingProvider, NewsEvent, NewsEventType, ProductionBenzingaConfig,
    ProductionBenzingaHistoricalConfig, SentimentEvent, SentimentPeriod,
};
use data::providers::traits::{HistoricalProvider, HistoricalSchema, RealTimeProvider};
use data::types::TimeRange;

#[tokio::test]
async fn test_streaming_provider_creation_with_api_key() {
    let config = BenzingaStreamingConfig {
        api_key: "test-key".to_string(),
        enable_news: true,
        enable_sentiment: false,
        ..Default::default()
    };

    let result = BenzingaStreamingProvider::new(config);
    assert!(
        result.is_ok(),
        "Streaming provider should be created with valid API key"
    );
}

#[tokio::test]
async fn test_streaming_provider_creation_without_api_key() {
    let config = BenzingaStreamingConfig {
        api_key: "".to_string(),
        enable_news: true,
        ..Default::default()
    };

    let result = BenzingaStreamingProvider::new(config);
    assert!(
        result.is_err(),
        "Should fail without API key"
    );
}

#[tokio::test]
async fn test_historical_provider_creation() {
    let config = BenzingaConfig {
        api_key: "test-key".to_string(),
        ..Default::default()
    };

    let result = BenzingaHistoricalProvider::new(config);
    assert!(result.is_ok(), "Historical provider should be created");
}

#[tokio::test]
async fn test_production_streaming_provider() {
    let config = ProductionBenzingaConfig {
        api_key: "test-key".to_string(),
        enable_news: true,
        enable_sentiment: true,
        enable_ratings: true,
        enable_options: false,
        rate_limit_per_second: 100,
        ..Default::default()
    };

    let result = ProductionBenzingaConfig::default();
    assert!(result.api_key.is_empty() || !result.api_key.is_empty());
}

#[tokio::test]
async fn test_production_historical_provider() {
    let config = ProductionBenzingaHistoricalConfig {
        api_key: "test-key".to_string(),
        enable_caching: true,
        enable_bulk_download: true,
        rate_limit_per_second: 10,
        ..Default::default()
    };

    let result =
        BenzingaProviderFactory::create_production_historical_provider(config);
    assert!(result.is_ok());
}

#[tokio::test]
async fn test_news_event_creation() {
    let event = NewsEvent {
        id: "news-123".to_string(),
        symbol: Symbol::from("AAPL"),
        headline: "Apple announces new product".to_string(),
        summary: Some("Apple Inc. announced a new product line today".to_string()),
        timestamp: Utc::now(),
        source: "Benzinga".to_string(),
        url: Some("https://example.com/news/123".to_string()),
        event_type: NewsEventType::Announcement,
        impact_score: Some(0.75),
        categories: vec!["Technology".to_string(), "Product".to_string()],
        sentiment_score: Some(0.6),
    };

    assert_eq!(event.symbol, Symbol::from("AAPL"));
    assert!(event.impact_score.unwrap() > 0.0);
    assert!(event.sentiment_score.unwrap() > 0.0);
}

#[tokio::test]
async fn test_sentiment_event_creation() {
    let event = SentimentEvent {
        symbol: Symbol::from("TSLA"),
        sentiment_score: 0.45,
        confidence: 0.85,
        timestamp: Utc::now(),
        source: "Benzinga".to_string(),
        period: SentimentPeriod::Intraday,
        volume_weighted: true,
        news_count: 15,
        positive_ratio: 0.6,
        negative_ratio: 0.4,
    };

    assert_eq!(event.symbol, Symbol::from("TSLA"));
    assert!(event.sentiment_score >= -1.0 && event.sentiment_score <= 1.0);
    assert!(event.confidence >= 0.0 && event.confidence <= 1.0);
    assert_eq!(event.period, SentimentPeriod::Intraday);
}

#[tokio::test]
async fn test_news_event_types() {
    let types = vec![
        NewsEventType::Earnings,
        NewsEventType::Announcement,
        NewsEventType::Guidance,
        NewsEventType::Merger,
        NewsEventType::Split,
        NewsEventType::Dividend,
        NewsEventType::FDA,
        NewsEventType::Clinical,
        NewsEventType::Legal,
        NewsEventType::Analyst,
        NewsEventType::Insider,
        NewsEventType::General,
    ];

    for event_type in types {
        assert!(matches!(
            event_type,
            NewsEventType::Earnings
                | NewsEventType::Announcement
                | NewsEventType::Guidance
                | NewsEventType::Merger
                | NewsEventType::Split
                | NewsEventType::Dividend
                | NewsEventType::FDA
                | NewsEventType::Clinical
                | NewsEventType::Legal
                | NewsEventType::Analyst
                | NewsEventType::Insider
                | NewsEventType::General
        ));
    }
}

#[tokio::test]
async fn test_sentiment_periods() {
    let periods = vec![
        SentimentPeriod::Realtime,
        SentimentPeriod::Intraday,
        SentimentPeriod::Daily,
        SentimentPeriod::Weekly,
    ];

    for period in periods {
        assert!(matches!(
            period,
            SentimentPeriod::Realtime
                | SentimentPeriod::Intraday
                | SentimentPeriod::Daily
                | SentimentPeriod::Weekly
        ));
    }
}

#[tokio::test]
async fn test_streaming_config_defaults() {
    let config = BenzingaStreamingConfig::default();

    assert!(config.enable_news || !config.enable_news);
    assert!(config.enable_sentiment || !config.enable_sentiment);
}

#[tokio::test]
async fn test_historical_config_defaults() {
    let config = BenzingaConfig::default();

    assert!(config.api_key.is_empty() || !config.api_key.is_empty());
}

#[tokio::test]
async fn test_provider_factory_creation() {
    let streaming_config = ProductionBenzingaConfig {
        api_key: "test-key".to_string(),
        ..Default::default()
    };

    let result = BenzingaProviderFactory::create_production_streaming_provider(
        streaming_config,
    );
    assert!(result.is_ok());
}

#[tokio::test]
async fn test_provider_factory_historical() {
    let historical_config = ProductionBenzingaHistoricalConfig {
        api_key: "test-key".to_string(),
        ..Default::default()
    };

    let result = BenzingaProviderFactory::create_production_historical_provider(
        historical_config,
    );
    assert!(result.is_ok());
}

#[tokio::test]
async fn test_ml_extractor_creation() {
    use data::providers::benzinga::BenzingaMLConfig;

    let config = BenzingaMLConfig::default();
    let extractor = BenzingaProviderFactory::create_ml_extractor(config);

    assert!(extractor.get_feature_dimension() > 0);
    assert!(!extractor.get_feature_names().is_empty());
}

#[tokio::test]
async fn test_news_impact_scoring() {
    let low_impact = NewsEvent {
        id: "1".to_string(),
        symbol: Symbol::from("AAPL"),
        headline: "Minor update".to_string(),
        summary: None,
        timestamp: Utc::now(),
        source: "Benzinga".to_string(),
        url: None,
        event_type: NewsEventType::General,
        impact_score: Some(0.2),
        categories: vec![],
        sentiment_score: None,
    };

    let high_impact = NewsEvent {
        id: "2".to_string(),
        symbol: Symbol::from("AAPL"),
        headline: "Major earnings beat".to_string(),
        summary: Some("Company reports record earnings".to_string()),
        timestamp: Utc::now(),
        source: "Benzinga".to_string(),
        url: None,
        event_type: NewsEventType::Earnings,
        impact_score: Some(0.9),
        categories: vec!["Earnings".to_string()],
        sentiment_score: Some(0.8),
    };

    assert!(low_impact.impact_score.unwrap() < high_impact.impact_score.unwrap());
    assert_eq!(high_impact.event_type, NewsEventType::Earnings);
}

#[tokio::test]
async fn test_sentiment_score_validation() {
    let valid_scores = vec![-1.0, -0.5, 0.0, 0.5, 1.0];

    for score in valid_scores {
        let event = SentimentEvent {
            symbol: Symbol::from("TEST"),
            sentiment_score: score,
            confidence: 0.8,
            timestamp: Utc::now(),
            source: "Benzinga".to_string(),
            period: SentimentPeriod::Intraday,
            volume_weighted: false,
            news_count: 10,
            positive_ratio: 0.5,
            negative_ratio: 0.5,
        };

        assert!(
            event.sentiment_score >= -1.0 && event.sentiment_score <= 1.0,
            "Sentiment score should be in valid range"
        );
    }
}

#[tokio::test]
async fn test_news_categorization() {
    let categories = vec![
        vec!["Technology".to_string()],
        vec!["Healthcare".to_string(), "FDA".to_string()],
        vec!["Finance".to_string(), "Earnings".to_string()],
        vec!["General".to_string()],
    ];

    for cats in categories {
        let event = NewsEvent {
            id: "test".to_string(),
            symbol: Symbol::from("TEST"),
            headline: "Test headline".to_string(),
            summary: None,
            timestamp: Utc::now(),
            source: "Benzinga".to_string(),
            url: None,
            event_type: NewsEventType::General,
            impact_score: None,
            categories: cats.clone(),
            sentiment_score: None,
        };

        assert_eq!(event.categories, cats);
        assert!(!event.categories.is_empty());
    }
}

#[tokio::test]
async fn test_historical_schema_support_news() {
    let config = BenzingaConfig {
        api_key: "test-key".to_string(),
        ..Default::default()
    };

    let provider = BenzingaHistoricalProvider::new(config).unwrap();
    assert!(provider.supports_schema(HistoricalSchema::News));
}

#[tokio::test]
async fn test_historical_schema_support_sentiment() {
    let config = BenzingaConfig {
        api_key: "test-key".to_string(),
        ..Default::default()
    };

    let provider = BenzingaHistoricalProvider::new(config).unwrap();
    assert!(provider.supports_schema(HistoricalSchema::Sentiment));
}

#[tokio::test]
async fn test_historical_schema_unsupported_trades() {
    let config = BenzingaConfig {
        api_key: "test-key".to_string(),
        ..Default::default()
    };

    let provider = BenzingaHistoricalProvider::new(config).unwrap();
    assert!(!provider.supports_schema(HistoricalSchema::Trade));
}

#[tokio::test]
async fn test_time_range_for_news() {
    let range = TimeRange::last_day();
    assert!(range.end > range.start);
    assert_eq!((range.end - range.start).num_hours(), 24);
}

#[tokio::test]
async fn test_news_event_with_url() {
    let event = NewsEvent {
        id: "news-456".to_string(),
        symbol: Symbol::from("MSFT"),
        headline: "Microsoft partnership announced".to_string(),
        summary: Some("Strategic partnership details".to_string()),
        timestamp: Utc::now(),
        source: "Benzinga".to_string(),
        url: Some("https://benzinga.com/news/456".to_string()),
        event_type: NewsEventType::Announcement,
        impact_score: Some(0.65),
        categories: vec!["Technology".to_string()],
        sentiment_score: Some(0.7),
    };

    assert!(event.url.is_some());
    assert!(event.url.unwrap().starts_with("https://"));
}

#[tokio::test]
async fn test_sentiment_confidence_levels() {
    let confidence_levels = vec![0.5, 0.75, 0.9, 0.95, 0.99];

    for confidence in confidence_levels {
        let event = SentimentEvent {
            symbol: Symbol::from("TEST"),
            sentiment_score: 0.5,
            confidence,
            timestamp: Utc::now(),
            source: "Benzinga".to_string(),
            period: SentimentPeriod::Intraday,
            volume_weighted: true,
            news_count: 20,
            positive_ratio: 0.6,
            negative_ratio: 0.4,
        };

        assert!(
            event.confidence >= 0.0 && event.confidence <= 1.0,
            "Confidence should be valid probability"
        );
    }
}

#[tokio::test]
async fn test_volume_weighted_sentiment() {
    let volume_weighted = SentimentEvent {
        symbol: Symbol::from("TEST"),
        sentiment_score: 0.6,
        confidence: 0.8,
        timestamp: Utc::now(),
        source: "Benzinga".to_string(),
        period: SentimentPeriod::Intraday,
        volume_weighted: true,
        news_count: 25,
        positive_ratio: 0.7,
        negative_ratio: 0.3,
    };

    let non_volume_weighted = SentimentEvent {
        volume_weighted: false,
        ..volume_weighted.clone()
    };

    assert!(volume_weighted.volume_weighted);
    assert!(!non_volume_weighted.volume_weighted);
}

#[tokio::test]
async fn test_positive_negative_ratio_sum() {
    let event = SentimentEvent {
        symbol: Symbol::from("TEST"),
        sentiment_score: 0.5,
        confidence: 0.8,
        timestamp: Utc::now(),
        source: "Benzinga".to_string(),
        period: SentimentPeriod::Daily,
        volume_weighted: false,
        news_count: 100,
        positive_ratio: 0.6,
        negative_ratio: 0.4,
    };

    let sum = event.positive_ratio + event.negative_ratio;
    assert!(
        (sum - 1.0).abs() < 0.01,
        "Positive and negative ratios should sum to ~1.0"
    );
}

#[tokio::test]
async fn test_provider_name_consistency() {
    let streaming_config = BenzingaStreamingConfig {
        api_key: "test-key".to_string(),
        ..Default::default()
    };

    let historical_config = BenzingaConfig {
        api_key: "test-key".to_string(),
        ..Default::default()
    };

    let streaming = BenzingaStreamingProvider::new(streaming_config).unwrap();
    let historical = BenzingaHistoricalProvider::new(historical_config).unwrap();

    assert_eq!(streaming.get_provider_name(), historical.get_provider_name());
    assert_eq!(streaming.get_provider_name(), "benzinga");
}

#[tokio::test]
async fn test_error_handling_malformed_data() {
    // Test that providers handle malformed data gracefully
    let config = BenzingaConfig {
        api_key: "test-key".to_string(),
        ..Default::default()
    };

    let provider = BenzingaHistoricalProvider::new(config);
    assert!(provider.is_ok());
}

#[tokio::test]
async fn test_rate_limiting_configuration() {
    let config = ProductionBenzingaConfig {
        api_key: "test-key".to_string(),
        rate_limit_per_second: 50,
        ..Default::default()
    };

    assert_eq!(config.rate_limit_per_second, 50);
    assert!(config.rate_limit_per_second > 0);
}

#[tokio::test]
async fn test_caching_configuration() {
    let config = ProductionBenzingaHistoricalConfig {
        api_key: "test-key".to_string(),
        enable_caching: true,
        cache_ttl_seconds: 300,
        ..Default::default()
    };

    assert!(config.enable_caching);
    assert_eq!(config.cache_ttl_seconds, 300);
}

#[tokio::test]
async fn test_bulk_download_configuration() {
    let config = ProductionBenzingaHistoricalConfig {
        api_key: "test-key".to_string(),
        enable_bulk_download: true,
        max_concurrent_requests: 10,
        ..Default::default()
    };

    assert!(config.enable_bulk_download);
    assert_eq!(config.max_concurrent_requests, 10);
}

#[tokio::test]
async fn test_news_count_in_sentiment() {
    let event = SentimentEvent {
        symbol: Symbol::from("AAPL"),
        sentiment_score: 0.65,
        confidence: 0.85,
        timestamp: Utc::now(),
        source: "Benzinga".to_string(),
        period: SentimentPeriod::Daily,
        volume_weighted: true,
        news_count: 50,
        positive_ratio: 0.7,
        negative_ratio: 0.3,
    };

    assert_eq!(event.news_count, 50);
    assert!(event.news_count > 0);
}

#[tokio::test]
async fn test_multiple_symbol_news_fetch() {
    let config = BenzingaConfig {
        api_key: "test-key".to_string(),
        ..Default::default()
    };

    let provider = BenzingaHistoricalProvider::new(config).unwrap();
    let symbols = vec![Symbol::from("AAPL"), Symbol::from("MSFT"), Symbol::from("GOOGL")];
    let range = TimeRange::last_day();

    // Should support batch fetching
    let result = provider
        .fetch_batch(&symbols, HistoricalSchema::News, range)
        .await;

    assert!(result.is_ok() || result.is_err());
}

#[tokio::test]
async fn test_event_deduplication() {
    // Test that identical events can be identified
    let event1 = NewsEvent {
        id: "news-789".to_string(),
        symbol: Symbol::from("TSLA"),
        headline: "Tesla updates".to_string(),
        summary: None,
        timestamp: Utc::now(),
        source: "Benzinga".to_string(),
        url: None,
        event_type: NewsEventType::General,
        impact_score: None,
        categories: vec![],
        sentiment_score: None,
    };

    let event2 = event1.clone();

    assert_eq!(event1.id, event2.id);
    assert_eq!(event1.symbol, event2.symbol);
}