foxhunt/ml/src/test_fixtures.rs

//! Test Fixtures and Common Testing Utilities
//!
//! This module provides common test symbols, configurations, and utilities
//! to ensure consistent testing across the ML codebase without hardcoded symbols.

use std::collections::HashMap;

/// Test symbol configuration with realistic market characteristics
#[derive(Debug, Clone)]
pub struct TestSymbolConfig {
    pub symbol: &'static str,
    pub base_price: f64,
    pub volatility: f64,
    pub exchange: &'static str,
    pub sector: &'static str,
    pub market_cap: &'static str,
}

/// Collection of predefined test symbols with different characteristics
pub const TEST_SYMBOLS: &[TestSymbolConfig] = &[
    TestSymbolConfig {
        symbol: "TEST_LARGE_1",
        base_price: 150.0,
        volatility: 0.25,
        exchange: "NASDAQ",
        sector: "Technology",
        market_cap: "Large",
    },
    TestSymbolConfig {
        symbol: "TEST_LARGE_2", 
        base_price: 250.0,
        volatility: 0.30,
        exchange: "NYSE",
        sector: "Technology",
        market_cap: "Large",
    },
    TestSymbolConfig {
        symbol: "TEST_MID_1",
        base_price: 75.0,
        volatility: 0.35,
        exchange: "NASDAQ",
        sector: "Healthcare",
        market_cap: "Mid",
    },
    TestSymbolConfig {
        symbol: "TEST_MID_2",
        base_price: 120.0,
        volatility: 0.28,
        exchange: "NYSE",
        sector: "Finance",
        market_cap: "Mid",
    },
    TestSymbolConfig {
        symbol: "TEST_SMALL_1",
        base_price: 35.0,
        volatility: 0.45,
        exchange: "NASDAQ",
        sector: "Biotech",
        market_cap: "Small",
    },
];

/// Get test symbol configuration by index (wraps around if index is too large)
pub fn get_test_symbol(index: usize) -> &'static TestSymbolConfig {
    &TEST_SYMBOLS[index % TEST_SYMBOLS.len()]
}

/// Get test symbol by name
pub fn get_test_symbol_by_name(symbol: &str) -> Option<&'static TestSymbolConfig> {
    TEST_SYMBOLS.iter().find(|config| config.symbol == symbol)
}

/// Get all test symbol names
pub fn get_test_symbol_names() -> Vec<&'static str> {
    TEST_SYMBOLS.iter().map(|config| config.symbol).collect()
}

/// Get test symbols by market cap
pub fn get_test_symbols_by_market_cap(market_cap: &str) -> Vec<&'static TestSymbolConfig> {
    TEST_SYMBOLS.iter()
        .filter(|config| config.market_cap == market_cap)
        .collect()
}

/// Get test symbols by exchange
pub fn get_test_symbols_by_exchange(exchange: &str) -> Vec<&'static TestSymbolConfig> {
    TEST_SYMBOLS.iter()
        .filter(|config| config.exchange == exchange)
        .collect()
}

/// Create test symbol mapping for easy lookups
pub fn create_test_symbol_map() -> HashMap<&'static str, &'static TestSymbolConfig> {
    TEST_SYMBOLS.iter()
        .map(|config| (config.symbol, config))
        .collect()
}

/// Generate realistic test price based on symbol configuration
pub fn generate_test_price(symbol_config: &TestSymbolConfig, variation_factor: f64) -> f64 {
    let base_price = symbol_config.base_price;
    let max_variation = base_price * symbol_config.volatility * variation_factor;
    let variation = (fastrand::f64() - 0.5) * max_variation;
    (base_price + variation).max(0.01) // Ensure positive price
}

/// Generate test volume based on market cap
pub fn generate_test_volume(symbol_config: &TestSymbolConfig) -> u64 {
    let base_volume = match symbol_config.market_cap {
        "Large" => 1_000_000,
        "Mid" => 500_000,
        "Small" => 100_000,
        _ => 250_000,
    };
    
    let variation = (fastrand::f64() * 0.5 + 0.75) as u64; // 75-125% variation
    base_volume * variation
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_get_test_symbol() {
        let symbol_0 = get_test_symbol(0);
        assert_eq!(symbol_0.symbol, "TEST_LARGE_1");
        
        let symbol_wrap = get_test_symbol(TEST_SYMBOLS.len());
        assert_eq!(symbol_wrap.symbol, "TEST_LARGE_1"); // Should wrap around
    }

    #[test]
    fn test_get_test_symbol_by_name() {
        let symbol = get_test_symbol_by_name("TEST_LARGE_1");
        assert!(symbol.is_some());
        assert_eq!(symbol.unwrap().symbol, "TEST_LARGE_1");
        
        let invalid = get_test_symbol_by_name("INVALID_SYMBOL");
        assert!(invalid.is_none());
    }

    #[test]
    fn test_get_test_symbol_names() {
        let names = get_test_symbol_names();
        assert_eq!(names.len(), TEST_SYMBOLS.len());
        assert!(names.contains(&"TEST_LARGE_1"));
        assert!(names.contains(&"TEST_SMALL_1"));
    }

    #[test]
    fn test_get_test_symbols_by_market_cap() {
        let large_caps = get_test_symbols_by_market_cap("Large");
        assert_eq!(large_caps.len(), 2);
        
        let small_caps = get_test_symbols_by_market_cap("Small");
        assert_eq!(small_caps.len(), 1);
        assert_eq!(small_caps[0].symbol, "TEST_SMALL_1");
    }

    #[test]
    fn test_get_test_symbols_by_exchange() {
        let nasdaq_symbols = get_test_symbols_by_exchange("NASDAQ");
        assert!(nasdaq_symbols.len() > 0);
        
        let nyse_symbols = get_test_symbols_by_exchange("NYSE");
        assert!(nyse_symbols.len() > 0);
    }

    #[test]
    fn test_create_test_symbol_map() {
        let symbol_map = create_test_symbol_map();
        assert_eq!(symbol_map.len(), TEST_SYMBOLS.len());
        assert!(symbol_map.contains_key("TEST_LARGE_1"));
    }

    #[test]
    fn test_generate_test_price() {
        let symbol_config = get_test_symbol(0);
        let price = generate_test_price(symbol_config, 0.1);
        
        // Price should be positive and within reasonable range
        assert!(price > 0.0);
        assert!(price > symbol_config.base_price * 0.8);
        assert!(price < symbol_config.base_price * 1.2);
    }

    #[test]
    fn test_generate_test_volume() {
        let large_cap = get_test_symbol(0);
        let small_cap = get_test_symbol(4);
        
        let large_volume = generate_test_volume(large_cap);
        let small_volume = generate_test_volume(small_cap);
        
        // Large cap should generally have higher volume
        assert!(large_volume > 0);
        assert!(small_volume > 0);
        assert!(large_volume > small_volume);
    }
}