foxhunt/ml/tests/bug21_bug22_bug23_compilation_fixes_test.rs

//! Regression tests for Bugs #21, #22, #23 - Compilation Error Prevention
//!
//! These tests ensure that:
//! 1. Bug #21: Decimal conversion fallback returns Decimal, not ()
//! 2. Bug #22: PortfolioTracker has high_water_mark() method if needed
//! 3. Bug #23: unrealized_pnl() is always called with current_price argument
//!
//! Status: All bugs already fixed in codebase (2025-11-14)
//! Purpose: Regression prevention for future refactoring

use ml::dqn::portfolio_tracker::PortfolioTracker;

/// Test 1: Bug #21 - Decimal conversion fallback returns previous value (Decimal), not ()
///
/// This test verifies that Decimal conversion fallback logic compiles correctly.
/// The actual implementation is in ml/src/dqn/risk_integration.rs (internal module).
///
/// Bug #21 (ALREADY FIXED):
/// - Location: ml/src/dqn/risk_integration.rs:48-52
/// - Issue: unwrap_or_else() closure must return Decimal, not ()
/// - Fix: Returns *self.portfolio_value.blocking_read() (Decimal)
///
/// NOTE: risk_integration module is internal and not exported, so we test the pattern
/// through PortfolioTracker which uses similar conversion patterns.
#[test]
fn test_decimal_conversion_pattern_compiles() {
    use rust_decimal::Decimal;

    // Test the Decimal conversion pattern that Bug #21 refers to
    let test_value = 100_000.0;
    let previous_value = Decimal::new(95_000, 0);

    // This is the pattern that Bug #21 fixed:
    // unwrap_or_else() must return Decimal, not ()
    let value_decimal = Decimal::try_from(test_value).unwrap_or_else(|_| {
        // CORRECT: Returns Decimal (previous value)
        previous_value
    });

    assert_eq!(value_decimal, Decimal::new(100_000, 0));

    // Test with NaN (should fall back to previous value)
    let nan_value = f64::NAN;
    let fallback_decimal = Decimal::try_from(nan_value).unwrap_or_else(|_| {
        // CORRECT: Returns Decimal (previous value), not ()
        previous_value
    });

    assert_eq!(fallback_decimal, Decimal::new(95_000, 0));

    println!("✅ Bug #21 Prevention: Decimal conversion fallback compiles correctly");
}

/// Test 2: Bug #22 - PortfolioTracker high_water_mark() method exists (if needed)
///
/// This test verifies that PortfolioTracker has all necessary accessor methods
/// for portfolio metrics including high_water_mark() if required.
///
/// Bug #22 (DOESN'T EXIST):
/// - Location: ml/src/trainers/dqn.rs:1091 (claimed)
/// - Issue: Method not found on PortfolioTracker
/// - Status: high_water_mark() is never called in codebase
/// - Purpose: This test documents that the method isn't needed
#[test]
fn test_portfolio_tracker_accessor_methods() {
    let tracker = PortfolioTracker::new(100_000.0, 0.0001, 0.0);

    // Verify existing accessor methods work
    let cash = tracker.cash_balance();
    assert_eq!(cash, 100_000.0);

    let position = tracker.current_position();
    assert_eq!(position, 0.0);

    let total = tracker.total_value(5000.0);
    assert_eq!(total, 100_000.0);

    let entry_price = tracker.average_entry_price();
    assert_eq!(entry_price, 0.0);

    let realized = tracker.realized_pnl();
    assert_eq!(realized, 0.0);

    let unrealized = tracker.unrealized_pnl(5000.0);  // ✅ Takes current_price argument
    assert_eq!(unrealized, 0.0);

    let tx_costs = tracker.transaction_costs();
    assert_eq!(tx_costs, 0.0);

    // NOTE: high_water_mark() method is NOT needed in current codebase
    // If it's added in the future, this test should be updated to verify it

    println!("✅ Bug #22 Prevention: All PortfolioTracker accessor methods work");
}

/// Test 3: Bug #23 - unrealized_pnl() accepts current_price argument
///
/// This test verifies that PortfolioTracker::unrealized_pnl() correctly requires
/// and uses the current_price argument for accurate P&L calculations.
///
/// Bug #23 (DOESN'T EXIST):
/// - Location: ml/src/trainers/dqn.rs:1098, 1100 (claimed)
/// - Issue: unrealized_pnl() called without current_price argument
/// - Status: Method signature requires current_price: f32
/// - Purpose: Verify correct usage pattern
#[test]
fn test_unrealized_pnl_with_current_price() {
    let mut tracker = PortfolioTracker::new(100_000.0, 0.0001, 0.0);

    // Open a long position at $5000
    use ml::dqn::action_space::{FactoredAction, ExposureLevel, OrderType, Urgency};
    let action = FactoredAction::new(ExposureLevel::Long100, OrderType::Market, Urgency::Normal);
    tracker.execute_action(action, 5000.0, 10.0);  // 10 contracts at $5000

    // Verify position opened
    assert_eq!(tracker.current_position(), 10.0);

    // Calculate unrealized P&L at different prices
    let pnl_at_entry = tracker.unrealized_pnl(5000.0);  // ✅ Must pass current_price
    assert!((pnl_at_entry - 0.0).abs() < 100.0);  // Near zero at entry price (minus tx costs)

    let pnl_at_5100 = tracker.unrealized_pnl(5100.0);  // ✅ Must pass current_price
    assert!(pnl_at_5100 > 0.0, "Price increase should generate profit");

    let pnl_at_4900 = tracker.unrealized_pnl(4900.0);  // ✅ Must pass current_price
    assert!(pnl_at_4900 < 0.0, "Price decrease should generate loss");

    // Verify P&L calculations are reasonable
    // Position: 10 contracts, Price change: +$100 = +$1000 profit (minus tx costs)
    assert!((pnl_at_5100 - 1000.0).abs() < 100.0, "Expected ~$1000 profit at $5100");

    // Position: 10 contracts, Price change: -$100 = -$1000 loss (minus tx costs)
    assert!((pnl_at_4900 + 1000.0).abs() < 100.0, "Expected ~$1000 loss at $4900");

    println!("✅ Bug #23 Prevention: unrealized_pnl() requires current_price argument");
}

/// Test 4: Comprehensive portfolio tracker integration test
///
/// This test verifies that all portfolio tracking methods work correctly together,
/// ensuring that any future refactoring won't break the core functionality.
#[test]
fn test_portfolio_tracker_comprehensive_integration() {
    let mut tracker = PortfolioTracker::new(100_000.0, 0.0001, 0.0);

    use ml::dqn::action_space::{FactoredAction, ExposureLevel, OrderType, Urgency};

    // Test 1: Open long position
    let long_action = FactoredAction::new(ExposureLevel::Long50, OrderType::LimitMaker, Urgency::Normal);
    tracker.execute_action(long_action, 5000.0, 10.0);  // 5 contracts (50% of 10 max)

    assert_eq!(tracker.current_position(), 5.0);
    let unrealized_5000 = tracker.unrealized_pnl(5000.0);  // ✅ Current price required
    assert!(unrealized_5000.abs() < 50.0);  // Near zero (minus small tx costs)

    // Test 2: Price moves up - check unrealized P&L
    let unrealized_5200 = tracker.unrealized_pnl(5200.0);  // ✅ Current price required
    assert!(unrealized_5200 > 0.0, "Should have unrealized profit");

    // Test 3: Close position - check realized P&L
    let flat_action = FactoredAction::new(ExposureLevel::Flat, OrderType::Market, Urgency::Aggressive);
    tracker.execute_action(flat_action, 5200.0, 10.0);

    assert_eq!(tracker.current_position(), 0.0);
    let realized = tracker.realized_pnl();
    assert!(realized > 0.0, "Should have realized profit after closing winning position");

    // Test 4: All accessor methods return valid values
    assert!(tracker.cash_balance().is_finite());
    assert_eq!(tracker.current_position(), 0.0);
    assert!(tracker.total_value(5200.0).is_finite());
    assert_eq!(tracker.average_entry_price(), 0.0);  // No position
    assert!(tracker.realized_pnl().is_finite());

    // Unrealized P&L when flat should be close to zero (may have small rounding)
    let unrealized = tracker.unrealized_pnl(5200.0);  // ✅ No position = no unrealized P&L
    assert!(unrealized.abs() < 1000.0, "Unrealized P&L should be near zero when flat, got: {}", unrealized);

    assert!(tracker.transaction_costs() > 0.0);  // Should have incurred tx costs

    println!("✅ Comprehensive Integration: All portfolio tracking methods work correctly");
}

/// Test 5: Rust_decimal conversion edge cases
///
/// This test verifies that Decimal::try_from() handles edge cases correctly,
/// which is relevant to Bug #21's context (conversion fallback logic).
#[test]
fn test_decimal_conversion_edge_cases() {
    use rust_decimal::Decimal;

    // Test normal values
    let normal = 100_000.0;
    assert!(Decimal::try_from(normal).is_ok());

    // Test zero
    let zero = 0.0;
    assert_eq!(Decimal::try_from(zero).unwrap(), Decimal::ZERO);

    // Test negative
    let negative = -5000.0;
    assert!(Decimal::try_from(negative).is_ok());

    // Test very large value
    let large = 1_000_000_000.0;
    assert!(Decimal::try_from(large).is_ok());

    // Test NaN (should fail)
    let nan = f64::NAN;
    assert!(Decimal::try_from(nan).is_err(), "NaN should fail conversion");

    // Test infinity (should fail)
    let inf = f64::INFINITY;
    assert!(Decimal::try_from(inf).is_err(), "Infinity should fail conversion");

    // Test negative infinity (should fail)
    let neg_inf = f64::NEG_INFINITY;
    assert!(Decimal::try_from(neg_inf).is_err(), "Negative infinity should fail conversion");

    println!("✅ Bug #21 Context: Decimal edge cases handled correctly");
}