foxhunt/ml/tests/action_masking_smoke_test.rs

//! Smoke tests for action masking functionality (Wave 9 Agent 2)
//!
//! Validates position limit enforcement via action masking

use ml::dqn::action_space::{get_valid_action_mask, ExposureLevel, FactoredAction};

#[test]
fn test_action_masking_at_neutral_position() {
    // At position 0.0, all 45 actions should be valid
    let mask = get_valid_action_mask(0.0, 2.0);

    assert_eq!(mask.len(), 45, "Mask should have 45 elements");
    assert_eq!(
        mask.iter().filter(|&&v| v).count(),
        45,
        "All actions should be valid at position 0.0"
    );
}

#[test]
fn test_action_masking_very_restrictive_limit() {
    // With max_position=0.6, only Flat and ±50% actions should be valid
    let mask = get_valid_action_mask(0.0, 0.6);

    // Count valid actions
    let valid_count = mask.iter().filter(|&&v| v).count();

    // Expected: Flat (9 actions), Short50 (9 actions), Long50 (9 actions) = 27 valid
    assert_eq!(
        valid_count, 27,
        "Only Flat, Short50, and Long50 should be valid (27/45 actions)"
    );

    // Verify Short100 is invalid (index 0-8)
    for idx in 0..9 {
        assert!(
            !mask[idx],
            "Short100 actions should be INVALID (exposure=-1.0 > 0.6)"
        );
    }

    // Verify Long100 is invalid (index 36-44)
    for idx in 36..45 {
        assert!(
            !mask[idx],
            "Long100 actions should be INVALID (exposure=+1.0 > 0.6)"
        );
    }

    // Verify Short50 is valid (index 9-17)
    for idx in 9..18 {
        assert!(
            mask[idx],
            "Short50 actions should be VALID (exposure=-0.5 < 0.6)"
        );
    }

    // Verify Flat is valid (index 18-26)
    for idx in 18..27 {
        assert!(
            mask[idx],
            "Flat actions should be VALID (exposure=0.0 < 0.6)"
        );
    }

    // Verify Long50 is valid (index 27-35)
    for idx in 27..36 {
        assert!(
            mask[idx],
            "Long50 actions should be VALID (exposure=+0.5 < 0.6)"
        );
    }
}

#[test]
fn test_action_masking_preserves_all_action_variants() {
    // Even with masking, each exposure level should have 9 action variants (3 orders × 3 urgencies)
    let mask = get_valid_action_mask(0.0, 1.0); // All actions valid

    // Short100: indices 0-8
    let short100_count = mask[0..9].iter().filter(|&&v| v).count();
    assert_eq!(short100_count, 9, "Short100 should have 9 variants");

    // Short50: indices 9-17
    let short50_count = mask[9..18].iter().filter(|&&v| v).count();
    assert_eq!(short50_count, 9, "Short50 should have 9 variants");

    // Flat: indices 18-26
    let flat_count = mask[18..27].iter().filter(|&&v| v).count();
    assert_eq!(flat_count, 9, "Flat should have 9 variants");

    // Long50: indices 27-35
    let long50_count = mask[27..36].iter().filter(|&&v| v).count();
    assert_eq!(long50_count, 9, "Long50 should have 9 variants");

    // Long100: indices 36-44
    let long100_count = mask[36..45].iter().filter(|&&v| v).count();
    assert_eq!(long100_count, 9, "Long100 should have 9 variants");
}

#[test]
fn test_action_masking_index_mapping_correctness() {
    // Verify that masked indices correctly map to expected FactoredActions
    let mask = get_valid_action_mask(0.0, 0.6);

    // Sample: Short100 should be masked
    let action_0 = FactoredAction::from_index(0).unwrap();
    assert_eq!(action_0.exposure, ExposureLevel::Short100);
    assert!(!mask[0], "Index 0 (Short100) should be masked");

    // Sample: Short50 should be valid
    let action_9 = FactoredAction::from_index(9).unwrap();
    assert_eq!(action_9.exposure, ExposureLevel::Short50);
    assert!(mask[9], "Index 9 (Short50) should be valid");

    // Sample: Flat should be valid
    let action_18 = FactoredAction::from_index(18).unwrap();
    assert_eq!(action_18.exposure, ExposureLevel::Flat);
    assert!(mask[18], "Index 18 (Flat) should be valid");

    // Sample: Long50 should be valid
    let action_27 = FactoredAction::from_index(27).unwrap();
    assert_eq!(action_27.exposure, ExposureLevel::Long50);
    assert!(mask[27], "Index 27 (Long50) should be valid");

    // Sample: Long100 should be masked
    let action_36 = FactoredAction::from_index(36).unwrap();
    assert_eq!(action_36.exposure, ExposureLevel::Long100);
    assert!(!mask[36], "Index 36 (Long100) should be masked");
}

#[test]
fn test_action_masking_boundary_conditions() {
    // Test exact boundary at max_position
    let mask = get_valid_action_mask(0.0, 1.0);

    // Exposure levels: [-1.0, -0.5, 0.0, 0.5, 1.0]
    // All should be valid since max(abs) = 1.0 <= 1.0
    let valid_count = mask.iter().filter(|&&v| v).count();
    assert_eq!(
        valid_count, 45,
        "All actions valid when exposure exactly equals max_position"
    );

    // Test slightly below max_position
    let mask_below = get_valid_action_mask(0.0, 0.99);
    let valid_below = mask_below.iter().filter(|&&v| v).count();

    // Short100 and Long100 should be masked (exposure=±1.0 > 0.99)
    // Expected: 27 valid (Flat + Short50 + Long50)
    assert_eq!(
        valid_below, 27,
        "Only 27 actions valid when max_position < max exposure"
    );
}

#[test]
fn test_action_masking_flat_always_valid() {
    // Flat (exposure=0.0) should ALWAYS be valid regardless of max_position
    let positions = vec![0.1, 0.5, 1.0, 2.0, 10.0];

    for max_pos in positions {
        let mask = get_valid_action_mask(0.0, max_pos);

        // Flat actions: indices 18-26
        for idx in 18..27 {
            assert!(
                mask[idx],
                "Flat actions should always be valid (max_position={})",
                max_pos
            );
        }
    }
}

#[test]
fn test_action_masking_edge_case_zero_max_position() {
    // Edge case: max_position=0.0 should only allow Flat
    let mask = get_valid_action_mask(0.0, 0.0);

    let valid_count = mask.iter().filter(|&&v| v).count();
    assert_eq!(
        valid_count, 9,
        "Only Flat actions (9) should be valid when max_position=0.0"
    );

    // Verify only Flat is valid
    for idx in 0..45 {
        let action = FactoredAction::from_index(idx).unwrap();
        let expected = action.exposure == ExposureLevel::Flat;
        assert_eq!(
            mask[idx],
            expected,
            "Action {} (exposure={:?}) should be {} at max_position=0.0",
            idx,
            action.exposure,
            if expected { "valid" } else { "invalid" }
        );
    }
}