test_full_quant_system.py

#!/usr/bin/env python3
"""
Test script to validate the complete quantitative trading system
This test verifies that the quantitative engine is properly integrated
into the Donchian strategy and produces meaningful results.
"""

import logging

import numpy as np

from brokers.mt5_connection_manager import MT5ConnectionManager
from core.quant_engine import QuantitativeEngine

# Configure logging
logging.basicConfig(
    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
)
logger = logging.getLogger(__name__)


def test_quantitative_integration():
    """Test the complete integration of quantitative analysis in the strategy"""
    print("🔍 Testing Complete Quantitative Trading System Integration...")

    # Initialize components
    mt5_manager = MT5ConnectionManager()
    connection_ok = mt5_manager.connect()

    if not connection_ok:
        logger.error("Failed to connect to MT5")
        return False

    try:
        # Initialize quantitative engine
        quant_engine = QuantitativeEngine()

        logger.info("✅ All components initialized successfully")

        # Test with sample data to simulate what happens in the strategy
        # Generate sample price data (simulating what would come from MT5)
        np.random.seed(42)  # For reproducible results
        sample_prices = 100 + np.cumsum(
            np.random.normal(0, 0.1, 200),
        )  # 200 price points

        logger.info(f"📊 Generated sample price data: {len(sample_prices)} points")
        logger.info(
            f"📊 Price range: {sample_prices.min():.5f} - {sample_prices.max():.5f}",
        )

        # Test quantitative analysis
        adx_value = 25.0  # Simulated ADX value
        di_plus = 20.0  # Simulated +DI value
        di_minus = 15.0  # Simulated -DI value

        logger.info(
            f"📈 Simulated indicators - ADX: {adx_value}, +DI: {di_plus}, -DI: {di_minus}",
        )

        # Calculate entry score using quantitative engine
        entry_result = quant_engine.calculate_entry_score(
            prices=sample_prices,
            adx_value=adx_value,
            di_plus=di_plus,
            di_minus=di_minus,
        )

        logger.info(f"🎯 Quantitative Entry Score: {entry_result['entry_score']:.3f}")
        logger.info(f"💡 Recommendation: {entry_result['recommendation']}")
        logger.info(f"📊 Filters: {entry_result['filters']}")

        # Test position sizing
        optimal_size = quant_engine.calculate_optimal_position_size(
            entry_score=entry_result["entry_score"],
            account_balance=10000,  # $10,000 account
        )

        logger.info(f"💰 Optimal Position Size: {optimal_size:.3f} lots")

        # Verify results make sense
        assert 0 <= entry_result["entry_score"] <= 1, (
            "Entry score should be between 0 and 1"
        )
        assert entry_result["recommendation"] in ["BUY", "SELL", "HOLD"], (
            "Invalid recommendation"
        )
        assert optimal_size >= 0, "Position size should be non-negative"

        logger.info("✅ Quantitative analysis passed validation")

        # Test optimizer
        optimal_period = quant_engine.optimizer.optimize_donchian_period(sample_prices)
        logger.info(f"⚙️  Optimal Donchian Period: {optimal_period}")
        assert 5 <= optimal_period <= 50, "Optimal period should be in reasonable range"

        logger.info("✅ All quantitative system tests passed!")

        return True

    except Exception as e:
        logger.error(f"❌ Error during quantitative system test: {e}")
        import traceback

        traceback.print_exc()
        return False
    finally:
        # Clean up
        mt5_manager.disconnect()


def test_edge_cases():
    """Test edge cases for the quantitative system"""
    print("\n🧪 Testing Edge Cases...")

    quant_engine = QuantitativeEngine()

    # Test with volatile data
    volatile_prices = 100 + np.cumsum(np.random.normal(0, 0.5, 100))  # High volatility

    result = quant_engine.calculate_entry_score(
        prices=volatile_prices,
        adx_value=15.0,  # Low ADX
        di_plus=10.0,
        di_minus=30.0,
    )

    logger.info(
        f"📉 Volatile market result - Score: {result['entry_score']:.3f}, Recommendation: {result['recommendation']}",
    )

    # Test with trending data
    trending_prices = np.linspace(100, 120, 100) + np.random.normal(
        0, 0.2, 100,
    )  # Upward trend

    result = quant_engine.calculate_entry_score(
        prices=trending_prices,
        adx_value=40.0,  # Strong trend
        di_plus=35.0,
        di_minus=10.0,
    )

    logger.info(
        f"📈 Trending market result - Score: {result['entry_score']:.3f}, Recommendation: {result['recommendation']}",
    )

    logger.info("✅ Edge case tests completed")


def main():
    """Main test function"""
    print("🚀 Starting Complete Quantitative Trading System Test")
    print("=" * 60)

    # Test main integration
    success = test_quantitative_integration()

    if success:
        # Test edge cases
        test_edge_cases()

        print("\n" + "=" * 60)
        print("🎉 All tests completed successfully!")
        print("📊 The quantitative trading system is working properly with:")
        print("   • Mathematical formulas for decision making")
        print("   • Statistical probability models")
        print("   • Dynamic position sizing based on quantitative analysis")
        print("   • Parameter optimization using quantitative methods")
        print("   • Integration with existing Donchian strategy")
        print("=" * 60)
    else:
        print("\n❌ Tests failed - please check the implementation")
        return 1

    return 0


if __name__ == "__main__":
    exit(main())