test: add trio tests and use Hypercorn as the server

Author: WSH032

src/fastapi_proxy_lib/core/websocket.py

@@ -42,7 +42,7 @@
         DEFAULT_MAX_MESSAGE_SIZE_BYTES,
         DEFAULT_QUEUE_SIZE,
     )
-except ImportError:
+except ImportError:  # pragma: no cover
     # ref: https://github.com/frankie567/httpx-ws/blob/b2135792141b71551b022ff0d76542a0263a890c/httpx_ws/_api.py#L31-L34
     DEFAULT_KEEPALIVE_PING_TIMEOUT_SECONDS = (  # pyright: ignore[reportConstantRedefinition]
         20.0

tests/app/tool.py

@@ -2,7 +2,7 @@
 
 from contextlib import AsyncExitStack
 from dataclasses import dataclass
-from typing import Any, Literal, TypedDict, Union
+from typing import Any, Literal, Optional, TypedDict, Union
 
 import anyio
 import httpx
@@ -11,17 +11,20 @@
 from fastapi import FastAPI
 from hypercorn import Config as HyperConfig
 from hypercorn.asyncio.run import (
-    worker_serve as hyper_aio_serve,  # pyright: ignore[reportUnknownVariableType]
+    worker_serve as hyper_aio_worker_serve,  # pyright: ignore[reportUnknownVariableType]
 )
 from hypercorn.trio.run import (
-    worker_serve as hyper_trio_serve,  # pyright: ignore[reportUnknownVariableType]
+    worker_serve as hyper_trio_worker_serve,  # pyright: ignore[reportUnknownVariableType]
+)
+from hypercorn.utils import (
+    repr_socket_addr,  # pyright: ignore[reportUnknownVariableType]
 )
 from hypercorn.utils import (
     wrap_app as hyper_wrap_app,  # pyright: ignore[reportUnknownVariableType]
 )
 from starlette.requests import Request
 from starlette.websockets import WebSocket
-from typing_extensions import Self
+from typing_extensions import Self, assert_never
 
 ServerRecvRequestsTypes = Union[Request, WebSocket]
 
@@ -55,7 +58,7 @@ def get_request(self) -> ServerRecvRequestsTypes:
         return server_recv_request
 
 
-class UvicornServer(uvicorn.Server):
+class _UvicornServer(uvicorn.Server):
     """subclass of `uvicorn.Server` which can use AsyncContext to launch and shutdown automatically."""
 
     async def __aenter__(self) -> Self:
@@ -89,7 +92,9 @@ def contx_socket_url(self) -> httpx.URL:
         config = self.config
         if config.fd is not None or config.uds is not None:
             raise RuntimeError("Only support tcp socket.")
-        # refer to: https://docs.python.org/zh-cn/3/library/socket.html#socket-families
+
+        # Implement ref:
+        # https://github.com/encode/uvicorn/blob/a2219eb2ed2bbda4143a0fb18c4b0578881b1ae8/uvicorn/server.py#L201-L220
         host, port = self._socket.getsockname()[:2]
         return httpx.URL(
             host=host,
@@ -99,25 +104,42 @@ def contx_socket_url(self) -> httpx.URL:
         )
 
 
-class HypercornServer:
+class _HypercornServer:
     """An AsyncContext to launch and shutdown Hypercorn server automatically."""
 
-    def __init__(self, app: FastAPI, config: HyperConfig):  # noqa: D107
+    def __init__(self, app: FastAPI, config: HyperConfig):
         self.config = config
         self.app = app
         self.should_exit = anyio.Event()
 
     async def __aenter__(self) -> Self:
         """Launch the server."""
-        self._sockets = self.config.create_sockets()
         self._exit_stack = AsyncExitStack()
 
         self.current_async_lib = sniffio.current_async_library()
 
         if self.current_async_lib == "asyncio":
-            serve_func = hyper_aio_serve  # pyright: ignore[reportUnknownVariableType]
+            serve_func = (  # pyright: ignore[reportUnknownVariableType]
+                hyper_aio_worker_serve
+            )
+
+            # Implement ref:
+            # https://github.com/pgjones/hypercorn/blob/3fbd5f245e5dfeaba6ad852d9135d6a32b228d05/src/hypercorn/asyncio/run.py#L89-L90
+            self._sockets = self.config.create_sockets()
+
         elif self.current_async_lib == "trio":
-            serve_func = hyper_trio_serve  # pyright: ignore[reportUnknownVariableType]
+            serve_func = (  # pyright: ignore[reportUnknownVariableType]
+                hyper_trio_worker_serve
+            )
+
+            # Implement ref:
+            # https://github.com/pgjones/hypercorn/blob/3fbd5f245e5dfeaba6ad852d9135d6a32b228d05/src/hypercorn/trio/run.py#L51-L56
+            self._sockets = self.config.create_sockets()
+            for sock in self._sockets.secure_sockets:
+                sock.listen(self.config.backlog)
+            for sock in self._sockets.insecure_sockets:
+                sock.listen(self.config.backlog)
+
         else:
             raise RuntimeError(f"Unsupported async library {self.current_async_lib!r}")
 
@@ -133,6 +155,7 @@ async def serve() -> None:
                 ),
                 self.config,
                 shutdown_trigger=self.should_exit.wait,
+                sockets=self._sockets,
             )
 
         task_group = await self._exit_stack.enter_async_context(
@@ -154,13 +177,32 @@ def contx_socket_url(self) -> httpx.URL:
         Note: The path of url is explicitly set to "/".
         """
         config = self.config
+        sockets = self._sockets
+
+        # Implement ref:
+        #   https://github.com/pgjones/hypercorn/blob/3fbd5f245e5dfeaba6ad852d9135d6a32b228d05/src/hypercorn/asyncio/run.py#L112-L149
+        #   https://github.com/pgjones/hypercorn/blob/3fbd5f245e5dfeaba6ad852d9135d6a32b228d05/src/hypercorn/trio/run.py#L61-L82
+
+        # We only run on one socket each time,
+        # so we raise `RuntimeError` to avoid other unknown errors during testing.
+        if sockets.insecure_sockets:
+            if len(sockets.insecure_sockets) > 1:
+                raise RuntimeError("Hypercorn test: Multiple insecure_sockets found.")
+            socket = sockets.insecure_sockets[0]
+        elif sockets.secure_sockets:
+            if len(sockets.secure_sockets) > 1:
+                raise RuntimeError("Hypercorn test: secure_sockets sockets found.")
+            socket = sockets.secure_sockets[0]
+        else:
+            raise RuntimeError("Hypercorn test: No socket found.")
 
-        bind = config.bind[0]
+        bind = repr_socket_addr(socket.family, socket.getsockname())
         if bind.startswith(("unix:", "fd://")):
             raise RuntimeError("Only support tcp socket.")
 
-        # refer to: https://docs.python.org/zh-cn/3/library/socket.html#socket-families
-        host, port = config.bind[0].split(":")
+        # Implement ref:
+        # https://docs.python.org/zh-cn/3/library/socket.html#socket-families
+        host, port = bind.split(":")
         port = int(port)
 
         return httpx.URL(
@@ -179,12 +221,16 @@ def __init__(
         app: FastAPI,
         host: str,
         port: int,
-        server_type: Literal["uvicorn", "hypercorn"] = "hypercorn",
+        server_type: Optional[Literal["uvicorn", "hypercorn"]] = None,
     ):
         """Only support ipv4 address.
 
         If use uvicorn, it only support asyncio backend.
+
+        If `host` == 0, then use random port.
         """
+        server_type = server_type if server_type is not None else "hypercorn"
+
         self.app = app
         self.host = host
         self.port = port
@@ -195,10 +241,12 @@ def __init__(
             config.bind = f"{host}:{port}"
 
             self.config = config
-            self.server = HypercornServer(app, config)
-        else:
+            self.server = _HypercornServer(app, config)
+        elif self.server_type == "uvicorn":
             self.config = uvicorn.Config(app, host=host, port=port)
-            self.server = UvicornServer(self.config)
+            self.server = _UvicornServer(self.config)
+        else:
+            assert_never(self.server_type)
 
     async def __aenter__(self) -> Self:
         """Launch the server."""

tests/conftest.py

@@ -15,12 +15,13 @@
     Callable,
     Coroutine,
     Literal,
+    Optional,
     Protocol,
 )
 
 import pytest
-import uvicorn
 from asgi_lifespan import LifespanManager
+from fastapi import FastAPI
 from fastapi_proxy_lib.fastapi.app import (
     forward_http_app,
     reverse_http_app,
@@ -30,7 +31,7 @@
 
 from .app.echo_http_app import get_app as get_http_test_app
 from .app.echo_ws_app import get_app as get_ws_test_app
-from .app.tool import AppDataclass4Test, UvicornServer
+from .app.tool import AppDataclass4Test, TestServer
 
 # ASGI types.
 # Copied from: https://github.com/florimondmanca/asgi-lifespan/blob/fbb0f440337314be97acaae1a3c0c7a2ec8298dd/src/asgi_lifespan/_types.py
@@ -61,17 +62,28 @@ class LifeAppDataclass4Test(AppDataclass4Test):
 """The lifespan of app will be managed automatically by pytest."""
 
 
-class UvicornServerFixture(Protocol):  # noqa: D101
+class TestServerFixture(Protocol):  # noqa: D101
     def __call__(  # noqa: D102
-        self, config: uvicorn.Config
-    ) -> Coroutine[None, None, UvicornServer]: ...
+        self,
+        app: FastAPI,
+        host: str,
+        port: int,
+        server_type: Optional[Literal["uvicorn", "hypercorn"]] = None,
+    ) -> Coroutine[None, None, TestServer]: ...
 
 
 # https://anyio.readthedocs.io/en/stable/testing.html#specifying-the-backends-to-run-on
-@pytest.fixture()
-def anyio_backend() -> Literal["asyncio"]:
+@pytest.fixture(
+    params=[
+        pytest.param(("asyncio", {"use_uvloop": False}), id="asyncio"),
+        pytest.param(
+            ("trio", {"restrict_keyboard_interrupt_to_checkpoints": True}), id="trio"
+        ),
+    ],
+)
+def anyio_backend(request: pytest.FixtureRequest):
     """Specify the async backend for `pytest.mark.anyio`."""
-    return "asyncio"
+    return request.param
 
 
 @pytest.fixture()
@@ -191,17 +203,22 @@ def reverse_ws_app_fct(
 
 
 @pytest.fixture()
-async def uvicorn_server_fixture() -> AsyncIterator[UvicornServerFixture]:
-    """Fixture for UvicornServer.
+async def test_server_fixture() -> AsyncIterator[TestServerFixture]:
+    """Fixture for TestServer.
 
     Will launch and shutdown automatically.
     """
     async with AsyncExitStack() as exit_stack:
 
-        async def uvicorn_server_fct(config: uvicorn.Config) -> UvicornServer:
-            uvicorn_server = await exit_stack.enter_async_context(
-                UvicornServer(config=config)
+        async def test_server_fct(
+            app: FastAPI,
+            host: str,
+            port: int,
+            server_type: Optional[Literal["uvicorn", "hypercorn"]] = None,
+        ) -> TestServer:
+            test_server = await exit_stack.enter_async_context(
+                TestServer(app=app, host=host, port=port, server_type=server_type)
             )
-            return uvicorn_server
+            return test_server
 
-        yield uvicorn_server_fct
+        yield test_server_fct