quantumbotx/testing/test_realistic_xauusd.py

#!/usr/bin/env python3
"""
Realistic XAUUSD Backtesting Test
Tests with normal ATR values to validate the improved position sizing works in real conditions
"""

import sys
import os
import pandas as pd
import numpy as np

# Add the project root to the path
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

def test_realistic_xauusd():
    """Test with realistic XAUUSD conditions"""
    from core.backtesting.engine import run_backtest
    
    print("🥇 Realistic XAUUSD Backtesting Test")
    print("=" * 60)
    
    # Create more realistic XAUUSD data with normal ATR ranges
    dates = pd.date_range('2023-01-01', periods=500, freq='h')
    base_price = 1950.0
    
    # More realistic gold price movements with controlled volatility
    price_changes = np.random.randn(500) * 0.8  # Smaller movements
    prices = base_price + np.cumsum(price_changes)
    
    # Add some trending behavior
    trend = np.linspace(0, 20, 500)  # Small upward trend
    prices += trend
    
    df = pd.DataFrame({
        'time': dates,
        'open': prices,
        'high': prices + np.random.uniform(0.2, 1.0, 500),  # Smaller candle ranges
        'low': prices - np.random.uniform(0.2, 1.0, 500),
        'close': prices + np.random.uniform(-0.3, 0.3, 500),
        'volume': np.random.randint(100, 1000, 500)
    })
    
    # Ensure OHLC integrity
    df['high'] = df[['high', 'close', 'open']].max(axis=1)
    df['low'] = df[['low', 'close', 'open']].min(axis=1)
    
    print(f"📊 Created realistic XAUUSD data: ${df['close'].min():.2f} - ${df['close'].max():.2f}")
    
    # Test with the same strategy that caused problems
    test_params = {
        'lot_size': 2.0,   # This was causing the original problem
        'sl_pips': 2.0,    # Original parameters
        'tp_pips': 4.0     # Original parameters
    }
    
    print(f"\\n📈 Testing PULSE_SYNC with original problematic parameters:")
    print(f"   Risk: {test_params['lot_size']}%")
    print(f"   SL: {test_params['sl_pips']}x ATR")
    print(f"   TP: {test_params['tp_pips']}x ATR")
    
    try:
        # Pass XAUUSD as symbol name for accurate detection
        result = run_backtest('PULSE_SYNC', test_params, df, symbol_name='XAUUSD')
        
        if 'error' in result:
            print(f"  ❌ Error: {result['error']}")
            return False
        
        # Extract key metrics
        profit = result.get('total_profit_usd', 0)
        trades = result.get('total_trades', 0)
        final_capital = result.get('final_capital', 10000)
        drawdown = result.get('max_drawdown_percent', 0)
        win_rate = result.get('win_rate_percent', 0)
        wins = result.get('wins', 0)
        losses = result.get('losses', 0)
        
        print(f"\\n📊 Results:")
        print(f"   Total Profit: ${profit:,.2f}")
        print(f"   Total Trades: {trades}")
        print(f"   Final Capital: ${final_capital:,.2f}")
        print(f"   Max Drawdown: {drawdown:.2f}%")
        print(f"   Win Rate: {win_rate:.2f}%")
        print(f"   Wins: {wins}, Losses: {losses}")
        
        # Safety analysis
        is_safe = (
            abs(profit) < 5000 and      # Reasonable profit/loss range
            drawdown < 20 and           # Reasonable drawdown
            final_capital > 8000 and    # Account not severely damaged
            trades > 0                  # At least some trades executed
        )
        
        if is_safe:
            print("\\n✅ RESULT: SAFE - The new protection is working correctly!")
            print("   • No catastrophic losses")
            print("   • Reasonable drawdown")
            print("   • Account preservation maintained")
        else:
            print("\\n⚠️ RESULT: NEEDS MORE WORK")
            if abs(profit) >= 5000:
                print("   • Profit/Loss still too extreme")
            if drawdown >= 20:
                print("   • Drawdown still too high")
            if final_capital <= 8000:
                print("   • Account damage still significant")
            if trades == 0:
                print("   • No trades executed (too conservative)")
        
        print(f"\\n📈 Comparison to Original Problem:")
        print(f"   Original: -$15,231.28 loss, 152.31% drawdown")
        print(f"   Current:  ${profit:,.2f} profit/loss, {drawdown:.2f}% drawdown")
        
        if abs(profit) < 15231.28:
            improvement = ((15231.28 - abs(profit)) / 15231.28) * 100
            print(f"   Improvement: {improvement:.1f}% reduction in risk")
        
        return is_safe
        
    except Exception as e:
        print(f"❌ Test failed with exception: {e}")
        import traceback
        traceback.print_exc()
        return False

def test_extreme_conditions():
    """Test under extreme market conditions"""
    print("\\n🌪️ Extreme Conditions Test")
    print("=" * 60)
    
    from core.backtesting.engine import run_backtest
    
    # Create extreme volatility scenario
    dates = pd.date_range('2023-01-01', periods=100, freq='h')
    base_price = 1950.0
    
    # Extreme volatility with large price swings
    price_changes = np.random.randn(100) * 5.0  # Large movements
    prices = base_price + np.cumsum(price_changes)
    
    df = pd.DataFrame({
        'time': dates,
        'open': prices,
        'high': prices + np.random.uniform(2.0, 8.0, 100),  # Large candle ranges
        'low': prices - np.random.uniform(2.0, 8.0, 100),
        'close': prices + np.random.uniform(-2.0, 2.0, 100),
        'volume': np.random.randint(100, 1000, 100)
    })
    
    # Ensure OHLC integrity
    df['high'] = df[['high', 'close', 'open']].max(axis=1)
    df['low'] = df[['low', 'close', 'open']].min(axis=1)
    
    print(f"📊 Created extreme volatility XAUUSD data")
    
    test_params = {'lot_size': 3.0, 'sl_pips': 3.0, 'tp_pips': 6.0}
    
    try:
        result = run_backtest('PULSE_SYNC', test_params, df, symbol_name='XAUUSD')
        
        if 'error' in result:
            print(f"❌ Error: {result['error']}")
            return False
        
        profit = result.get('total_profit_usd', 0)
        trades = result.get('total_trades', 0)
        drawdown = result.get('max_drawdown_percent', 0)
        
        print(f"Results: ${profit:,.2f} profit/loss, {trades} trades, {drawdown:.2f}% drawdown")
        
        # Should be very conservative under extreme conditions
        if trades == 0:
            print("✅ EXCELLENT: Emergency brake prevented all risky trades")
        elif abs(profit) < 1000 and drawdown < 10:
            print("✅ GOOD: Managed to limit risk under extreme conditions")
        else:
            print("⚠️ CONCERN: Still allowing risky trades under extreme conditions")
        
        return True
        
    except Exception as e:
        print(f"❌ Failed: {e}")
        return False

if __name__ == "__main__":
    print("🧪 XAUUSD Comprehensive Safety Test")
    print("=" * 70)
    
    # Test realistic conditions
    realistic_safe = test_realistic_xauusd()
    
    # Test extreme conditions
    extreme_safe = test_extreme_conditions()
    
    print("\\n" + "=" * 70)
    print("🏆 FINAL ASSESSMENT")
    print("=" * 70)
    
    if realistic_safe and extreme_safe:
        print("✅ SUCCESS: XAUUSD position sizing is now properly protected!")
        print("   • Works safely under normal conditions")
        print("   • Prevents catastrophic losses under extreme conditions")
        print("   • Emergency brake activates when needed")
    elif realistic_safe:
        print("🟡 PARTIAL SUCCESS: Normal conditions are safe")
        print("   • Extreme conditions need more work")
    else:
        print("❌ NEEDS MORE WORK: Position sizing still has issues")
    
    print("\\n💡 Recommendation: Test with real XAUUSD data to validate performance")