test(chat): add comprehensive tests for emergency chat endpoint

- Add unit tests for intent detection and Maritaca integration
- Add integration tests for performance and concurrency
- Test fallback behavior when external services fail
- Verify session continuity and error recovery
- Test response variety and metadata consistency
- Add health endpoint monitoring tests

tests/integration/test_chat_emergency_integration.py

@@ -0,0 +1,209 @@
+"""Integration tests for emergency chat endpoint"""
+
+import pytest
+import asyncio
+from fastapi.testclient import TestClient
+from unittest.mock import patch
+import time
+
+from src.api.routes.chat_emergency import router
+
+
+class TestEmergencyEndpointIntegration:
+    """Integration tests for emergency chat endpoint"""
+    
+    @pytest.fixture
+    def app(self):
+        """Create FastAPI app with emergency router"""
+        from fastapi import FastAPI
+        app = FastAPI()
+        app.include_router(router)
+        return app
+    
+    @pytest.fixture
+    def client(self, app):
+        """Create test client"""
+        return TestClient(app)
+    
+    def test_emergency_endpoint_performance(self, client):
+        """Test emergency endpoint response time"""
+        messages = [
+            "Olá!",
+            "Quero investigar contratos",
+            "Como funciona o sistema?",
+            "Mostre gastos de 2024",
+            "Analise fornecedor XYZ"
+        ]
+        
+        response_times = []
+        
+        for message in messages:
+            start_time = time.time()
+            response = client.post(
+                "/api/v1/chat/emergency",
+                json={"message": message}
+            )
+            end_time = time.time()
+            
+            assert response.status_code == 200
+            response_times.append(end_time - start_time)
+        
+        # Verify all responses are fast (under 100ms for fallback)
+        assert all(t < 0.1 for t in response_times), f"Response times: {response_times}"
+        
+        # Average should be very fast
+        avg_time = sum(response_times) / len(response_times)
+        assert avg_time < 0.05, f"Average response time: {avg_time}"
+    
+    def test_emergency_endpoint_concurrent_requests(self, client):
+        """Test emergency endpoint under concurrent load"""
+        import concurrent.futures
+        
+        def make_request(message):
+            response = client.post(
+                "/api/v1/chat/emergency",
+                json={"message": message}
+            )
+            return response.status_code, response.json()
+        
+        messages = [f"Teste concorrente {i}" for i in range(20)]
+        
+        with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
+            futures = [executor.submit(make_request, msg) for msg in messages]
+            results = [future.result() for future in concurrent.futures.as_completed(futures)]
+        
+        # All requests should succeed
+        assert all(status == 200 for status, _ in results)
+        
+        # All should have valid responses
+        for _, data in results:
+            assert "session_id" in data
+            assert "message" in data
+            assert len(data["message"]) > 0
+    
+    def test_emergency_endpoint_session_continuity(self, client):
+        """Test session continuity across multiple messages"""
+        session_id = "test-session-continuity"
+        
+        messages = [
+            "Olá!",
+            "Quero investigar contratos",
+            "Mostre os mais recentes"
+        ]
+        
+        for i, message in enumerate(messages):
+            response = client.post(
+                "/api/v1/chat/emergency",
+                json={"message": message, "session_id": session_id}
+            )
+            
+            assert response.status_code == 200
+            data = response.json()
+            assert data["session_id"] == session_id
+            
+            # Verify response makes sense for the intent
+            if i == 0:  # Greeting
+                assert data["metadata"]["intent"] == "greeting"
+            elif i == 1:  # Investigation
+                assert data["metadata"]["intent"] == "investigation"
+    
+    def test_emergency_endpoint_error_recovery(self, client):
+        """Test emergency endpoint handles errors gracefully"""
+        # Test with various edge cases
+        edge_cases = [
+            {"message": "a"},  # Very short
+            {"message": "?" * 100},  # Special characters
+            {"message": "SELECT * FROM users"},  # SQL-like
+            {"message": "<script>alert('test')</script>"},  # XSS attempt
+            {"message": "😀" * 50},  # Emojis
+        ]
+        
+        for payload in edge_cases:
+            response = client.post(
+                "/api/v1/chat/emergency",
+                json=payload
+            )
+            
+            assert response.status_code == 200
+            data = response.json()
+            assert "message" in data
+            assert len(data["message"]) > 0
+            assert "error" not in data
+    
+    @pytest.mark.asyncio
+    async def test_emergency_endpoint_maritaca_fallback(self, client):
+        """Test fallback when Maritaca fails"""
+        with patch.dict('os.environ', {'MARITACA_API_KEY': 'test-key'}):
+            # Mock Maritaca to fail
+            with patch('httpx.AsyncClient') as mock_client:
+                mock_instance = mock_client.return_value.__aenter__.return_value
+                mock_instance.post.side_effect = Exception("API Error")
+                
+                response = client.post(
+                    "/api/v1/chat/emergency",
+                    json={"message": "Test with failed Maritaca"}
+                )
+                
+                assert response.status_code == 200
+                data = response.json()
+                
+                # Should fallback to intelligent responses
+                assert data["agent_id"] == "system"
+                assert data["metadata"]["backend"] == "intelligent_fallback"
+                assert len(data["message"]) > 0
+    
+    def test_emergency_endpoint_response_variety(self, client):
+        """Test that responses vary for same intent"""
+        responses = []
+        
+        # Send same greeting multiple times
+        for _ in range(5):
+            response = client.post(
+                "/api/v1/chat/emergency",
+                json={"message": "Olá!"}
+            )
+            
+            assert response.status_code == 200
+            data = response.json()
+            responses.append(data["message"])
+        
+        # Should have some variety in responses
+        unique_responses = set(responses)
+        assert len(unique_responses) >= 2, "Responses should vary"
+    
+    def test_emergency_health_monitoring(self, client):
+        """Test health endpoint provides accurate status"""
+        # Test without Maritaca
+        with patch.dict('os.environ', {}, clear=True):
+            response = client.get("/api/v1/chat/emergency/health")
+            assert response.status_code == 200
+            data = response.json()
+            assert data["status"] == "operational"
+            assert data["maritaca_configured"] is False
+        
+        # Test with Maritaca
+        with patch.dict('os.environ', {'MARITACA_API_KEY': 'test-key'}):
+            response = client.get("/api/v1/chat/emergency/health")
+            assert response.status_code == 200
+            data = response.json()
+            assert data["maritaca_configured"] is True
+    
+    def test_emergency_endpoint_metadata_consistency(self, client):
+        """Test metadata is consistent and complete"""
+        response = client.post(
+            "/api/v1/chat/emergency",
+            json={"message": "Test metadata"}
+        )
+        
+        assert response.status_code == 200
+        data = response.json()
+        
+        # Check required metadata fields
+        assert "backend" in data["metadata"]
+        assert "timestamp" in data["metadata"]
+        assert "intent" in data["metadata"]
+        
+        # Timestamp should be valid ISO format
+        from datetime import datetime
+        timestamp = datetime.fromisoformat(data["metadata"]["timestamp"])
+        assert timestamp.year >= 2024

tests/unit/test_chat_emergency.py

@@ -0,0 +1,280 @@
+"""Unit tests for emergency chat endpoint"""
+
+import pytest
+from unittest.mock import patch, AsyncMock
+from fastapi.testclient import TestClient
+from httpx import Response
+import json
+
+from src.api.routes.chat_emergency import (
+    router,
+    detect_intent,
+    try_maritaca,
+    ChatRequest,
+    ChatResponse
+)
+
+
+class TestDetectIntent:
+    """Test intent detection function"""
+    
+    def test_detect_greeting_intent(self):
+        """Test greeting intent detection"""
+        greetings = ["olá", "Oi", "bom dia", "Boa tarde", "BOA NOITE", "prazer"]
+        for greeting in greetings:
+            assert detect_intent(greeting) == "greeting"
+            assert detect_intent(f"{greeting}, como vai?") == "greeting"
+    
+    def test_detect_investigation_intent(self):
+        """Test investigation intent detection"""
+        investigations = [
+            "investigar contratos",
+            "verificar gastos",
+            "analisar fornecedores",
+            "buscar licitações",
+            "procurar irregularidades"
+        ]
+        for text in investigations:
+            assert detect_intent(text) == "investigation"
+    
+    def test_detect_help_intent(self):
+        """Test help intent detection"""
+        help_texts = [
+            "ajuda",
+            "pode me ajudar",
+            "o que você consegue fazer",
+            "como funciona",
+            "o que posso perguntar"
+        ]
+        for text in help_texts:
+            assert detect_intent(text) == "help"
+    
+    def test_detect_default_intent(self):
+        """Test default intent for unmatched texts"""
+        defaults = [
+            "quero saber sobre contratos",
+            "mostre gastos de 2024",
+            "fornecedor XYZ"
+        ]
+        for text in defaults:
+            assert detect_intent(text) == "default"
+
+
+class TestTryMaritaca:
+    """Test Maritaca AI integration"""
+    
+    @pytest.mark.asyncio
+    async def test_maritaca_without_api_key(self):
+        """Test Maritaca returns None without API key"""
+        with patch.dict('os.environ', {}, clear=True):
+            result = await try_maritaca("test message")
+            assert result is None
+    
+    @pytest.mark.asyncio
+    async def test_maritaca_successful_request(self):
+        """Test successful Maritaca API call"""
+        with patch.dict('os.environ', {'MARITACA_API_KEY': 'test-key'}):
+            mock_response = AsyncMock()
+            mock_response.status_code = 200
+            mock_response.json.return_value = {"answer": "Test response from Maritaca"}
+            
+            with patch('httpx.AsyncClient') as mock_client:
+                mock_instance = mock_client.return_value.__aenter__.return_value
+                mock_instance.post.return_value = mock_response
+                
+                result = await try_maritaca("test message")
+                assert result == "Test response from Maritaca"
+                
+                # Verify API call was made correctly
+                mock_instance.post.assert_called_once()
+                call_args = mock_instance.post.call_args
+                assert call_args[0][0] == "https://chat.maritaca.ai/api/chat/inference"
+                assert "authorization" in call_args[1]["headers"]
+                assert "Bearer test-key" in call_args[1]["headers"]["authorization"]
+    
+    @pytest.mark.asyncio
+    async def test_maritaca_api_error(self):
+        """Test Maritaca API error handling"""
+        with patch.dict('os.environ', {'MARITACA_API_KEY': 'test-key'}):
+            mock_response = AsyncMock()
+            mock_response.status_code = 500
+            
+            with patch('httpx.AsyncClient') as mock_client:
+                mock_instance = mock_client.return_value.__aenter__.return_value
+                mock_instance.post.return_value = mock_response
+                
+                result = await try_maritaca("test message")
+                assert result is None
+    
+    @pytest.mark.asyncio
+    async def test_maritaca_network_error(self):
+        """Test Maritaca network error handling"""
+        with patch.dict('os.environ', {'MARITACA_API_KEY': 'test-key'}):
+            with patch('httpx.AsyncClient') as mock_client:
+                mock_instance = mock_client.return_value.__aenter__.return_value
+                mock_instance.post.side_effect = Exception("Network error")
+                
+                result = await try_maritaca("test message")
+                assert result is None
+
+
+class TestChatEmergencyEndpoint:
+    """Test emergency chat endpoint"""
+    
+    @pytest.fixture
+    def client(self):
+        """Create test client"""
+        from fastapi import FastAPI
+        app = FastAPI()
+        app.include_router(router)
+        return TestClient(app)
+    
+    def test_emergency_endpoint_greeting(self, client):
+        """Test emergency endpoint with greeting"""
+        response = client.post(
+            "/api/v1/chat/emergency",
+            json={"message": "Olá, bom dia!"}
+        )
+        
+        assert response.status_code == 200
+        data = response.json()
+        
+        assert "session_id" in data
+        assert data["agent_id"] == "system"
+        assert data["agent_name"] == "Assistente Cidadão.AI"
+        assert len(data["message"]) > 0
+        assert data["confidence"] == 0.85
+        assert len(data["suggested_actions"]) > 0
+        assert data["metadata"]["intent"] == "greeting"
+        assert data["metadata"]["backend"] == "intelligent_fallback"
+    
+    def test_emergency_endpoint_investigation(self, client):
+        """Test emergency endpoint with investigation request"""
+        response = client.post(
+            "/api/v1/chat/emergency",
+            json={"message": "Quero investigar contratos suspeitos"}
+        )
+        
+        assert response.status_code == 200
+        data = response.json()
+        
+        assert data["metadata"]["intent"] == "investigation"
+        assert "search_contracts" in data["suggested_actions"]
+    
+    def test_emergency_endpoint_help(self, client):
+        """Test emergency endpoint with help request"""
+        response = client.post(
+            "/api/v1/chat/emergency",
+            json={"message": "Como posso usar o sistema?"}
+        )
+        
+        assert response.status_code == 200
+        data = response.json()
+        
+        assert data["metadata"]["intent"] == "help"
+        assert any(action in ["help", "examples", "documentation"] for action in data["suggested_actions"])
+    
+    def test_emergency_endpoint_with_session_id(self, client):
+        """Test emergency endpoint preserves session_id"""
+        session_id = "test-session-123"
+        response = client.post(
+            "/api/v1/chat/emergency",
+            json={"message": "teste", "session_id": session_id}
+        )
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert data["session_id"] == session_id
+    
+    def test_emergency_endpoint_without_session_id(self, client):
+        """Test emergency endpoint generates session_id"""
+        response = client.post(
+            "/api/v1/chat/emergency",
+            json={"message": "teste"}
+        )
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert "session_id" in data
+        assert data["session_id"].startswith("emergency_")
+    
+    @pytest.mark.asyncio
+    async def test_emergency_endpoint_with_maritaca(self, client):
+        """Test emergency endpoint using Maritaca"""
+        with patch.dict('os.environ', {'MARITACA_API_KEY': 'test-key'}):
+            with patch('src.api.routes.chat_emergency.try_maritaca') as mock_maritaca:
+                mock_maritaca.return_value = "Response from Maritaca AI"
+                
+                response = client.post(
+                    "/api/v1/chat/emergency",
+                    json={"message": "teste com maritaca"}
+                )
+                
+                assert response.status_code == 200
+                data = response.json()
+                
+                assert data["agent_id"] == "maritaca"
+                assert data["agent_name"] == "Assistente Cidadão.AI (Maritaca)"
+                assert data["message"] == "Response from Maritaca AI"
+                assert data["confidence"] == 0.95
+                assert data["metadata"]["backend"] == "maritaca_ai"
+                assert data["metadata"]["model"] == "sabia-3"
+    
+    def test_emergency_endpoint_validation_error(self, client):
+        """Test emergency endpoint with invalid input"""
+        # Empty message
+        response = client.post(
+            "/api/v1/chat/emergency",
+            json={"message": ""}
+        )
+        assert response.status_code == 422
+        
+        # Message too long
+        response = client.post(
+            "/api/v1/chat/emergency",
+            json={"message": "a" * 1001}
+        )
+        assert response.status_code == 422
+        
+        # Missing message
+        response = client.post(
+            "/api/v1/chat/emergency",
+            json={}
+        )
+        assert response.status_code == 422
+
+
+class TestEmergencyHealthEndpoint:
+    """Test emergency health check endpoint"""
+    
+    @pytest.fixture
+    def client(self):
+        """Create test client"""
+        from fastapi import FastAPI
+        app = FastAPI()
+        app.include_router(router)
+        return TestClient(app)
+    
+    def test_health_endpoint_without_maritaca(self, client):
+        """Test health endpoint without Maritaca API key"""
+        with patch.dict('os.environ', {}, clear=True):
+            response = client.get("/api/v1/chat/emergency/health")
+            
+            assert response.status_code == 200
+            data = response.json()
+            
+            assert data["status"] == "operational"
+            assert data["endpoint"] == "/api/v1/chat/emergency"
+            assert data["maritaca_configured"] is False
+            assert data["fallback_ready"] is True
+            assert "timestamp" in data
+    
+    def test_health_endpoint_with_maritaca(self, client):
+        """Test health endpoint with Maritaca API key"""
+        with patch.dict('os.environ', {'MARITACA_API_KEY': 'test-key'}):
+            response = client.get("/api/v1/chat/emergency/health")
+            
+            assert response.status_code == 200
+            data = response.json()
+            
+            assert data["maritaca_configured"] is True