foxhunt/ml/tests/agent47_multi_asset_portfolio_test.rs

//! Agent 47: Multi-Asset Portfolio Integration Tests (Tier 2)
//!
//! Test-driven development suite for multi-asset portfolio management:
//! - Multi-symbol position tracking
//! - Correlation-aware risk calculation (VaR)
//! - Transfer learning across symbols
//! - Portfolio-level metrics
//!
//! SUCCESS CRITERIA:
//! - ✅ All 15-18 tests passing
//! - ✅ 3 symbols managed simultaneously
//! - ✅ Correlation-aware risk working
//! - ✅ Transfer learning functional

use ml::dqn::action_space::{ExposureLevel, FactoredAction, OrderType, Urgency};
use ml::dqn::multi_asset::{MultiAssetPortfolioTracker, Symbol};
use ml::dqn::Experience;
use ndarray::Array2;
use rust_decimal::Decimal;
use std::collections::{HashMap, VecDeque};

// ==================== Test 1-3: Basic Multi-Symbol Tracking ====================

#[test]
fn test_multi_asset_initialization() {
    let symbols = vec![
        Symbol::new("ES_FUT"),
        Symbol::new("NQ_FUT"),
        Symbol::new("YM_FUT"),
    ];
    let initial_capital_per_symbol = Decimal::from(10_000);

    let tracker = MultiAssetPortfolioTracker::new(symbols.clone(), initial_capital_per_symbol);

    // Each symbol should have independent portfolio tracker
    assert_eq!(tracker.num_symbols(), 3);
    assert_eq!(tracker.symbols(), &symbols);

    // Check initial capital allocation
    for symbol in &symbols {
        let position = tracker.get_position(symbol).unwrap();
        assert_eq!(position.cash_balance(), 10_000.0);
        assert_eq!(position.current_position(), 0.0);
    }
}

#[test]
fn test_multi_asset_independent_positions() {
    let symbols = vec![Symbol::new("ES_FUT"), Symbol::new("NQ_FUT")];
    let mut tracker = MultiAssetPortfolioTracker::new(symbols.clone(), Decimal::from(10_000));

    // Trade ES_FUT: Long100
    let es_action = FactoredAction::new(ExposureLevel::Long100, OrderType::Market, Urgency::Normal);
    let es_price = 4500.0;
    let es_max_position = 10.0;
    tracker.execute_action(&Symbol::new("ES_FUT"), es_action, es_price, es_max_position);

    // Trade NQ_FUT: Short50
    let nq_action = FactoredAction::new(
        ExposureLevel::Short50,
        OrderType::LimitMaker,
        Urgency::Patient,
    );
    let nq_price = 15000.0;
    let nq_max_position = 5.0;
    tracker.execute_action(&Symbol::new("NQ_FUT"), nq_action, nq_price, nq_max_position);

    // Verify independent positions
    let es_pos = tracker.get_position(&Symbol::new("ES_FUT")).unwrap();
    assert_eq!(es_pos.current_position(), 10.0); // Long100 = +1.0 * 10.0

    let nq_pos = tracker.get_position(&Symbol::new("NQ_FUT")).unwrap();
    assert_eq!(nq_pos.current_position(), -2.5); // Short50 = -0.5 * 5.0
}

#[test]
fn test_multi_asset_total_portfolio_value() {
    let symbols = vec![Symbol::new("ES_FUT"), Symbol::new("NQ_FUT")];
    let mut tracker = MultiAssetPortfolioTracker::new(symbols.clone(), Decimal::from(10_000));

    // ES_FUT: Long 10 contracts at 4500.0
    let es_action = FactoredAction::new(ExposureLevel::Long100, OrderType::Market, Urgency::Normal);
    tracker.execute_action(&Symbol::new("ES_FUT"), es_action, 4500.0, 10.0);

    // NQ_FUT: Short 2.5 contracts at 15000.0
    let nq_action = FactoredAction::new(
        ExposureLevel::Short50,
        OrderType::LimitMaker,
        Urgency::Patient,
    );
    tracker.execute_action(&Symbol::new("NQ_FUT"), nq_action, 15000.0, 5.0);

    // Calculate total portfolio value
    let prices = HashMap::from([
        (Symbol::new("ES_FUT"), 4600.0),  // +100 per contract
        (Symbol::new("NQ_FUT"), 14800.0), // +200 per contract (short profits from price drop)
    ]);

    let total_value = tracker.total_portfolio_value(&prices);

    // ES_FUT: 10_000 - (10 * 4500) + (10 * 4600) = 10_000 - 45000 + 46000 = 11_000
    // NQ_FUT: 10_000 + (2.5 * 15000) - (2.5 * 14800) = 10_000 + 37500 - 37000 = 10_500
    // Total: 11_000 + 10_500 = 21_500
    assert!((total_value - 21_500.0).abs() < 100.0); // Allow small transaction cost variance
}

// ==================== Test 4-6: Correlation-Aware Risk (VaR) ====================

#[test]
fn test_correlation_matrix_initialization() {
    let symbols = vec![Symbol::new("ES_FUT"), Symbol::new("NQ_FUT")];
    let tracker = MultiAssetPortfolioTracker::new(symbols, Decimal::from(10_000));

    // Default correlation matrix should be identity (uncorrelated)
    let corr_matrix = tracker.correlation_matrix();
    assert_eq!(corr_matrix[[0, 0]], 1.0); // ES with ES = 1.0
    assert_eq!(corr_matrix[[1, 1]], 1.0); // NQ with NQ = 1.0
    assert_eq!(corr_matrix[[0, 1]], 0.0); // ES with NQ = 0.0 (default uncorrelated)
    assert_eq!(corr_matrix[[1, 0]], 0.0); // NQ with ES = 0.0 (symmetric)
}

#[test]
fn test_correlation_matrix_update() {
    let symbols = vec![Symbol::new("ES_FUT"), Symbol::new("NQ_FUT")];
    let mut tracker = MultiAssetPortfolioTracker::new(symbols, Decimal::from(10_000));

    // Set positive correlation between ES and NQ (0.85)
    let mut corr_matrix = Array2::eye(2);
    corr_matrix[[0, 1]] = 0.85;
    corr_matrix[[1, 0]] = 0.85;

    tracker.set_correlation_matrix(corr_matrix);

    // Verify update
    let updated_matrix = tracker.correlation_matrix();
    assert_eq!(updated_matrix[[0, 1]], 0.85);
    assert_eq!(updated_matrix[[1, 0]], 0.85);
}

#[test]
fn test_portfolio_var_calculation() {
    let symbols = vec![Symbol::new("ES_FUT"), Symbol::new("NQ_FUT")];
    let mut tracker = MultiAssetPortfolioTracker::new(symbols.clone(), Decimal::from(10_000));

    // Set correlation: ES and NQ highly correlated (0.80)
    let mut corr_matrix = Array2::eye(2);
    corr_matrix[[0, 1]] = 0.80;
    corr_matrix[[1, 0]] = 0.80;
    tracker.set_correlation_matrix(corr_matrix);

    // ES_FUT: Long 10 contracts at 4500.0
    let es_action = FactoredAction::new(ExposureLevel::Long100, OrderType::Market, Urgency::Normal);
    tracker.execute_action(&Symbol::new("ES_FUT"), es_action, 4500.0, 10.0);

    // NQ_FUT: Long 5 contracts at 15000.0 (same direction = higher VaR due to correlation)
    let nq_action = FactoredAction::new(ExposureLevel::Long100, OrderType::Market, Urgency::Normal);
    tracker.execute_action(&Symbol::new("NQ_FUT"), nq_action, 15000.0, 5.0);

    let prices = HashMap::from([
        (Symbol::new("ES_FUT"), 4500.0),
        (Symbol::new("NQ_FUT"), 15000.0),
    ]);

    let var = tracker.calculate_portfolio_var(&prices);

    // VaR should be > 0 and increase with correlation
    assert!(var > 0.0);

    // Test correlation impact: uncorrelated portfolios have lower VaR
    let mut uncorr_tracker = MultiAssetPortfolioTracker::new(symbols.clone(), Decimal::from(10_000));
    uncorr_tracker.execute_action(&Symbol::new("ES_FUT"), es_action, 4500.0, 10.0);
    uncorr_tracker.execute_action(&Symbol::new("NQ_FUT"), nq_action, 15000.0, 5.0);
    let uncorr_var = uncorr_tracker.calculate_portfolio_var(&prices);

    assert!(
        var > uncorr_var,
        "Correlated portfolio should have higher VaR: {} vs {}",
        var,
        uncorr_var
    );
}

// ==================== Test 7-9: Multi-Symbol DQN Integration ====================

#[test]
fn test_multi_symbol_state_representation() {
    // State should include ALL symbols' features
    // [market_features_128, portfolio_features_sym1_3, portfolio_features_sym2_3, ...]
    // For 3 symbols: 128 + 3*3 = 137 features

    let symbols = vec![
        Symbol::new("ES_FUT"),
        Symbol::new("NQ_FUT"),
        Symbol::new("YM_FUT"),
    ];
    let tracker = MultiAssetPortfolioTracker::new(symbols.clone(), Decimal::from(10_000));

    let market_features = vec![0.0; 128]; // Placeholder for 128 market features
    let prices = HashMap::from([
        (Symbol::new("ES_FUT"), 4500.0),
        (Symbol::new("NQ_FUT"), 15000.0),
        (Symbol::new("YM_FUT"), 35000.0),
    ]);

    let state_vector = tracker.build_state_vector(&market_features, &prices);

    // Verify state dimension: 128 market + 3*3 portfolio = 137
    assert_eq!(state_vector.len(), 137);

    // First 128 are market features (all zeros in this test)
    for i in 0..128 {
        assert_eq!(state_vector[i], 0.0);
    }

    // Next 9 are portfolio features (3 per symbol)
    // Each symbol: [normalized_value, normalized_position, spread]
    assert_eq!(state_vector[128], 1.0); // ES normalized value = 10000/10000 = 1.0
    assert_eq!(state_vector[129], 0.0); // ES normalized position = 0.0
    assert!((state_vector[130] - 0.0001).abs() < 1e-6); // ES spread (float precision)

    assert_eq!(state_vector[131], 1.0); // NQ normalized value
    assert_eq!(state_vector[132], 0.0); // NQ normalized position
    assert!((state_vector[133] - 0.0001).abs() < 1e-6); // NQ spread (float precision)

    assert_eq!(state_vector[134], 1.0); // YM normalized value
    assert_eq!(state_vector[135], 0.0); // YM normalized position
    assert!((state_vector[136] - 0.0001).abs() < 1e-6); // YM spread (float precision)
}

#[test]
fn test_symbol_selection_rotation() {
    let symbols = vec![
        Symbol::new("ES_FUT"),
        Symbol::new("NQ_FUT"),
        Symbol::new("YM_FUT"),
    ];
    let mut tracker = MultiAssetPortfolioTracker::new(symbols.clone(), Decimal::from(10_000));

    // Set opportunity scores (e.g., based on volatility or momentum)
    let opportunity_scores = HashMap::from([
        (Symbol::new("ES_FUT"), 0.5),
        (Symbol::new("NQ_FUT"), 0.8),  // Highest opportunity
        (Symbol::new("YM_FUT"), 0.3),
    ]);

    tracker.set_opportunity_scores(opportunity_scores);

    // Select active symbol (should be NQ_FUT)
    let active_symbol = tracker.select_active_symbol();
    assert_eq!(active_symbol, Symbol::new("NQ_FUT"));
}

#[test]
fn test_multi_symbol_epoch_reset() {
    let symbols = vec![Symbol::new("ES_FUT"), Symbol::new("NQ_FUT")];
    let mut tracker = MultiAssetPortfolioTracker::new(symbols.clone(), Decimal::from(10_000));

    // Execute trades on both symbols
    let action = FactoredAction::new(ExposureLevel::Long100, OrderType::Market, Urgency::Normal);
    tracker.execute_action(&Symbol::new("ES_FUT"), action, 4500.0, 10.0);
    tracker.execute_action(&Symbol::new("NQ_FUT"), action, 15000.0, 5.0);

    // Verify positions are non-zero
    assert!(tracker.get_position(&Symbol::new("ES_FUT")).unwrap().current_position() != 0.0);
    assert!(tracker.get_position(&Symbol::new("NQ_FUT")).unwrap().current_position() != 0.0);

    // Reset all portfolios
    tracker.reset_all();

    // Verify all positions are flat
    for symbol in &symbols {
        let position = tracker.get_position(symbol).unwrap();
        assert_eq!(position.current_position(), 0.0);
        assert_eq!(position.cash_balance(), 10_000.0);
    }
}

// ==================== Test 10-12: Transfer Learning ====================

#[test]
fn test_shared_q_network_initialization() {
    // Transfer learning: Same Q-network weights used across all symbols
    // Different symbols = different state inputs, but same learned patterns

    use ml::dqn::dqn::{WorkingDQN, WorkingDQNConfig};
    use candle_core::Tensor;

    let config = WorkingDQNConfig {
        state_dim: 137, // 128 market + 9 portfolio (3 symbols * 3 features)
        num_actions: 45,
        hidden_dims: vec![256, 128],
        learning_rate: 0.0001,
        gamma: 0.99,
        epsilon_start: 1.0,
        epsilon_end: 0.05,
        epsilon_decay: 0.995,
        replay_buffer_capacity: 100_000,
        batch_size: 64,
        min_replay_size: 1000,
        target_update_freq: 1000,
        use_double_dqn: true,
        use_huber_loss: true,
        huber_delta: 1.0,
        leaky_relu_alpha: 0.01,
        gradient_clip_norm: 10.0,
        tau: 0.001,
        use_soft_updates: true,
        warmup_steps: 80_000,
        temperature_start: 1.0,
        temperature_decay: 0.99,
    };

    let dqn = WorkingDQN::new(config).unwrap();

    // Verify network can handle multi-symbol state
    let device = candle_core::Device::Cpu;
    let state_vec = vec![0.0f32; 137];
    // Need batch dimension: [1, 137] instead of [137]
    let state = Tensor::from_vec(state_vec, (1, 137), &device).unwrap();
    let q_values = dqn.forward(&state).unwrap();

    // Q-values should be a tensor with shape [1, 45] (batch_size=1, 45 actions)
    assert_eq!(q_values.dims(), &[1, 45]);
}

#[test]
fn test_cross_symbol_experience_sharing() {
    // Experiences from different symbols should populate the same replay buffer
    // This enables transfer learning (patterns learned on ES_FUT help NQ_FUT)

    let mut replay_buffer: VecDeque<Experience> = VecDeque::with_capacity(1000);

    // ES_FUT experience
    let es_state = vec![0.0f32; 137]; // 137-dim state
    let es_action = 0u8;
    let es_reward = 150i32; // Scaled to fixed-point (1.5 * 100)
    let es_next_state = vec![0.1f32; 137];
    let es_done = false;

    let es_experience = Experience {
        state: es_state.clone(),
        action: es_action,
        reward: es_reward,
        next_state: es_next_state.clone(),
        done: es_done,
        timestamp: 0,
    };

    // NQ_FUT experience
    let nq_state = vec![0.2f32; 137];
    let nq_action = 10u8;
    let nq_reward = 200i32; // Scaled to fixed-point (2.0 * 100)
    let nq_next_state = vec![0.3f32; 137];
    let nq_done = false;

    let nq_experience = Experience {
        state: nq_state.clone(),
        action: nq_action,
        reward: nq_reward,
        next_state: nq_next_state.clone(),
        done: nq_done,
        timestamp: 1,
    };

    // Add both to shared buffer
    replay_buffer.push_back(es_experience);
    replay_buffer.push_back(nq_experience);

    // Verify both experiences are in buffer
    assert_eq!(replay_buffer.len(), 2);

    // Sample batch should include experiences from both symbols
    let batch: Vec<_> = replay_buffer.iter().take(2).collect();
    assert_eq!(batch.len(), 2);
}

#[test]
fn test_transfer_learning_convergence() {
    // Test that training on ES_FUT improves performance on NQ_FUT
    // (without training directly on NQ_FUT data)

    // This test verifies the CONCEPT of transfer learning
    // In practice, we'd measure Q-value quality or P&L on untrained symbols

    use ml::dqn::dqn::{WorkingDQN, WorkingDQNConfig};
    use candle_core::Tensor;

    let config = WorkingDQNConfig {
        state_dim: 137,
        num_actions: 45,
        hidden_dims: vec![128, 64],
        learning_rate: 0.001,
        gamma: 0.99,
        epsilon_start: 1.0,
        epsilon_end: 0.05,
        epsilon_decay: 0.995,
        replay_buffer_capacity: 10_000,
        batch_size: 32,
        min_replay_size: 100,
        target_update_freq: 100,
        use_double_dqn: true,
        use_huber_loss: true,
        huber_delta: 1.0,
        leaky_relu_alpha: 0.01,
        gradient_clip_norm: 10.0,
        tau: 0.001,
        use_soft_updates: true,
        warmup_steps: 1000,
        temperature_start: 1.0,
        temperature_decay: 0.99,
    };

    let dqn = WorkingDQN::new(config).unwrap();

    // ES_FUT state (symbol ID embedded in state)
    let device = candle_core::Device::Cpu;
    let es_state_vec = vec![1.0f32; 137]; // All features = 1.0 for ES
    // Need batch dimension: [1, 137] instead of [137]
    let es_state = Tensor::from_vec(es_state_vec, (1, 137), &device).unwrap();
    let es_q_values_before = dqn.forward(&es_state).unwrap();

    // NQ_FUT state (different features)
    let nq_state_vec = vec![0.5f32; 137]; // All features = 0.5 for NQ
    let nq_state = Tensor::from_vec(nq_state_vec, (1, 137), &device).unwrap();
    let nq_q_values_before = dqn.forward(&nq_state).unwrap();

    // Verify Q-values are different for different symbols (sanity check)
    // We can't directly compare Tensors, so check shapes instead
    assert_eq!(es_q_values_before.dims(), &[1, 45]);
    assert_eq!(nq_q_values_before.dims(), &[1, 45]);

    // After training on ES_FUT (simulated), Q-values should change for BOTH symbols
    // This is because they share the same network weights
    // (In real test, we'd actually train the network)

    // For now, just verify the network CAN process both symbol states
    // Network accepts different inputs and produces valid output shapes
}

// ==================== Test 13-15: Risk Management Integration ====================

#[test]
fn test_position_limit_per_symbol() {
    let symbols = vec![Symbol::new("ES_FUT"), Symbol::new("NQ_FUT")];
    let mut tracker = MultiAssetPortfolioTracker::new(symbols.clone(), Decimal::from(10_000));

    // Set different position limits per symbol
    tracker.set_max_position(&Symbol::new("ES_FUT"), 20.0);
    tracker.set_max_position(&Symbol::new("NQ_FUT"), 10.0);

    // Try to exceed ES_FUT limit (Long100 = +1.0 * max_position)
    let action = FactoredAction::new(ExposureLevel::Long100, OrderType::Market, Urgency::Normal);
    tracker.execute_action(&Symbol::new("ES_FUT"), action, 4500.0, 25.0); // Request 25, limit is 20

    // Position should be clamped to 20.0
    let es_pos = tracker.get_position(&Symbol::new("ES_FUT")).unwrap();
    assert!(es_pos.current_position().abs() <= 20.0);
}

#[test]
fn test_cash_reserve_enforcement_multi_symbol() {
    let symbols = vec![Symbol::new("ES_FUT"), Symbol::new("NQ_FUT")];
    let mut tracker = MultiAssetPortfolioTracker::with_cash_reserve(
        symbols.clone(),
        Decimal::from(10_000),
        10.0, // 10% cash reserve
    );

    // ES_FUT: Try to use all cash (should be rejected)
    let action = FactoredAction::new(ExposureLevel::Long100, OrderType::Market, Urgency::Normal);
    tracker.execute_action(&Symbol::new("ES_FUT"), action, 4500.0, 10.0); // 10 * 4500 = 45,000

    // Should have maintained 10% cash reserve
    let total_cash = tracker
        .symbols()
        .iter()
        .map(|sym| tracker.get_position(sym).unwrap().cash_balance())
        .sum::<f32>();

    let total_value = tracker.total_portfolio_value(&HashMap::from([
        (Symbol::new("ES_FUT"), 4500.0),
        (Symbol::new("NQ_FUT"), 0.0),
    ]));

    assert!(total_cash as f64 >= total_value * 0.10); // At least 10% reserve
}

#[test]
fn test_transaction_costs_multi_symbol() {
    let symbols = vec![Symbol::new("ES_FUT"), Symbol::new("NQ_FUT")];
    let mut tracker = MultiAssetPortfolioTracker::new(symbols.clone(), Decimal::from(10_000));

    // ES_FUT: Market order (0.15% fee)
    let es_action = FactoredAction::new(ExposureLevel::Long100, OrderType::Market, Urgency::Normal);
    tracker.execute_action(&Symbol::new("ES_FUT"), es_action, 4500.0, 10.0);

    // NQ_FUT: LimitMaker order (0.05% rebate)
    let nq_action = FactoredAction::new(
        ExposureLevel::Long100,
        OrderType::LimitMaker,
        Urgency::Patient,
    );
    tracker.execute_action(&Symbol::new("NQ_FUT"), nq_action, 15000.0, 5.0);

    // Verify transaction costs are tracked per symbol
    let es_costs = tracker.get_position(&Symbol::new("ES_FUT")).unwrap().transaction_costs();
    let nq_costs = tracker.get_position(&Symbol::new("NQ_FUT")).unwrap().transaction_costs();

    // ES: 10 * 4500 * 0.0015 = 67.5
    assert!((es_costs - 67.5).abs() < 1.0);

    // NQ: 5 * 15000 * 0.0005 = 37.5
    assert!((nq_costs - 37.5).abs() < 1.0);

    // Total transaction costs
    let total_costs = tracker.total_transaction_costs();
    assert!((total_costs - (67.5 + 37.5)).abs() < 2.0);
}

// ==================== Test 16-18: Advanced Portfolio Analytics ====================

#[test]
fn test_portfolio_sharpe_ratio() {
    let symbols = vec![Symbol::new("ES_FUT"), Symbol::new("NQ_FUT")];
    let mut tracker = MultiAssetPortfolioTracker::new(symbols.clone(), Decimal::from(10_000));

    // Simulate 10 steps of trading
    let es_prices = vec![4500.0, 4520.0, 4510.0, 4530.0, 4550.0, 4540.0, 4560.0, 4580.0, 4570.0, 4590.0];
    let nq_prices = vec![15000.0, 15050.0, 15030.0, 15080.0, 15100.0, 15090.0, 15120.0, 15150.0, 15140.0, 15170.0];

    let action = FactoredAction::new(ExposureLevel::Long50, OrderType::Market, Urgency::Normal);

    for (es_price, nq_price) in es_prices.iter().zip(nq_prices.iter()) {
        tracker.execute_action(&Symbol::new("ES_FUT"), action, *es_price, 10.0);
        tracker.execute_action(&Symbol::new("NQ_FUT"), action, *nq_price, 5.0);

        // Track portfolio value over time
        let prices = HashMap::from([
            (Symbol::new("ES_FUT"), *es_price),
            (Symbol::new("NQ_FUT"), *nq_price),
        ]);
        tracker.record_portfolio_value(&prices);
    }

    // Calculate Sharpe ratio (requires at least 2 observations)
    let sharpe = tracker.calculate_sharpe_ratio(0.0); // Risk-free rate = 0
    assert!(sharpe.is_finite());
}

#[test]
fn test_portfolio_drawdown() {
    let symbols = vec![Symbol::new("ES_FUT")];
    let mut tracker = MultiAssetPortfolioTracker::new(symbols.clone(), Decimal::from(10_000));

    // Simulate drawdown scenario
    let prices = vec![4500.0, 4600.0, 4550.0, 4400.0, 4500.0]; // Peak at 4600, trough at 4400
    let action = FactoredAction::new(ExposureLevel::Long100, OrderType::Market, Urgency::Normal);

    for price in prices {
        tracker.execute_action(&Symbol::new("ES_FUT"), action, price, 10.0);
        let price_map = HashMap::from([(Symbol::new("ES_FUT"), price)]);
        tracker.record_portfolio_value(&price_map);
    }

    // Calculate max drawdown
    let max_drawdown = tracker.calculate_max_drawdown();

    // Drawdown = (Peak - Trough) / Peak = (4600 - 4400) / 4600 = 0.0435 = 4.35%
    assert!(max_drawdown > 0.0);
    assert!(max_drawdown < 0.10); // Should be < 10%
}

#[test]
fn test_portfolio_win_rate() {
    let symbols = vec![Symbol::new("ES_FUT")];
    let mut tracker = MultiAssetPortfolioTracker::new(symbols.clone(), Decimal::from(10_000));

    // Simulate 5 trades: 3 wins, 2 losses
    let trade_pnls = vec![100.0, -50.0, 200.0, -30.0, 150.0]; // 3 wins, 2 losses

    for pnl in trade_pnls {
        tracker.record_trade_pnl(pnl);
    }

    let win_rate = tracker.calculate_win_rate();
    assert_eq!(win_rate, 0.6); // 3/5 = 60%
}