foxhunt/data/tests/test_provider_traits.rs.disabled

//! Comprehensive tests for provider traits and common data types
//!
//! This module contains extensive tests for the provider trait system,
//! covering HistoricalSchema, ConnectionStatus, ConnectionState, and the
//! trait implementations for real-time and historical data providers.

use chrono::{DateTime, Duration as ChronoDuration, Utc};
use data::error::{DataError, Result};
use data::providers::common::{
    AggregateEvent, AnalystRatingEvent, ConnectionStatusEvent, ErrorEvent,
    MarketState, MarketStatusEvent, NewsEvent, NewsEventType, OptionsContract,
    OptionsSentiment, OptionsType, OrderBookSide, OrderBookSnapshot, OrderBookUpdate, PriceLevel,
    PriceLevelChange, PriceLevelChangeType, RatingAction, SentimentEvent,
    SentimentPeriod, UnusualOptionsEvent, UnusualOptionsType,
};
use common::error::ErrorCategory;
use common::{QuoteEvent, TradeEvent};
use data::types::ExtendedMarketDataEvent;
use common::MarketDataEvent;
use data::providers::traits::{
    ConnectionState, ConnectionStatus, HistoricalProvider, HistoricalSchema, RealTimeProvider,
};
use data::types::TimeRange;
use rust_decimal_macros::dec;
use serde_json;
use std::collections::HashMap;
use std::time::Duration;
use tokio_test;
use rust_decimal::Decimal;
use common::Symbol;

/// Test HistoricalSchema categorization
#[test]
fn test_historical_schema_is_market_data() {
    assert!(HistoricalSchema::Trade.is_market_data());
    assert!(HistoricalSchema::Quote.is_market_data());
    assert!(HistoricalSchema::OrderBookL2.is_market_data());
    assert!(HistoricalSchema::OrderBookL3.is_market_data());
    assert!(HistoricalSchema::OHLCV.is_market_data());

    assert!(!HistoricalSchema::News.is_market_data());
    assert!(!HistoricalSchema::Sentiment.is_market_data());
    assert!(!HistoricalSchema::AnalystRating.is_market_data());
    assert!(!HistoricalSchema::UnusualOptions.is_market_data());
}

/// Test HistoricalSchema news data categorization
#[test]
fn test_historical_schema_is_news_data() {
    assert!(HistoricalSchema::News.is_news_data());
    assert!(HistoricalSchema::Sentiment.is_news_data());
    assert!(HistoricalSchema::AnalystRating.is_news_data());
    assert!(HistoricalSchema::UnusualOptions.is_news_data());

    assert!(!HistoricalSchema::Trade.is_news_data());
    assert!(!HistoricalSchema::Quote.is_news_data());
    assert!(!HistoricalSchema::OrderBookL2.is_news_data());
    assert!(!HistoricalSchema::OrderBookL3.is_news_data());
    assert!(!HistoricalSchema::OHLCV.is_news_data());
}

/// Test HistoricalSchema typical provider mapping
#[test]
fn test_historical_schema_typical_provider() {
    // Market data schemas should use Databento
    assert_eq!(HistoricalSchema::Trade.typical_provider(), "databento");
    assert_eq!(HistoricalSchema::Quote.typical_provider(), "databento");
    assert_eq!(
        HistoricalSchema::OrderBookL2.typical_provider(),
        "databento"
    );
    assert_eq!(
        HistoricalSchema::OrderBookL3.typical_provider(),
        "databento"
    );
    assert_eq!(HistoricalSchema::OHLCV.typical_provider(), "databento");

    // News/sentiment schemas should use Benzinga
    assert_eq!(HistoricalSchema::News.typical_provider(), "benzinga");
    assert_eq!(HistoricalSchema::Sentiment.typical_provider(), "benzinga");
    assert_eq!(
        HistoricalSchema::AnalystRating.typical_provider(),
        "benzinga"
    );
    assert_eq!(
        HistoricalSchema::UnusualOptions.typical_provider(),
        "benzinga"
    );
}

/// Test HistoricalSchema serialization
#[test]
fn test_historical_schema_serialization() {
    let schemas = vec![
        HistoricalSchema::Trade,
        HistoricalSchema::Quote,
        HistoricalSchema::OrderBookL2,
        HistoricalSchema::OrderBookL3,
        HistoricalSchema::OHLCV,
        HistoricalSchema::News,
        HistoricalSchema::Sentiment,
        HistoricalSchema::AnalystRating,
        HistoricalSchema::UnusualOptions,
    ];

    for schema in schemas {
        let json = serde_json::to_string(&schema);
        assert!(json.is_ok(), "Failed to serialize schema: {:?}", schema);

        let deserialized: Result<HistoricalSchema, _> = serde_json::from_str(&json.unwrap());
        assert!(
            deserialized.is_ok(),
            "Failed to deserialize schema: {:?}",
            schema
        );
        assert_eq!(deserialized.unwrap(), schema);
    }
}

/// Test ConnectionState creation and comparison
#[test]
fn test_connection_state() {
    let states = vec![
        ConnectionState::Disconnected,
        ConnectionState::Connecting,
        ConnectionState::Connected,
        ConnectionState::Reconnecting,
        ConnectionState::Failed,
    ];

    for state in states {
        // Test serialization
        let json = serde_json::to_string(&state);
        assert!(json.is_ok());

        let deserialized: Result<ConnectionState, _> = serde_json::from_str(&json.unwrap());
        assert!(deserialized.is_ok());
        assert_eq!(deserialized.unwrap(), state);
    }
}

/// Test ConnectionStatus default creation
#[test]
fn test_connection_status_default() {
    let status = ConnectionStatus::default();

    assert_eq!(status.state, ConnectionState::Disconnected);
    assert_eq!(status.active_subscriptions, 0);
    assert_eq!(status.events_per_second, 0.0);
    assert_eq!(status.latency_micros, None);
    assert_eq!(status.recent_error_count, 0);
    assert_eq!(status.last_message_time, None);
    assert_eq!(status.last_connection_attempt, None);
}

/// Test ConnectionStatus disconnected creation
#[test]
fn test_connection_status_disconnected() {
    let status = ConnectionStatus::disconnected();

    assert_eq!(status.state, ConnectionState::Disconnected);
    assert_eq!(status.active_subscriptions, 0);
    assert_eq!(status.events_per_second, 0.0);
    assert!(!status.is_healthy());
}

/// Test ConnectionStatus connected creation
#[test]
fn test_connection_status_connected() {
    let status = ConnectionStatus::connected();

    assert_eq!(status.state, ConnectionState::Connected);
    assert!(status.last_connection_attempt.is_some());
    assert!(!status.is_healthy()); // Not healthy without recent messages
}

/// Test ConnectionStatus health assessment
#[test]
fn test_connection_status_health() {
    // Unhealthy due to high error count
    let mut status = ConnectionStatus {
        state: ConnectionState::Connected,
        recent_error_count: 15,
        last_message_time: Some(Utc::now() - ChronoDuration::seconds(10)),
        ..Default::default()
    };
    assert!(!status.is_healthy());

    // Unhealthy due to old messages
    status.recent_error_count = 0;
    status.last_message_time = Some(Utc::now() - ChronoDuration::seconds(60));
    assert!(!status.is_healthy());

    // Healthy with recent messages and low error count
    status.last_message_time = Some(Utc::now() - ChronoDuration::seconds(10));
    assert!(status.is_healthy());
}

/// Test ConnectionStatus serialization
#[test]
fn test_connection_status_serialization() {
    let status = ConnectionStatus {
        state: ConnectionState::Connected,
        active_subscriptions: 5,
        events_per_second: 125.5,
        latency_micros: Some(250),
        recent_error_count: 2,
        last_message_time: Some(Utc::now()),
        last_connection_attempt: Some(Utc::now()),
    };

    let json = serde_json::to_string(&status);
    assert!(json.is_ok());

    let deserialized: Result<ConnectionStatus, _> = serde_json::from_str(&json.unwrap());
    assert!(deserialized.is_ok());

    let deserialized_status = deserialized.unwrap();
    assert_eq!(deserialized_status.state, status.state);
    assert_eq!(
        deserialized_status.active_subscriptions,
        status.active_subscriptions
    );
    assert_eq!(
        deserialized_status.events_per_second,
        status.events_per_second
    );
    assert_eq!(deserialized_status.latency_micros, status.latency_micros);
    assert_eq!(
        deserialized_status.recent_error_count,
        status.recent_error_count
    );
}

/// Test MarketDataEvent symbol extraction
#[test]
fn test_market_data_event_symbol() {
    let trade = TradeEvent {
        symbol: Symbol::from("AAPL"),
        price: dec!(150.00),
        size: dec!(100),
        exchange: "NASDAQ".to_string(),
        conditions: vec![],
        trade_id: None,
        timestamp: Utc::now(),
        sequence: 1,
    };

    let event = MarketDataEvent::Trade(trade);
    assert_eq!(event.symbol(), Some(&Symbol::from("AAPL")));

    let news = NewsEvent {
        story_id: "test123".to_string(),
        headline: "Test News".to_string(),
        content: "Test news content".to_string(),
        summary: "Test news summary".to_string(),
        symbol: Some(Symbol::from("MSFT")),
        symbols: vec![Symbol::from("MSFT"), Symbol::from("GOOGL")],
        category: "Tech".to_string(),
        tags: vec![],
        impact_score: None,
        importance: 0.5,
        author: "Test Author".to_string(),
        source: "Test".to_string(),
        published_at: Utc::now(),
        timestamp: Utc::now(),
        url: "".to_string(),
        sentiment_score: None,
        sentiment: None,
        event_type: NewsEventType::News,
    };

    let news_event = ExtendedMarketDataEvent::NewsAlert(news);
    assert_eq!(news_event.symbol(), "MSFT");

    let status = ConnectionStatusEvent {
        provider: "test".to_string(),
        status: data::providers::common::ConnectionState::Connected,
        message: None,
        timestamp: Utc::now(),
    };

    let status_event = MarketDataEvent::ConnectionStatus(status);
    assert_eq!(status_event.symbol(), None);
}

/// Test MarketDataEvent timestamp extraction
#[test]
fn test_market_data_event_timestamp() {
    let now = Utc::now();

    let trade = TradeEvent {
        symbol: Symbol::from("SPY"),
        price: dec!(400.00),
        size: dec!(100),
        exchange: "NYSE".to_string(),
        conditions: vec![],
        trade_id: None,
        timestamp: now,
        sequence: 1,
    };

    let event = MarketDataEvent::Trade(trade);
    assert_eq!(event.timestamp(), now);
}

/// Test MarketDataEvent type categorization
#[test]
fn test_market_data_event_categorization() {
    let trade = TradeEvent {
        symbol: Symbol::from("QQQ"),
        price: dec!(350.00),
        size: dec!(100),
        exchange: "NASDAQ".to_string(),
        conditions: vec![],
        trade_id: None,
        timestamp: Utc::now(),
        sequence: 1,
    };
    let trade_event = MarketDataEvent::Trade(trade);

    assert!(trade_event.is_market_data());
    assert!(!trade_event.is_news_data());
    assert!(!trade_event.is_system_event());
    assert_eq!(trade_event.expected_provider(), "databento");

    let news = NewsEvent {
        story_id: "news456".to_string(),
        headline: "Market Update".to_string(),
        content: "Market update content".to_string(),
        summary: "Market update summary".to_string(),
        symbol: Some(Symbol::from("IWM")),
        symbols: vec![Symbol::from("IWM")],
        category: "Markets".to_string(),
        tags: vec![],
        impact_score: None,
        importance: 0.5,
        author: "News Author".to_string(),
        source: "News Source".to_string(),
        published_at: Utc::now(),
        timestamp: Utc::now(),
        url: "".to_string(),
        sentiment_score: None,
        sentiment: None,
        event_type: NewsEventType::News,
    };
    let news_event = ExtendedMarketDataEvent::NewsAlert(news);

    // ExtendedMarketDataEvent doesn't have these methods, removing test for now
    // assert!(!news_event.is_market_data());
    // assert!(news_event.is_news_data());
    // assert!(!news_event.is_system_event());
    // assert_eq!(news_event.expected_provider(), "benzinga");

    let error = ErrorEvent {
        provider: "test".to_string(),
        message: "Test error".to_string(),
        code: None,
        category: ErrorCategory::Connection,
        recoverable: true,
        timestamp: Utc::now(),
    };
    let error_event = MarketDataEvent::Error(error);

    assert!(!error_event.is_market_data());
    assert!(!error_event.is_news_data());
    assert!(error_event.is_system_event());
    assert_eq!(error_event.expected_provider(), "system");
}

/// Test TradeEvent creation and serialization
#[test]
fn test_trade_event_serialization() {
    let trade = TradeEvent {
        symbol: Symbol::from("TSLA"),
        price: dec!(250.75),
        size: dec!(500),
        exchange: "NASDAQ".to_string(),
        conditions: vec![1, 2],
        trade_id: Some("trade123".to_string()),
        timestamp: Utc::now(),
        sequence: 12345,
    };

    let json = serde_json::to_string(&trade);
    assert!(json.is_ok());

    let deserialized: Result<TradeEvent, _> = serde_json::from_str(&json.unwrap());
    assert!(deserialized.is_ok());

    let deserialized_trade = deserialized.unwrap();
    assert_eq!(deserialized_trade.symbol, trade.symbol);
    assert_eq!(deserialized_trade.price, trade.price);
    assert_eq!(deserialized_trade.size, trade.size);
    assert_eq!(deserialized_trade.exchange, trade.exchange);
    assert_eq!(deserialized_trade.conditions, trade.conditions);
    assert_eq!(deserialized_trade.trade_id, trade.trade_id);
    assert_eq!(deserialized_trade.sequence, trade.sequence);
}

/// Test QuoteEvent creation and serialization
#[test]
fn test_quote_event_serialization() {
    let quote = QuoteEvent {
        symbol: Symbol::from("AMD"),
        bid: Some(dec!(95.25)),
        ask: Some(dec!(95.26)),
        bid_size: Some(dec!(1000)),
        ask_size: Some(dec!(800)),
        bid_exchange: Some("NYSE".to_string()),
        ask_exchange: Some("NASDAQ".to_string()),
        conditions: vec![0],
        timestamp: Utc::now(),
        sequence: 54321,
    };

    let json = serde_json::to_string(&quote);
    assert!(json.is_ok());

    let deserialized: Result<QuoteEvent, _> = serde_json::from_str(&json.unwrap());
    assert!(deserialized.is_ok());

    let deserialized_quote = deserialized.unwrap();
    assert_eq!(deserialized_quote.symbol, quote.symbol);
    assert_eq!(deserialized_quote.bid, quote.bid);
    assert_eq!(deserialized_quote.ask, quote.ask);
    assert_eq!(deserialized_quote.bid_size, quote.bid_size);
    assert_eq!(deserialized_quote.ask_size, quote.ask_size);
}

/// Test OrderBookSnapshot with price levels
#[test]
fn test_order_book_snapshot_serialization() {
    let snapshot = OrderBookSnapshot {
        symbol: Symbol::from("NVDA"),
        bids: vec![
            PriceLevel {
                price: dec!(875.50),
                size: dec!(100),
                order_count: Some(5),
            },
            PriceLevel {
                price: dec!(875.49),
                size: dec!(200),
                order_count: Some(3),
            },
        ],
        asks: vec![
            PriceLevel {
                price: dec!(875.51),
                size: dec!(150),
                order_count: Some(2),
            },
            PriceLevel {
                price: dec!(875.52),
                size: dec!(300),
                order_count: Some(7),
            },
        ],
        exchange: "NASDAQ".to_string(),
        timestamp: Utc::now(),
        sequence: 98765,
    };

    let json = serde_json::to_string(&snapshot);
    assert!(json.is_ok());

    let deserialized: Result<OrderBookSnapshot, _> = serde_json::from_str(&json.unwrap());
    assert!(deserialized.is_ok());

    let deserialized_snapshot = deserialized.unwrap();
    assert_eq!(deserialized_snapshot.symbol, snapshot.symbol);
    assert_eq!(deserialized_snapshot.bids.len(), snapshot.bids.len());
    assert_eq!(deserialized_snapshot.asks.len(), snapshot.asks.len());
    assert_eq!(deserialized_snapshot.bids[0].price, snapshot.bids[0].price);
    assert_eq!(deserialized_snapshot.asks[0].size, snapshot.asks[0].size);
}

/// Test OrderBookUpdate with price level changes
#[test]
fn test_order_book_update_serialization() {
    let update = OrderBookUpdate {
        symbol: Symbol::from("META"),
        bid_changes: vec![
            PriceLevelChange {
                price: dec!(475.25),
                size: dec!(0), // Remove level
                change_type: PriceLevelChangeType::Delete,
                side: OrderBookSide::Bid,
            },
            PriceLevelChange {
                price: dec!(475.24),
                size: dec!(300),
                change_type: PriceLevelChangeType::Update,
                side: OrderBookSide::Bid,
            },
        ],
        ask_changes: vec![PriceLevelChange {
            price: dec!(475.26),
            size: dec!(250),
            change_type: PriceLevelChangeType::Add,
            side: OrderBookSide::Ask,
        }],
        exchange: "NASDAQ".to_string(),
        timestamp: Utc::now(),
        sequence: 13579,
    };

    let json = serde_json::to_string(&update);
    assert!(json.is_ok());

    let deserialized: Result<OrderBookUpdate, _> = serde_json::from_str(&json.unwrap());
    assert!(deserialized.is_ok());

    let deserialized_update = deserialized.unwrap();
    assert_eq!(deserialized_update.symbol, update.symbol);
    assert_eq!(
        deserialized_update.bid_changes.len(),
        update.bid_changes.len()
    );
    assert_eq!(
        deserialized_update.ask_changes.len(),
        update.ask_changes.len()
    );
    assert_eq!(
        deserialized_update.bid_changes[0].change_type,
        PriceLevelChangeType::Delete
    );
    assert_eq!(
        deserialized_update.ask_changes[0].change_type,
        PriceLevelChangeType::Add
    );
}

/// Test PriceLevelChangeType and OrderBookSide serialization
#[test]
fn test_price_level_change_types() {
    let change_types = vec![
        PriceLevelChangeType::Add,
        PriceLevelChangeType::Update,
        PriceLevelChangeType::Delete,
    ];

    for change_type in change_types {
        let json = serde_json::to_string(&change_type);
        assert!(json.is_ok());

        let deserialized: Result<PriceLevelChangeType, _> = serde_json::from_str(&json.unwrap());
        assert!(deserialized.is_ok());
        assert_eq!(deserialized.unwrap(), change_type);
    }

    let sides = vec![OrderBookSide::Bid, OrderBookSide::Ask];

    for side in sides {
        let json = serde_json::to_string(&side);
        assert!(json.is_ok());

        let deserialized: Result<OrderBookSide, _> = serde_json::from_str(&json.unwrap());
        assert!(deserialized.is_ok());
        assert_eq!(deserialized.unwrap(), side);
    }
}

/// Test AggregateEvent (OHLCV) serialization
#[test]
fn test_aggregate_event_serialization() {
    let now = Utc::now();
    let aggregate = AggregateEvent {
        symbol: Symbol::from("SPY"),
        open: dec!(425.00),
        high: dec!(425.75),
        low: dec!(424.50),
        close: dec!(425.25),
        volume: dec!(1_500_000),
        vwap: Some(dec!(425.12)),
        trade_count: Some(25000),
        start_timestamp: now - ChronoDuration::minutes(1),
        end_timestamp: now,
    };

    let json = serde_json::to_string(&aggregate);
    assert!(json.is_ok());

    let deserialized: Result<AggregateEvent, _> = serde_json::from_str(&json.unwrap());
    assert!(deserialized.is_ok());

    let deserialized_agg = deserialized.unwrap();
    assert_eq!(deserialized_agg.symbol, aggregate.symbol);
    assert_eq!(deserialized_agg.open, aggregate.open);
    assert_eq!(deserialized_agg.high, aggregate.high);
    assert_eq!(deserialized_agg.low, aggregate.low);
    assert_eq!(deserialized_agg.close, aggregate.close);
    assert_eq!(deserialized_agg.volume, aggregate.volume);
    assert_eq!(deserialized_agg.vwap, aggregate.vwap);
    assert_eq!(deserialized_agg.trade_count, aggregate.trade_count);
}

/// Test SentimentEvent serialization
#[test]
fn test_sentiment_event_serialization() {
    let sentiment = SentimentEvent {
        symbol: Symbol::from("AAPL"),
        sentiment_score: 0.65,
        bullish_ratio: 0.75,
        bearish_ratio: 0.25,
        sample_size: 1000,
        period: SentimentPeriod::Hourly,
        sources: vec!["twitter".to_string(), "reddit".to_string()],
        confidence: Some(0.85),
        timestamp: Utc::now(),
    };

    let json = serde_json::to_string(&sentiment);
    assert!(json.is_ok());

    let deserialized: Result<SentimentEvent, _> = serde_json::from_str(&json.unwrap());
    assert!(deserialized.is_ok());

    let deserialized_sentiment = deserialized.unwrap();
    assert_eq!(deserialized_sentiment.symbol, sentiment.symbol);
    assert_eq!(
        deserialized_sentiment.sentiment_score,
        sentiment.sentiment_score
    );
    assert_eq!(deserialized_sentiment.period, sentiment.period);
    assert_eq!(deserialized_sentiment.sources, sentiment.sources);
}

/// Test AnalystRatingEvent serialization
#[test]
fn test_analyst_rating_event_serialization() {
    let rating = AnalystRatingEvent {
        symbol: Symbol::from("GOOGL"),
        analyst: "Goldman Sachs".to_string(),
        firm: "Goldman Sachs".to_string(),
        action: RatingAction::Upgrade,
        current_rating: "Buy".to_string(),
        previous_rating: Some("Hold".to_string()),
        price_target: Some(dec!(180.00)),
        previous_price_target: Some(dec!(160.00)),
        comment: Some("Strong AI prospects".to_string()),
        rating_date: Utc::now(),
        timestamp: Utc::now(),
    };

    let json = serde_json::to_string(&rating);
    assert!(json.is_ok());

    let deserialized: Result<AnalystRatingEvent, _> = serde_json::from_str(&json.unwrap());
    assert!(deserialized.is_ok());

    let deserialized_rating = deserialized.unwrap();
    assert_eq!(deserialized_rating.symbol, rating.symbol);
    assert_eq!(deserialized_rating.action, rating.action);
    assert_eq!(deserialized_rating.price_target, rating.price_target);
}

/// Test ErrorCategory serialization
#[test]
fn test_error_category_serialization() {
    let categories = vec![
        ErrorCategory::Connection,
        ErrorCategory::Authentication,
        ErrorCategory::RateLimit,
        ErrorCategory::Parse,
        ErrorCategory::Subscription,
        ErrorCategory::Other,
    ];

    for category in categories {
        let json = serde_json::to_string(&category);
        assert!(json.is_ok());

        let deserialized: Result<ErrorCategory, _> = serde_json::from_str(&json.unwrap());
        assert!(deserialized.is_ok());
        assert_eq!(deserialized.unwrap(), category);
    }
}

/// Test MarketState serialization
#[test]
fn test_market_state_serialization() {
    let states = vec![
        MarketState::Open,
        MarketState::Closed,
        MarketState::PreMarket,
        MarketState::AfterMarket,
        MarketState::Holiday,
    ];

    for state in states {
        let json = serde_json::to_string(&state);
        assert!(json.is_ok());

        let deserialized: Result<MarketState, _> = serde_json::from_str(&json.unwrap());
        assert!(deserialized.is_ok());
        assert_eq!(deserialized.unwrap(), state);
    }
}

/// Test ErrorEvent serialization
#[test]
fn test_error_event_serialization() {
    let error = ErrorEvent {
        provider: "databento".to_string(),
        message: "Connection timeout".to_string(),
        code: Some("TIMEOUT".to_string()),
        category: ErrorCategory::Connection,
        recoverable: true,
        timestamp: Utc::now(),
    };

    let json = serde_json::to_string(&error);
    assert!(json.is_ok());

    let deserialized: Result<ErrorEvent, _> = serde_json::from_str(&json.unwrap());
    assert!(deserialized.is_ok());

    let deserialized_error = deserialized.unwrap();
    assert_eq!(deserialized_error.provider, error.provider);
    assert_eq!(deserialized_error.message, error.message);
    assert_eq!(deserialized_error.category, error.category);
    assert_eq!(deserialized_error.recoverable, error.recoverable);
}

/// Test MarketStatusEvent serialization
#[test]
fn test_market_status_event_serialization() {
    let market_status = MarketStatusEvent {
        market: "NYSE".to_string(),
        status: MarketState::Open,
        next_open: None,
        next_close: Some(Utc::now() + ChronoDuration::hours(6)),
        extended_hours: true,
        timestamp: Utc::now(),
    };

    let json = serde_json::to_string(&market_status);
    assert!(json.is_ok());

    let deserialized: Result<MarketStatusEvent, _> = serde_json::from_str(&json.unwrap());
    assert!(deserialized.is_ok());

    let deserialized_status = deserialized.unwrap();
    assert_eq!(deserialized_status.market, market_status.market);
    assert_eq!(deserialized_status.status, market_status.status);
    assert_eq!(
        deserialized_status.extended_hours,
        market_status.extended_hours
    );
}

/// Test complete MarketDataEvent serialization for all variants
#[test]
fn test_complete_market_data_event_serialization() {
    let events = vec![
        MarketDataEvent::Trade(TradeEvent {
            symbol: Symbol::from("TEST"),
            price: dec!(100.0),
            size: dec!(100),
            exchange: "TEST".to_string(),
            conditions: vec![],
            trade_id: None,
            timestamp: Utc::now(),
            sequence: 1,
        }),
        MarketDataEvent::Quote(QuoteEvent {
            symbol: Symbol::from("TEST"),
            bid: Some(dec!(99.99)),
            ask: Some(dec!(100.01)),
            bid_size: Some(dec!(100)),
            ask_size: Some(dec!(100)),
            bid_exchange: None,
            ask_exchange: None,
            conditions: vec![],
            timestamp: Utc::now(),
            sequence: 2,
        }),
        MarketDataEvent::OrderBookL2Snapshot(OrderBookSnapshot {
            symbol: Symbol::from("TEST"),
            bids: vec![],
            asks: vec![],
            exchange: "TEST".to_string(),
            timestamp: Utc::now(),
            sequence: 3,
        }),
        MarketDataEvent::Error(ErrorEvent {
            provider: "test".to_string(),
            message: "Test error".to_string(),
            code: None,
            category: ErrorCategory::Other,
            recoverable: true,
            timestamp: Utc::now(),
        }),
    ];

    for (i, event) in events.iter().enumerate() {
        let json = serde_json::to_string(event);
        assert!(json.is_ok(), "Failed to serialize event {}: {:?}", i, event);

        let deserialized: Result<MarketDataEvent, _> = serde_json::from_str(&json.unwrap());
        assert!(deserialized.is_ok(), "Failed to deserialize event {}", i);
    }
}

/// Test TimeRange creation and validation
#[test]
fn test_time_range_creation() {
    let start = Utc::now() - ChronoDuration::days(1);
    let end = Utc::now();

    let range = TimeRange { start, end };

    assert!(range.start < range.end);
    assert!(range.end > range.start);
}

/// Test Symbol serialization in events
#[test]
fn test_symbol_in_events() {
    let symbol = Symbol::from("COMPLEX.SYMBOL-123");

    let trade = TradeEvent {
        symbol: symbol.clone(),
        price: dec!(50.00),
        size: dec!(1000),
        exchange: "TEST".to_string(),
        conditions: vec![],
        trade_id: None,
        timestamp: Utc::now(),
        sequence: 1,
    };

    let json = serde_json::to_string(&trade);
    assert!(json.is_ok());

    let deserialized: Result<TradeEvent, _> = serde_json::from_str(&json.unwrap());
    assert!(deserialized.is_ok());
    assert_eq!(deserialized.unwrap().symbol, symbol);
}