Added tests for AioHttpRouter and aiohttp in README.md

Author: mr-fatalyst

README.md

@@ -30,6 +30,9 @@ pip install fastopenapi
 
 #### Install FastOpenAPI with a specific framework:
 ```bash
+pip install fastopenapi[aiohttp]
+```
+```bash
 pip install fastopenapi[falcon]
 ```
 ```bash
@@ -60,6 +63,35 @@ pip install fastopenapi[tornado]
 
 #### Examples:
 
+- ![AIOHTTP](https://img.shields.io/badge/AioHttp-0078D7?style=flat&logo=python&logoColor=white)
+  <details>
+    <summary>Click to expand the Falcon Example</summary>
+    
+    ```python
+    from aiohttp import web
+    from pydantic import BaseModel
+    
+    from fastopenapi.routers import AioHttpRouter
+    
+    app = web.Application()
+    router = AioHttpRouter(app=app)
+    
+    
+    class HelloResponse(BaseModel):
+        message: str
+    
+    
+    @router.get("/hello", tags=["Hello"], status_code=200, response_model=HelloResponse)
+    async def hello(name: str):
+        """Say hello from aiohttp"""
+        return HelloResponse(message=f"Hello, {name}! It's aiohttp!")
+    
+    
+    if __name__ == "__main__":
+        web.run_app(app, host="127.0.0.1", port=8000)
+    ```
+  </details>
+
 - ![Falcon](https://img.shields.io/badge/Falcon-45b8d8?style=flat&logo=falcon&logoColor=white)
   <details>
     <summary>Click to expand the Falcon Example</summary>
@@ -267,7 +299,7 @@ http://127.0.0.1:8000/redoc
 ## ⚙️ Features
 - **Generate OpenAPI schemas** with Pydantic v2.
 - **Data validation** using Pydantic models.
-- **Supports multiple frameworks:** Falcon, Flask, Quart, Sanic, Starlette, Tornado.
+- **Supports multiple frameworks:** AIOHTTP, Falcon, Flask, Quart, Sanic, Starlette, Tornado.
 - **Proxy routing provides FastAPI-style routing**
 
 ---

fastopenapi/base_router.py

@@ -371,4 +371,6 @@ def resolve_endpoint_params(
     def openapi(self) -> dict:
         if self._openapi_schema is None:
             self._openapi_schema = self.generate_openapi()
+            # We don't need model cache anymore
+            self.__class__._model_schema_cache.clear()
         return self._openapi_schema

fastopenapi/routers/__init__.py

@@ -6,7 +6,7 @@ def __init__(self, *args, **kwargs):
 try:
     from fastopenapi.routers.aiohttp import AioHttpRouter
 except ModuleNotFoundError:
-    FalconRouter = AioHttpRouter
+    AioHttpRouter = MissingRouter
 
 try:
     from fastopenapi.routers.falcon import FalconRouter
@@ -39,6 +39,7 @@ def __init__(self, *args, **kwargs):
     TornadoRouter = MissingRouter
 
 __all__ = [
+    "AioHttpRouter",
     "FalconRouter",
     "FlaskRouter",
     "QuartRouter",

fastopenapi/routers/aiohttp.py

@@ -81,11 +81,3 @@ async def redoc_view(request):
             self.app.router.add_route("GET", self.openapi_url, openapi_view)
             self.app.router.add_route("GET", self.docs_url, docs_view)
             self.app.router.add_route("GET", self.redoc_url, redoc_view)
-
-    def configure_routes(self, app: web.Application):
-        """
-        Configure routes for an application when not passed during initialization
-        """
-        for path, method, view in self._routes_aiohttp:
-            app.router.add_route(method.upper(), path, view)
-        self._register_docs_endpoints()

tests/aiohttp/__init__.py

@@ -0,0 +1,104 @@
+import pytest
+from aiohttp import web
+from pydantic import BaseModel
+
+from fastopenapi.routers import AioHttpRouter
+
+
+class Item(BaseModel):
+    id: int
+    name: str
+    description: str = None
+
+
+class CreateItemRequest(BaseModel):
+    name: str
+    description: str = None
+
+
+class ItemResponse(BaseModel):
+    id: int
+    name: str
+    description: str = None
+
+
+@pytest.fixture
+async def dummy_endpoint():
+    return {"message": "dummy"}
+
+
+@pytest.fixture
+def items_db():
+    return [
+        {"id": 1, "name": "Item 1", "description": "Description 1"},
+        {"id": 2, "name": "Item 2", "description": "Description 2"},
+    ]
+
+
+@pytest.fixture
+def app(items_db):  # noqa: C901
+    app = web.Application()
+    router = AioHttpRouter(
+        app=app,
+        title="Test API",
+        description="Test API for AioHttpRouter",
+        version="0.1.0",
+    )
+
+    @router.get("/items", response_model=list[ItemResponse], tags=["items"])
+    async def get_items():
+        return [Item(**item) for item in items_db]
+
+    @router.get("/items-sync", response_model=list[ItemResponse], tags=["items"])
+    def get_items_sync():
+        return [Item(**item) for item in items_db]
+
+    @router.get("/items-fail", response_model=list[ItemResponse], tags=["items"])
+    async def get_items_fail():
+        raise Exception("TEST ERROR")
+
+    @router.get("/items/{item_id}", response_model=ItemResponse, tags=["items"])
+    async def get_item(item_id: int):
+        for item in items_db:
+            if item["id"] == item_id:
+                return Item(**item)
+        raise web.HTTPNotFound(text="Not Found")
+
+    @router.post("/items", response_model=ItemResponse, status_code=201, tags=["items"])
+    async def create_item(item: CreateItemRequest):
+        new_id = max(item_["id"] for item_ in items_db) + 1
+        new_item = {"id": new_id, "name": item.name, "description": item.description}
+        items_db.append(new_item)
+        return Item(**new_item)
+
+    @router.put("/items/{item_id}", response_model=ItemResponse, tags=["items"])
+    async def update_item(item_id: int, item: CreateItemRequest):
+        for existing_item in items_db:
+            if existing_item["id"] == item_id:
+                existing_item["name"] = item.name
+                existing_item["description"] = item.description
+                return Item(**existing_item)
+        raise web.HTTPNotFound(text="Not Found")
+
+    @router.delete("/items/{item_id}", status_code=204, tags=["items"])
+    async def delete_item(item_id: int):
+        for i, item in enumerate(items_db):
+            if item["id"] == item_id:
+                del items_db[i]
+                return None
+        raise web.HTTPNotFound(text="Not Found")
+
+    return app
+
+
+@pytest.fixture
+def client(app, event_loop):
+    from aiohttp.test_utils import TestClient, TestServer
+
+    server = TestServer(app, loop=event_loop)
+    event_loop.run_until_complete(server.start_server())
+    client = TestClient(server, loop=event_loop)
+    event_loop.run_until_complete(client.start_server())
+    yield client
+    event_loop.run_until_complete(client.close())
+    event_loop.run_until_complete(server.close())

tests/aiohttp/conftest.py

@@ -0,0 +1,140 @@
+import json
+
+import pytest
+
+
+class TestAioHttpIntegration:
+    @pytest.mark.asyncio
+    async def test_get_items(self, client):
+        """Test retrieving all items"""
+        resp = await client.get("/items")
+        assert resp.status == 200
+        data = await resp.json()
+        assert len(data) == 2
+        assert data[0]["name"] == "Item 1"
+        assert data[1]["name"] == "Item 2"
+
+    @pytest.mark.asyncio
+    async def test_get_items_sync(self, client):
+        """Test retrieving all items (synchronous endpoint)"""
+        resp = await client.get("/items-sync")
+        assert resp.status == 200
+        data = await resp.json()
+        assert len(data) == 2
+        assert data[0]["name"] == "Item 1"
+        assert data[1]["name"] == "Item 2"
+
+    @pytest.mark.asyncio
+    async def test_get_items_fail(self, client):
+        """Test retrieving items with generated error"""
+        resp = await client.get("/items-fail")
+        assert resp.status == 500
+        data = await resp.json()
+        assert data["detail"] == "TEST ERROR"
+
+    @pytest.mark.asyncio
+    async def test_get_item(self, client):
+        """Test retrieving item by ID"""
+        resp = await client.get("/items/1")
+        assert resp.status == 200
+        data = await resp.json()
+        assert data["id"] == 1
+        assert data["name"] == "Item 1"
+        assert data["description"] == "Description 1"
+
+    @pytest.mark.asyncio
+    async def test_get_item_unprocessable(self, client):
+        """Test retrieving item with incorrect parameter type"""
+        resp = await client.get("/items/abc")
+        assert resp.status == 422
+        data = await resp.json()
+        assert "Error casting parameter" in data["detail"]
+
+    @pytest.mark.asyncio
+    async def test_get_nonexistent_item(self, client):
+        """Test retrieving non-existent item"""
+        resp = await client.get("/items/999")
+        assert resp.status == 404
+
+    @pytest.mark.asyncio
+    async def test_create_item(self, client):
+        """Test creating an item"""
+        new_item = {"name": "New Item", "description": "New Description"}
+        headers = {"Content-Type": "application/json"}
+        resp = await client.post("/items", data=json.dumps(new_item), headers=headers)
+        assert resp.status == 201
+        data = await resp.json()
+        assert data["id"] == 3
+        assert data["name"] == "New Item"
+        assert data["description"] == "New Description"
+
+    @pytest.mark.asyncio
+    async def test_create_item_incorrect(self, client):
+        """Test creating an item with invalid data"""
+        new_item = {"name": None, "description": "New Description"}
+        headers = {"Content-Type": "application/json"}
+        resp = await client.post("/items", data=json.dumps(new_item), headers=headers)
+        assert resp.status == 422
+        data = await resp.json()
+        assert "Validation error for parameter" in data["detail"]
+
+    @pytest.mark.asyncio
+    async def test_create_item_invalid_json(self, client):
+        """Test creating an item with invalid JSON"""
+        headers = {"Content-Type": "application/json"}
+        resp = await client.post("/items", data="incorrect json", headers=headers)
+        assert resp.status == 422
+        data = await resp.json()
+        assert "Validation error for parameter" in data["detail"]
+
+    @pytest.mark.asyncio
+    async def test_update_item(self, client):
+        """Test updating an item"""
+        update_data = {"name": "Updated Item", "description": "Updated Description"}
+        headers = {"Content-Type": "application/json"}
+        resp = await client.put(
+            "/items/2", data=json.dumps(update_data), headers=headers
+        )
+        assert resp.status == 200
+        data = await resp.json()
+        assert data["id"] == 2
+        assert data["name"] == "Updated Item"
+        assert data["description"] == "Updated Description"
+
+    @pytest.mark.asyncio
+    async def test_delete_item(self, client):
+        """Test deleting an item"""
+        resp = await client.delete("/items/1")
+        assert resp.status == 204
+
+        # Check that the item was actually deleted
+        resp = await client.get("/items/1")
+        assert resp.status == 404
+
+    @pytest.mark.asyncio
+    async def test_openapi_schema_endpoint(self, client):
+        """Test OpenAPI schema endpoint"""
+        resp = await client.get("/openapi.json")
+        assert resp.status == 200
+        schema = await resp.json()
+        assert schema["info"]["title"] == "Test API"
+        assert "/items" in schema["paths"]
+        assert "/items/{item_id}" in schema["paths"]
+
+    @pytest.mark.asyncio
+    async def test_swagger_ui_endpoint(self, client):
+        """Test Swagger UI endpoint"""
+        resp = await client.get("/docs")
+        assert resp.status == 200
+        text = await resp.text()
+        assert "text/html" in resp.headers["Content-Type"]
+        assert "swagger-ui" in text
+
+    @pytest.mark.asyncio
+    async def test_redoc_ui_endpoint(self, client):
+        """Test ReDoc UI endpoint"""
+        resp = await client.get("/redoc")
+        assert resp.status == 200
+        text = await resp.text()
+        assert "text/html" in resp.headers["Content-Type"]
+        assert "redoc" in text