foxhunt/ml/tests/partial_reversal_validation.rs

//! Simple validation test for partial reversal support (Wave 16 P2-C)
//!
//! This test suite uses the CORRECT PortfolioTracker API to validate
//! the two-phase reversal logic implementation.

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

#[test]
fn test_full_reversal_sufficient_cash() {
    // Test 1: Full reversal with ample cash (baseline)
    let mut tracker = PortfolioTracker::new(20_000.0, 0.0001, 0.0);
    let price = 5_600.0;

    // Step 1: Open short position (-1.0)
    let short_action = FactoredAction::new(ExposureLevel::Short100, OrderType::Market, Urgency::Normal);
    tracker.execute_action(short_action, price, 1.0);

    assert_eq!(tracker.current_position(), -1.0, "Should have -1.0 short position");

    // Step 2: Reverse to long (+1.0) with sufficient cash
    let long_action = FactoredAction::new(ExposureLevel::Long100, OrderType::Market, Urgency::Normal);
    tracker.execute_action(long_action, price, 1.0);

    assert_eq!(tracker.current_position(), 1.0, "Should complete full reversal to +1.0 long");
    assert!(tracker.cash_balance() > 0.0, "Should have positive cash remaining");
}

#[test]
fn test_partial_reversal_limited_cash() {
    // Test 2: Partial reversal when cash is limited
    let mut tracker = PortfolioTracker::new(10_000.0, 0.0001, 0.0);
    let price = 5_600.0;

    // Step 1: Open short position (-1.0)
    let short_action = FactoredAction::new(ExposureLevel::Short100, OrderType::Market, Urgency::Normal);
    tracker.execute_action(short_action, price, 1.0);

    let cash_before_reversal = tracker.cash_balance();
    println!("Cash before reversal: ${:.2}", cash_before_reversal);

    // Step 2: Attempt full reversal to long (+1.0)
    // With limited cash, should achieve partial reversal
    let long_action = FactoredAction::new(ExposureLevel::Long100, OrderType::Market, Urgency::Normal);
    tracker.execute_action(long_action, price, 1.0);

    let final_position = tracker.current_position();
    let final_cash = tracker.cash_balance();

    println!("Final position: {:.4}, Final cash: ${:.2}", final_position, final_cash);

    // Assertions:
    // 1. Position should be >= 0 (closed short, opened some long)
    assert!(final_position >= 0.0, "Position should be non-negative after reversal");

    // 2. Position should be < 1.0 (partial fill due to cash constraint)
    assert!(final_position < 1.0, "Position should be partial (< 1.0) due to limited cash");

    // 3. Cash should be low but >= 0
    assert!(final_cash >= 0.0, "Cash should never go negative");
}

#[test]
fn test_reversal_to_flat_only() {
    // Test 3: Reversal with only enough cash for Phase 1 (close position)
    // Result: Should end at flat (0.0) position
    let mut tracker = PortfolioTracker::new(7_000.0, 0.0001, 0.0);
    let price = 5_600.0;

    // Step 1: Open long position (+1.0)
    let long_action = FactoredAction::new(ExposureLevel::Long100, OrderType::Market, Urgency::Normal);
    tracker.execute_action(long_action, price, 1.0);

    let cash_after_long = tracker.cash_balance();
    println!("Cash after opening long: ${:.2}", cash_after_long);

    // Step 2: Attempt reversal to short (-1.0)
    // With very limited cash, should only close long (Phase 1), not open short (Phase 2)
    let short_action = FactoredAction::new(ExposureLevel::Short100, OrderType::Market, Urgency::Normal);
    tracker.execute_action(short_action, price, 1.0);

    let final_position = tracker.current_position();
    let final_cash = tracker.cash_balance();

    println!("Final position: {:.4}, Final cash: ${:.2}", final_position, final_cash);

    // Assertion: Should end at flat (0.0) or very small short position
    // Depending on cash, might have 0.0 or small partial short
    assert!(final_position >= -0.1, "Position should be near flat or small short");
    assert!(final_cash >= 0.0, "Cash should never go negative");
}

#[test]
fn test_transaction_costs_tracked() {
    // Test 4: Verify transaction costs are tracked during reversal
    let mut tracker = PortfolioTracker::new(20_000.0, 0.0001, 0.0);
    let price = 5_600.0;

    // Execute short → long reversal
    let short_action = FactoredAction::new(ExposureLevel::Short100, OrderType::Market, Urgency::Normal);
    tracker.execute_action(short_action, price, 1.0);

    let tx_cost_after_short = tracker.transaction_costs();
    assert!(tx_cost_after_short > 0.0, "Should have transaction costs from short");

    let long_action = FactoredAction::new(ExposureLevel::Long100, OrderType::Market, Urgency::Normal);
    tracker.execute_action(long_action, price, 1.0);

    let tx_cost_after_reversal = tracker.transaction_costs();

    println!("TX costs - Short: ${:.2}, Reversal: ${:.2}",
             tx_cost_after_short, tx_cost_after_reversal);

    // Assertions:
    // 1. Costs increased after reversal (Phase 1 + Phase 2 costs)
    assert!(tx_cost_after_reversal > tx_cost_after_short,
            "Transaction costs should increase after reversal");

    // 2. Market order rate is 0.15% (0.0015)
    // For 2 trades of 1 contract at $5,600: 2 * 5600 * 0.0015 = $16.80 minimum
    assert!(tx_cost_after_reversal >= 16.0,
            "Transaction costs should be at least $16 for two market orders");
}

#[test]
fn test_negative_cash_guard() {
    // Test 5: Verify negative cash is guarded against
    // This is a safety test - should never happen in practice
    let mut tracker = PortfolioTracker::new(1_000.0, 0.0001, 0.0);
    let price = 5_600.0;

    // Try to open short with minimal capital
    let short_action = FactoredAction::new(ExposureLevel::Short100, OrderType::Market, Urgency::Normal);
    tracker.execute_action(short_action, price, 1.0);

    // Cash should never go negative
    assert!(tracker.cash_balance() >= 0.0, "Cash should never be negative");
}

#[test]
fn test_multiple_reversals() {
    // Test 6: Multiple reversals in sequence
    let mut tracker = PortfolioTracker::new(30_000.0, 0.0001, 0.0);
    let price = 5_600.0;

    // Reversal 1: Flat → Short
    let short_action = FactoredAction::new(ExposureLevel::Short100, OrderType::Market, Urgency::Normal);
    tracker.execute_action(short_action, price, 1.0);
    println!("After Reversal 1 (Short): Position={:.2}, Cash=${:.2}",
             tracker.current_position(), tracker.cash_balance());

    // Reversal 2: Short → Long
    let long_action = FactoredAction::new(ExposureLevel::Long100, OrderType::Market, Urgency::Normal);
    tracker.execute_action(long_action, price, 1.0);
    println!("After Reversal 2 (Long): Position={:.2}, Cash=${:.2}",
             tracker.current_position(), tracker.cash_balance());

    // Reversal 3: Long → Short
    tracker.execute_action(short_action, price, 1.0);
    println!("After Reversal 3 (Short): Position={:.2}, Cash=${:.2}",
             tracker.current_position(), tracker.cash_balance());

    // Assertions:
    assert!(tracker.cash_balance() >= 0.0, "Cash should never go negative");

    let tx_costs = tracker.transaction_costs();
    println!("Total transaction costs: ${:.2}", tx_costs);

    // Should have costs from all reversals (6 trades total: 3 reversals × 2 phases each)
    // Minimum: 6 * 5600 * 0.0015 = $50.40
    assert!(tx_costs >= 50.0, "Should have accumulated transaction costs");
}

#[test]
fn test_cash_reserve_enforcement() {
    // Test 7: Verify cash reserve is enforced during Phase 2
    let mut tracker = PortfolioTracker::new(15_000.0, 0.0001, 10.0); // 10% reserve
    let price = 5_600.0;

    // Open short position
    let short_action = FactoredAction::new(ExposureLevel::Short100, OrderType::Market, Urgency::Normal);
    tracker.execute_action(short_action, price, 1.0);

    let cash_before = tracker.cash_balance();
    println!("Cash before reversal: ${:.2}", cash_before);

    // Attempt reversal with reserve requirement
    let long_action = FactoredAction::new(ExposureLevel::Long100, OrderType::Market, Urgency::Normal);
    tracker.execute_action(long_action, price, 1.0);

    let final_position = tracker.current_position();
    let final_cash = tracker.cash_balance();
    let portfolio_value = tracker.total_value(price);

    println!("Final position: {:.4}, Final cash: ${:.2}, Portfolio value: ${:.2}",
             final_position, final_cash, portfolio_value);

    // Assertion: Cash reserve should be enforced
    let reserve_required = portfolio_value * 0.10;
    println!("Reserve required (10%): ${:.2}", reserve_required);

    // Cash should be close to or above reserve (may be slightly below due to rounding)
    assert!(final_cash >= reserve_required * 0.95,
            "Cash should respect reserve requirement (within 5% tolerance)");
}