aegis-stack 0.2.0rc2__py3-none-any.whl

aegis/templates/copier-aegis-project/{{ project_slug }}/tests/services/test_middleware_inspector.py.jinja

@@ -0,0 +1,248 @@
+"""Tests for FastAPI middleware introspection service."""
+
+import pytest
+from unittest.mock import Mock, MagicMock
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from app.services.backend.middleware_inspector import (
+    FastAPIMiddlewareInspector,
+    get_fastapi_middleware_metadata,
+)
+from app.services.backend.models import MiddlewareInfo, MiddlewareMetadata
+
+
+class TestFastAPIMiddlewareInspector:
+    """Test cases for FastAPI middleware introspection."""
+
+    def test_configured_app_middleware_detection(self, app: FastAPI):
+        """Test middleware detection with configured app (includes CORS by default)."""
+        inspector = FastAPIMiddlewareInspector(app)
+        
+        metadata = inspector.get_middleware_metadata()
+        
+        assert isinstance(metadata, MiddlewareMetadata)
+        # The configured app should have at least CORS middleware
+        assert metadata.total_middleware >= 1
+        assert metadata.security_count >= 1
+        assert "CORSMiddleware" in metadata.security_middleware
+        assert metadata.error is None
+        assert metadata.fallback is False
+
+    def test_empty_middleware_stack(self):
+        """Test with FastAPI app that has no middleware."""
+        app = FastAPI()
+        inspector = FastAPIMiddlewareInspector(app)
+        
+        metadata = inspector.get_middleware_metadata()
+        
+        assert isinstance(metadata, MiddlewareMetadata)
+        assert metadata.total_middleware == 0
+        assert metadata.security_count == 0
+        assert metadata.middleware_stack == []
+        assert metadata.security_middleware == []
+        assert metadata.error is None
+        assert metadata.fallback is False
+
+    def test_cors_middleware_detection(self):
+        """Test detection and configuration extraction for CORS middleware."""
+        app = FastAPI()
+        app.add_middleware(
+            CORSMiddleware,
+            allow_origins=["https://example.com"],
+            allow_credentials=True,
+            allow_methods=["GET", "POST"],
+            allow_headers=["X-Test-Header"],
+        )
+        
+        inspector = FastAPIMiddlewareInspector(app)
+        metadata = inspector.get_middleware_metadata()
+        
+        assert metadata.total_middleware >= 1
+        assert metadata.security_count >= 1
+        assert "CORSMiddleware" in metadata.security_middleware
+        
+        # Find the CORS middleware in the stack
+        cors_middleware = None
+        for mw in metadata.middleware_stack:
+            if mw.type == "CORSMiddleware":
+                cors_middleware = mw
+                break
+        
+        assert cors_middleware is not None
+        assert cors_middleware.is_security is True
+        assert cors_middleware.config.get("allow_origins") == ["https://example.com"]
+        assert cors_middleware.config.get("allow_credentials") is True
+
+    def test_security_middleware_identification(self):
+        """Test identification of security-related middleware."""
+        inspector = FastAPIMiddlewareInspector(FastAPI())
+        
+        # Test security keyword detection
+        assert inspector._is_security_middleware(
+            "CORSMiddleware", "fastapi.middleware.cors"
+        )
+        assert inspector._is_security_middleware(
+            "AuthMiddleware", "app.middleware.auth"
+        )
+        assert inspector._is_security_middleware("JWTMiddleware", "app.middleware.jwt")
+        assert inspector._is_security_middleware(
+            "RateLimitMiddleware", "app.middleware.rate"
+        )
+        assert inspector._is_security_middleware(
+            "SecurityHeadersMiddleware", "app.middleware.security"
+        )
+        
+        # Test non-security middleware
+        assert not inspector._is_security_middleware(
+            "GZipMiddleware", "fastapi.middleware.gzip"
+        )
+        assert not inspector._is_security_middleware(
+            "LoggingMiddleware", "app.middleware.logging"
+        )
+
+    def test_middleware_order_detection(self):
+        """Test that middleware order is correctly detected."""
+        app = FastAPI()
+        
+        # Add middleware in specific order
+        # Note: FastAPI adds in reverse order of execution
+        app.add_middleware(CORSMiddleware)
+        
+        # Mock a custom middleware for testing
+        class CustomMiddleware:
+            def __init__(self, app):
+                self.app = app
+            
+            async def __call__(self, scope, receive, send):
+                return await self.app(scope, receive, send)
+        
+        # We can't easily test the exact ordering without a more complex setup,
+        # but we can test that order numbers are assigned
+        inspector = FastAPIMiddlewareInspector(app)
+        metadata = inspector.get_middleware_metadata()
+        
+        # Verify that middleware have order numbers starting from 0
+        for idx, middleware in enumerate(metadata.middleware_stack):
+            assert middleware.order == idx
+
+    def test_middleware_config_extraction(self):
+        """Test extraction of middleware-specific configuration."""
+        inspector = FastAPIMiddlewareInspector(FastAPI())
+        
+        # Mock CORS middleware
+        cors_mock = Mock()
+        cors_mock.allow_origins = ["http://localhost:3000"]
+        cors_mock.allow_methods = ["*"]
+        cors_mock.allow_headers = ["*"]
+        cors_mock.allow_credentials = True
+        
+        config = inspector._extract_middleware_config(cors_mock)
+        
+        assert config["allow_origins"] == ["http://localhost:3000"]
+        assert config["allow_methods"] == ["*"]
+        assert config["allow_headers"] == ["*"]
+        assert config["allow_credentials"] is True
+
+    def test_middleware_introspection_error_handling(self):
+        """Test error handling in middleware introspection."""
+        # Mock an app that raises an exception during introspection
+        app_mock = Mock()
+        app_mock.app = app_mock  # Circular reference to break the loop
+        
+        # Force an exception during middleware traversal
+        def side_effect(*args, **kwargs):
+            raise ValueError("Test error")
+        
+        app_mock.__getattribute__ = side_effect
+        
+        inspector = FastAPIMiddlewareInspector(app_mock)
+        metadata = inspector.get_middleware_metadata()
+
+        # Should return fallback metadata
+        assert metadata.fallback is True
+        assert metadata.error is not None
+        assert "Mock" in metadata.error  # Error is actually about Mock object iteration
+        assert metadata.total_middleware == 0
+
+    def test_extract_middleware_info_error_handling(self):
+        """Test error handling in individual middleware info extraction."""
+        inspector = FastAPIMiddlewareInspector(FastAPI())
+
+        # Mock middleware that raises an exception by overriding __module__ access
+        class BadMiddleware:
+            __name__ = "BadMiddleware"
+
+            @property
+            def __module__(self) -> str:
+                raise ZeroDivisionError("Test exception")
+
+        bad_middleware = BadMiddleware()
+
+        result = inspector._extract_middleware_info(bad_middleware, 0)
+
+        # Should return None on error
+        assert result is None
+
+    def test_get_fastapi_middleware_metadata_convenience_function(self):
+        """Test the convenience function for getting middleware metadata."""
+        app = FastAPI()
+        app.add_middleware(CORSMiddleware)
+
+        metadata = get_fastapi_middleware_metadata(app)
+
+        assert isinstance(metadata, MiddlewareMetadata)
+        assert metadata.total_middleware >= 1
+
+    def test_middleware_metadata_model_dump(self):
+        """Test that middleware metadata can be dumped for ComponentStatus."""
+        app = FastAPI()
+        app.add_middleware(CORSMiddleware)
+
+        metadata = get_fastapi_middleware_metadata(app)
+        dumped = metadata.model_dump_for_metadata()
+
+        assert isinstance(dumped, dict)
+        assert "middleware_stack" in dumped
+        assert "total_middleware" in dumped
+        assert "security_count" in dumped
+        assert "security_middleware" in dumped
+
+    def test_middleware_info_model_creation(self):
+        """Test MiddlewareInfo model creation and validation."""
+        middleware_info = MiddlewareInfo(
+            type="CORSMiddleware",
+            module="fastapi.middleware.cors",
+            order=0,
+            config={"allow_origins": ["*"]},
+            is_security=True,
+        )
+
+        assert middleware_info.type == "CORSMiddleware"
+        assert middleware_info.module == "fastapi.middleware.cors"
+        assert middleware_info.order == 0
+        assert middleware_info.config == {"allow_origins": ["*"]}
+        assert middleware_info.is_security is True
+
+    def test_middleware_metadata_model_creation(self):
+        """Test MiddlewareMetadata model creation and validation."""
+        middleware_info = MiddlewareInfo(
+            type="CORSMiddleware",
+            module="fastapi.middleware.cors",
+            order=0,
+            is_security=True,
+        )
+
+        metadata = MiddlewareMetadata(
+            middleware_stack=[middleware_info],
+            total_middleware=1,
+            security_middleware=["CORSMiddleware"],
+            security_count=1,
+        )
+
+        assert len(metadata.middleware_stack) == 1
+        assert metadata.total_middleware == 1
+        assert metadata.security_middleware == ["CORSMiddleware"]
+        assert metadata.security_count == 1
+        assert metadata.error is None
+        assert metadata.fallback is False

aegis/templates/copier-aegis-project/{{ project_slug }}/tests/services/test_scheduled_task_manager.py.jinja

@@ -0,0 +1,292 @@
+{%- if scheduler_backend != "memory" %}
+"""
+Tests for ScheduledTaskManager service.
+
+Tests the service layer for scheduled task management, including database
+operations and task data transformations.
+"""
+
+import pickle
+from datetime import datetime
+from unittest.mock import AsyncMock, MagicMock, patch
+from typing import Any
+
+import pytest
+
+from app.services.scheduler.scheduled_task_manager import ScheduledTaskManager
+from app.services.scheduler.models import APSchedulerJob, ScheduledTask, TaskStatistics
+
+
+class MockTrigger:
+    """Simple mock trigger that can be pickled for testing."""
+    
+    def __init__(self):
+        self.__class__.__name__ = "IntervalTrigger"
+
+
+class TestScheduledTaskManager:
+    """Test the ScheduledTaskManager service layer."""
+
+    @pytest.fixture
+    def manager(self) -> ScheduledTaskManager:
+        """Create a ScheduledTaskManager instance for testing."""
+        return ScheduledTaskManager()
+
+    @pytest.fixture
+    def mock_job_data(self) -> dict[str, Any]:
+        """Mock job data as stored by APScheduler."""
+        return {
+            "name": "Test Job",
+            "func": "test.module.function",
+            "trigger": MockTrigger(),
+            "max_instances": 1,
+            "coalesce": True,
+        }
+
+    @pytest.fixture
+    def mock_apscheduler_job(self, mock_job_data: dict[str, Any]) -> APSchedulerJob:
+        """Create a mock APSchedulerJob for testing."""
+        # Create job state as APScheduler would pickle it
+        job_state = pickle.dumps(mock_job_data)
+
+        return APSchedulerJob(
+            id="test_job_id",
+            next_run_time=datetime.now().timestamp(),
+            job_state=job_state
+        )
+
+    @pytest.mark.asyncio
+    async def test_has_persistence_table_exists(
+        self, manager: ScheduledTaskManager
+    ) -> None:
+        """Test has_persistence returns True when apscheduler_jobs table exists."""
+        with patch(
+            "app.services.scheduler.scheduled_task_manager.async_engine"
+        ) as mock_engine:
+            mock_conn = AsyncMock()
+            mock_conn.run_sync.return_value = ["apscheduler_jobs", "other_table"]
+
+            mock_engine.begin.return_value.__aenter__.return_value = mock_conn
+
+            result = await manager.has_persistence()
+            assert result is True
+
+    @pytest.mark.asyncio
+    async def test_has_persistence_table_missing(
+        self, manager: ScheduledTaskManager
+    ) -> None:
+        """Test has_persistence returns False when apscheduler_jobs table missing."""
+        with patch(
+            "app.services.scheduler.scheduled_task_manager.async_engine"
+        ) as mock_engine:
+            mock_conn = AsyncMock()
+            mock_conn.run_sync.return_value = ["other_table"]
+
+            mock_engine.begin.return_value.__aenter__.return_value = mock_conn
+
+            result = await manager.has_persistence()
+            assert result is False
+
+    @pytest.mark.asyncio
+    async def test_has_persistence_database_error(
+        self, manager: ScheduledTaskManager
+    ) -> None:
+        """Test has_persistence handles database errors gracefully."""
+        with patch(
+            "app.services.scheduler.scheduled_task_manager.async_engine"
+        ) as mock_engine:
+            mock_engine.begin.side_effect = Exception("Database error")
+
+            result = await manager.has_persistence()
+            assert result is False
+
+    @pytest.mark.asyncio
+    async def test_list_tasks_no_persistence(
+        self, manager: ScheduledTaskManager
+    ) -> None:
+        """Test list_tasks raises RuntimeError when persistence not available."""
+        with patch.object(manager, "has_persistence", return_value=False):
+            with pytest.raises(RuntimeError, match="persistence"):
+                await manager.list_tasks()
+
+    @pytest.mark.asyncio
+    async def test_list_tasks_with_jobs(
+        self, manager: ScheduledTaskManager, mock_apscheduler_job: APSchedulerJob
+    ) -> None:
+        """Test list_tasks returns properly formatted tasks."""
+        with patch.object(manager, "has_persistence", return_value=True), \
+             patch(
+                 "app.services.scheduler.scheduled_task_manager.get_async_session"
+             ) as mock_session:
+
+            # Mock session and query result
+            mock_session_instance = AsyncMock()
+            mock_session.return_value.__aenter__.return_value = mock_session_instance
+
+            mock_result = MagicMock()
+            mock_result.all.return_value = [mock_apscheduler_job]
+            mock_session_instance.exec.return_value = mock_result
+
+            tasks = await manager.list_tasks()
+
+            assert len(tasks) == 1
+            task = tasks[0]
+            assert isinstance(task, ScheduledTask)
+            assert task.job_id == "test_job_id"
+            assert task.name == "Test Job"
+            assert task.status == "active"  # Has next_run_time
+
+    @pytest.mark.asyncio
+    async def test_list_tasks_empty_database(
+        self, manager: ScheduledTaskManager
+    ) -> None:
+        """Test list_tasks returns empty list when no jobs in database."""
+        with patch.object(manager, "has_persistence", return_value=True), \
+             patch(
+                 "app.services.scheduler.scheduled_task_manager.get_async_session"
+             ) as mock_session:
+
+            mock_session_instance = AsyncMock()
+            mock_session.return_value.__aenter__.return_value = mock_session_instance
+
+            mock_result = MagicMock()
+            mock_result.all.return_value = []
+            mock_session_instance.exec.return_value = mock_result
+
+            tasks = await manager.list_tasks()
+            assert len(tasks) == 0
+
+    @pytest.mark.asyncio
+    async def test_get_task_found(
+        self, manager: ScheduledTaskManager, mock_apscheduler_job: APSchedulerJob
+    ) -> None:
+        """Test get_task returns task when found."""
+        with patch(
+            "app.services.scheduler.scheduled_task_manager.get_async_session"
+        ) as mock_session:
+            mock_session_instance = AsyncMock()
+            mock_session.return_value.__aenter__.return_value = mock_session_instance
+
+            mock_result = MagicMock()
+            mock_result.first.return_value = mock_apscheduler_job
+            mock_session_instance.exec.return_value = mock_result
+
+            task = await manager.get_task("test_job_id")
+
+            assert task is not None
+            assert isinstance(task, ScheduledTask)
+            assert task.job_id == "test_job_id"
+            assert task.name == "Test Job"
+
+    @pytest.mark.asyncio
+    async def test_get_task_not_found(
+        self, manager: ScheduledTaskManager
+    ) -> None:
+        """Test get_task returns None when task not found."""
+        with patch(
+            "app.services.scheduler.scheduled_task_manager.get_async_session"
+        ) as mock_session:
+            mock_session_instance = AsyncMock()
+            mock_session.return_value.__aenter__.return_value = mock_session_instance
+
+            mock_result = MagicMock()
+            mock_result.first.return_value = None
+            mock_session_instance.exec.return_value = mock_result
+
+            task = await manager.get_task("non_existent_job")
+            assert task is None
+
+    @pytest.mark.asyncio
+    async def test_get_statistics(self, manager: ScheduledTaskManager) -> None:
+        """Test get_statistics returns proper TaskStatistics."""
+        # Mock list_tasks to return test data
+        mock_tasks = [
+            ScheduledTask(
+                job_id="job1", name="Job 1", function="test.func1", schedule="Every 1m",
+                trigger_type="interval", status="active", max_instances=1, coalesce=True
+            ),
+            ScheduledTask(
+                job_id="job2", name="Job 2", function="test.func2", schedule="Every 5m",
+                trigger_type="interval", status="paused", max_instances=1, coalesce=True
+            ),
+            ScheduledTask(
+                job_id="job3", name="Job 3", function="test.func3", schedule="Daily",
+                trigger_type="cron", status="active", max_instances=1, coalesce=True
+            ),
+        ]
+
+        with patch.object(manager, "list_tasks", return_value=mock_tasks):
+            stats = await manager.get_statistics()
+
+            assert isinstance(stats, TaskStatistics)
+            assert stats.total_tasks == 3
+            assert stats.active_tasks == 2
+            assert stats.paused_tasks == 1
+
+    def test_format_trigger_interval(self, manager: ScheduledTaskManager) -> None:
+        """Test _format_trigger handles interval triggers correctly."""
+        # Mock IntervalTrigger
+        mock_trigger = MagicMock()
+        mock_trigger.__class__.__name__ = "IntervalTrigger"
+
+        # Test seconds
+        mock_trigger.interval.total_seconds.return_value = 30
+        result = manager._format_trigger(mock_trigger)
+        assert result == "Every 30s"
+
+        # Test minutes
+        mock_trigger.interval.total_seconds.return_value = 300  # 5 minutes
+        result = manager._format_trigger(mock_trigger)
+        assert result == "Every 5m"
+
+        # Test hours
+        mock_trigger.interval.total_seconds.return_value = 7200  # 2 hours
+        result = manager._format_trigger(mock_trigger)
+        assert result == "Every 2h"
+
+    def test_format_trigger_cron(self, manager: ScheduledTaskManager) -> None:
+        """Test _format_trigger handles cron triggers correctly."""
+        mock_trigger = MagicMock()
+        mock_trigger.__class__.__name__ = "CronTrigger"
+
+        # Mock fields
+        mock_field = MagicMock()
+        mock_field.name = "hour"
+        mock_field.__str__ = MagicMock(return_value="2")
+        mock_trigger.fields = [mock_field]
+
+        result = manager._format_trigger(mock_trigger)
+        assert result == "Cron: hour=2"
+
+    def test_format_trigger_unknown(self, manager: ScheduledTaskManager) -> None:
+        """Test _format_trigger handles unknown triggers."""
+        result = manager._format_trigger(None)
+        assert result == "Unknown"
+
+        mock_trigger = MagicMock()
+        mock_trigger.__class__.__name__ = "UnknownTrigger"
+        result = manager._format_trigger(mock_trigger)
+        assert result == "Unknown"
+
+    def test_get_trigger_type(self, manager: ScheduledTaskManager) -> None:
+        """Test _get_trigger_type extracts trigger types correctly."""
+        # Test interval
+        mock_trigger = MagicMock()
+        mock_trigger.__class__.__name__ = "IntervalTrigger"
+        result = manager._get_trigger_type(mock_trigger)
+        assert result == "interval"
+
+        # Test cron
+        mock_trigger.__class__.__name__ = "CronTrigger"
+        result = manager._get_trigger_type(mock_trigger)
+        assert result == "cron"
+
+        # Test date
+        mock_trigger.__class__.__name__ = "DateTrigger"
+        result = manager._get_trigger_type(mock_trigger)
+        assert result == "date"
+
+        # Test unknown
+        result = manager._get_trigger_type(None)
+        assert result == "unknown"
+{%- endif %}

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

@@ -0,0 +1,98 @@
+"""Test system monitoring functions."""
+
+import pytest
+from app.services.system import (
+    ComponentStatus,
+    get_system_status,
+    is_system_healthy,
+    register_health_check,
+)
+
+
+class TestSystemService:
+    """Test the system monitoring functions."""
+
+    @pytest.mark.asyncio
+    async def test_component_status_creation(self) -> None:
+        """Test component status Pydantic model."""
+        status = ComponentStatus(
+            name="test_component",
+            message="All good",
+            response_time_ms=100.0,
+            metadata={"version": "1.0"},
+        )
+
+        assert status.name == "test_component"
+        assert status.healthy is True
+        assert status.message == "All good"
+        assert status.response_time_ms == 100.0
+        assert status.metadata == {"version": "1.0"}
+
+    @pytest.mark.asyncio
+    async def test_system_status_properties(self) -> None:
+        """Test system status Pydantic model properties."""
+        status = await get_system_status()
+
+        assert isinstance(status.overall_healthy, bool)
+        assert len(status.components) >= 1
+        assert isinstance(status.healthy_components, list)
+        assert isinstance(status.unhealthy_components, list)
+        assert isinstance(status.health_percentage, float)
+
+    @pytest.mark.asyncio
+    async def test_system_health_checks(self) -> None:
+        """Test basic health checks functionality."""
+        status = await get_system_status()
+
+        # Test that we get valid system information
+        assert hasattr(status, "components")
+        assert hasattr(status, "overall_healthy")
+        assert hasattr(status, "timestamp")
+        assert hasattr(status, "system_info")
+
+        # Verify components exist (at least core system checks)
+        assert len(status.components) > 0
+
+        # Check that each component has required fields
+        for component_name, component_status in status.components.items():
+            assert isinstance(component_name, str)
+            assert isinstance(component_status.healthy, bool)
+            assert isinstance(component_status.message, str)
+            assert isinstance(component_status.name, str)
+
+    @pytest.mark.asyncio
+    async def test_is_system_healthy(self) -> None:
+        """Test quick health check function."""
+        healthy = await is_system_healthy()
+        assert isinstance(healthy, bool)
+
+    @pytest.mark.asyncio
+    async def test_custom_health_check_registration(self) -> None:
+        """Test custom health check registration."""
+
+        async def custom_check() -> ComponentStatus:
+            return ComponentStatus(
+                name="custom_test",
+                message="Custom check passed",
+                response_time_ms=None,
+            )
+
+        # Register custom check
+        register_health_check("custom_test", custom_check)
+
+        try:
+            # Get status and verify custom check is included under aegis component
+            status = await get_system_status()
+            assert "aegis" in status.components
+            aegis_component = status.components["aegis"]
+            assert "components" in aegis_component.sub_components
+            components_group = aegis_component.sub_components["components"]
+            assert "custom_test" in components_group.sub_components
+            assert components_group.sub_components["custom_test"].name == "custom_test"
+            assert components_group.sub_components["custom_test"].healthy is True
+        finally:
+            # Clean up the custom health check registration
+            from app.services.system.health import _health_checks
+
+            if "custom_test" in _health_checks:
+                del _health_checks["custom_test"]