More tests

pyproject.toml

@@ -115,6 +115,7 @@ ignore = [
     "B006",   # trust me
     "B008",   # can't get it to work with extend-immutable-calls
     "N818",   # Exceptions
+    "RUF006", # Buggy for now
     "RUF013", # False implicit optionals
 ]
 

tests/conftest.py

@@ -1,4 +1,4 @@
-from asyncio import Event, create_task, new_event_loop
+from asyncio import create_task, new_event_loop
 from asyncio.exceptions import CancelledError
 from collections.abc import AsyncIterator, Callable
 from contextlib import suppress
@@ -8,6 +8,7 @@
 from .aiohttp import make_app as make_aiohttp_app
 from .aiohttp import run_on_aiohttp
 from .django import run_on_django
+from .django_uapi_app.views import app
 from .flask import make_app as make_flask_app
 from .flask import run_on_flask
 from .quart import make_app as make_quart_app
@@ -37,13 +38,12 @@ async def server(request, unused_tcp_port_factory: Callable[..., int]):
         with suppress(CancelledError):
             await t
     elif request.param == "flask":
-        shutdown_event = Event()
-        t = create_task(run_on_flask(make_flask_app(), unused_tcp_port, shutdown_event))
+        t = create_task(run_on_flask(make_flask_app(), unused_tcp_port))
         yield unused_tcp_port
-        shutdown_event.set()
-        await t
+        t.cancel()
+        with suppress(CancelledError):
+            await t
     elif request.param == "quart":
-        shutdown_event = Event()
         t = create_task(run_on_quart(make_quart_app(), unused_tcp_port))
         yield unused_tcp_port
         t.cancel()
@@ -56,11 +56,11 @@ async def server(request, unused_tcp_port_factory: Callable[..., int]):
         with suppress(CancelledError):
             await t
     elif request.param == "django":
-        shutdown_event = Event()
-        t = create_task(run_on_django(unused_tcp_port, shutdown_event))
+        t = create_task(run_on_django(app, unused_tcp_port))
         yield unused_tcp_port
-        shutdown_event.set()
-        await t
+        t.cancel()
+        with suppress(CancelledError):
+            await t
     else:
         raise Exception("Unknown server framework")
 
@@ -81,13 +81,13 @@ async def server_with_openapi(
         with suppress(CancelledError):
             await t
     elif request.param == "flask":
-        shutdown_event = Event()
         flask_app = make_flask_app()
         flask_app.serve_openapi()
-        t = create_task(run_on_flask(flask_app, unused_tcp_port, shutdown_event))
+        t = create_task(run_on_flask(flask_app, unused_tcp_port))
         yield unused_tcp_port
-        shutdown_event.set()
-        await t
+        t.cancel()
+        with suppress(CancelledError):
+            await t
     elif request.param == "quart":
         quart_app = make_quart_app()
         quart_app.serve_openapi()
@@ -105,10 +105,10 @@ async def server_with_openapi(
         with suppress(CancelledError):
             await t
     elif request.param == "django":
-        shutdown_event = Event()
-        t = create_task(run_on_django(unused_tcp_port, shutdown_event))
+        t = create_task(run_on_django(app, unused_tcp_port))
         yield unused_tcp_port
-        shutdown_event.set()
-        await t
+        t.cancel()
+        with suppress(CancelledError):
+            await t
     else:
         raise Exception("Unknown server framework")

tests/django.py

@@ -1,13 +1,40 @@
-from asyncio import Event
+from asyncio import CancelledError, Event, create_task
 
 from hypercorn.asyncio import serve
 from hypercorn.config import Config
 
+from uapi.django import DjangoApp
 
-async def run_on_django(port: int, shutdown_event: Event):
-    from .django_uapi.django_uapi.wsgi import application
+# Sigh
+urlpatterns: list = []
+
+
+async def run_on_django(app: DjangoApp, port: int) -> None:
+    from django.conf import settings
+    from django.core.handlers.wsgi import WSGIHandler
+
+    urlpatterns.clear()
+    urlpatterns.extend(app.to_urlpatterns())
+
+    if not settings.configured:
+        settings.configure(ROOT_URLCONF=__name__, DEBUG=True)
+
+    application = WSGIHandler()
 
     config = Config()
     config.bind = [f"localhost:{port}"]
 
-    await serve(application, config, shutdown_trigger=shutdown_event.wait, mode="wsgi")  # type: ignore
+    event = Event()
+
+    t = create_task(
+        serve(application, config, shutdown_trigger=event.wait, mode="wsgi")  # type: ignore
+    )
+
+    try:
+        await t
+    except CancelledError:
+        event.set()
+        await t
+        raise
+    finally:
+        urlpatterns.clear()

tests/flask.py

@@ -1,4 +1,4 @@
-from asyncio import Event
+from asyncio import CancelledError, Event, create_task
 
 from hypercorn.asyncio import serve
 from hypercorn.config import Config
@@ -73,13 +73,24 @@ def request_method_native(req_method: Method) -> Response:
     return app
 
 
-async def run_on_flask(app: FlaskApp, port: int, shutdown_event: Event):
+async def run_on_flask(app: FlaskApp, port: int):
     config = Config()
     config.bind = [f"localhost:{port}"]
 
-    await serve(
-        app.to_framework_app(__name__),
-        config,
-        shutdown_trigger=shutdown_event.wait,  # type: ignore
-        mode="wsgi",
+    event = Event()
+
+    t = create_task(
+        serve(
+            app.to_framework_app(__name__),
+            config,
+            shutdown_trigger=event.wait,  # type: ignore
+            mode="wsgi",
+        )
     )
+
+    try:
+        await t
+    except CancelledError:
+        event.set()
+        await t
+        raise

tests/openapi/test_openapi_uis.py

@@ -1,5 +1,6 @@
-from asyncio import Event, create_task
+from asyncio import CancelledError, create_task
 from collections.abc import Callable
+from contextlib import suppress
 
 import pytest
 
@@ -19,13 +20,12 @@ async def openapi_renderer_app(unused_tcp_port_factory: Callable[..., int]):
     app.serve_redoc(openapi_path="/openapi_test.json")
     app.serve_elements(openapi_path="/openapi_test.json")
 
-    shutdown_event = Event()
-
-    t = create_task(run_on_flask(app, unused_tcp_port, shutdown_event))
+    t = create_task(run_on_flask(app, unused_tcp_port))
     yield unused_tcp_port
 
-    shutdown_event.set()
-    await t
+    t.cancel()
+    with suppress(CancelledError):
+        await t
 
 
 async def test_elements(openapi_renderer_app: int) -> None:

tests/sessions/conftest.py

@@ -1,4 +1,4 @@
-from asyncio import CancelledError, Event, create_task
+from asyncio import CancelledError, create_task
 from collections.abc import Callable
 from contextlib import suppress
 
@@ -76,15 +76,14 @@ async def secure_cookie_session_app(
         t.cancel()
         with suppress(CancelledError):
             await t
-
     elif request.param == "flask":
         flask_app = FlaskApp()
         configure_secure_session_app(flask_app)
-        shutdown_event = Event()
-        t = create_task(run_on_flask(flask_app, unused_tcp_port, shutdown_event))
+        t = create_task(run_on_flask(flask_app, unused_tcp_port))
         yield unused_tcp_port
-        shutdown_event.set()
-        await t
+        t.cancel()
+        with suppress(CancelledError):
+            await t
     elif request.param == "quart":
         quart_app = QuartApp()
         configure_secure_session_app(quart_app)

tests/test_get.py

@@ -89,4 +89,5 @@ async def test_user_response_class(server):
     async with AsyncClient() as client:
         resp = await client.get(f"http://localhost:{server}/throttled")
         assert resp.status_code == 429
-        assert resp.headers["content-length"] == "0"
+        # Django omits the content-length
+        assert resp.headers.get("content-length", "0") == "0"

tests/test_shorthands.py

@@ -3,13 +3,22 @@
 from datetime import datetime, timezone
 from typing import Any
 
+import pytest
 from httpx import AsyncClient
 
-from uapi.quart import App
+from uapi.aiohttp import AiohttpApp
+from uapi.django import DjangoApp
+from uapi.flask import FlaskApp
+from uapi.quart import App, QuartApp
 from uapi.shorthands import ResponseShorthand
+from uapi.starlette import StarletteApp
 from uapi.status import BaseResponse, Created, Ok
 
+from .aiohttp import run_on_aiohttp
+from .django import run_on_django
+from .flask import run_on_flask
 from .quart import run_on_quart
+from .starlette import run_on_starlette
 
 
 class DatetimeShorthand(ResponseShorthand[datetime]):
@@ -22,15 +31,34 @@ def is_union_member(value: Any) -> bool:
         return isinstance(value, datetime)
 
 
-async def test_custom_shorthand(unused_tcp_port: int) -> None:
+@pytest.mark.parametrize(
+    "app_type", [QuartApp, AiohttpApp, StarletteApp, FlaskApp, DjangoApp]
+)
+async def test_custom_shorthand(
+    unused_tcp_port: int,
+    app_type: type[QuartApp]
+    | type[AiohttpApp]
+    | type[StarletteApp]
+    | type[FlaskApp]
+    | type[DjangoApp],
+) -> None:
     """Custom shorthands work."""
-    app = App().add_response_shorthand(DatetimeShorthand)
+    app = app_type[None]().add_response_shorthand(DatetimeShorthand)  # type: ignore
 
     @app.get("/")
-    async def datetime_handler() -> datetime:
+    def datetime_handler() -> datetime:
         return datetime(2000, 1, 1, 0, 0, 0, 0, tzinfo=timezone.utc)
 
-    t = create_task(run_on_quart(app, unused_tcp_port))
+    if app_type is QuartApp:
+        t = create_task(run_on_quart(app, unused_tcp_port))
+    elif app_type is AiohttpApp:
+        t = create_task(run_on_aiohttp(app, unused_tcp_port))
+    elif app_type is StarletteApp:
+        t = create_task(run_on_starlette(app, unused_tcp_port))
+    elif app_type is FlaskApp:
+        t = create_task(run_on_flask(app, unused_tcp_port))
+    elif app_type is DjangoApp:
+        t = create_task(run_on_django(app, unused_tcp_port))
 
     try:
         async with AsyncClient() as client: