Local changes: Updated model training, removed debug instrumentation, and configuration improvements

tests/unit/backend/core/test_dependencies.py

@@ -0,0 +1,77 @@
+"""Tests for backend dependencies."""
+
+import pytest
+from unittest.mock import patch, Mock
+from backend.core.dependencies import (
+    get_database, get_trading_engine, get_portfolio_tracker,
+    get_strategy_registry, get_backtesting_engine, get_exchange_factory
+)
+
+
+class TestGetDatabase:
+    """Tests for get_database dependency."""
+    
+    def test_get_database_singleton(self):
+        """Test that get_database returns same instance."""
+        db1 = get_database()
+        db2 = get_database()
+        # Should be cached/same instance due to lru_cache
+        assert db1 is db2
+
+
+class TestGetTradingEngine:
+    """Tests for get_trading_engine dependency."""
+    
+    @patch('backend.core.dependencies.get_trading_engine')
+    def test_get_trading_engine(self, mock_get_engine):
+        """Test getting trading engine."""
+        mock_engine = Mock()
+        mock_get_engine.return_value = mock_engine
+        engine = get_trading_engine()
+        assert engine is not None
+
+
+class TestGetPortfolioTracker:
+    """Tests for get_portfolio_tracker dependency."""
+    
+    @patch('backend.core.dependencies.get_portfolio_tracker')
+    def test_get_portfolio_tracker(self, mock_get_tracker):
+        """Test getting portfolio tracker."""
+        mock_tracker = Mock()
+        mock_get_tracker.return_value = mock_tracker
+        tracker = get_portfolio_tracker()
+        assert tracker is not None
+
+
+class TestGetStrategyRegistry:
+    """Tests for get_strategy_registry dependency."""
+    
+    @patch('backend.core.dependencies.get_strategy_registry')
+    def test_get_strategy_registry(self, mock_get_registry):
+        """Test getting strategy registry."""
+        mock_registry = Mock()
+        mock_get_registry.return_value = mock_registry
+        registry = get_strategy_registry()
+        assert registry is not None
+
+
+class TestGetBacktestingEngine:
+    """Tests for get_backtesting_engine dependency."""
+    
+    @patch('backend.core.dependencies.get_backtesting_engine')
+    def test_get_backtesting_engine(self, mock_get_engine):
+        """Test getting backtesting engine."""
+        mock_engine = Mock()
+        mock_get_engine.return_value = mock_engine
+        engine = get_backtesting_engine()
+        assert engine is not None
+
+
+class TestGetExchangeFactory:
+    """Tests for get_exchange_factory dependency."""
+    
+    def test_get_exchange_factory(self):
+        """Test getting exchange factory."""
+        factory = get_exchange_factory()
+        assert factory is not None
+

tests/unit/backend/core/test_schemas.py

@@ -0,0 +1,128 @@
+"""Tests for Pydantic schemas."""
+
+import pytest
+from decimal import Decimal
+from datetime import datetime
+from pydantic import ValidationError
+
+from backend.core.schemas import (
+    OrderCreate, OrderResponse, OrderSide, OrderType, OrderStatus,
+    PositionResponse, PortfolioResponse, PortfolioHistoryResponse
+)
+
+
+class TestOrderCreate:
+    """Tests for OrderCreate schema."""
+    
+    def test_order_create_valid(self):
+        """Test valid order creation."""
+        order = OrderCreate(
+            exchange_id=1,
+            symbol="BTC/USD",
+            side=OrderSide.BUY,
+            order_type=OrderType.MARKET,
+            quantity=Decimal("0.1"),
+            paper_trading=True
+        )
+        assert order.exchange_id == 1
+        assert order.symbol == "BTC/USD"
+        assert order.side == OrderSide.BUY
+    
+    def test_order_create_with_price(self):
+        """Test order creation with price."""
+        order = OrderCreate(
+            exchange_id=1,
+            symbol="BTC/USD",
+            side=OrderSide.BUY,
+            order_type=OrderType.LIMIT,
+            quantity=Decimal("0.1"),
+            price=Decimal("50000"),
+            paper_trading=True
+        )
+        assert order.price == Decimal("50000")
+    
+    def test_order_create_invalid_side(self):
+        """Test order creation with invalid side."""
+        with pytest.raises(ValidationError):
+            OrderCreate(
+                exchange_id=1,
+                symbol="BTC/USD",
+                side="invalid",
+                order_type=OrderType.MARKET,
+                quantity=Decimal("0.1")
+            )
+
+
+class TestOrderResponse:
+    """Tests for OrderResponse schema."""
+    
+    def test_order_response_from_dict(self):
+        """Test creating OrderResponse from dictionary."""
+        order_data = {
+            "id": 1,
+            "exchange_id": 1,
+            "strategy_id": None,
+            "symbol": "BTC/USD",
+            "order_type": OrderType.MARKET,
+            "side": OrderSide.BUY,
+            "status": OrderStatus.FILLED,
+            "quantity": Decimal("0.1"),
+            "price": Decimal("50000"),
+            "filled_quantity": Decimal("0.1"),
+            "average_fill_price": Decimal("50000"),
+            "fee": Decimal("5"),
+            "paper_trading": True,
+            "created_at": datetime.now(),
+            "updated_at": datetime.now(),
+            "filled_at": datetime.now()
+        }
+        
+        order = OrderResponse(**order_data)
+        assert order.id == 1
+        assert order.symbol == "BTC/USD"
+
+
+class TestPositionResponse:
+    """Tests for PositionResponse schema."""
+    
+    def test_position_response_valid(self):
+        """Test valid position response."""
+        position = PositionResponse(
+            symbol="BTC/USD",
+            quantity=Decimal("0.1"),
+            entry_price=Decimal("50000"),
+            current_price=Decimal("51000"),
+            unrealized_pnl=Decimal("100"),
+            realized_pnl=Decimal("0")
+        )
+        assert position.symbol == "BTC/USD"
+        assert position.unrealized_pnl == Decimal("100")
+
+
+class TestPortfolioResponse:
+    """Tests for PortfolioResponse schema."""
+    
+    def test_portfolio_response_valid(self):
+        """Test valid portfolio response."""
+        portfolio = PortfolioResponse(
+            positions=[],
+            performance={"total_return": 0.1},
+            timestamp="2025-01-01T00:00:00"
+        )
+        assert portfolio.positions == []
+        assert portfolio.performance["total_return"] == 0.1
+
+
+class TestPortfolioHistoryResponse:
+    """Tests for PortfolioHistoryResponse schema."""
+    
+    def test_portfolio_history_response_valid(self):
+        """Test valid portfolio history response."""
+        history = PortfolioHistoryResponse(
+            dates=["2025-01-01", "2025-01-02"],
+            values=[1000.0, 1100.0],
+            pnl=[0.0, 100.0]
+        )
+        assert len(history.dates) == 2
+        assert len(history.values) == 2
+