foxhunt/ml/tests/compliance_dqn_training_integration_test.rs

// Compliance Engine Integration with DQN Training
// Tests that compliance rules are enforced during actual DQN training

use common::types::{Price, Symbol};
use ml::dqn::hyperparameters::DQNHyperparameters;
use ml::trainers::dqn::DQNTrainer;
use risk::compliance::{ComplianceValidator, PositionLimit, RegulatoryReportingConfig};
use risk::risk_types::{ComplianceConfig, PositionLimits};
use std::collections::HashMap;
use std::sync::Arc;

// Helper to create minimal compliance config
fn create_minimal_compliance_config() -> ComplianceConfig {
    ComplianceConfig {
        rules: vec![],
        position_limits: PositionLimits {
            max_position_per_instrument: HashMap::new(),
            max_portfolio_value: Price::from_f64(1_000_000.0).unwrap(),
            max_leverage: 5.0,
            max_concentration_pct: 0.1,
            global_limit: Price::from_f64(10_000_000.0).unwrap(),
        },
        audit_retention_days: 2555,
        market_abuse_threshold: Some(Price::from_f64(100_000.0).unwrap()),
        large_exposure_threshold: Price::from_f64(500_000.0).unwrap(),
    }
}

#[tokio::test]
async fn test_dqn_trainer_with_compliance_creation() {
    // Test that DQNTrainer can be created with compliance engine
    let hyperparams = DQNHyperparameters {
        learning_rate: 0.001,
        gamma: 0.99,
        epsilon_start: 1.0,
        epsilon_end: 0.05,
        epsilon_decay: 0.995,
        batch_size: 32,
        buffer_size: 10000,
        min_replay_size: 100,
        target_update_frequency: 100,
        initial_capital: 100_000.0,
        max_position: 10.0,
        hold_penalty_weight: 0.01,
        movement_threshold: 0.02,
    };

    let config = create_minimal_compliance_config();
    let regulatory_config = RegulatoryReportingConfig::default();
    let compliance_engine = Arc::new(ComplianceValidator::new(config, regulatory_config));

    let trainer_result = DQNTrainer::new_with_compliance(hyperparams, compliance_engine);

    assert!(
        trainer_result.is_ok(),
        "DQNTrainer creation with compliance failed: {:?}",
        trainer_result.err()
    );
}

#[tokio::test]
async fn test_compliance_engine_accessible() {
    // Test that compliance engine is accessible from trainer
    let hyperparams = DQNHyperparameters {
        learning_rate: 0.001,
        gamma: 0.99,
        epsilon_start: 1.0,
        epsilon_end: 0.05,
        epsilon_decay: 0.995,
        batch_size: 32,
        buffer_size: 10000,
        min_replay_size: 100,
        target_update_frequency: 100,
        initial_capital: 100_000.0,
        max_position: 10.0,
        hold_penalty_weight: 0.01,
        movement_threshold: 0.02,
    };

    let config = create_minimal_compliance_config();
    let regulatory_config = RegulatoryReportingConfig::default();
    let compliance_engine = Arc::new(ComplianceValidator::new(config, regulatory_config));

    // Set a position limit
    let limit = PositionLimit {
        instrument_id: "ES_FUT".to_string(),
        max_position_size: Price::from_f64(10.0).unwrap(),
        max_daily_turnover: Price::from_f64(100_000.0).unwrap(),
        concentration_limit: Price::from_f64(0.1).unwrap(),
        regulatory_basis: "Internal Risk Policy".to_string(),
    };

    compliance_engine
        .set_position_limit("ES_FUT".to_string(), limit)
        .await
        .unwrap();

    let _trainer = DQNTrainer::new_with_compliance(hyperparams, compliance_engine.clone()).unwrap();

    // Verify position limit was set
    let metrics = compliance_engine.get_compliance_metrics().await;
    assert!(metrics.contains_key("compliance_rate"));
}

#[tokio::test]
async fn test_compliance_audit_trail() {
    // Test that compliance checks create audit trail
    let hyperparams = DQNHyperparameters {
        learning_rate: 0.001,
        gamma: 0.99,
        epsilon_start: 1.0,
        epsilon_end: 0.05,
        epsilon_decay: 0.995,
        batch_size: 32,
        buffer_size: 10000,
        min_replay_size: 100,
        target_update_frequency: 100,
        initial_capital: 100_000.0,
        max_position: 10.0,
        hold_penalty_weight: 0.01,
        movement_threshold: 0.02,
    };

    let config = create_minimal_compliance_config();
    let regulatory_config = RegulatoryReportingConfig::default();
    let compliance_engine = Arc::new(ComplianceValidator::new(config, regulatory_config));

    let _trainer = DQNTrainer::new_with_compliance(hyperparams, compliance_engine.clone()).unwrap();

    // Initial audit trail should be empty
    let initial_audit = compliance_engine.get_enhanced_audit_trail(Some(100)).await;
    let initial_count = initial_audit.len();

    // After creating trainer, audit trail should still be accessible
    assert!(initial_count >= 0); // Can be 0 or more depending on initialization
}

#[tokio::test]
async fn test_hot_reload_capability() {
    // Test that compliance rules can be reloaded during training
    let hyperparams = DQNHyperparameters {
        learning_rate: 0.001,
        gamma: 0.99,
        epsilon_start: 1.0,
        epsilon_end: 0.05,
        epsilon_decay: 0.995,
        batch_size: 32,
        buffer_size: 10000,
        min_replay_size: 100,
        target_update_frequency: 100,
        initial_capital: 100_000.0,
        max_position: 10.0,
        hold_penalty_weight: 0.01,
        movement_threshold: 0.02,
    };

    let config = create_minimal_compliance_config();
    let regulatory_config = RegulatoryReportingConfig::default();
    let compliance_engine = Arc::new(ComplianceValidator::new(config, regulatory_config));

    let _trainer = DQNTrainer::new_with_compliance(hyperparams, compliance_engine.clone()).unwrap();

    // Clear cache to simulate hot-reload
    compliance_engine.clear_compliance_rules().await;

    let count_after_clear = compliance_engine.compliance_rule_count().await;
    assert_eq!(count_after_clear, 0);
}

#[tokio::test]
async fn test_compliance_without_engine() {
    // Test that DQNTrainer works without compliance engine (backwards compatibility)
    let hyperparams = DQNHyperparameters {
        learning_rate: 0.001,
        gamma: 0.99,
        epsilon_start: 1.0,
        epsilon_end: 0.05,
        epsilon_decay: 0.995,
        batch_size: 32,
        buffer_size: 10000,
        min_replay_size: 100,
        target_update_frequency: 100,
        initial_capital: 100_000.0,
        max_position: 10.0,
        hold_penalty_weight: 0.01,
        movement_threshold: 0.02,
    };

    let trainer_result = DQNTrainer::new(hyperparams);

    assert!(
        trainer_result.is_ok(),
        "DQNTrainer creation without compliance failed: {:?}",
        trainer_result.err()
    );
}

#[tokio::test]
async fn test_regulatory_reporting() {
    // Test that regulatory reporting works with compliance engine
    let hyperparams = DQNHyperparameters {
        learning_rate: 0.001,
        gamma: 0.99,
        epsilon_start: 1.0,
        epsilon_end: 0.05,
        epsilon_decay: 0.995,
        batch_size: 32,
        buffer_size: 10000,
        min_replay_size: 100,
        target_update_frequency: 100,
        initial_capital: 100_000.0,
        max_position: 10.0,
        hold_penalty_weight: 0.01,
        movement_threshold: 0.02,
    };

    let config = create_minimal_compliance_config();
    let mut regulatory_config = RegulatoryReportingConfig::default();
    regulatory_config.mifid2_enabled = true;
    regulatory_config.basel_iii_enabled = true;

    let compliance_engine = Arc::new(ComplianceValidator::new(config, regulatory_config));
    let _trainer = DQNTrainer::new_with_compliance(hyperparams, compliance_engine.clone()).unwrap();

    // Generate regulatory report
    let start_date = chrono::Utc::now() - chrono::Duration::hours(1);
    let end_date = chrono::Utc::now();

    let report = compliance_engine
        .generate_regulatory_report(start_date, end_date)
        .await
        .unwrap();

    assert!(report.contains("REGULATORY COMPLIANCE REPORT"));
    assert!(report.contains("MiFID II"));
    assert!(report.contains("Basel III"));
}