eae3c31e53
Patterns applied: - Pattern 2: Float comparison (2x: utils.rs, var_edge_cases_tests.rs) - Pattern 7: Date/time construction (2x: production_streaming.rs, streaming.rs) - Pattern 1: Duration/time ops (2x: rate limiter, semaphore) - Pattern 4: Optional field access (1x: position_tracker.rs) Changes: - data/src/utils.rs: Float sort with NaN handling - data/src/providers/benzinga/production_streaming.rs: Rate limiter + semaphore + date/time - data/src/providers/benzinga/streaming.rs: Date/time construction - risk/src/position_tracker.rs: Emergency fallback counter - risk/tests/var_edge_cases_tests.rs: Test helper float sort Test impact: 0 failures (182/182 passing) Compilation: Clean (0 errors, 0 warnings) Time: 25 min (44% under budget)
1041 lines
37 KiB
Rust
1041 lines
37 KiB
Rust
//! Comprehensive tests for the strategy execution engine
|
|
//!
|
|
//! Target Coverage: 70-80% of strategy_engine.rs
|
|
//! Focus Areas:
|
|
//! - Portfolio state management (position tracking, cash balance)
|
|
//! - Order generation and execution (signal → order → fill)
|
|
//! - Multi-strategy execution (concurrent strategies)
|
|
//! - Event processing (market data → strategy signals → position updates)
|
|
//! - Edge cases (partial fills, position sizing, transaction costs)
|
|
|
|
use anyhow::Result;
|
|
use chrono::{Duration, Utc};
|
|
use rust_decimal::prelude::ToPrimitive;
|
|
use rust_decimal::Decimal;
|
|
use std::collections::HashMap;
|
|
use std::sync::Arc;
|
|
|
|
mod mock_repositories;
|
|
|
|
use backtesting_service::service::BacktestContext;
|
|
use backtesting_service::strategy_engine::{MarketData, StrategyEngine, TimeFrame, TradeSide};
|
|
use config::structures::BacktestingStrategyConfig;
|
|
use mock_repositories::*;
|
|
|
|
// ============================================================================
|
|
// PORTFOLIO STATE MANAGEMENT TESTS
|
|
// ============================================================================
|
|
|
|
/// Test portfolio initialization with initial capital
|
|
#[tokio::test]
|
|
async fn test_portfolio_initialization() -> Result<()> {
|
|
let market_data_repo = Box::new(MockMarketDataRepository::new());
|
|
let trading_repo = Box::new(MockTradingRepository::new());
|
|
let news_repo = Box::new(MockNewsRepository::new());
|
|
|
|
let repositories = Arc::new(MockBacktestingRepositories::new(
|
|
market_data_repo,
|
|
trading_repo,
|
|
news_repo,
|
|
))
|
|
as Arc<dyn backtesting_service::repositories::BacktestingRepositories>;
|
|
|
|
let config = BacktestingStrategyConfig::default();
|
|
let engine = StrategyEngine::new(&config, repositories).await?;
|
|
|
|
let now = Utc::now();
|
|
let context = BacktestContext {
|
|
id: "test_portfolio_init_001".to_string(),
|
|
status: backtesting_service::foxhunt::tli::BacktestStatus::Running,
|
|
progress: 0.0,
|
|
current_date: now.format("%Y-%m-%d").to_string(),
|
|
trades_executed: 0,
|
|
current_pnl: 0.0,
|
|
started_at: now.timestamp_nanos_opt().unwrap_or(0),
|
|
completed_at: None,
|
|
error_message: None,
|
|
strategy_name: "buy_and_hold".to_string(),
|
|
symbols: vec!["AAPL".to_string()],
|
|
initial_capital: 50000.0,
|
|
parameters: HashMap::new(),
|
|
};
|
|
|
|
// Even with no market data, portfolio should be initialized
|
|
let trades = engine.execute_backtest(&context).await?;
|
|
|
|
// No trades executed, but no errors
|
|
assert_eq!(trades.len(), 0);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Test position tracking through multiple buy/sell cycles
|
|
#[tokio::test]
|
|
async fn test_position_tracking_buy_sell_cycles() -> Result<()> {
|
|
// Generate market data with oscillating prices
|
|
let mut market_data = Vec::new();
|
|
let start_time = Utc::now() - Duration::days(10);
|
|
|
|
// Create price pattern: up, down, up, down (to trigger multiple trades)
|
|
for i in 0..10 {
|
|
let price = if i % 2 == 0 { 100.0 } else { 110.0 };
|
|
let timestamp = start_time + Duration::days(i);
|
|
|
|
market_data.push(MarketData {
|
|
symbol: "AAPL".to_string(),
|
|
timestamp,
|
|
open: Decimal::from_f64_retain(price * 0.99).unwrap(),
|
|
high: Decimal::from_f64_retain(price * 1.01).unwrap(),
|
|
low: Decimal::from_f64_retain(price * 0.98).unwrap(),
|
|
close: Decimal::from_f64_retain(price).unwrap(),
|
|
volume: Decimal::from(1000000),
|
|
timeframe: TimeFrame::Daily,
|
|
});
|
|
}
|
|
|
|
let market_data_repo = Box::new(MockMarketDataRepository::with_data(market_data.clone()));
|
|
let trading_repo = Box::new(MockTradingRepository::new());
|
|
let news_repo = Box::new(MockNewsRepository::new());
|
|
|
|
let repositories = Arc::new(MockBacktestingRepositories::new(
|
|
market_data_repo,
|
|
trading_repo,
|
|
news_repo,
|
|
))
|
|
as Arc<dyn backtesting_service::repositories::BacktestingRepositories>;
|
|
|
|
let config = BacktestingStrategyConfig::default();
|
|
let engine = StrategyEngine::new(&config, repositories).await?;
|
|
|
|
let context = BacktestContext {
|
|
id: "test_position_tracking_001".to_string(),
|
|
status: backtesting_service::foxhunt::tli::BacktestStatus::Running,
|
|
progress: 0.0,
|
|
current_date: start_time.format("%Y-%m-%d").to_string(),
|
|
trades_executed: 0,
|
|
current_pnl: 0.0,
|
|
started_at: start_time.timestamp_nanos_opt().unwrap_or(0),
|
|
completed_at: None,
|
|
error_message: None,
|
|
strategy_name: "buy_and_hold".to_string(),
|
|
symbols: vec!["AAPL".to_string()],
|
|
initial_capital: 20000.0,
|
|
parameters: HashMap::new(),
|
|
};
|
|
|
|
let trades = engine.execute_backtest(&context).await?;
|
|
|
|
// Buy and hold should only buy once (first position entry)
|
|
assert!(!trades.is_empty(), "Should have at least one trade");
|
|
assert_eq!(trades[0].side, TradeSide::Buy);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Test position sizing with available capital
|
|
#[tokio::test]
|
|
async fn test_position_sizing_with_capital_limits() -> Result<()> {
|
|
let market_data = generate_sample_market_data("AAPL", 5, 1000.0, 0.01);
|
|
|
|
let market_data_repo = Box::new(MockMarketDataRepository::with_data(market_data.clone()));
|
|
let trading_repo = Box::new(MockTradingRepository::new());
|
|
let news_repo = Box::new(MockNewsRepository::new());
|
|
|
|
let repositories = Arc::new(MockBacktestingRepositories::new(
|
|
market_data_repo,
|
|
trading_repo,
|
|
news_repo,
|
|
))
|
|
as Arc<dyn backtesting_service::repositories::BacktestingRepositories>;
|
|
|
|
let config = BacktestingStrategyConfig::default();
|
|
let engine = StrategyEngine::new(&config, repositories).await?;
|
|
|
|
let start_time = market_data.first().expect("INVARIANT: Collection should be non-empty").timestamp;
|
|
|
|
let context = BacktestContext {
|
|
id: "test_position_sizing_001".to_string(),
|
|
status: backtesting_service::foxhunt::tli::BacktestStatus::Running,
|
|
progress: 0.0,
|
|
current_date: start_time.format("%Y-%m-%d").to_string(),
|
|
trades_executed: 0,
|
|
current_pnl: 0.0,
|
|
started_at: start_time.timestamp_nanos_opt().unwrap_or(0),
|
|
completed_at: None,
|
|
error_message: None,
|
|
strategy_name: "buy_and_hold".to_string(),
|
|
symbols: vec!["AAPL".to_string()],
|
|
initial_capital: 5000.0, // Limited capital vs high price stock
|
|
parameters: {
|
|
let mut params = HashMap::new();
|
|
params.insert("allocation".to_string(), "1.0".to_string());
|
|
params
|
|
},
|
|
};
|
|
|
|
let trades = engine.execute_backtest(&context).await?;
|
|
|
|
if !trades.is_empty() {
|
|
// Verify position size respects capital limits
|
|
let trade = &trades[0];
|
|
let position_value =
|
|
trade.quantity.to_f64().unwrap_or(0.0) * trade.entry_price.to_f64().unwrap_or(0.0);
|
|
|
|
// Position value should not exceed initial capital + buffer for costs
|
|
assert!(
|
|
position_value <= 5500.0,
|
|
"Position value {} should not significantly exceed capital",
|
|
position_value
|
|
);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Test cash balance tracking across multiple trades
|
|
#[tokio::test]
|
|
async fn test_cash_balance_tracking() -> Result<()> {
|
|
let market_data = generate_sample_market_data("AAPL", 20, 150.0, 0.02);
|
|
|
|
let market_data_repo = Box::new(MockMarketDataRepository::with_data(market_data.clone()));
|
|
let trading_repo = Box::new(MockTradingRepository::new());
|
|
let news_repo = Box::new(MockNewsRepository::new());
|
|
|
|
let repositories = Arc::new(MockBacktestingRepositories::new(
|
|
market_data_repo,
|
|
trading_repo,
|
|
news_repo,
|
|
))
|
|
as Arc<dyn backtesting_service::repositories::BacktestingRepositories>;
|
|
|
|
let config = BacktestingStrategyConfig {
|
|
commission_rate: 0.001, // 0.1% commission
|
|
slippage_rate: 0.0005, // 0.05% slippage
|
|
..Default::default()
|
|
};
|
|
let engine = StrategyEngine::new(&config, repositories).await?;
|
|
|
|
let start_time = market_data.first().expect("INVARIANT: Collection should be non-empty").timestamp;
|
|
|
|
let context = BacktestContext {
|
|
id: "test_cash_tracking_001".to_string(),
|
|
status: backtesting_service::foxhunt::tli::BacktestStatus::Running,
|
|
progress: 0.0,
|
|
current_date: start_time.format("%Y-%m-%d").to_string(),
|
|
trades_executed: 0,
|
|
current_pnl: 0.0,
|
|
started_at: start_time.timestamp_nanos_opt().unwrap_or(0),
|
|
completed_at: None,
|
|
error_message: None,
|
|
strategy_name: "buy_and_hold".to_string(),
|
|
symbols: vec!["AAPL".to_string()],
|
|
initial_capital: 10000.0,
|
|
parameters: HashMap::new(),
|
|
};
|
|
|
|
let trades = engine.execute_backtest(&context).await?;
|
|
|
|
// Verify trades were executed (cash was deducted for purchases)
|
|
if !trades.is_empty() {
|
|
// First trade should be a buy
|
|
assert_eq!(trades[0].side, TradeSide::Buy);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
// ============================================================================
|
|
// ORDER GENERATION AND EXECUTION TESTS
|
|
// ============================================================================
|
|
|
|
/// Test signal to order conversion
|
|
#[tokio::test]
|
|
async fn test_signal_to_order_conversion() -> Result<()> {
|
|
let market_data = generate_sample_market_data("MSFT", 10, 200.0, 0.01);
|
|
|
|
let market_data_repo = Box::new(MockMarketDataRepository::with_data(market_data.clone()));
|
|
let trading_repo = Box::new(MockTradingRepository::new());
|
|
let news_repo = Box::new(MockNewsRepository::new());
|
|
|
|
let repositories = Arc::new(MockBacktestingRepositories::new(
|
|
market_data_repo,
|
|
trading_repo,
|
|
news_repo,
|
|
))
|
|
as Arc<dyn backtesting_service::repositories::BacktestingRepositories>;
|
|
|
|
let config = BacktestingStrategyConfig::default();
|
|
let engine = StrategyEngine::new(&config, repositories).await?;
|
|
|
|
let start_time = market_data.first().expect("INVARIANT: Collection should be non-empty").timestamp;
|
|
|
|
let context = BacktestContext {
|
|
id: "test_signal_order_001".to_string(),
|
|
status: backtesting_service::foxhunt::tli::BacktestStatus::Running,
|
|
progress: 0.0,
|
|
current_date: start_time.format("%Y-%m-%d").to_string(),
|
|
trades_executed: 0,
|
|
current_pnl: 0.0,
|
|
started_at: start_time.timestamp_nanos_opt().unwrap_or(0),
|
|
completed_at: None,
|
|
error_message: None,
|
|
strategy_name: "moving_average_crossover".to_string(),
|
|
symbols: vec!["MSFT".to_string()],
|
|
initial_capital: 50000.0,
|
|
parameters: {
|
|
let mut params = HashMap::new();
|
|
params.insert("trigger_price".to_string(), "195.0".to_string());
|
|
params
|
|
},
|
|
};
|
|
|
|
let trades = engine.execute_backtest(&context).await?;
|
|
|
|
// Verify orders were generated from signals
|
|
for trade in &trades {
|
|
assert!(!trade.symbol.is_empty(), "Trade should have symbol");
|
|
assert!(trade.quantity > Decimal::ZERO, "Trade should have quantity");
|
|
assert!(
|
|
trade.entry_price > Decimal::ZERO,
|
|
"Trade should have entry price"
|
|
);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Test order execution with slippage
|
|
#[tokio::test]
|
|
async fn test_order_execution_with_slippage() -> Result<()> {
|
|
let market_data = generate_sample_market_data("AAPL", 15, 150.0, 0.015);
|
|
|
|
let market_data_repo = Box::new(MockMarketDataRepository::with_data(market_data.clone()));
|
|
let trading_repo = Box::new(MockTradingRepository::new());
|
|
let news_repo = Box::new(MockNewsRepository::new());
|
|
|
|
let repositories = Arc::new(MockBacktestingRepositories::new(
|
|
market_data_repo,
|
|
trading_repo,
|
|
news_repo,
|
|
))
|
|
as Arc<dyn backtesting_service::repositories::BacktestingRepositories>;
|
|
|
|
let config = BacktestingStrategyConfig {
|
|
commission_rate: 0.0,
|
|
slippage_rate: 0.002, // 0.2% slippage
|
|
..Default::default()
|
|
};
|
|
let engine = StrategyEngine::new(&config, repositories).await?;
|
|
|
|
let start_time = market_data.first().expect("INVARIANT: Collection should be non-empty").timestamp;
|
|
|
|
let context = BacktestContext {
|
|
id: "test_slippage_001".to_string(),
|
|
status: backtesting_service::foxhunt::tli::BacktestStatus::Running,
|
|
progress: 0.0,
|
|
current_date: start_time.format("%Y-%m-%d").to_string(),
|
|
trades_executed: 0,
|
|
current_pnl: 0.0,
|
|
started_at: start_time.timestamp_nanos_opt().unwrap_or(0),
|
|
completed_at: None,
|
|
error_message: None,
|
|
strategy_name: "buy_and_hold".to_string(),
|
|
symbols: vec!["AAPL".to_string()],
|
|
initial_capital: 20000.0,
|
|
parameters: HashMap::new(),
|
|
};
|
|
|
|
let trades = engine.execute_backtest(&context).await?;
|
|
|
|
// With slippage, effective prices should differ from market prices
|
|
if !trades.is_empty() {
|
|
// Entry price should be affected by slippage (higher for buys)
|
|
let trade = &trades[0];
|
|
if trade.side == TradeSide::Buy {
|
|
// Entry price should be slightly higher than market due to slippage
|
|
assert!(
|
|
trade.entry_price > Decimal::ZERO,
|
|
"Buy order should have positive entry price with slippage"
|
|
);
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Test commission calculation accuracy
|
|
#[tokio::test]
|
|
async fn test_commission_calculation() -> Result<()> {
|
|
let market_data = generate_sample_market_data("AAPL", 10, 100.0, 0.01);
|
|
|
|
let market_data_repo = Box::new(MockMarketDataRepository::with_data(market_data.clone()));
|
|
let trading_repo = Box::new(MockTradingRepository::new());
|
|
let news_repo = Box::new(MockNewsRepository::new());
|
|
|
|
let repositories = Arc::new(MockBacktestingRepositories::new(
|
|
market_data_repo,
|
|
trading_repo,
|
|
news_repo,
|
|
))
|
|
as Arc<dyn backtesting_service::repositories::BacktestingRepositories>;
|
|
|
|
let config = BacktestingStrategyConfig {
|
|
commission_rate: 0.005, // 0.5% commission (high for testing)
|
|
slippage_rate: 0.0,
|
|
..Default::default()
|
|
};
|
|
let engine = StrategyEngine::new(&config, repositories).await?;
|
|
|
|
let start_time = market_data.first().expect("INVARIANT: Collection should be non-empty").timestamp;
|
|
|
|
let context = BacktestContext {
|
|
id: "test_commission_001".to_string(),
|
|
status: backtesting_service::foxhunt::tli::BacktestStatus::Running,
|
|
progress: 0.0,
|
|
current_date: start_time.format("%Y-%m-%d").to_string(),
|
|
trades_executed: 0,
|
|
current_pnl: 0.0,
|
|
started_at: start_time.timestamp_nanos_opt().unwrap_or(0),
|
|
completed_at: None,
|
|
error_message: None,
|
|
strategy_name: "buy_and_hold".to_string(),
|
|
symbols: vec!["AAPL".to_string()],
|
|
initial_capital: 10000.0,
|
|
parameters: HashMap::new(),
|
|
};
|
|
|
|
let trades = engine.execute_backtest(&context).await?;
|
|
|
|
// High commission should reduce returns
|
|
if !trades.is_empty() {
|
|
// Just verify execution completed
|
|
assert!(trades[0].quantity > Decimal::ZERO);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
// ============================================================================
|
|
// MULTI-STRATEGY EXECUTION TESTS
|
|
// ============================================================================
|
|
|
|
/// Test multiple strategies on same data
|
|
#[tokio::test]
|
|
async fn test_multiple_strategies_same_data() -> Result<()> {
|
|
let market_data = generate_sample_market_data("AAPL", 30, 150.0, 0.02);
|
|
|
|
// Strategy 1: Buy and hold
|
|
let market_data_repo1 = Box::new(MockMarketDataRepository::with_data(market_data.clone()));
|
|
let trading_repo1 = Box::new(MockTradingRepository::new());
|
|
let news_repo1 = Box::new(MockNewsRepository::new());
|
|
|
|
let repos1 = Arc::new(MockBacktestingRepositories::new(
|
|
market_data_repo1,
|
|
trading_repo1,
|
|
news_repo1,
|
|
)) as Arc<dyn backtesting_service::repositories::BacktestingRepositories>;
|
|
|
|
let config = BacktestingStrategyConfig::default();
|
|
let engine1 = StrategyEngine::new(&config, repos1).await?;
|
|
|
|
// Strategy 2: Moving average crossover
|
|
let market_data_repo2 = Box::new(MockMarketDataRepository::with_data(market_data.clone()));
|
|
let trading_repo2 = Box::new(MockTradingRepository::new());
|
|
let news_repo2 = Box::new(MockNewsRepository::new());
|
|
|
|
let repos2 = Arc::new(MockBacktestingRepositories::new(
|
|
market_data_repo2,
|
|
trading_repo2,
|
|
news_repo2,
|
|
)) as Arc<dyn backtesting_service::repositories::BacktestingRepositories>;
|
|
|
|
let engine2 = StrategyEngine::new(&config, repos2).await?;
|
|
|
|
let start_time = market_data.first().expect("INVARIANT: Collection should be non-empty").timestamp;
|
|
|
|
let context1 = BacktestContext {
|
|
id: "test_multi_strat_bh_001".to_string(),
|
|
status: backtesting_service::foxhunt::tli::BacktestStatus::Running,
|
|
progress: 0.0,
|
|
current_date: start_time.format("%Y-%m-%d").to_string(),
|
|
trades_executed: 0,
|
|
current_pnl: 0.0,
|
|
started_at: start_time.timestamp_nanos_opt().unwrap_or(0),
|
|
completed_at: None,
|
|
error_message: None,
|
|
strategy_name: "buy_and_hold".to_string(),
|
|
symbols: vec!["AAPL".to_string()],
|
|
initial_capital: 10000.0,
|
|
parameters: HashMap::new(),
|
|
};
|
|
|
|
let context2 = BacktestContext {
|
|
id: "test_multi_strat_ma_001".to_string(),
|
|
status: backtesting_service::foxhunt::tli::BacktestStatus::Running,
|
|
progress: 0.0,
|
|
current_date: start_time.format("%Y-%m-%d").to_string(),
|
|
trades_executed: 0,
|
|
current_pnl: 0.0,
|
|
started_at: start_time.timestamp_nanos_opt().unwrap_or(0),
|
|
completed_at: None,
|
|
error_message: None,
|
|
strategy_name: "moving_average_crossover".to_string(),
|
|
symbols: vec!["AAPL".to_string()],
|
|
initial_capital: 10000.0,
|
|
parameters: {
|
|
let mut params = HashMap::new();
|
|
params.insert("trigger_price".to_string(), "145.0".to_string());
|
|
params
|
|
},
|
|
};
|
|
|
|
let _trades1 = engine1.execute_backtest(&context1).await?;
|
|
let _trades2 = engine2.execute_backtest(&context2).await?;
|
|
|
|
// Both strategies should execute independently
|
|
// (reaching this point means both executed successfully)
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Test strategy isolation (positions don't interfere)
|
|
#[tokio::test]
|
|
async fn test_strategy_isolation() -> Result<()> {
|
|
let symbols = vec!["AAPL".to_string(), "MSFT".to_string()];
|
|
|
|
let mut market_data = Vec::new();
|
|
market_data.extend(generate_sample_market_data("AAPL", 20, 150.0, 0.02));
|
|
market_data.extend(generate_sample_market_data("MSFT", 20, 200.0, 0.015));
|
|
|
|
let market_data_repo = Box::new(MockMarketDataRepository::with_data(market_data.clone()));
|
|
let trading_repo = Box::new(MockTradingRepository::new());
|
|
let news_repo = Box::new(MockNewsRepository::new());
|
|
|
|
let repositories = Arc::new(MockBacktestingRepositories::new(
|
|
market_data_repo,
|
|
trading_repo,
|
|
news_repo,
|
|
))
|
|
as Arc<dyn backtesting_service::repositories::BacktestingRepositories>;
|
|
|
|
let config = BacktestingStrategyConfig::default();
|
|
let engine = StrategyEngine::new(&config, repositories).await?;
|
|
|
|
let start_time = market_data.first().expect("INVARIANT: Collection should be non-empty").timestamp;
|
|
|
|
let context = BacktestContext {
|
|
id: "test_isolation_001".to_string(),
|
|
status: backtesting_service::foxhunt::tli::BacktestStatus::Running,
|
|
progress: 0.0,
|
|
current_date: start_time.format("%Y-%m-%d").to_string(),
|
|
trades_executed: 0,
|
|
current_pnl: 0.0,
|
|
started_at: start_time.timestamp_nanos_opt().unwrap_or(0),
|
|
completed_at: None,
|
|
error_message: None,
|
|
strategy_name: "buy_and_hold".to_string(),
|
|
symbols: symbols.clone(),
|
|
initial_capital: 20000.0,
|
|
parameters: {
|
|
let mut params = HashMap::new();
|
|
params.insert("allocation".to_string(), "0.5".to_string());
|
|
params
|
|
},
|
|
};
|
|
|
|
let trades = engine.execute_backtest(&context).await?;
|
|
|
|
// Verify trades are isolated by symbol
|
|
let aapl_trades: Vec<_> = trades.iter().filter(|t| t.symbol == "AAPL").collect();
|
|
let msft_trades: Vec<_> = trades.iter().filter(|t| t.symbol == "MSFT").collect();
|
|
|
|
// Each symbol should have independent positions
|
|
if !aapl_trades.is_empty() && !msft_trades.is_empty() {
|
|
assert!(
|
|
aapl_trades[0].trade_id != msft_trades[0].trade_id,
|
|
"Trades should have unique IDs"
|
|
);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
// ============================================================================
|
|
// EVENT PROCESSING TESTS
|
|
// ============================================================================
|
|
|
|
/// Test market data event processing flow
|
|
#[tokio::test]
|
|
async fn test_market_data_event_flow() -> Result<()> {
|
|
// Create sequential market data events
|
|
let mut market_data = Vec::new();
|
|
let start_time = Utc::now() - Duration::days(5);
|
|
|
|
for i in 0..5 {
|
|
let timestamp = start_time + Duration::days(i);
|
|
market_data.push(MarketData {
|
|
symbol: "AAPL".to_string(),
|
|
timestamp,
|
|
open: Decimal::from(100 + i * 2),
|
|
high: Decimal::from(102 + i * 2),
|
|
low: Decimal::from(98 + i * 2),
|
|
close: Decimal::from(101 + i * 2),
|
|
volume: Decimal::from(1000000),
|
|
timeframe: TimeFrame::Daily,
|
|
});
|
|
}
|
|
|
|
let market_data_repo = Box::new(MockMarketDataRepository::with_data(market_data.clone()));
|
|
let trading_repo = Box::new(MockTradingRepository::new());
|
|
let news_repo = Box::new(MockNewsRepository::new());
|
|
|
|
let repositories = Arc::new(MockBacktestingRepositories::new(
|
|
market_data_repo,
|
|
trading_repo,
|
|
news_repo,
|
|
))
|
|
as Arc<dyn backtesting_service::repositories::BacktestingRepositories>;
|
|
|
|
let config = BacktestingStrategyConfig::default();
|
|
let engine = StrategyEngine::new(&config, repositories).await?;
|
|
|
|
let context = BacktestContext {
|
|
id: "test_event_flow_001".to_string(),
|
|
status: backtesting_service::foxhunt::tli::BacktestStatus::Running,
|
|
progress: 0.0,
|
|
current_date: start_time.format("%Y-%m-%d").to_string(),
|
|
trades_executed: 0,
|
|
current_pnl: 0.0,
|
|
started_at: start_time.timestamp_nanos_opt().unwrap_or(0),
|
|
completed_at: None,
|
|
error_message: None,
|
|
strategy_name: "buy_and_hold".to_string(),
|
|
symbols: vec!["AAPL".to_string()],
|
|
initial_capital: 10000.0,
|
|
parameters: HashMap::new(),
|
|
};
|
|
|
|
let trades = engine.execute_backtest(&context).await?;
|
|
|
|
// Events should be processed in order
|
|
if !trades.is_empty() {
|
|
let first_trade = &trades[0];
|
|
// First trade should occur on or after start time
|
|
assert!(
|
|
first_trade.entry_time >= start_time,
|
|
"Trade entry time should be after start time"
|
|
);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Test news event integration with strategy signals
|
|
#[tokio::test]
|
|
async fn test_news_event_integration() -> Result<()> {
|
|
let symbols = vec!["TSLA".to_string()];
|
|
let market_data = generate_sample_market_data("TSLA", 20, 250.0, 0.02);
|
|
|
|
// Generate news events with varying sentiment
|
|
let news_events = generate_sample_news_events(&symbols, 15);
|
|
|
|
let market_data_repo = Box::new(MockMarketDataRepository::with_data(market_data.clone()));
|
|
let trading_repo = Box::new(MockTradingRepository::new());
|
|
let news_repo = Box::new(MockNewsRepository::with_events(news_events));
|
|
|
|
let repositories = Arc::new(MockBacktestingRepositories::new(
|
|
market_data_repo,
|
|
trading_repo,
|
|
news_repo,
|
|
))
|
|
as Arc<dyn backtesting_service::repositories::BacktestingRepositories>;
|
|
|
|
let config = BacktestingStrategyConfig::default();
|
|
let engine = StrategyEngine::new(&config, repositories).await?;
|
|
|
|
let start_time = market_data.first().expect("INVARIANT: Collection should be non-empty").timestamp;
|
|
|
|
let context = BacktestContext {
|
|
id: "test_news_integration_001".to_string(),
|
|
status: backtesting_service::foxhunt::tli::BacktestStatus::Running,
|
|
progress: 0.0,
|
|
current_date: start_time.format("%Y-%m-%d").to_string(),
|
|
trades_executed: 0,
|
|
current_pnl: 0.0,
|
|
started_at: start_time.timestamp_nanos_opt().unwrap_or(0),
|
|
completed_at: None,
|
|
error_message: None,
|
|
strategy_name: "news_aware_strategy".to_string(),
|
|
symbols: symbols.clone(),
|
|
initial_capital: 50000.0,
|
|
parameters: {
|
|
let mut params = HashMap::new();
|
|
params.insert("sentiment_threshold".to_string(), "0.2".to_string());
|
|
params.insert("max_position_size".to_string(), "0.15".to_string());
|
|
params
|
|
},
|
|
};
|
|
|
|
let trades = engine.execute_backtest(&context).await?;
|
|
|
|
// News-aware strategy should process news events
|
|
// Verify execution completed successfully (reaching this point means success)
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Test event ordering and chronological processing
|
|
#[tokio::test]
|
|
async fn test_chronological_event_processing() -> Result<()> {
|
|
// Create out-of-order market data, but repo should handle ordering
|
|
let mut market_data = Vec::new();
|
|
let base_time = Utc::now() - Duration::days(10);
|
|
|
|
for i in 0..10 {
|
|
let timestamp = base_time + Duration::days(i);
|
|
market_data.push(MarketData {
|
|
symbol: "AAPL".to_string(),
|
|
timestamp,
|
|
open: Decimal::from(100),
|
|
high: Decimal::from(102),
|
|
low: Decimal::from(98),
|
|
close: Decimal::from(100 + i),
|
|
volume: Decimal::from(1000000),
|
|
timeframe: TimeFrame::Daily,
|
|
});
|
|
}
|
|
|
|
let market_data_repo = Box::new(MockMarketDataRepository::with_data(market_data.clone()));
|
|
let trading_repo = Box::new(MockTradingRepository::new());
|
|
let news_repo = Box::new(MockNewsRepository::new());
|
|
|
|
let repositories = Arc::new(MockBacktestingRepositories::new(
|
|
market_data_repo,
|
|
trading_repo,
|
|
news_repo,
|
|
))
|
|
as Arc<dyn backtesting_service::repositories::BacktestingRepositories>;
|
|
|
|
let config = BacktestingStrategyConfig::default();
|
|
let engine = StrategyEngine::new(&config, repositories).await?;
|
|
|
|
let start_time = market_data.first().expect("INVARIANT: Collection should be non-empty").timestamp;
|
|
|
|
let context = BacktestContext {
|
|
id: "test_chronological_001".to_string(),
|
|
status: backtesting_service::foxhunt::tli::BacktestStatus::Running,
|
|
progress: 0.0,
|
|
current_date: start_time.format("%Y-%m-%d").to_string(),
|
|
trades_executed: 0,
|
|
current_pnl: 0.0,
|
|
started_at: start_time.timestamp_nanos_opt().unwrap_or(0),
|
|
completed_at: None,
|
|
error_message: None,
|
|
strategy_name: "buy_and_hold".to_string(),
|
|
symbols: vec!["AAPL".to_string()],
|
|
initial_capital: 10000.0,
|
|
parameters: HashMap::new(),
|
|
};
|
|
|
|
let trades = engine.execute_backtest(&context).await?;
|
|
|
|
// If multiple trades, verify chronological order
|
|
if trades.len() > 1 {
|
|
for i in 1..trades.len() {
|
|
assert!(
|
|
trades[i].entry_time >= trades[i - 1].entry_time,
|
|
"Trades should be in chronological order"
|
|
);
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
// ============================================================================
|
|
// EDGE CASES AND ERROR HANDLING
|
|
// ============================================================================
|
|
|
|
/// Test handling of extreme volatility
|
|
#[tokio::test]
|
|
async fn test_extreme_volatility_handling() -> Result<()> {
|
|
// Generate highly volatile market data
|
|
let market_data = generate_sample_market_data("GME", 15, 50.0, 0.5); // 50% volatility!
|
|
|
|
let market_data_repo = Box::new(MockMarketDataRepository::with_data(market_data.clone()));
|
|
let trading_repo = Box::new(MockTradingRepository::new());
|
|
let news_repo = Box::new(MockNewsRepository::new());
|
|
|
|
let repositories = Arc::new(MockBacktestingRepositories::new(
|
|
market_data_repo,
|
|
trading_repo,
|
|
news_repo,
|
|
))
|
|
as Arc<dyn backtesting_service::repositories::BacktestingRepositories>;
|
|
|
|
let config = BacktestingStrategyConfig {
|
|
commission_rate: 0.001,
|
|
slippage_rate: 0.005, // Higher slippage for volatile stocks
|
|
..Default::default()
|
|
};
|
|
let engine = StrategyEngine::new(&config, repositories).await?;
|
|
|
|
let start_time = market_data.first().expect("INVARIANT: Collection should be non-empty").timestamp;
|
|
|
|
let context = BacktestContext {
|
|
id: "test_volatility_001".to_string(),
|
|
status: backtesting_service::foxhunt::tli::BacktestStatus::Running,
|
|
progress: 0.0,
|
|
current_date: start_time.format("%Y-%m-%d").to_string(),
|
|
trades_executed: 0,
|
|
current_pnl: 0.0,
|
|
started_at: start_time.timestamp_nanos_opt().unwrap_or(0),
|
|
completed_at: None,
|
|
error_message: None,
|
|
strategy_name: "buy_and_hold".to_string(),
|
|
symbols: vec!["GME".to_string()],
|
|
initial_capital: 10000.0,
|
|
parameters: HashMap::new(),
|
|
};
|
|
|
|
// Should handle extreme volatility without panicking
|
|
let result = engine.execute_backtest(&context).await;
|
|
assert!(
|
|
result.is_ok(),
|
|
"Should handle extreme volatility gracefully"
|
|
);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Test zero/negative price edge case
|
|
#[tokio::test]
|
|
async fn test_zero_price_handling() -> Result<()> {
|
|
// Create market data with a zero price (edge case)
|
|
let start_time = Utc::now() - Duration::days(3);
|
|
let market_data = vec![
|
|
MarketData {
|
|
symbol: "TEST".to_string(),
|
|
timestamp: start_time,
|
|
open: Decimal::from(100),
|
|
high: Decimal::from(102),
|
|
low: Decimal::from(98),
|
|
close: Decimal::from(100),
|
|
volume: Decimal::from(1000000),
|
|
timeframe: TimeFrame::Daily,
|
|
},
|
|
MarketData {
|
|
symbol: "TEST".to_string(),
|
|
timestamp: start_time + Duration::days(1),
|
|
open: Decimal::ZERO, // Edge case: zero price
|
|
high: Decimal::ZERO,
|
|
low: Decimal::ZERO,
|
|
close: Decimal::ZERO,
|
|
volume: Decimal::from(0),
|
|
timeframe: TimeFrame::Daily,
|
|
},
|
|
];
|
|
|
|
let market_data_repo = Box::new(MockMarketDataRepository::with_data(market_data.clone()));
|
|
let trading_repo = Box::new(MockTradingRepository::new());
|
|
let news_repo = Box::new(MockNewsRepository::new());
|
|
|
|
let repositories = Arc::new(MockBacktestingRepositories::new(
|
|
market_data_repo,
|
|
trading_repo,
|
|
news_repo,
|
|
))
|
|
as Arc<dyn backtesting_service::repositories::BacktestingRepositories>;
|
|
|
|
let config = BacktestingStrategyConfig::default();
|
|
let engine = StrategyEngine::new(&config, repositories).await?;
|
|
|
|
let context = BacktestContext {
|
|
id: "test_zero_price_001".to_string(),
|
|
status: backtesting_service::foxhunt::tli::BacktestStatus::Running,
|
|
progress: 0.0,
|
|
current_date: start_time.format("%Y-%m-%d").to_string(),
|
|
trades_executed: 0,
|
|
current_pnl: 0.0,
|
|
started_at: start_time.timestamp_nanos_opt().unwrap_or(0),
|
|
completed_at: None,
|
|
error_message: None,
|
|
strategy_name: "buy_and_hold".to_string(),
|
|
symbols: vec!["TEST".to_string()],
|
|
initial_capital: 10000.0,
|
|
parameters: HashMap::new(),
|
|
};
|
|
|
|
// Should handle zero prices without dividing by zero
|
|
let result = engine.execute_backtest(&context).await;
|
|
assert!(result.is_ok(), "Should handle zero prices gracefully");
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Test strategy with invalid parameters
|
|
#[tokio::test]
|
|
async fn test_invalid_strategy_parameters() -> Result<()> {
|
|
let market_data = generate_sample_market_data("AAPL", 10, 150.0, 0.01);
|
|
|
|
let market_data_repo = Box::new(MockMarketDataRepository::with_data(market_data.clone()));
|
|
let trading_repo = Box::new(MockTradingRepository::new());
|
|
let news_repo = Box::new(MockNewsRepository::new());
|
|
|
|
let repositories = Arc::new(MockBacktestingRepositories::new(
|
|
market_data_repo,
|
|
trading_repo,
|
|
news_repo,
|
|
))
|
|
as Arc<dyn backtesting_service::repositories::BacktestingRepositories>;
|
|
|
|
let config = BacktestingStrategyConfig::default();
|
|
let engine = StrategyEngine::new(&config, repositories).await?;
|
|
|
|
let start_time = market_data.first().expect("INVARIANT: Collection should be non-empty").timestamp;
|
|
|
|
let context = BacktestContext {
|
|
id: "test_invalid_params_002".to_string(),
|
|
status: backtesting_service::foxhunt::tli::BacktestStatus::Running,
|
|
progress: 0.0,
|
|
current_date: start_time.format("%Y-%m-%d").to_string(),
|
|
trades_executed: 0,
|
|
current_pnl: 0.0,
|
|
started_at: start_time.timestamp_nanos_opt().unwrap_or(0),
|
|
completed_at: None,
|
|
error_message: None,
|
|
strategy_name: "moving_average_crossover".to_string(),
|
|
symbols: vec!["AAPL".to_string()],
|
|
initial_capital: 10000.0,
|
|
parameters: {
|
|
let mut params = HashMap::new();
|
|
params.insert("trigger_price".to_string(), "invalid_number".to_string());
|
|
params
|
|
},
|
|
};
|
|
|
|
// Should handle invalid parameters gracefully (parse error → fallback)
|
|
let result = engine.execute_backtest(&context).await;
|
|
assert!(
|
|
result.is_ok(),
|
|
"Should handle invalid parameters without panic"
|
|
);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Test non-existent strategy name
|
|
#[tokio::test]
|
|
async fn test_nonexistent_strategy() -> Result<()> {
|
|
let market_data_repo = Box::new(MockMarketDataRepository::new());
|
|
let trading_repo = Box::new(MockTradingRepository::new());
|
|
let news_repo = Box::new(MockNewsRepository::new());
|
|
|
|
let repositories = Arc::new(MockBacktestingRepositories::new(
|
|
market_data_repo,
|
|
trading_repo,
|
|
news_repo,
|
|
))
|
|
as Arc<dyn backtesting_service::repositories::BacktestingRepositories>;
|
|
|
|
let config = BacktestingStrategyConfig::default();
|
|
let engine = StrategyEngine::new(&config, repositories).await?;
|
|
|
|
let now = Utc::now();
|
|
let context = BacktestContext {
|
|
id: "test_nonexistent_001".to_string(),
|
|
status: backtesting_service::foxhunt::tli::BacktestStatus::Running,
|
|
progress: 0.0,
|
|
current_date: now.format("%Y-%m-%d").to_string(),
|
|
trades_executed: 0,
|
|
current_pnl: 0.0,
|
|
started_at: now.timestamp_nanos_opt().unwrap_or(0),
|
|
completed_at: None,
|
|
error_message: None,
|
|
strategy_name: "nonexistent_strategy_xyz".to_string(),
|
|
symbols: vec!["AAPL".to_string()],
|
|
initial_capital: 10000.0,
|
|
parameters: HashMap::new(),
|
|
};
|
|
|
|
// Should return error for non-existent strategy
|
|
let result = engine.execute_backtest(&context).await;
|
|
assert!(result.is_err(), "Should error for non-existent strategy");
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Test PnL calculation accuracy across multiple trades
|
|
#[tokio::test]
|
|
async fn test_pnl_calculation_accuracy() -> Result<()> {
|
|
// Create predictable price movements for PnL testing
|
|
let start_time = Utc::now() - Duration::days(5);
|
|
let market_data = vec![
|
|
MarketData {
|
|
symbol: "AAPL".to_string(),
|
|
timestamp: start_time,
|
|
open: Decimal::from(100),
|
|
high: Decimal::from(102),
|
|
low: Decimal::from(98),
|
|
close: Decimal::from(100),
|
|
volume: Decimal::from(1000000),
|
|
timeframe: TimeFrame::Daily,
|
|
},
|
|
MarketData {
|
|
symbol: "AAPL".to_string(),
|
|
timestamp: start_time + Duration::days(1),
|
|
open: Decimal::from(100),
|
|
high: Decimal::from(112),
|
|
low: Decimal::from(98),
|
|
close: Decimal::from(110), // +10% gain
|
|
volume: Decimal::from(1500000),
|
|
timeframe: TimeFrame::Daily,
|
|
},
|
|
];
|
|
|
|
let market_data_repo = Box::new(MockMarketDataRepository::with_data(market_data.clone()));
|
|
let trading_repo = Box::new(MockTradingRepository::new());
|
|
let news_repo = Box::new(MockNewsRepository::new());
|
|
|
|
let repositories = Arc::new(MockBacktestingRepositories::new(
|
|
market_data_repo,
|
|
trading_repo,
|
|
news_repo,
|
|
))
|
|
as Arc<dyn backtesting_service::repositories::BacktestingRepositories>;
|
|
|
|
let config = BacktestingStrategyConfig {
|
|
commission_rate: 0.0,
|
|
slippage_rate: 0.0,
|
|
..Default::default()
|
|
};
|
|
let engine = StrategyEngine::new(&config, repositories).await?;
|
|
|
|
let context = BacktestContext {
|
|
id: "test_pnl_001".to_string(),
|
|
status: backtesting_service::foxhunt::tli::BacktestStatus::Running,
|
|
progress: 0.0,
|
|
current_date: start_time.format("%Y-%m-%d").to_string(),
|
|
trades_executed: 0,
|
|
current_pnl: 0.0,
|
|
started_at: start_time.timestamp_nanos_opt().unwrap_or(0),
|
|
completed_at: None,
|
|
error_message: None,
|
|
strategy_name: "buy_and_hold".to_string(),
|
|
symbols: vec!["AAPL".to_string()],
|
|
initial_capital: 10000.0,
|
|
parameters: HashMap::new(),
|
|
};
|
|
|
|
let trades = engine.execute_backtest(&context).await?;
|
|
|
|
// Buy and hold with no costs should track price movements accurately
|
|
// Note: buy_and_hold only buys once and holds, so no sell trades
|
|
if !trades.is_empty() {
|
|
assert_eq!(trades[0].side, TradeSide::Buy);
|
|
// For buy-and-hold, there's no exit, so no PnL to verify here
|
|
}
|
|
|
|
Ok(())
|
|
}
|