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

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

import pytest
from unittest.mock import Mock

from liquidcode.middleware.body_parser import BodyParserMiddleware
from liquidcode.http import HttpRequest, HttpResponse


class TestBodyParserMiddleware:
    """Тесты парсинга тела запроса."""

    def test_json_parsing(self):
        """Парсинг JSON тела."""
        middleware = BodyParserMiddleware()
        
        body = b'{"name": "test", "value": 123}'
        request = HttpRequest(
            method="POST",
            path="/api/test",
            headers={"Content-Type": "application/json"},
            body=body
        )
        
        def call_next(req):
            return HttpResponse({"parsed": req.get_attr("parsed_body")}, 200)
        
        response = middleware(request, call_next)
        
        assert response.get_content() == {"parsed": {"name": "test", "value": 123}}

    def test_form_urlencoded_parsing(self):
        """Парсинг form-urlencoded тела."""
        middleware = BodyParserMiddleware()
        
        body = b"name=test&value=123"
        request = HttpRequest(
            method="POST",
            path="/api/test",
            headers={"Content-Type": "application/x-www-form-urlencoded"},
            body=body
        )
        
        def call_next(req):
            return HttpResponse({"parsed": req.get_attr("parsed_body")}, 200)
        
        response = middleware(request, call_next)
        
        parsed = response.get_content()["parsed"]
        assert parsed["name"] == "test"
        assert parsed["value"] == "123"

    def test_no_body(self):
        """Обработка отсутствия тела."""
        middleware = BodyParserMiddleware()
        
        request = HttpRequest(
            method="GET",
            path="/api/test",
            headers={},
            body=b""
        )
        
        def call_next(req):
            return HttpResponse({"parsed": req.get_attr("parsed_body")}, 200)
        
        response = middleware(request, call_next)
        
        assert response.get_content() == {"parsed": None}

    def test_invalid_json(self):
        """Обработка некорректного JSON."""
        middleware = BodyParserMiddleware()
        
        body = b'{"invalid": json}'
        request = HttpRequest(
            method="POST",
            path="/api/test",
            headers={"Content-Type": "application/json"},
            body=body
        )
        
        def call_next(req):
            return HttpResponse({"parsed": req.get_attr("parsed_body")}, 200)
        
        response = middleware(request, call_next)
        
        assert response.get_content() == {"parsed": None}

    def test_no_content_type(self):
        """Обработка отсутствия Content-Type."""
        middleware = BodyParserMiddleware()
        
        body = b"some data"
        request = HttpRequest(
            method="POST",
            path="/api/test",
            headers={},
            body=body
        )
        
        def call_next(req):
            return HttpResponse({"parsed": req.get_attr("parsed_body")}, 200)
        
        response = middleware(request, call_next)
        
        assert response.get_content() == {"parsed": None}

    def test_content_type_case_insensitive(self):
        """Чувствительность к регистру Content-Type."""
        middleware = BodyParserMiddleware()
        
        body = b'{"test": true}'
        request = HttpRequest(
            method="POST",
            path="/api/test",
            headers={"Content-Type": "application/json"},
            body=body
        )
        
        def call_next(req):
            return HttpResponse({"parsed": req.get_attr("parsed_body")}, 200)
        
        response = middleware(request, call_next)
        
        assert response.get_content() == {"parsed": {"test": True}}

    def test_json_with_special_characters(self):
        """Парсинг JSON со специальными символами."""
        middleware = BodyParserMiddleware()
        
        body = b'{"message": "Hello, World!", "emoji": "\uD83D\uDE00"}'
        request = HttpRequest(
            method="POST",
            path="/api/test",
            headers={"Content-Type": "application/json"},
            body=body
        )
        
        def call_next(req):
            return HttpResponse({"parsed": req.get_attr("parsed_body")}, 200)
        
        response = middleware(request, call_next)
        
        parsed = response.get_content()["parsed"]
        assert parsed["message"] == "Hello, World!"
        assert parsed["emoji"] == "😀"

    def test_empty_json_object(self):
        """Парсинг пустого JSON объекта."""
        middleware = BodyParserMiddleware()
        
        body = b'{}'
        request = HttpRequest(
            method="POST",
            path="/api/test",
            headers={"Content-Type": "application/json"},
            body=body
        )
        
        def call_next(req):
            return HttpResponse({"parsed": req.get_attr("parsed_body")}, 200)
        
        response = middleware(request, call_next)
        
        assert response.get_content() == {"parsed": {}}

    def test_json_array(self):
        """Парсинг JSON массива."""
        middleware = BodyParserMiddleware()
        
        body = b'[1, 2, 3]'
        request = HttpRequest(
            method="POST",
            path="/api/test",
            headers={"Content-Type": "application/json"},
            body=body
        )
        
        def call_next(req):
            return HttpResponse({"parsed": req.get_attr("parsed_body")}, 200)
        
        response = middleware(request, call_next)
        
        assert response.get_content() == {"parsed": [1, 2, 3]}

    def test_nested_json(self):
        """Парсинг вложенного JSON."""
        middleware = BodyParserMiddleware()
        
        body = b'{"user": {"name": "test", "age": 30}}'
        request = HttpRequest(
            method="POST",
            path="/api/test",
            headers={"Content-Type": "application/json"},
            body=body
        )
        
        def call_next(req):
            return HttpResponse({"parsed": req.get_attr("parsed_body")}, 200)
        
        response = middleware(request, call_next)
        
        parsed = response.get_content()["parsed"]
        assert parsed["user"]["name"] == "test"
        assert parsed["user"]["age"] == 30

    def test_form_with_multiple_values(self):
        """Парсинг form-urlencoded с несколькими значениями."""
        middleware = BodyParserMiddleware()
        
        body = b"tags=python&tags=javascript&name=test"
        request = HttpRequest(
            method="POST",
            path="/api/test",
            headers={"Content-Type": "application/x-www-form-urlencoded"},
            body=body
        )
        
        def call_next(req):
            return HttpResponse({"parsed": req.get_attr("parsed_body")}, 200)
        
        response = middleware(request, call_next)
        
        parsed = response.get_content()["parsed"]
        # parse_qs сохраняет первое значение
        assert parsed["name"] == "test"

    def test_middleware_chain(self):
        """Проверка middleware в цепочке."""
        middleware = BodyParserMiddleware()
        
        body = b'{"test": "value"}'
        request = HttpRequest(
            method="POST",
            path="/api/test",
            headers={"Content-Type": "application/json"},
            body=body
        )
        
        def call_next(req):
            # Проверяем, что parsed_body сохранён
            assert req.get_attr("parsed_body") is not None
            return HttpResponse({"success": True}, 200)
        
        response = middleware(request, call_next)
        
        assert response.get_content() == {"success": True}