tests/unit/middleware/test_error_handling.py - develop-0.4 - liquid-g/liquid-code

tests/unit/middleware/test_error_handling.py
314 строк10 KB
User
0.4.4 - унифицирована загрузка middleware в application.py; дописаны тесты: - Всего тестов: 341 - Общее покрытие: 64%
05 июл 2026, 14:02
05 июл 2026, 14:0227abc28
"""Unit-тесты для ErrorHandlingMiddleware."""

import pytest
from unittest.mock import Mock, patch

from liquidcode.middleware.error_handling import ErrorHandlingMiddleware
from liquidcode.http import HttpRequest, HttpResponse


class TestErrorHandlingMiddleware:
    """Тесты middleware обработки ошибок."""

    def test_no_error(self):
        """Без ошибок - пропускает запрос."""
        middleware = ErrorHandlingMiddleware()
        
        request = HttpRequest(
            method="GET",
            path="/api/test",
            headers={},
            body=b""
        )
        
        response = HttpResponse({"data": "test"}, 200)
        result = middleware(request, lambda req: response)
        
        assert result.get_content() == {"data": "test"}
        assert result.get_status() == 200

    def test_exception_handled(self):
        """Обработка исключения."""
        middleware = ErrorHandlingMiddleware()
        
        request = HttpRequest(
            method="GET",
            path="/api/test",
            headers={"Accept": "application/json"},
            body=b""
        )
        
        def raise_error(req):
            raise ValueError("Test error")
        
        result = middleware(request, raise_error)
        
        assert result.get_status() == 500
        content = result.get_content()
        assert content["error"] == "Test error"
        assert content["status"] == 500
        assert content["path"] == "/api/test"

    def test_json_response_by_default(self):
        """JSON ответ с Accept заголовком application/json."""
        middleware = ErrorHandlingMiddleware()
        
        request = HttpRequest(
            method="GET",
            path="/api/test",
            headers={"Accept": "application/json"},
            body=b""
        )
        
        def raise_error(req):
            raise Exception("Error")
        
        result = middleware(request, raise_error)
        
        headers = result.get_headers()
        assert "application/json" in headers.get("Content-Type", "")

    def test_json_response_with_accept_header(self):
        """JSON по Accept заголовку."""
        middleware = ErrorHandlingMiddleware()
        
        request = HttpRequest(
            method="GET",
            path="/api/test",
            headers={"Accept": "application/json"},
            body=b""
        )
        
        def raise_error(req):
            raise Exception("Error")
        
        result = middleware(request, raise_error)
        
        assert "application/json" in result.get_headers().get("Content-Type", "")

    def test_html_response_without_accept(self):
        """HTML ответ без Accept заголовка."""
        middleware = ErrorHandlingMiddleware()
        
        request = HttpRequest(
            method="GET",
            path="/api/test",
            headers={},
            body=b""
        )
        
        def raise_error(req):
            raise Exception("Error")
        
        result = middleware(request, raise_error)
        
        assert "text/html" in result.get_headers().get("Content-Type", "")

    def test_custom_exception_status(self):
        """Статус из исключения."""
        class CustomError(Exception):
            status_code = 400
        
        middleware = ErrorHandlingMiddleware()
        
        request = HttpRequest(
            method="GET",
            path="/api/test",
            headers={},
            body=b""
        )
        
        def raise_error(req):
            raise CustomError("Bad request")
        
        result = middleware(request, raise_error)
        
        assert result.get_status() == 400

    def test_debug_mode(self):
        """Режим отладки с traceback."""
        middleware = ErrorHandlingMiddleware(debug=True)
        
        request = HttpRequest(
            method="GET",
            path="/api/test",
            headers={"Accept": "application/json"},
            body=b""
        )
        
        def raise_error(req):
            raise ValueError("Debug error")
        
        result = middleware(request, raise_error)
        
        content = result.get_content()
        assert "traceback" in content
        assert isinstance(content["traceback"], list)

    def test_container_template_manager(self):
        """TemplateManager из контейнера."""
        mock_container = Mock()
        mock_template_manager = Mock()
        mock_template_manager.render.return_value = "<h1>Error</h1>"
        mock_container.get.return_value = mock_template_manager
        
        middleware = ErrorHandlingMiddleware(container=mock_container)
        
        request = HttpRequest(
            method="GET",
            path="/api/test",
            headers={},
            body=b""
        )
        
        def raise_error(req):
            raise Exception("Error")
        
        result = middleware(request, raise_error)
        
        assert result.get_status() == 500
        mock_container.get.assert_called_once()
        # TemplateManager не используется, fallback HTML
        assert "text/html" in result.get_headers().get("Content-Type", "")

    def test_template_manager_error_fallback(self):
        """Fallback при ошибке рендеринга шаблона."""
        mock_container = Mock()
        mock_template_manager = Mock()
        mock_template_manager.render.side_effect = Exception("Template not found")
        mock_container.get.return_value = mock_template_manager
        
        middleware = ErrorHandlingMiddleware(container=mock_container)
        
        request = HttpRequest(
            method="GET",
            path="/api/test",
            headers={},
            body=b""
        )
        
        def raise_error(req):
            raise Exception("Error")
        
        result = middleware(request, raise_error)
        
        # Должен вернуться fallback HTML
        assert "text/html" in result.get_headers().get("Content-Type", "")

    def test_accept_header_with_q_values(self):
        """Accept заголовок с q-значениями."""
        middleware = ErrorHandlingMiddleware()
        
        request = HttpRequest(
            method="GET",
            path="/api/test",
            headers={"Accept": "text/html;q=0.8, application/json;q=0.9"},
            body=b""
        )
        
        def raise_error(req):
            raise Exception("Error")
        
        result = middleware(request, raise_error)
        
        # JSON имеет больший weight
        assert "application/json" in result.get_headers().get("Content-Type", "")

    def test_prefer_json_option(self):
        """Опция prefer_json."""
        middleware = ErrorHandlingMiddleware(prefer_json=True)
        
        request = HttpRequest(
            method="GET",
            path="/api/test",
            headers={"Accept": "text/html"},
            body=b""
        )
        
        def raise_error(req):
            raise Exception("Error")
        
        result = middleware(request, raise_error)
        
        assert "application/json" in result.get_headers().get("Content-Type", "")

    def test_error_with_path_and_method(self):
        """Ошибка содержит путь и метод."""
        middleware = ErrorHandlingMiddleware()
        
        request = HttpRequest(
            method="POST",
            path="/api/users",
            headers={},
            body=b""
        )
        
        def raise_error(req):
            raise Exception("Create failed")
        
        result = middleware(request, raise_error)
        
        # Для HTML ответа content - это bytes
        content_bytes = result.get_content()
        assert isinstance(content_bytes, bytes)
        assert b"/api/users" in content_bytes

    def test_multiple_errors_in_chain(self):
        """Несколько middleware в цепочке."""
        middleware1 = ErrorHandlingMiddleware()
        middleware2 = Mock()
        middleware2.return_value = HttpResponse({"result": "ok"}, 200)
        
        request = HttpRequest(
            method="GET",
            path="/api/test",
            headers={},
            body=b""
        )
        
        def call_next(req):
            return middleware2(req)
        
        # ErrorHandlingMiddleware не должен мешать успешному запросу
        result = middleware1(request, call_next)
        
        assert result.get_content() == {"result": "ok"}

    def test_empty_error_message(self):
        """Пустое сообщение об ошибке."""
        middleware = ErrorHandlingMiddleware()
        
        request = HttpRequest(
            method="GET",
            path="/api/test",
            headers={},
            body=b""
        )
        
        def raise_error(req):
            raise Exception()
        
        result = middleware(request, raise_error)
        
        # Для HTML ответа content - это bytes
        content_bytes = result.get_content()
        assert isinstance(content_bytes, bytes)
        assert b"500" in content_bytes

    def test_accept_html_preferred(self):
        """HTML предпочтителен."""
        middleware = ErrorHandlingMiddleware()
        
        request = HttpRequest(
            method="GET",
            path="/api/test",
            headers={"Accept": "text/html;q=0.9, application/json;q=0.8"},
            body=b""
        )
        
        def raise_error(req):
            raise Exception("Error")
        
        result = middleware(request, raise_error)
        
        assert "text/html" in result.get_headers().get("Content-Type", "")