aegis-stack 0.2.0rc2__py3-none-any.whl

aegis/templates/copier-aegis-project/{{ project_slug }}/tests/services/ai/__init__.py

@@ -0,0 +1 @@
+"""Tests for AI service components."""

aegis/templates/copier-aegis-project/{{ project_slug }}/tests/services/ai/conftest.py

@@ -0,0 +1,78 @@
+"""Shared fixtures for AI service tests."""
+
+from unittest.mock import MagicMock
+
+import pytest
+from app.services.ai.models import AIProvider, Conversation, MessageRole
+from app.services.ai.service import AIService
+
+
+@pytest.fixture
+def mock_ai_settings():
+    """Create mock settings for AI service testing."""
+    settings = MagicMock()
+    settings.AI_ENABLED = True
+    settings.AI_PROVIDER = "public"
+    settings.AI_MODEL = "gpt-3.5-turbo"
+    settings.AI_TEMPERATURE = 0.7
+    settings.AI_MAX_TOKENS = 1000
+    settings.AI_TIMEOUT_SECONDS = 30.0
+
+    # Provider API keys (None for PUBLIC)
+    settings.OPENAI_API_KEY = None
+    settings.ANTHROPIC_API_KEY = None
+    settings.GOOGLE_API_KEY = None
+    settings.GROQ_API_KEY = None
+    settings.MISTRAL_API_KEY = None
+    settings.COHERE_API_KEY = None
+
+    return settings
+
+
+@pytest.fixture
+def ai_service(mock_ai_settings):
+    """Create AI service instance for testing."""
+    return AIService(mock_ai_settings)
+
+
+@pytest.fixture
+def sample_conversation():
+    """Create a sample conversation for testing."""
+    return Conversation(
+        id="test-conversation-123",
+        provider=AIProvider.PUBLIC,
+        model="gpt-3.5-turbo",
+        title="Test Conversation",
+    )
+
+
+@pytest.fixture
+def conversation_with_messages(sample_conversation):
+    """Create a conversation with sample messages."""
+    sample_conversation.add_message(MessageRole.USER, "Hello, how are you?")
+    sample_conversation.add_message(MessageRole.ASSISTANT, "I'm doing well, thank you!")
+    sample_conversation.add_message(MessageRole.USER, "What's the weather like?")
+    return sample_conversation
+
+
+@pytest.fixture
+def free_provider_settings(mock_ai_settings):
+    """Create settings with a free provider."""
+    mock_ai_settings.AI_PROVIDER = "public"
+    return mock_ai_settings
+
+
+@pytest.fixture
+def paid_provider_settings(mock_ai_settings):
+    """Create settings with a paid provider (no API key)."""
+    mock_ai_settings.AI_PROVIDER = "openai"
+    mock_ai_settings.OPENAI_API_KEY = None  # Missing API key
+    return mock_ai_settings
+
+
+@pytest.fixture
+def paid_provider_with_key_settings(mock_ai_settings):
+    """Create settings with a paid provider and API key."""
+    mock_ai_settings.AI_PROVIDER = "openai"
+    mock_ai_settings.OPENAI_API_KEY = "sk-test-key-123"
+    return mock_ai_settings

aegis/templates/copier-aegis-project/{{ project_slug }}/tests/services/ai/test_health.py

@@ -0,0 +1,157 @@
+"""Tests for AI service health checks."""
+
+import pytest
+from app.core.config import settings
+from app.services.ai.health import check_ai_service_health
+from app.services.ai.models import AIProvider
+from app.services.system.models import ComponentStatusType
+
+
+class TestAIHealthCheck:
+    """Test AI service health check functionality."""
+
+    @pytest.mark.asyncio
+    async def test_health_check_returns_component_status(self) -> None:
+        """Test that health check returns valid ComponentStatus."""
+        status = await check_ai_service_health()
+
+        assert status.name == "ai"
+        assert isinstance(status.status, ComponentStatusType)
+        assert isinstance(status.message, str)
+        assert isinstance(status.metadata, dict)
+
+    @pytest.mark.asyncio
+    async def test_health_check_metadata_structure(self) -> None:
+        """Test that health check includes expected metadata fields."""
+        status = await check_ai_service_health()
+
+        # Core metadata fields
+        assert "service_type" in status.metadata
+        assert status.metadata["service_type"] == "ai"
+        assert "engine" in status.metadata
+        assert status.metadata["engine"] == "pydantic-ai"
+        assert "enabled" in status.metadata
+        assert "provider" in status.metadata
+        assert "model" in status.metadata
+
+    @pytest.mark.asyncio
+    async def test_health_check_provider_metadata(self) -> None:
+        """Test provider-specific metadata in health check.
+
+        This test would have caught the bug where provider
+        was returned as enum when it should be string.
+        """
+        status = await check_ai_service_health()
+
+        # Provider should be a string (due to use_enum_values=True in config)
+        provider = status.metadata.get("provider")
+        assert isinstance(provider, str)
+        assert provider in [p.value for p in AIProvider]
+
+    @pytest.mark.asyncio
+    async def test_health_check_free_tier_metadata(self) -> None:
+        """Test that free tier status is correctly reported.
+
+        This test would have caught the bug where provider enum
+        was compared to list of strings.
+        """
+        status = await check_ai_service_health()
+
+        # Should have free tier info when service is enabled
+        if status.metadata.get("enabled"):
+            assert "provider_free_tier" in status.metadata
+            assert isinstance(status.metadata["provider_free_tier"], bool)
+
+            # PUBLIC provider should be free
+            if status.metadata["provider"] == "public":
+                assert status.metadata["provider_free_tier"] is True
+
+    @pytest.mark.asyncio
+    async def test_health_check_streaming_capability(self) -> None:
+        """Test that streaming capability is correctly reported."""
+        status = await check_ai_service_health()
+
+        if status.metadata.get("enabled"):
+            assert "provider_supports_streaming" in status.metadata
+            assert isinstance(status.metadata["provider_supports_streaming"], bool)
+
+    @pytest.mark.asyncio
+    async def test_health_check_when_enabled(self) -> None:
+        """Test health check when AI service is enabled."""
+        # Assuming default config has AI enabled
+        if settings.AI_ENABLED:
+            status = await check_ai_service_health()
+
+            assert status.metadata["enabled"] is True
+            assert status.status in [
+                ComponentStatusType.HEALTHY,
+                ComponentStatusType.UNHEALTHY,
+            ]
+
+    @pytest.mark.asyncio
+    async def test_health_check_dependencies_metadata(self) -> None:
+        """Test that dependencies are listed in metadata."""
+        status = await check_ai_service_health()
+
+        assert "dependencies" in status.metadata
+        dependencies = status.metadata["dependencies"]
+
+        assert "backend" in dependencies
+        assert "pydantic_ai" in dependencies
+
+    @pytest.mark.asyncio
+    async def test_health_check_validation_errors(self) -> None:
+        """Test that validation errors are counted in metadata."""
+        status = await check_ai_service_health()
+
+        assert "validation_errors_count" in status.metadata
+        assert isinstance(status.metadata["validation_errors_count"], int)
+        assert status.metadata["validation_errors_count"] >= 0
+
+    @pytest.mark.asyncio
+    async def test_health_check_handles_errors_gracefully(self) -> None:
+        """Test that health check doesn't crash on errors."""
+        # This should always succeed, even with invalid config
+        status = await check_ai_service_health()
+
+        assert status is not None
+        assert status.name == "ai"
+        # Either healthy or unhealthy, but shouldn't crash
+        assert status.status in [
+            ComponentStatusType.HEALTHY,
+            ComponentStatusType.UNHEALTHY,
+        ]
+
+
+class TestAIHealthMetadataAccuracy:
+    """Test accuracy of AI health metadata values."""
+
+    @pytest.mark.asyncio
+    async def test_public_provider_metadata_accuracy(self) -> None:
+        """Test that PUBLIC provider metadata is accurate."""
+        # Assuming default config uses PUBLIC provider
+        status = await check_ai_service_health()
+
+        if status.metadata.get("provider") == "public":
+            # PUBLIC should be free
+            assert status.metadata.get("provider_free_tier") is True
+            # PUBLIC doesn't support streaming
+            assert status.metadata.get("provider_supports_streaming") is False
+
+    @pytest.mark.asyncio
+    async def test_agent_ready_metadata(self) -> None:
+        """Test that agent readiness is reported."""
+        status = await check_ai_service_health()
+
+        assert "agent_ready" in status.metadata
+        # Agents are created per-request, should always be ready when enabled
+        if status.metadata.get("enabled"):
+            assert status.metadata["agent_ready"] is True
+
+    @pytest.mark.asyncio
+    async def test_configuration_valid_metadata(self) -> None:
+        """Test that configuration validity is reported."""
+        status = await check_ai_service_health()
+
+        assert "configuration_valid" in status.metadata
+        assert isinstance(status.metadata["configuration_valid"], bool)

aegis/templates/copier-aegis-project/{{ project_slug }}/tests/services/ai/test_models.py

@@ -0,0 +1,164 @@
+"""Tests for AI service models and provider functions."""
+
+from app.services.ai.models import (
+    AIProvider,
+    ProviderCapabilities,
+    get_free_providers,
+    get_provider_capabilities,
+)
+
+
+class TestProviderFunctions:
+    """Test provider utility functions."""
+
+    def test_get_free_providers_returns_enum_list(self) -> None:
+        """Ensure get_free_providers returns list of AIProvider enums, not strings."""
+        providers = get_free_providers()
+
+        assert isinstance(providers, list)
+        assert len(providers) > 0
+        # CRITICAL: Must return AIProvider enums, not strings
+        assert all(isinstance(p, AIProvider) for p in providers)
+
+    def test_free_providers_enum_membership(self) -> None:
+        """Test that AIProvider enum membership checks work correctly.
+
+        This test would have caught the bug where get_free_providers
+        returned list[str] instead of list[AIProvider].
+        """
+        free_providers = get_free_providers()
+
+        # These comparisons must work (enum in list[enum])
+        assert AIProvider.PUBLIC in free_providers
+        assert AIProvider.GROQ in free_providers
+        assert AIProvider.GOOGLE in free_providers
+        assert AIProvider.COHERE in free_providers
+
+        # These should NOT be free (paid only)
+        assert AIProvider.OPENAI not in free_providers
+        assert AIProvider.ANTHROPIC not in free_providers
+        assert AIProvider.MISTRAL not in free_providers
+
+    def test_free_providers_string_join(self) -> None:
+        """Test that free providers can be joined as strings for display."""
+        free_providers = get_free_providers()
+
+        # This is what the CLI does - must work with .value
+        providers_list = ", ".join(p.value for p in free_providers)
+
+        assert isinstance(providers_list, str)
+        assert "public" in providers_list
+        assert "groq" in providers_list
+
+    def test_get_provider_capabilities_public(self) -> None:
+        """Test capabilities for PUBLIC provider."""
+        caps = get_provider_capabilities(AIProvider.PUBLIC)
+
+        assert isinstance(caps, ProviderCapabilities)
+        assert caps.provider == AIProvider.PUBLIC
+        assert caps.free_tier_available is True
+        assert caps.supports_streaming is False
+        assert caps.supports_function_calling is False
+        assert caps.supports_vision is False
+
+    def test_get_provider_capabilities_openai(self) -> None:
+        """Test capabilities for OpenAI provider."""
+        caps = get_provider_capabilities(AIProvider.OPENAI)
+
+        assert caps.provider == AIProvider.OPENAI
+        assert caps.free_tier_available is False
+        assert caps.supports_streaming is True
+        assert caps.supports_function_calling is True
+        assert caps.supports_vision is True
+
+    def test_get_provider_capabilities_groq(self) -> None:
+        """Test capabilities for Groq provider (free tier)."""
+        caps = get_provider_capabilities(AIProvider.GROQ)
+
+        assert caps.provider == AIProvider.GROQ
+        assert caps.free_tier_available is True
+        assert caps.supports_streaming is True
+
+    def test_all_providers_have_capabilities(self) -> None:
+        """Ensure all providers have defined capabilities."""
+        for provider in AIProvider:
+            caps = get_provider_capabilities(provider)
+            assert isinstance(caps, ProviderCapabilities)
+            assert caps.provider == provider
+
+    def test_free_tier_consistency(self) -> None:
+        """Ensure free_tier_available matches get_free_providers result."""
+        free_providers = get_free_providers()
+
+        for provider in AIProvider:
+            caps = get_provider_capabilities(provider)
+
+            if provider in free_providers:
+                assert caps.free_tier_available is True, (
+                    f"{provider} should have free_tier_available=True"
+                )
+            else:
+                assert caps.free_tier_available is False, (
+                    f"{provider} should have free_tier_available=False"
+                )
+
+
+class TestAIProviderEnum:
+    """Test AIProvider enum behavior."""
+
+    def test_provider_enum_values(self) -> None:
+        """Test that provider enums have correct string values."""
+        assert AIProvider.OPENAI.value == "openai"
+        assert AIProvider.ANTHROPIC.value == "anthropic"
+        assert AIProvider.GOOGLE.value == "google"
+        assert AIProvider.GROQ.value == "groq"
+        assert AIProvider.MISTRAL.value == "mistral"
+        assert AIProvider.COHERE.value == "cohere"
+        assert AIProvider.PUBLIC.value == "public"
+
+    def test_provider_enum_from_string(self) -> None:
+        """Test creating provider from string value."""
+        assert AIProvider("openai") == AIProvider.OPENAI
+        assert AIProvider("public") == AIProvider.PUBLIC
+
+    def test_provider_enum_comparison(self) -> None:
+        """Test that provider enum comparisons work correctly."""
+        provider = AIProvider.PUBLIC
+
+        # Enum equality
+        assert provider == AIProvider.PUBLIC
+        assert provider != AIProvider.OPENAI
+
+        # String comparison should work (due to str inheritance)
+        assert provider == "public"
+        assert provider != "openai"
+
+
+class TestProviderCapabilitiesModel:
+    """Test ProviderCapabilities Pydantic model."""
+
+    def test_provider_capabilities_creation(self) -> None:
+        """Test creating ProviderCapabilities instance."""
+        caps = ProviderCapabilities(
+            provider=AIProvider.OPENAI,
+            supports_streaming=True,
+            supports_function_calling=True,
+            supports_vision=True,
+            free_tier_available=False,
+        )
+
+        assert caps.provider == AIProvider.OPENAI
+        assert caps.supports_streaming is True
+        assert caps.supports_function_calling is True
+        assert caps.supports_vision is True
+        assert caps.free_tier_available is False
+
+    def test_provider_capabilities_defaults(self) -> None:
+        """Test default values for ProviderCapabilities."""
+        caps = ProviderCapabilities(provider=AIProvider.PUBLIC)
+
+        # Defaults from model definition
+        assert caps.supports_streaming is True
+        assert caps.supports_function_calling is False
+        assert caps.supports_vision is False
+        assert caps.free_tier_available is False

aegis/templates/copier-aegis-project/{{ project_slug }}/tests/services/ai/test_service.py

@@ -0,0 +1,198 @@
+"""Tests for AI service core functionality."""
+
+import pytest
+from app.core.config import settings
+from app.services.ai.models import AIProvider
+from app.services.ai.service import AIService
+
+
+class TestAIServiceInitialization:
+    """Test AI service initialization."""
+
+    def test_service_initialization(self) -> None:
+        """Test that AIService initializes correctly."""
+        service = AIService(settings)
+
+        assert service.settings == settings
+        assert service.config is not None
+        assert service.conversation_manager is not None
+
+    def test_service_config_loaded(self) -> None:
+        """Test that configuration is loaded from settings."""
+        service = AIService(settings)
+
+        assert hasattr(service.config, "enabled")
+        assert hasattr(service.config, "provider")
+        assert hasattr(service.config, "model")
+
+
+class TestAIServiceStatus:
+    """Test AI service status reporting."""
+
+    def test_get_service_status_structure(self) -> None:
+        """Test that service status has expected structure."""
+        service = AIService(settings)
+        status = service.get_service_status()
+
+        assert isinstance(status, dict)
+        assert "enabled" in status
+        assert "provider" in status
+        assert "model" in status
+        assert "agent_initialized" in status
+        assert "total_conversations" in status
+        assert "configuration_valid" in status
+
+    def test_get_service_status_provider_type(self) -> None:
+        """Test that provider is returned as string, not enum.
+
+        This test would have caught the bug where code tried to call
+        .value on provider when it was already a string due to
+        use_enum_values=True in AIServiceConfig.
+        """
+        service = AIService(settings)
+        status = service.get_service_status()
+
+        provider = status["provider"]
+
+        # Provider should be string (Pydantic converts enum to string)
+        assert isinstance(provider, str)
+        # Should be a valid provider value
+        assert provider in [p.value for p in AIProvider]
+
+    def test_get_service_status_enabled_bool(self) -> None:
+        """Test that enabled is a boolean."""
+        service = AIService(settings)
+        status = service.get_service_status()
+
+        assert isinstance(status["enabled"], bool)
+
+    def test_get_service_status_agent_initialized(self) -> None:
+        """Test that agent_initialized is always True."""
+        service = AIService(settings)
+        status = service.get_service_status()
+
+        # Agents created per request, always available
+        assert status["agent_initialized"] is True
+
+    def test_get_service_status_configuration_valid(self) -> None:
+        """Test that configuration_valid reflects validation state."""
+        service = AIService(settings)
+        status = service.get_service_status()
+
+        assert isinstance(status["configuration_valid"], bool)
+
+    def test_get_service_status_conversation_count(self) -> None:
+        """Test that total_conversations starts at 0."""
+        service = AIService(settings)
+        status = service.get_service_status()
+
+        # New service should have no conversations
+        assert status["total_conversations"] == 0
+
+
+class TestAIServiceValidation:
+    """Test AI service validation."""
+
+    def test_validate_service_returns_list(self) -> None:
+        """Test that validate_service returns list of errors."""
+        service = AIService(settings)
+        errors = service.validate_service()
+
+        assert isinstance(errors, list)
+        assert all(isinstance(e, str) for e in errors)
+
+    def test_validate_service_with_valid_config(self) -> None:
+        """Test validation with valid configuration."""
+        service = AIService(settings)
+        errors = service.validate_service()
+
+        # PUBLIC provider should have no errors (no API key required)
+        if service.config.provider == AIProvider.PUBLIC:
+            assert len(errors) == 0
+
+
+class TestAIServiceConversationManagement:
+    """Test conversation management methods."""
+
+    def test_get_conversation_not_found(self) -> None:
+        """Test getting non-existent conversation."""
+        service = AIService(settings)
+        conversation = service.get_conversation("nonexistent-id")
+
+        assert conversation is None
+
+    def test_list_conversations_empty(self) -> None:
+        """Test listing conversations when none exist."""
+        service = AIService(settings)
+        conversations = service.list_conversations("test-user")
+
+        assert isinstance(conversations, list)
+        assert len(conversations) == 0
+
+    def test_conversation_manager_integration(self) -> None:
+        """Test that conversation manager is properly integrated."""
+        service = AIService(settings)
+
+        # ConversationManager should be accessible
+        assert hasattr(service, "conversation_manager")
+        assert hasattr(service.conversation_manager, "conversations")
+        assert isinstance(service.conversation_manager.conversations, dict)
+
+
+class TestAIServiceConfigIntegration:
+    """Test integration with configuration."""
+
+    def test_config_provider_enum_to_string_conversion(self) -> None:
+        """Test that Pydantic converts provider enum to string.
+
+        This documents the behavior that caused the .value bug:
+        AIServiceConfig has use_enum_values=True, which means
+        self.config.provider is already a string, not an enum.
+        """
+        service = AIService(settings)
+
+        # Config provider is a string due to use_enum_values=True
+        assert isinstance(service.config.provider, str)
+
+        # Should be able to compare with enum values
+        assert service.config.provider == AIProvider.PUBLIC.value
+
+    def test_service_uses_config_correctly(self) -> None:
+        """Test that service uses config values correctly."""
+        service = AIService(settings)
+
+        # Service should use config values
+        assert service.config.enabled is not None
+        assert service.config.model is not None
+        assert service.config.temperature is not None
+
+
+class TestAIServiceErrorHandling:
+    """Test error handling in AI service."""
+
+    @pytest.mark.asyncio
+    async def test_chat_disabled_service_error(self, mock_ai_settings) -> None:
+        """Test that chat raises error when service is disabled."""
+        # Disable AI service
+        mock_ai_settings.AI_ENABLED = False
+
+        service = AIService(mock_ai_settings)
+
+        with pytest.raises(Exception) as exc_info:
+            await service.chat("test message")
+
+        assert "disabled" in str(exc_info.value).lower()
+
+    @pytest.mark.asyncio
+    async def test_stream_chat_disabled_service_error(self, mock_ai_settings) -> None:
+        """Test that stream_chat raises error when service is disabled."""
+        # Disable AI service
+        mock_ai_settings.AI_ENABLED = False
+
+        service = AIService(mock_ai_settings)
+
+        with pytest.raises(Exception) as exc_info:
+            async for _ in service.stream_chat("test message"):
+                pass
+
+        assert "disabled" in str(exc_info.value).lower()