aitbc/apps/ai-engine/tests/test_integration_ai_engine.py

"""Integration tests for AI engine service"""

import pytest
import sys
import sys
from pathlib import Path
from datetime import datetime, timezone
from unittest.mock import Mock, patch, MagicMock
from fastapi.testclient import TestClient


# Mock numpy before importing
sys.modules['numpy'] = MagicMock()

from ai_service import app, ai_engine


@pytest.mark.integration
def test_analyze_market_endpoint():
    """Test /api/ai/analyze endpoint"""
    client = TestClient(app)
    
    with patch('ai_service.np.random.uniform') as mock_uniform:
        mock_uniform.side_effect = [0.005, 0.02, 5000, 50, 0.005, 0.03, 0.01, 0.8, 0.6, 0.03, 0.5, 0.4]
        with patch('ai_service.np.random.choice') as mock_choice:
            mock_choice.return_value = 'bullish'
            
            response = client.post("/api/ai/analyze", json={"symbol": "AITBC/BTC", "analysis_type": "full"})
            
            assert response.status_code == 200
            data = response.json()
            assert data['status'] == 'success'
            assert 'analysis' in data
            assert data['analysis']['symbol'] == 'AITBC/BTC'


@pytest.mark.integration
def test_execute_ai_trade_endpoint():
    """Test /api/ai/trade endpoint"""
    client = TestClient(app)
    
    with patch('ai_service.np.random.uniform') as mock_uniform:
        mock_uniform.side_effect = [0.005, 0.02, 5000, 50, 0.005, 0.03, 0.01, 0.8, 0.6, 0.03, 0.5, 0.4, 0.5, 0.3, 0.1]
        with patch('ai_service.np.random.choice') as mock_choice:
            mock_choice.return_value = 'bullish'
            
            response = client.post("/api/ai/trade", json={"symbol": "AITBC/BTC", "strategy": "ai_enhanced"})
            
            assert response.status_code == 200
            data = response.json()
            assert data['status'] == 'success'
            assert 'decision' in data
            assert data['decision']['symbol'] == 'AITBC/BTC'
            assert 'signal' in data['decision']


@pytest.mark.integration
def test_predict_market_endpoint():
    """Test /api/ai/predict/{symbol} endpoint"""
    client = TestClient(app)
    
    with patch('ai_service.np.random.uniform') as mock_uniform:
        mock_uniform.side_effect = [0.005, 0.02, 5000, 50, 0.005, 0.03, 0.01, 0.8, 0.6, 0.03, 0.5, 0.4]
        with patch('ai_service.np.random.choice') as mock_choice:
            mock_choice.return_value = 'bullish'
            
            response = client.get("/api/ai/predict/AITBC-BTC")
            
            assert response.status_code == 200
            data = response.json()
            assert data['status'] == 'success'
            assert 'predictions' in data
            assert 'price' in data['predictions']
            assert 'risk' in data['predictions']
            assert 'sentiment' in data['predictions']


@pytest.mark.integration
def test_get_ai_dashboard_endpoint():
    """Test /api/ai/dashboard endpoint"""
    client = TestClient(app)
    
    # The dashboard endpoint calls analyze_market and make_trading_decision multiple times
    # Mock the entire ai_engine methods to avoid complex numpy mocking
    with patch.object(ai_engine, 'analyze_market') as mock_analyze, \
         patch.object(ai_engine, 'make_trading_decision') as mock_decision:
        
        mock_analyze.return_value = {
            'symbol': 'AITBC/BTC',
            'current_price': 0.005,
            'price_change_24h': 0.02,
            'volume_24h': 5000,
            'rsi': 50,
            'macd': 0.005,
            'volatility': 0.03,
            'ai_predictions': {
                'price_prediction': {'predicted_change': 0.01, 'confidence': 0.8},
                'risk_assessment': {'risk_score': 0.5, 'volatility': 0.03},
                'sentiment_analysis': {'sentiment_score': 0.5, 'overall_sentiment': 'bullish'}
            },
            'timestamp': datetime.now(timezone.utc)
        }
        
        mock_decision.return_value = {
            'symbol': 'AITBC/BTC',
            'signal': 'buy',
            'confidence': 0.5,
            'quantity': 500,
            'price': 0.005,
            'reasoning': 'Test reasoning',
            'timestamp': datetime.now(timezone.utc)
        }
        
        response = client.get("/api/ai/dashboard")
        
        assert response.status_code == 200
        data = response.json()
        assert data['status'] == 'success'
        assert 'dashboard' in data
        assert 'market_overview' in data['dashboard']
        assert 'symbol_analysis' in data['dashboard']
        assert len(data['dashboard']['symbol_analysis']) == 3


@pytest.mark.integration
def test_get_ai_status_endpoint():
    """Test /api/ai/status endpoint"""
    client = TestClient(app)
    
    response = client.get("/api/ai/status")
    
    assert response.status_code == 200
    data = response.json()
    assert data['status'] == 'active'
    assert data['models_loaded'] is True
    assert 'services' in data
    assert 'capabilities' in data
    assert 'trading_engine' in data['services']
    assert 'market_analysis' in data['services']


@pytest.mark.integration
def test_health_check_endpoint():
    """Test /api/health endpoint"""
    client = TestClient(app)
    
    response = client.get("/api/health")
    
    assert response.status_code == 200
    data = response.json()
    assert data['status'] == 'ok'


@pytest.mark.integration
def test_analyze_market_with_default_strategy():
    """Test analyze endpoint with default strategy"""
    client = TestClient(app)
    
    with patch('ai_service.np.random.uniform') as mock_uniform:
        mock_uniform.side_effect = [0.005, 0.02, 5000, 50, 0.005, 0.03, 0.01, 0.8, 0.6, 0.03, 0.5, 0.4]
        with patch('ai_service.np.random.choice') as mock_choice:
            mock_choice.return_value = 'bullish'
            
            response = client.post("/api/ai/analyze", json={"symbol": "AITBC/ETH"})
            
            assert response.status_code == 200
            data = response.json()
            assert data['status'] == 'success'


@pytest.mark.integration
def test_trade_endpoint_with_default_strategy():
    """Test trade endpoint with default strategy"""
    client = TestClient(app)
    
    with patch('ai_service.np.random.uniform') as mock_uniform:
        mock_uniform.side_effect = [0.005, 0.02, 5000, 50, 0.005, 0.03, 0.01, 0.8, 0.6, 0.03, 0.5, 0.4, 0.5, 0.3, 0.1]
        with patch('ai_service.np.random.choice') as mock_choice:
            mock_choice.return_value = 'bullish'
            
            response = client.post("/api/ai/trade", json={"symbol": "AITBC/USDT"})
            
            assert response.status_code == 200
            data = response.json()
            assert data['status'] == 'success'