linters

Author: krylosov-aa

async_pytest_httpserver/__init__.py

@@ -1,8 +1,9 @@
 from .web_service_mock import MockData, WebServiceMock
-from .fixtures import external_service_mock
+from .fixtures import external_service_mock, AddMockDataFunc
 
 __all__ = [
     "MockData",
     "WebServiceMock",
     "external_service_mock",
+    "AddMockDataFunc",
 ]

async_pytest_httpserver/fixtures.py

@@ -1,30 +1,26 @@
-from typing import Callable
-
-import pytest_asyncio
+from typing import Any, Awaitable, Callable, List, Tuple
 from aiohttp import web
+from aiohttp.test_utils import TestServer
+import pytest_asyncio
 
 from .web_service_mock import MockData, WebServiceMock
 
+AddMockDataFunc = Callable[[MockData], List[dict[str, Any]]]
 
-@pytest_asyncio.fixture
-async def external_service_mock(aiohttp_server):
-    """
-    Mock server for an external service
 
-    Returns:
-    function for adding an API to the server
-    """
+@pytest_asyncio.fixture
+async def external_service_mock(
+    aiohttp_server: Callable[[web.Application], Awaitable[TestServer]],
+) -> Callable[[], Awaitable[Tuple[str, AddMockDataFunc]]]:
+    """Mock server for an external service."""
 
-    async def _create_mock() -> tuple[
-        str, Callable[[MockData], list[dict[str, any]]]
-    ]:
+    async def _create_mock() -> Tuple[str, AddMockDataFunc]:
         app = web.Application()
         web_service = WebServiceMock()
-        # The route catches requests for any path with any method.
-        # The web_service is responsible for actual routing, allowing new
-        # APIs to be added at server runtime.
+
         app.router.add_route("*", "/{tail:.+}", web_service.handle)
+
         server = await aiohttp_server(app)
-        return f"http://{server.host}:{server.port}", web_service.add_mock_data
+        return str(server.make_url("")), web_service.add_mock_data
 
     return _create_mock

async_pytest_httpserver/web_service_mock.py

@@ -1,19 +1,21 @@
 from copy import deepcopy
 from dataclasses import dataclass
 from inspect import isawaitable
-from typing import Awaitable, Callable
+from typing import Any, Awaitable, Callable
 
 from aiohttp import web
 
 
+ResponseHandler = Callable[
+    [web.Request], web.Response | Awaitable[web.Response]
+]
+
+
 @dataclass
 class MockData:
     method: str  # the method we replace
     path: str  # the API path we are replacing
-    response: (
-        web.Response
-        | Callable[[web.Request], web.Response | Awaitable[web.Response]]
-    )
+    response: web.Response | ResponseHandler
 
 
 class WebServiceMock:
@@ -24,9 +26,9 @@ class WebServiceMock:
         2. Add real APIs via add_mock_data
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._mock_data: list[MockData] = []
-        self._call_info = {}
+        self._call_info: dict[str, dict[str, list[dict[str, Any]]]] = {}
 
     async def handle(self, request: web.Request) -> web.Response:
         """
@@ -41,19 +43,18 @@ async def handle(self, request: web.Request) -> web.Response:
                 await self._save_request(mock.method, mock.path, request)
                 if isinstance(mock.response, web.Response):
                     return deepcopy(mock.response)
-                else:
-                    response = mock.response(request)
-                    if isawaitable(response):
-                        return await response
-                    else:
-                        return response
-
-        raise Exception(
+
+                response = mock.response(request)
+                if isawaitable(response):
+                    return await response
+                return response
+
+        raise LookupError(
             f"Mock with method={request.method} "
             f"and url={request.path} not found"
         )
 
-    def add_mock_data(self, mock_data: MockData) -> list[dict[str, any]]:
+    def add_mock_data(self, mock_data: MockData) -> list[dict[str, Any]]:
         """Saves a new mock and returns a reference to the call history"""
         self._mock_data.append(mock_data)
 
@@ -66,11 +67,12 @@ def add_mock_data(self, mock_data: MockData) -> list[dict[str, any]]:
     async def _save_request(
         self, method: str, path: str, request: web.Request
     ) -> None:
-        data = {"headers": request.headers}
+        data: dict[str, Any] = {"headers": request.headers}
+
         if request.can_read_body:
             if request.content_type == "application/json":
                 data["json"] = await request.json()
-            if request.content_type == "text/plain":
+            elif request.content_type == "text/plain":
                 data["text"] = await request.text()
 
         self._call_info[path][method].append(data)

mypy.ini

@@ -1,3 +1,6 @@
 [mypy]
 strict = true
 pretty = true
+
+[mypy-tests.*]
+disable_error_code = no-untyped-def

pyproject.toml

@@ -18,6 +18,3 @@ dev = [
     "ruff>=0.14.8",
     "wemake-python-styleguide>=1.4.0",
 ]
-
-[project.entry-points.pytest11]
-my_fixtures = "async_pytest_httpserver.fixtures"

setup.cfg

@@ -1,7 +1,6 @@
 [flake8]
 exclude = .venv
-;ignore=WPS476, WPS300, WPS410, WPS412, WPS501, WPS229, WPS202, WPS110, WPS473
-;    WPS217, WPS430, WPS420
-;
-;per-file-ignores =
-;    examples/*: WPS110, WPS432, WPS204, WPS114, WPS226, WPS201, WPS213
+ignore=WPS110, WPS430, WPS234, WPS300, WPS476, W503, WPS412, WPS410
+
+per-file-ignores =
+    tests/*: WPS226, WPS300

tests/conftest.py

@@ -1,43 +1,56 @@
-from typing import Any, AsyncGenerator, Awaitable, Callable
+from typing import Any, AsyncGenerator, Awaitable, Callable, List
 
 import pytest
 import pytest_asyncio
 from aiohttp import web, ClientSession
 
-from async_pytest_httpserver import MockData
+from async_pytest_httpserver import (
+    MockData,
+    AddMockDataFunc,
+)
 from . import settings
 
 
 @pytest_asyncio.fixture
 async def some_service_mock(
-    external_service_mock,
-) -> AsyncGenerator[Callable[[MockData], list[dict[str, any]]]]:
+    external_service_mock: Callable[
+        [], Awaitable[tuple[str, AddMockDataFunc]]
+    ],
+) -> AsyncGenerator[AddMockDataFunc, None]:
     """
     Example of how to use
     """
     url, add_mock_data = await external_service_mock()
-    # You have a URL for an external service specified somewhere.
-    # We're replacing it with a new one as part of our testing.
     old_url = settings.EXTERNAL_SERVICE_URL
     settings.EXTERNAL_SERVICE_URL = url
-    yield add_mock_data
-    settings.EXTERNAL_SERVICE_URL = old_url
+    try:
+        yield add_mock_data
+    finally:
+        settings.EXTERNAL_SERVICE_URL = old_url
 
 
 @pytest.fixture
-def some_service_mock_api(some_service_mock):
+def some_service_mock_api(
+    some_service_mock: AddMockDataFunc,
+) -> Callable[
+    [
+        web.Response
+        | Callable[[web.Request], web.Response | Awaitable[web.Response]]
+    ],
+    List[dict[str, Any]],
+]:
     """An example of a fixture where a specific API is mocked"""
 
     def _create_mock(
         response: web.Response
         | Callable[[web.Request], web.Response | Awaitable[web.Response]],
-    ) -> list[dict[str, Any]]:
+    ) -> List[dict[str, Any]]:
         return some_service_mock(MockData("POST", "/some_api", response))
 
     return _create_mock
 
 
 @pytest_asyncio.fixture
-async def client() -> AsyncGenerator[ClientSession, Any]:
+async def client() -> AsyncGenerator[ClientSession, None]:
     async with ClientSession() as session:
         yield session