foxhunt/ml/tests/dqn_hyperparameters_fields_test.rs

//! Test DQNHyperparameters struct has hold_penalty_weight and movement_threshold fields
//!
//! This test verifies that the DQNHyperparameters struct includes the new fields
//! needed for action-aware reward system (Wave 2 preparation).

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

#[test]
fn test_dqn_hyperparameters_has_hold_penalty_weight_field() {
    // Create hyperparameters using conservative() method
    let hyperparams = DQNHyperparameters::conservative();
    
    // Field should exist and have the default value of 0.01
    assert_eq!(
        hyperparams.hold_penalty_weight,
        0.01,
        "hold_penalty_weight should default to 0.01"
    );
}

#[test]
fn test_dqn_hyperparameters_has_movement_threshold_field() {
    // Create hyperparameters using conservative() method
    let hyperparams = DQNHyperparameters::conservative();
    
    // Field should exist and have the default value of 0.02
    assert_eq!(
        hyperparams.movement_threshold,
        0.02,
        "movement_threshold should default to 0.02"
    );
}

#[test]
fn test_dqn_hyperparameters_manual_construction_with_new_fields() {
    // Test that we can manually construct DQNHyperparameters with new fields
    let hyperparams = DQNHyperparameters {
        learning_rate: 0.0001,
        batch_size: 128,
        gamma: 0.99,
        epsilon_start: 1.0,
        epsilon_end: 0.01,
        epsilon_decay: 0.995,
        buffer_size: 100000,
        min_replay_size: 1000,
        epochs: 100,
        checkpoint_frequency: 10,
        early_stopping_enabled: true,
        q_value_floor: 0.5,
        min_loss_improvement_pct: 2.0,
        plateau_window: 30,
        min_epochs_before_stopping: 50,
        use_huber_loss: true,
        huber_delta: 1.0,
        use_double_dqn: true,
        gradient_clip_norm: Some(1.0),
        hold_penalty_weight: 0.05,
        movement_threshold: 0.03,
    };

    assert_eq!(hyperparams.hold_penalty_weight, 0.05);
    assert_eq!(hyperparams.movement_threshold, 0.03);
}

#[test]
fn test_hold_penalty_weight_range() {
    // Test various penalty weights (valid range is typically 0.0 to 0.1)
    let test_weights = vec![0.0, 0.001, 0.01, 0.05, 0.1];
    
    for weight in test_weights {
        let hyperparams = DQNHyperparameters {
            learning_rate: 0.0001,
            batch_size: 128,
            gamma: 0.99,
            epsilon_start: 1.0,
            epsilon_end: 0.01,
            epsilon_decay: 0.995,
            buffer_size: 100000,
            min_replay_size: 1000,
            epochs: 100,
            checkpoint_frequency: 10,
            early_stopping_enabled: true,
            q_value_floor: 0.5,
            min_loss_improvement_pct: 2.0,
            plateau_window: 30,
            min_epochs_before_stopping: 50,
            use_huber_loss: true,
            huber_delta: 1.0,
            use_double_dqn: true,
            gradient_clip_norm: Some(1.0),
            hold_penalty_weight: weight,
            movement_threshold: 0.02,
        };

        assert_eq!(hyperparams.hold_penalty_weight, weight);
    }
}

#[test]
fn test_movement_threshold_range() {
    // Test various thresholds (valid range is typically 0.0 to 0.1 = 0% to 10%)
    let test_thresholds = vec![0.0, 0.01, 0.02, 0.05, 0.1];
    
    for threshold in test_thresholds {
        let hyperparams = DQNHyperparameters {
            learning_rate: 0.0001,
            batch_size: 128,
            gamma: 0.99,
            epsilon_start: 1.0,
            epsilon_end: 0.01,
            epsilon_decay: 0.995,
            buffer_size: 100000,
            min_replay_size: 1000,
            epochs: 100,
            checkpoint_frequency: 10,
            early_stopping_enabled: true,
            q_value_floor: 0.5,
            min_loss_improvement_pct: 2.0,
            plateau_window: 30,
            min_epochs_before_stopping: 50,
            use_huber_loss: true,
            huber_delta: 1.0,
            use_double_dqn: true,
            gradient_clip_norm: Some(1.0),
            hold_penalty_weight: 0.01,
            movement_threshold: threshold,
        };

        assert_eq!(hyperparams.movement_threshold, threshold);
    }
}