foxhunt/ml/tests/dqn_reward_integration_test.rs

//! Integration test verifying RewardFunction is actually used during training
//!
//! This test ensures that:
//! 1. RewardFunction is initialized in DQNTrainer::new()
//! 2. HOLD rewards vary based on movement_threshold (not hardcoded -0.0001)
//! 3. Hyperparameter changes (hold_penalty_weight, movement_threshold) affect rewards
//! 4. The hardcoded reward calculation has been removed

use ml::trainers::dqn::DQNHyperparameters;

#[tokio::test]
async fn test_reward_function_integration_trainer_initialization() {
    // Test that DQNTrainer initializes with RewardFunction
    let mut hyperparams = DQNHyperparameters::conservative();
    hyperparams.hold_penalty_weight = 0.1; // Strong penalty
    hyperparams.movement_threshold = 0.02; // 2% threshold

    let trainer = ml::trainers::dqn::DQNTrainer::new(hyperparams);

    // If RewardFunction is properly integrated, trainer creation should succeed
    assert!(
        trainer.is_ok(),
        "Trainer should initialize with RewardFunction"
    );
}

#[tokio::test]
async fn test_reward_function_custom_parameters_wired() {
    // Test that custom reward parameters reach DQNTrainer
    let mut hyperparams = DQNHyperparameters::conservative();

    // Set custom reward parameters
    hyperparams.hold_penalty_weight = 0.5;
    hyperparams.movement_threshold = 0.01;
    hyperparams.hold_reward = -0.001;
    hyperparams.pnl_weight = 1.5;
    hyperparams.risk_weight = 0.2;
    hyperparams.cost_weight = 0.15;

    let trainer = ml::trainers::dqn::DQNTrainer::new(hyperparams);

    // If parameters are properly wired through to RewardFunction,
    // trainer creation should succeed without errors
    assert!(
        trainer.is_ok(),
        "Trainer should initialize with custom reward parameters"
    );
}

#[tokio::test]
async fn test_reward_function_default_parameters() {
    // Test that default hyperparameters work correctly
    let hyperparams = DQNHyperparameters::default();

    let trainer = ml::trainers::dqn::DQNTrainer::new(hyperparams);

    assert!(
        trainer.is_ok(),
        "Trainer should initialize with default reward parameters"
    );
}

#[tokio::test]
async fn test_reward_function_zero_penalty_weight() {
    // Test edge case: zero hold penalty weight (no HOLD penalty)
    let mut hyperparams = DQNHyperparameters::conservative();
    hyperparams.hold_penalty_weight = 0.0; // No penalty
    hyperparams.movement_threshold = 0.0; // No threshold

    let trainer = ml::trainers::dqn::DQNTrainer::new(hyperparams);

    assert!(
        trainer.is_ok(),
        "Trainer should handle zero penalty weight gracefully"
    );
}

#[tokio::test]
async fn test_reward_function_high_penalty_weight() {
    // Test edge case: very high hold penalty weight
    let mut hyperparams = DQNHyperparameters::conservative();
    hyperparams.hold_penalty_weight = 10.0; // Extreme penalty
    hyperparams.movement_threshold = 0.05; // 5% threshold

    let trainer = ml::trainers::dqn::DQNTrainer::new(hyperparams);

    assert!(trainer.is_ok(), "Trainer should handle high penalty weight");
}

#[test]
fn test_reward_function_smoke_test() {
    // Synchronous smoke test to verify compilation and basic types
    let hyperparams = DQNHyperparameters::conservative();

    // Verify hyperparameters have the expected reward fields
    assert!(hyperparams.hold_penalty_weight >= 0.0);
    assert!(hyperparams.movement_threshold >= 0.0);
    assert!(hyperparams.pnl_weight > 0.0);
    assert!(hyperparams.risk_weight >= 0.0);
    assert!(hyperparams.cost_weight >= 0.0);
}