finished initial backtest / engine

apps/stock/orchestrator/test-order-flow.ts

@@ -0,0 +1,122 @@
+#!/usr/bin/env bun
+
+/**
+ * Test order flow through the full backtest system
+ */
+
+import { BacktestEngine } from './src/backtest/BacktestEngine';
+import { StrategyManager } from './src/strategies/StrategyManager';
+import { StorageService } from './src/services/StorageService';
+import { getLogger } from '@stock-bot/logger';
+import { SimpleMovingAverageCrossover } from './src/strategies/examples/SimpleMovingAverageCrossover';
+
+async function testOrderFlow() {
+  console.log('Testing order flow in backtest...\n');
+  
+  // Create minimal container
+  const logger = getLogger('test');
+  const container = {
+    logger,
+    custom: {}
+  };
+  
+  // Create services
+  const storageService = new StorageService(container as any);
+  const strategyManager = new StrategyManager(container as any);
+  
+  // First test the strategy directly
+  console.log('=== Testing Strategy Directly ===');
+  const testStrategy = new SimpleMovingAverageCrossover({
+    id: 'test-direct',
+    name: 'Direct Test',
+    enabled: true,
+    symbols: ['AAPL'],
+    allocation: 1.0
+  }, null, null);
+  
+  let directSignals = 0;
+  let directOrders = 0;
+  
+  testStrategy.on('signal', (signal) => {
+    directSignals++;
+    console.log(`Direct signal #${directSignals}:`, signal);
+  });
+  
+  testStrategy.on('order', (order) => {
+    directOrders++;
+    console.log(`Direct order #${directOrders}:`, order);
+  });
+  
+  await testStrategy.start();
+  
+  // Generate test data with clear crossover
+  for (let i = 0; i < 30; i++) {
+    const basePrice = 100;
+    const price = i < 15 ? basePrice - i * 0.5 : basePrice + (i - 15) * 0.5;
+    
+    await testStrategy.onMarketData({
+      type: 'bar',
+      data: {
+        symbol: 'AAPL',
+        open: price,
+        high: price + 1,
+        low: price - 1,
+        close: price,
+        volume: 1000000,
+        timestamp: Date.now() + i * 86400000
+      }
+    });
+  }
+  
+  await testStrategy.stop();
+  console.log(`\nDirect test: ${directSignals} signals, ${directOrders} orders\n`);
+  
+  // Now test through backtest engine
+  console.log('=== Testing Through Backtest Engine ===');
+  
+  // Create backtest engine (it will initialize strategies)
+  const backtestEngine = new BacktestEngine(container as any, storageService, strategyManager);
+  
+  // Hook into backtest engine to see what's happening
+  const origProcessMarketData = (backtestEngine as any).processMarketData;
+  (backtestEngine as any).processMarketData = async function(data: any) {
+    console.log(`Processing market data: ${data.data.symbol} @ ${data.data.close}`);
+    return origProcessMarketData.call(this, data);
+  };
+  
+  const origCheckAndFillOrders = (backtestEngine as any).checkAndFillOrders;
+  (backtestEngine as any).checkAndFillOrders = async function(data: any) {
+    const pendingCount = this.pendingOrders.size;
+    if (pendingCount > 0) {
+      console.log(`Checking ${pendingCount} pending orders...`);
+    }
+    return origCheckAndFillOrders.call(this, data);
+  };
+  
+  const config = {
+    mode: 'backtest',
+    name: 'Order Flow Test',
+    strategy: 'sma-crossover',
+    symbols: ['AAPL'],
+    startDate: '2023-01-01T00:00:00Z',
+    endDate: '2023-02-01T00:00:00Z',  // Just 1 month
+    initialCapital: 100000,
+    dataFrequency: '1d',
+    commission: 0.001,
+    slippage: 0.0001
+  };
+  
+  try {
+    const result = await backtestEngine.runBacktest(config);
+    
+    console.log('\nBacktest Results:');
+    console.log(`Total Return: ${result.metrics.totalReturn.toFixed(2)}%`);
+    console.log(`Total Trades: ${result.metrics.totalTrades}`);
+    console.log(`Trades in history: ${result.trades.length}`);
+    
+  } catch (error) {
+    console.error('Backtest failed:', error);
+  }
+}
+
+testOrderFlow().catch(console.error);