Improve coverage

tests/test_dependencies.py

@@ -0,0 +1,205 @@
+"""Tests for dependency injection."""
+
+from unittest.mock import AsyncMock, Mock, patch
+
+import pytest
+
+from capa_de_integracion.config import Settings
+from capa_de_integracion.dependencies import (
+    get_conversation_manager,
+    get_dlp_service,
+    get_firestore_service,
+    get_notification_manager,
+    get_quick_reply_content_service,
+    get_rag_service,
+    get_redis_service,
+    init_services,
+    shutdown_services,
+    startup_services,
+)
+from capa_de_integracion.services import (
+    ConversationManagerService,
+    DLPService,
+    NotificationManagerService,
+    QuickReplyContentService,
+)
+from capa_de_integracion.services.firestore_service import FirestoreService
+from capa_de_integracion.services.rag import EchoRAGService, HTTPRAGService
+from capa_de_integracion.services.redis_service import RedisService
+
+
+def test_get_redis_service():
+    """Test get_redis_service returns RedisService."""
+    # Clear cache first
+    get_redis_service.cache_clear()
+
+    service = get_redis_service()
+    assert isinstance(service, RedisService)
+
+    # Should return same instance (cached)
+    service2 = get_redis_service()
+    assert service is service2
+
+
+def test_get_firestore_service():
+    """Test get_firestore_service returns FirestoreService."""
+    get_firestore_service.cache_clear()
+
+    service = get_firestore_service()
+    assert isinstance(service, FirestoreService)
+
+    # Should return same instance (cached)
+    service2 = get_firestore_service()
+    assert service is service2
+
+
+def test_get_dlp_service():
+    """Test get_dlp_service returns DLPService."""
+    get_dlp_service.cache_clear()
+
+    service = get_dlp_service()
+    assert isinstance(service, DLPService)
+
+    # Should return same instance (cached)
+    service2 = get_dlp_service()
+    assert service is service2
+
+
+def test_get_quick_reply_content_service():
+    """Test get_quick_reply_content_service returns QuickReplyContentService."""
+    get_quick_reply_content_service.cache_clear()
+
+    service = get_quick_reply_content_service()
+    assert isinstance(service, QuickReplyContentService)
+
+    # Should return same instance (cached)
+    service2 = get_quick_reply_content_service()
+    assert service is service2
+
+
+def test_get_notification_manager():
+    """Test get_notification_manager returns NotificationManagerService."""
+    get_notification_manager.cache_clear()
+    get_redis_service.cache_clear()
+    get_firestore_service.cache_clear()
+    get_dlp_service.cache_clear()
+
+    service = get_notification_manager()
+    assert isinstance(service, NotificationManagerService)
+
+    # Should return same instance (cached)
+    service2 = get_notification_manager()
+    assert service is service2
+
+
+def test_get_rag_service_http():
+    """Test get_rag_service returns HTTPRAGService when echo disabled."""
+    get_rag_service.cache_clear()
+
+    with patch("capa_de_integracion.dependencies.settings") as mock_settings, \
+         patch("capa_de_integracion.dependencies.HTTPRAGService") as mock_http_rag:
+        mock_settings.rag_echo_enabled = False
+        mock_settings.rag_endpoint_url = "http://test.example.com"
+
+        mock_http_rag.return_value = Mock(spec=HTTPRAGService)
+
+        service = get_rag_service()
+
+        mock_http_rag.assert_called_once()
+        assert service is not None
+
+
+def test_get_rag_service_echo():
+    """Test get_rag_service returns EchoRAGService when echo enabled."""
+    get_rag_service.cache_clear()
+
+    with patch("capa_de_integracion.dependencies.settings") as mock_settings:
+        mock_settings.rag_echo_enabled = True
+
+        service = get_rag_service()
+        assert isinstance(service, EchoRAGService)
+
+
+def test_get_conversation_manager():
+    """Test get_conversation_manager returns ConversationManagerService."""
+    get_conversation_manager.cache_clear()
+    get_redis_service.cache_clear()
+    get_firestore_service.cache_clear()
+    get_dlp_service.cache_clear()
+    get_rag_service.cache_clear()
+
+    with patch("capa_de_integracion.dependencies.get_rag_service") as mock_get_rag:
+        mock_get_rag.return_value = Mock(spec=EchoRAGService)
+
+        service = get_conversation_manager()
+        assert isinstance(service, ConversationManagerService)
+
+        # Should return same instance (cached)
+        service2 = get_conversation_manager()
+        assert service is service2
+
+
+def test_init_services():
+    """Test init_services (placeholder function)."""
+    settings = Settings.model_validate({})
+    # Should not raise - it's a placeholder
+    init_services(settings)
+
+
+@pytest.mark.asyncio
+async def test_startup_services(emulator_settings):
+    """Test startup_services connects to Redis."""
+    get_redis_service.cache_clear()
+
+    # Mock Redis service to avoid actual connection
+    with patch("capa_de_integracion.dependencies.get_redis_service") as mock_get_redis:
+        from unittest.mock import AsyncMock
+
+        mock_redis = Mock(spec=RedisService)
+        mock_redis.connect = AsyncMock()
+        mock_get_redis.return_value = mock_redis
+
+        await startup_services()
+
+        mock_redis.connect.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_shutdown_services(emulator_settings):
+    """Test shutdown_services closes all services."""
+    get_redis_service.cache_clear()
+    get_firestore_service.cache_clear()
+    get_dlp_service.cache_clear()
+    get_rag_service.cache_clear()
+
+    # Create mock services
+    with patch("capa_de_integracion.dependencies.get_redis_service") as mock_get_redis, \
+         patch("capa_de_integracion.dependencies.get_firestore_service") as mock_get_firestore, \
+         patch("capa_de_integracion.dependencies.get_dlp_service") as mock_get_dlp, \
+         patch("capa_de_integracion.dependencies.get_rag_service") as mock_get_rag:
+
+        from unittest.mock import AsyncMock
+
+        mock_redis = Mock(spec=RedisService)
+        mock_redis.close = AsyncMock()
+        mock_get_redis.return_value = mock_redis
+
+        mock_firestore = Mock(spec=FirestoreService)
+        mock_firestore.close = AsyncMock()
+        mock_get_firestore.return_value = mock_firestore
+
+        mock_dlp = Mock(spec=DLPService)
+        mock_dlp.close = AsyncMock()
+        mock_get_dlp.return_value = mock_dlp
+
+        mock_rag = Mock(spec=EchoRAGService)
+        mock_rag.close = AsyncMock()
+        mock_get_rag.return_value = mock_rag
+
+        await shutdown_services()
+
+        # Verify each service's close method was called
+        mock_redis.close.assert_called_once()
+        mock_firestore.close.assert_called_once()
+        mock_dlp.close.assert_called_once()
+        mock_rag.close.assert_called_once()