uvicorn 0.30.6__tar.gz → 0.31.0__tar.gz

{uvicorn-0.30.6 → uvicorn-0.31.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: uvicorn
-Version: 0.30.6
+Version: 0.31.0
 Summary: The lightning-fast ASGI server.
 Project-URL: Changelog, https://github.com/encode/uvicorn/blob/master/CHANGELOG.md
 Project-URL: Funding, https://github.com/sponsors/encode

{uvicorn-0.30.6 → uvicorn-0.31.0}/pyproject.toml

@@ -59,7 +59,11 @@ Source = "https://github.com/encode/uvicorn"
 path = "uvicorn/__init__.py"
 
 [tool.hatch.build.targets.sdist]
-include = ["/uvicorn"]
+include = [
+    "/uvicorn",
+    "/tests",
+    "/requirements.txt",
+]
 
 [tool.ruff]
 line-length = 120

uvicorn-0.31.0/requirements.txt

@@ -0,0 +1,32 @@
+-e .[standard]
+
+# TODO: Remove this after h11 makes a release. By this writing, h11 was on 0.14.0.
+# Core dependencies
+h11 @ git+https://github.com/python-hyper/h11.git@master
+
+# Explicit optionals
+a2wsgi==1.10.6
+wsproto==1.2.0
+websockets==12.0
+
+# Packaging
+build==1.2.1
+twine==5.1.1
+
+# Testing
+ruff==0.5.0
+pytest==8.2.2
+pytest-mock==3.14.0
+mypy==1.10.1
+types-click==7.1.8
+types-pyyaml==6.0.12.20240311
+trustme==1.1.0
+cryptography==43.0.1
+coverage==7.5.4
+coverage-conditional-plugin==0.9.0
+httpx==0.27.0
+watchgod==0.8.2
+
+# Documentation
+mkdocs==1.6.0
+mkdocs-material==9.5.27

uvicorn-0.31.0/tests/conftest.py

@@ -0,0 +1,283 @@
+from __future__ import annotations
+
+import contextlib
+import importlib.util
+import os
+import socket
+import ssl
+from copy import deepcopy
+from hashlib import md5
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from threading import Thread
+from time import sleep
+from typing import Any
+from uuid import uuid4
+
+import pytest
+
+try:
+    import trustme
+    from cryptography.hazmat.backends import default_backend
+    from cryptography.hazmat.primitives import serialization
+
+    HAVE_TRUSTME = True
+except ImportError:  # pragma: no cover
+    HAVE_TRUSTME = False
+
+from uvicorn.config import LOGGING_CONFIG
+from uvicorn.importer import import_from_string
+
+# Note: We explicitly turn the propagate on just for tests, because pytest
+# caplog not able to capture no-propagate loggers.
+#
+# And the caplog_for_logger helper also not work on test config cases, because
+# when create Config object, Config.configure_logging will remove caplog.handler.
+#
+# The simple solution is set propagate=True before execute tests.
+#
+# See also: https://github.com/pytest-dev/pytest/issues/3697
+LOGGING_CONFIG["loggers"]["uvicorn"]["propagate"] = True
+
+
+@pytest.fixture
+def tls_certificate_authority() -> trustme.CA:
+    if not HAVE_TRUSTME:
+        pytest.skip("trustme not installed")  # pragma: no cover
+    return trustme.CA()
+
+
+@pytest.fixture
+def tls_certificate(tls_certificate_authority: trustme.CA) -> trustme.LeafCert:
+    return tls_certificate_authority.issue_cert(
+        "localhost",
+        "127.0.0.1",
+        "::1",
+    )
+
+
+@pytest.fixture
+def tls_ca_certificate_pem_path(tls_certificate_authority: trustme.CA):
+    with tls_certificate_authority.cert_pem.tempfile() as ca_cert_pem:
+        yield ca_cert_pem
+
+
+@pytest.fixture
+def tls_ca_certificate_private_key_path(tls_certificate_authority: trustme.CA):
+    with tls_certificate_authority.private_key_pem.tempfile() as private_key:
+        yield private_key
+
+
+@pytest.fixture
+def tls_certificate_private_key_encrypted_path(tls_certificate):
+    private_key = serialization.load_pem_private_key(
+        tls_certificate.private_key_pem.bytes(),
+        password=None,
+        backend=default_backend(),
+    )
+    encrypted_key = private_key.private_bytes(
+        serialization.Encoding.PEM,
+        serialization.PrivateFormat.TraditionalOpenSSL,
+        serialization.BestAvailableEncryption(b"uvicorn password for the win"),
+    )
+    with trustme.Blob(encrypted_key).tempfile() as private_encrypted_key:
+        yield private_encrypted_key
+
+
+@pytest.fixture
+def tls_certificate_private_key_path(tls_certificate: trustme.CA):
+    with tls_certificate.private_key_pem.tempfile() as private_key:
+        yield private_key
+
+
+@pytest.fixture
+def tls_certificate_key_and_chain_path(tls_certificate: trustme.LeafCert):
+    with tls_certificate.private_key_and_cert_chain_pem.tempfile() as cert_pem:
+        yield cert_pem
+
+
+@pytest.fixture
+def tls_certificate_server_cert_path(tls_certificate: trustme.LeafCert):
+    with tls_certificate.cert_chain_pems[0].tempfile() as cert_pem:
+        yield cert_pem
+
+
+@pytest.fixture
+def tls_ca_ssl_context(tls_certificate_authority: trustme.CA) -> ssl.SSLContext:
+    ssl_ctx = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
+    tls_certificate_authority.configure_trust(ssl_ctx)
+    return ssl_ctx
+
+
+@pytest.fixture(scope="package")
+def reload_directory_structure(tmp_path_factory: pytest.TempPathFactory):
+    """
+    This fixture creates a directory structure to enable reload parameter tests
+
+    The fixture has the following structure:
+    root
+    ├── [app, app_first, app_second, app_third]
+    │   ├── css
+    │   │   └── main.css
+    │   ├── js
+    │   │   └── main.js
+    │   ├── src
+    │   │   └── main.py
+    │   └── sub
+    │       └── sub.py
+    ├── ext
+    │   └── ext.jpg
+    ├── .dotted
+    ├── .dotted_dir
+    │   └── file.txt
+    └── main.py
+    """
+    root = tmp_path_factory.mktemp("reload_directory")
+    apps = ["app", "app_first", "app_second", "app_third"]
+
+    root_file = root / "main.py"
+    root_file.touch()
+
+    dotted_file = root / ".dotted"
+    dotted_file.touch()
+
+    dotted_dir = root / ".dotted_dir"
+    dotted_dir.mkdir()
+    dotted_dir_file = dotted_dir / "file.txt"
+    dotted_dir_file.touch()
+
+    for app in apps:
+        app_path = root / app
+        app_path.mkdir()
+        dir_files = [
+            ("src", ["main.py"]),
+            ("js", ["main.js"]),
+            ("css", ["main.css"]),
+            ("sub", ["sub.py"]),
+        ]
+        for directory, files in dir_files:
+            directory_path = app_path / directory
+            directory_path.mkdir()
+            for file in files:
+                file_path = directory_path / file
+                file_path.touch()
+    ext_dir = root / "ext"
+    ext_dir.mkdir()
+    ext_file = ext_dir / "ext.jpg"
+    ext_file.touch()
+
+    yield root
+
+
+@pytest.fixture
+def anyio_backend() -> str:
+    return "asyncio"
+
+
+@pytest.fixture(scope="function")
+def logging_config() -> dict[str, Any]:
+    return deepcopy(LOGGING_CONFIG)
+
+
+@pytest.fixture
+def short_socket_name(tmp_path, tmp_path_factory):  # pragma: py-win32
+    max_sock_len = 100
+    socket_filename = "my.sock"
+    identifier = f"{uuid4()}-"
+    identifier_len = len(identifier.encode())
+    tmp_dir = Path("/tmp").resolve()
+    os_tmp_dir = Path(os.getenv("TMPDIR", "/tmp")).resolve()
+    basetemp = Path(
+        str(tmp_path_factory.getbasetemp()),
+    ).resolve()
+    hash_basetemp = md5(
+        str(basetemp).encode(),
+    ).hexdigest()
+
+    def make_tmp_dir(base_dir):
+        return TemporaryDirectory(
+            dir=str(base_dir),
+            prefix="p-",
+            suffix=f"-{hash_basetemp}",
+        )
+
+    paths = basetemp, os_tmp_dir, tmp_dir
+    for _num, tmp_dir_path in enumerate(paths, 1):
+        with make_tmp_dir(tmp_dir_path) as tmpd:
+            tmpd = Path(tmpd).resolve()
+            sock_path = str(tmpd / socket_filename)
+            sock_path_len = len(sock_path.encode())
+            if sock_path_len <= max_sock_len:
+                if max_sock_len - sock_path_len >= identifier_len:  # pragma: no cover
+                    sock_path = str(tmpd / "".join((identifier, socket_filename)))
+                yield sock_path
+                return
+
+
+def sleep_touch(*paths: Path):
+    sleep(0.1)
+    for p in paths:
+        p.touch()
+
+
+@pytest.fixture
+def touch_soon():
+    threads = []
+
+    def start(*paths: Path):
+        thread = Thread(target=sleep_touch, args=paths)
+        thread.start()
+        threads.append(thread)
+
+    yield start
+
+    for t in threads:
+        t.join()
+
+
+def _unused_port(socket_type: int) -> int:
+    """Find an unused localhost port from 1024-65535 and return it."""
+    with contextlib.closing(socket.socket(type=socket_type)) as sock:
+        sock.bind(("127.0.0.1", 0))
+        return sock.getsockname()[1]
+
+
+# This was copied from pytest-asyncio.
+# Ref.: https://github.com/pytest-dev/pytest-asyncio/blob/25d9592286682bc6dbfbf291028ff7a9594cf283/pytest_asyncio/plugin.py#L525-L527  # noqa: E501
+@pytest.fixture
+def unused_tcp_port() -> int:
+    return _unused_port(socket.SOCK_STREAM)
+
+
+@pytest.fixture(
+    params=[
+        pytest.param(
+            "uvicorn.protocols.websockets.wsproto_impl:WSProtocol",
+            marks=pytest.mark.skipif(not importlib.util.find_spec("wsproto"), reason="wsproto not installed."),
+            id="wsproto",
+        ),
+        pytest.param(
+            "uvicorn.protocols.websockets.websockets_impl:WebSocketProtocol",
+            id="websockets",
+        ),
+    ]
+)
+def ws_protocol_cls(request: pytest.FixtureRequest):
+    return import_from_string(request.param)
+
+
+@pytest.fixture(
+    params=[
+        pytest.param(
+            "uvicorn.protocols.http.httptools_impl:HttpToolsProtocol",
+            marks=pytest.mark.skipif(
+                not importlib.util.find_spec("httptools"),
+                reason="httptools not installed.",
+            ),
+            id="httptools",
+        ),
+        pytest.param("uvicorn.protocols.http.h11_impl:H11Protocol", id="h11"),
+    ]
+)
+def http_protocol_cls(request: pytest.FixtureRequest):
+    return import_from_string(request.param)

uvicorn-0.31.0/tests/importer/circular_import_a.py

@@ -0,0 +1,4 @@
+# Used by test_importer.py
+from .circular_import_b import foo  # noqa
+
+bar = 123  # pragma: no cover

uvicorn-0.31.0/tests/importer/circular_import_b.py

@@ -0,0 +1,4 @@
+# Used by test_importer.py
+from .circular_import_a import bar  # noqa
+
+foo = 123  # pragma: no cover

uvicorn-0.31.0/tests/importer/raise_import_error.py

@@ -0,0 +1,5 @@
+# Used by test_importer.py
+
+myattr = 123
+
+import does_not_exist  # noqa

uvicorn-0.31.0/tests/importer/test_importer.py

@@ -0,0 +1,53 @@
+import pytest
+
+from uvicorn.importer import ImportFromStringError, import_from_string
+
+
+def test_invalid_format() -> None:
+    with pytest.raises(ImportFromStringError) as exc_info:
+        import_from_string("example:")
+    expected = 'Import string "example:" must be in format "<module>:<attribute>".'
+    assert expected in str(exc_info.value)
+
+
+def test_invalid_module() -> None:
+    with pytest.raises(ImportFromStringError) as exc_info:
+        import_from_string("module_does_not_exist:myattr")
+    expected = 'Could not import module "module_does_not_exist".'
+    assert expected in str(exc_info.value)
+
+
+def test_invalid_attr() -> None:
+    with pytest.raises(ImportFromStringError) as exc_info:
+        import_from_string("tempfile:attr_does_not_exist")
+    expected = 'Attribute "attr_does_not_exist" not found in module "tempfile".'
+    assert expected in str(exc_info.value)
+
+
+def test_internal_import_error() -> None:
+    with pytest.raises(ImportError):
+        import_from_string("tests.importer.raise_import_error:myattr")
+
+
+def test_valid_import() -> None:
+    instance = import_from_string("tempfile:TemporaryFile")
+    from tempfile import TemporaryFile
+
+    assert instance == TemporaryFile
+
+
+def test_no_import_needed() -> None:
+    from tempfile import TemporaryFile
+
+    instance = import_from_string(TemporaryFile)
+    assert instance == TemporaryFile
+
+
+def test_circular_import_error() -> None:
+    with pytest.raises(ImportError) as exc_info:
+        import_from_string("tests.importer.circular_import_a:bar")
+    expected = (
+        "cannot import name 'bar' from partially initialized module "
+        "'tests.importer.circular_import_a' (most likely due to a circular import)"
+    )
+    assert expected in str(exc_info.value)

uvicorn-0.31.0/tests/middleware/test_logging.py

@@ -0,0 +1,211 @@
+from __future__ import annotations
+
+import contextlib
+import logging
+import socket
+import sys
+import typing
+
+import httpx
+import pytest
+import websockets
+import websockets.client
+
+from tests.utils import run_server
+from uvicorn import Config
+from uvicorn._types import ASGIReceiveCallable, ASGISendCallable, Scope
+
+if typing.TYPE_CHECKING:
+    import sys
+
+    from uvicorn.protocols.websockets.websockets_impl import WebSocketProtocol
+    from uvicorn.protocols.websockets.wsproto_impl import WSProtocol as _WSProtocol
+
+    if sys.version_info >= (3, 10):  # pragma: no cover
+        from typing import TypeAlias
+    else:  # pragma: no cover
+        from typing_extensions import TypeAlias
+
+    WSProtocol: TypeAlias = "type[WebSocketProtocol | _WSProtocol]"
+
+pytestmark = pytest.mark.anyio
+
+
+@contextlib.contextmanager
+def caplog_for_logger(caplog: pytest.LogCaptureFixture, logger_name: str) -> typing.Iterator[pytest.LogCaptureFixture]:
+    logger = logging.getLogger(logger_name)
+    logger.propagate, old_propagate = False, logger.propagate
+    logger.addHandler(caplog.handler)
+    try:
+        yield caplog
+    finally:
+        logger.removeHandler(caplog.handler)
+        logger.propagate = old_propagate
+
+
+async def app(scope: Scope, receive: ASGIReceiveCallable, send: ASGISendCallable):
+    assert scope["type"] == "http"
+    await send({"type": "http.response.start", "status": 204, "headers": []})
+    await send({"type": "http.response.body", "body": b"", "more_body": False})
+
+
+async def test_trace_logging(caplog: pytest.LogCaptureFixture, logging_config, unused_tcp_port: int):
+    config = Config(
+        app=app,
+        log_level="trace",
+        log_config=logging_config,
+        lifespan="auto",
+        port=unused_tcp_port,
+    )
+    with caplog_for_logger(caplog, "uvicorn.asgi"):
+        async with run_server(config):
+            async with httpx.AsyncClient() as client:
+                response = await client.get(f"http://127.0.0.1:{unused_tcp_port}")
+        assert response.status_code == 204
+        messages = [record.message for record in caplog.records if record.name == "uvicorn.asgi"]
+        assert "ASGI [1] Started scope=" in messages.pop(0)
+        assert "ASGI [1] Raised exception" in messages.pop(0)
+        assert "ASGI [2] Started scope=" in messages.pop(0)
+        assert "ASGI [2] Send " in messages.pop(0)
+        assert "ASGI [2] Send " in messages.pop(0)
+        assert "ASGI [2] Completed" in messages.pop(0)
+
+
+async def test_trace_logging_on_http_protocol(http_protocol_cls, caplog, logging_config, unused_tcp_port: int):
+    config = Config(
+        app=app,
+        log_level="trace",
+        http=http_protocol_cls,
+        log_config=logging_config,
+        port=unused_tcp_port,
+    )
+    with caplog_for_logger(caplog, "uvicorn.error"):
+        async with run_server(config):
+            async with httpx.AsyncClient() as client:
+                response = await client.get(f"http://127.0.0.1:{unused_tcp_port}")
+        assert response.status_code == 204
+        messages = [record.message for record in caplog.records if record.name == "uvicorn.error"]
+        assert any(" - HTTP connection made" in message for message in messages)
+        assert any(" - HTTP connection lost" in message for message in messages)
+
+
+async def test_trace_logging_on_ws_protocol(
+    ws_protocol_cls: WSProtocol,
+    caplog,
+    logging_config,
+    unused_tcp_port: int,
+):
+    async def websocket_app(scope: Scope, receive: ASGIReceiveCallable, send: ASGISendCallable):
+        assert scope["type"] == "websocket"
+        while True:
+            message = await receive()
+            if message["type"] == "websocket.connect":
+                await send({"type": "websocket.accept"})
+            elif message["type"] == "websocket.disconnect":
+                break
+
+    async def open_connection(url):
+        async with websockets.client.connect(url) as websocket:
+            return websocket.open
+
+    config = Config(
+        app=websocket_app,
+        log_level="trace",
+        log_config=logging_config,
+        ws=ws_protocol_cls,
+        port=unused_tcp_port,
+    )
+    with caplog_for_logger(caplog, "uvicorn.error"):
+        async with run_server(config):
+            is_open = await open_connection(f"ws://127.0.0.1:{unused_tcp_port}")
+        assert is_open
+        messages = [record.message for record in caplog.records if record.name == "uvicorn.error"]
+        assert any(" - Upgrading to WebSocket" in message for message in messages)
+        assert any(" - WebSocket connection made" in message for message in messages)
+        assert any(" - WebSocket connection lost" in message for message in messages)
+
+
+@pytest.mark.parametrize("use_colors", [(True), (False), (None)])
+async def test_access_logging(use_colors: bool, caplog: pytest.LogCaptureFixture, logging_config, unused_tcp_port: int):
+    config = Config(app=app, use_colors=use_colors, log_config=logging_config, port=unused_tcp_port)
+    with caplog_for_logger(caplog, "uvicorn.access"):
+        async with run_server(config):
+            async with httpx.AsyncClient() as client:
+                response = await client.get(f"http://127.0.0.1:{unused_tcp_port}")
+
+        assert response.status_code == 204
+        messages = [record.message for record in caplog.records if record.name == "uvicorn.access"]
+        assert '"GET / HTTP/1.1" 204' in messages.pop()
+
+
+@pytest.mark.parametrize("use_colors", [(True), (False)])
+async def test_default_logging(
+    use_colors: bool, caplog: pytest.LogCaptureFixture, logging_config, unused_tcp_port: int
+):
+    config = Config(app=app, use_colors=use_colors, log_config=logging_config, port=unused_tcp_port)
+    with caplog_for_logger(caplog, "uvicorn.access"):
+        async with run_server(config):
+            async with httpx.AsyncClient() as client:
+                response = await client.get(f"http://127.0.0.1:{unused_tcp_port}")
+        assert response.status_code == 204
+        messages = [record.message for record in caplog.records if "uvicorn" in record.name]
+        assert "Started server process" in messages.pop(0)
+        assert "Waiting for application startup" in messages.pop(0)
+        assert "ASGI 'lifespan' protocol appears unsupported" in messages.pop(0)
+        assert "Application startup complete" in messages.pop(0)
+        assert "Uvicorn running on http://127.0.0.1" in messages.pop(0)
+        assert '"GET / HTTP/1.1" 204' in messages.pop(0)
+        assert "Shutting down" in messages.pop(0)
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason="require unix-like system")
+async def test_running_log_using_uds(
+    caplog: pytest.LogCaptureFixture, short_socket_name: str, unused_tcp_port: int
+):  # pragma: py-win32
+    config = Config(app=app, uds=short_socket_name, port=unused_tcp_port)
+    with caplog_for_logger(caplog, "uvicorn.access"):
+        async with run_server(config):
+            ...
+
+    messages = [record.message for record in caplog.records if "uvicorn" in record.name]
+    assert f"Uvicorn running on unix socket {short_socket_name} (Press CTRL+C to quit)" in messages
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason="require unix-like system")
+async def test_running_log_using_fd(caplog: pytest.LogCaptureFixture, unused_tcp_port: int):  # pragma: py-win32
+    with contextlib.closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as sock:
+        fd = sock.fileno()
+        config = Config(app=app, fd=fd, port=unused_tcp_port)
+        with caplog_for_logger(caplog, "uvicorn.access"):
+            async with run_server(config):
+                ...
+        sockname = sock.getsockname()
+    messages = [record.message for record in caplog.records if "uvicorn" in record.name]
+    assert f"Uvicorn running on socket {sockname} (Press CTRL+C to quit)" in messages
+
+
+async def test_unknown_status_code(caplog: pytest.LogCaptureFixture, unused_tcp_port: int):
+    async def app(scope: Scope, receive: ASGIReceiveCallable, send: ASGISendCallable):
+        assert scope["type"] == "http"
+        await send({"type": "http.response.start", "status": 599, "headers": []})
+        await send({"type": "http.response.body", "body": b"", "more_body": False})
+
+    config = Config(app=app, port=unused_tcp_port)
+    with caplog_for_logger(caplog, "uvicorn.access"):
+        async with run_server(config):
+            async with httpx.AsyncClient() as client:
+                response = await client.get(f"http://127.0.0.1:{unused_tcp_port}")
+
+        assert response.status_code == 599
+        messages = [record.message for record in caplog.records if record.name == "uvicorn.access"]
+        assert '"GET / HTTP/1.1" 599' in messages.pop()
+
+
+async def test_server_start_with_port_zero(caplog: pytest.LogCaptureFixture):
+    config = Config(app=app, port=0)
+    async with run_server(config) as _server:
+        server = _server.servers[0]
+        sock = server.sockets[0]
+        host, port = sock.getsockname()
+    messages = [record.message for record in caplog.records if "uvicorn" in record.name]
+    assert f"Uvicorn running on http://{host}:{port} (Press CTRL+C to quit)" in messages

uvicorn-0.31.0/tests/middleware/test_message_logger.py

@@ -0,0 +1,49 @@
+import httpx
+import pytest
+
+from tests.middleware.test_logging import caplog_for_logger
+from uvicorn.logging import TRACE_LOG_LEVEL
+from uvicorn.middleware.message_logger import MessageLoggerMiddleware
+
+
+@pytest.mark.anyio
+async def test_message_logger(caplog):
+    async def app(scope, receive, send):
+        await receive()
+        await send({"type": "http.response.start", "status": 200, "headers": []})
+        await send({"type": "http.response.body", "body": b"", "more_body": False})
+
+    with caplog_for_logger(caplog, "uvicorn.asgi"):
+        caplog.set_level(TRACE_LOG_LEVEL, logger="uvicorn.asgi")
+        caplog.set_level(TRACE_LOG_LEVEL)
+
+        transport = httpx.ASGITransport(MessageLoggerMiddleware(app))  # type: ignore
+        async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
+            response = await client.get("/")
+        assert response.status_code == 200
+        messages = [record.msg % record.args for record in caplog.records]
+        assert sum(["ASGI [1] Started" in message for message in messages]) == 1
+        assert sum(["ASGI [1] Send" in message for message in messages]) == 2
+        assert sum(["ASGI [1] Receive" in message for message in messages]) == 1
+        assert sum(["ASGI [1] Completed" in message for message in messages]) == 1
+        assert sum(["ASGI [1] Raised exception" in message for message in messages]) == 0
+
+
+@pytest.mark.anyio
+async def test_message_logger_exc(caplog):
+    async def app(scope, receive, send):
+        raise RuntimeError()
+
+    with caplog_for_logger(caplog, "uvicorn.asgi"):
+        caplog.set_level(TRACE_LOG_LEVEL, logger="uvicorn.asgi")
+        caplog.set_level(TRACE_LOG_LEVEL)
+        transport = httpx.ASGITransport(MessageLoggerMiddleware(app))  # type: ignore
+        async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
+            with pytest.raises(RuntimeError):
+                await client.get("/")
+        messages = [record.msg % record.args for record in caplog.records]
+        assert sum(["ASGI [1] Started" in message for message in messages]) == 1
+        assert sum(["ASGI [1] Send" in message for message in messages]) == 0
+        assert sum(["ASGI [1] Receive" in message for message in messages]) == 0
+        assert sum(["ASGI [1] Completed" in message for message in messages]) == 0
+        assert sum(["ASGI [1] Raised exception" in message for message in messages]) == 1