homelab_automation/tests/backend/test_routes_server.py

"""
Tests pour les routes de logs serveur.

Couvre:
- GET /api/server/logs (console et db)
"""

import pytest
from unittest.mock import patch, MagicMock, AsyncMock
from httpx import AsyncClient

pytestmark = [pytest.mark.unit, pytest.mark.asyncio]


class TestGetServerLogsConsole:
    """Tests pour GET /api/server/logs avec source console."""

    async def test_get_console_logs_default(self, client: AsyncClient):
        """Récupère les logs console par défaut."""
        mock_logs = [
            {"timestamp": "2025-01-15T10:00:00", "level": "INFO", "message": "Test log 1"},
            {"timestamp": "2025-01-15T10:01:00", "level": "DEBUG", "message": "Test log 2"},
        ]
        
        with patch("app.routes.server.console_log_service") as mock_service:
            mock_service.get_logs.return_value = mock_logs
            mock_service.get_count.return_value = 2
            
            response = await client.get("/api/server/logs")
        
        assert response.status_code == 200
        data = response.json()
        assert data["source"] == "console"
        assert data["count"] == 2
        assert len(data["logs"]) == 2
        assert data["limit"] == 500
        assert data["offset"] == 0

    async def test_get_console_logs_with_pagination(self, client: AsyncClient):
        """Récupère les logs console avec pagination."""
        with patch("app.routes.server.console_log_service") as mock_service:
            mock_service.get_logs.return_value = []
            mock_service.get_count.return_value = 100
            
            response = await client.get("/api/server/logs?limit=10&offset=20")
        
        assert response.status_code == 200
        data = response.json()
        assert data["limit"] == 10
        assert data["offset"] == 20
        mock_service.get_logs.assert_called_once_with(limit=10, offset=20, level=None)

    async def test_get_console_logs_with_level_filter(self, client: AsyncClient):
        """Récupère les logs console avec filtre de niveau."""
        mock_logs = [
            {"timestamp": "2025-01-15T10:00:00", "level": "ERROR", "message": "Error log"},
        ]
        
        with patch("app.routes.server.console_log_service") as mock_service:
            mock_service.get_logs.return_value = mock_logs
            mock_service.get_count.return_value = 1
            
            response = await client.get("/api/server/logs?level=ERROR")
        
        assert response.status_code == 200
        mock_service.get_logs.assert_called_once_with(limit=500, offset=0, level="ERROR")

    async def test_get_console_logs_explicit_source(self, client: AsyncClient):
        """Récupère les logs console avec source explicite."""
        with patch("app.routes.server.console_log_service") as mock_service:
            mock_service.get_logs.return_value = []
            mock_service.get_count.return_value = 0
            
            response = await client.get("/api/server/logs?log_source=console")
        
        assert response.status_code == 200
        data = response.json()
        assert data["source"] == "console"


class TestGetServerLogsDB:
    """Tests pour GET /api/server/logs avec source db."""

    async def test_get_db_logs(self, client: AsyncClient, db_session):
        """Récupère les logs depuis la base de données."""
        response = await client.get("/api/server/logs?log_source=db")
        
        assert response.status_code == 200
        data = response.json()
        assert data["source"] == "db"
        assert "logs" in data
        assert "count" in data

    async def test_get_db_logs_with_pagination(self, client: AsyncClient, db_session):
        """Récupère les logs DB avec pagination."""
        response = await client.get("/api/server/logs?log_source=db&limit=5&offset=10")
        
        assert response.status_code == 200
        data = response.json()
        assert data["limit"] == 5
        assert data["offset"] == 10

    async def test_get_db_logs_with_level_filter(self, client: AsyncClient, db_session):
        """Récupère les logs DB avec filtre de niveau."""
        response = await client.get("/api/server/logs?log_source=db&level=ERROR")
        
        assert response.status_code == 200
        data = response.json()
        assert data["source"] == "db"

    async def test_get_db_logs_with_source_filter(self, client: AsyncClient, db_session):
        """Récupère les logs DB avec filtre de source."""
        response = await client.get("/api/server/logs?log_source=db&source=ansible")
        
        assert response.status_code == 200
        data = response.json()
        assert data["source"] == "db"

    async def test_get_db_logs_with_all_filters(self, client: AsyncClient, db_session):
        """Récupère les logs DB avec tous les filtres."""
        response = await client.get(
            "/api/server/logs?log_source=db&level=WARN&source=scheduler&limit=20&offset=5"
        )
        
        assert response.status_code == 200
        data = response.json()
        assert data["source"] == "db"
        assert data["limit"] == 20
        assert data["offset"] == 5


class TestServerLogsResponseStructure:
    """Tests pour la structure des réponses de logs."""

    async def test_console_logs_response_structure(self, client: AsyncClient):
        """Vérifie la structure de la réponse pour les logs console."""
        mock_logs = [
            {"timestamp": "2025-01-15T10:00:00", "level": "INFO", "message": "Test"},
        ]
        
        with patch("app.routes.server.console_log_service") as mock_service:
            mock_service.get_logs.return_value = mock_logs
            mock_service.get_count.return_value = 1
            
            response = await client.get("/api/server/logs")
        
        assert response.status_code == 200
        data = response.json()
        assert "logs" in data
        assert "count" in data
        assert "limit" in data
        assert "offset" in data
        assert "source" in data

    async def test_db_logs_response_structure(self, client: AsyncClient, db_session):
        """Vérifie la structure de la réponse pour les logs DB."""
        response = await client.get("/api/server/logs?log_source=db")
        
        assert response.status_code == 200
        data = response.json()
        assert "logs" in data
        assert "count" in data
        assert "limit" in data
        assert "offset" in data
        assert "source" in data
        assert data["source"] == "db"