Introduce Hypercorn as a test HTTP/2 server

setup.cfg

@@ -14,7 +14,7 @@ combine_as_imports = True
 force_grid_wrap = 0
 include_trailing_comma = True
 known_first_party = httpx,httpxprof,tests
-known_third_party = brotli,certifi,chardet,click,cryptography,h11,h2,hstspreload,nox,pytest,requests,rfc3986,setuptools,tqdm,trio,trustme,uvicorn
+known_third_party = brotli,certifi,chardet,click,cryptography,h11,h2,hstspreload,hypercorn,nox,pytest,requests,rfc3986,setuptools,tqdm,trio,trustme,uvicorn
 line_length = 88
 multi_line_output = 3
 

test-requirements.txt

@@ -8,6 +8,7 @@ flake8
 flake8-bugbear
 flake8-comprehensions
 flake8-pie
+hypercorn
 isort
 mypy
 pytest

tests/conftest.py

@@ -1,11 +1,14 @@
 import asyncio
+import functools
 import json
 import os
 import threading
 import time
 import typing
+import sys
 
 import pytest
+import trio
 import trustme
 from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives.serialization import (
@@ -14,6 +17,8 @@
  PrivateFormat,
  load_pem_private_key,
 )
+import hypercorn.config
+import hypercorn.trio
 from uvicorn.config import Config
 from uvicorn.main import Server
 
@@ -288,3 +293,83 @@ def https_server(cert_pem_file, cert_private_key_file):
  )
  server = TestServer(config=config)
  yield from serve_in_thread(server)
+
+
+async def h2_app(scope, receive, send):
+ assert scope["type"] == "http"
+ assert scope["http_version"] == "2"
+
+ body = b""
+ more_body = True
+
+ while more_body:
+ message = await receive()
+ body += message.get("body", b"")
+ more_body = message.get("more_body", False)
+
+ data = {"method": scope["method"], "path": scope["path"], "body": body.decode()}
+ content = json.dumps(data).encode()
+ headers = [(b"content-length", b"%d" % len(content))]
+
+ await send({"type": "http.response.start", "status": 200, "headers": headers})
+ await send({"type": "http.response.body", "body": content})
+
+
+class H2Server:
+ """
+ An HTTP/2 ASGI server class.
+
+ This is a wrapper around Hypercorn that matches the parts of the
+ uvicorn `Server` interface we use in our tests.
+ """
+
+ def __init__(
+ self, app: typing.Callable, host: str, port: int, certfile: str, keyfile: str
+ ):
+ self.app = app
+ self.config = hypercorn.config.Config()
+ self.config.bind = [f"{host}:{port}"]
+ self.config.certfile = certfile
+ self.config.keyfile = keyfile
+ self.config.worker_class = "trio"
+ self.started = False
+ self.should_exit = False
+
+ @property
+ def url(self) -> URL:
+ authority = self.config.bind[0]
+ return URL(f"https://{authority}")
+
+ def run(self) -> None:
+ async def shutdown_trigger() -> None:
+ while not self.should_exit:
+ await trio.sleep(0.1)
+
+ bound_serve = functools.partial(
+ hypercorn.trio.serve, shutdown_trigger=shutdown_trigger
+ )
+
+ async def main() -> None:
+ async with trio.open_nursery() as nursery:
+ await nursery.start(bound_serve, self.app, self.config)
+ self.started = True
+
+ trio.run(main)
+
+
+@pytest.fixture(scope=SERVER_SCOPE)
+def h2_server(
+ cert_pem_file: str, cert_private_key_file: str
+) -> typing.Iterator[H2Server]:
+ if sys.version_info < (3, 7):
+ pytest.skip(reason="Hypercorn requires Python 3.7 or higher")
+
+ server = H2Server(
+ app=h2_app,
+ host="127.0.0.1",
+ port=8002,
+ certfile=cert_pem_file,
+ keyfile=cert_private_key_file,
+ )
+
+ yield from serve_in_thread(server)

tests/dispatch/test_http2.py

@@ -1,7 +1,6 @@
 import json
 
 import h2.connection
-import h2.events
 from h2.settings import SettingCodes
 
 from httpx import AsyncClient, Client, Response
@@ -21,31 +20,27 @@ def app(request):
  return Response(200, headers=headers, content=content)
 
 
-def test_http2_get_request():
- backend = MockHTTP2Backend(app=app)
-
- with Client(backend=backend) as client:
- response = client.get("http://example.org")
+def test_http2_get_request(h2_server):
+ with Client(http_versions=["HTTP/2"], verify=False) as client:
+ response = client.get(h2_server.url)
 
  assert response.status_code == 200
  assert json.loads(response.content) == {"method": "GET", "path": "/", "body": ""}
 
 
-async def test_async_http2_get_request(backend):
-backend = MockHTTP2Backend(app=app, backend=backend)
-
-async with AsyncClient(backend=backend) as client:
- response = await client.get("http://example.org")
+async def test_async_http2_get_request(backend, h2_server):
+async with AsyncClient(
+ backend=backend, http_versions=["HTTP/2"], verify=False
+ ) as client:
+ response = await client.get(h2_server.url)
 
  assert response.status_code == 200
  assert json.loads(response.content) == {"method": "GET", "path": "/", "body": ""}
 
 
-def test_http2_post_request():
- backend = MockHTTP2Backend(app=app)
-
- with Client(backend=backend) as client:
- response = client.post("http://example.org", data=b"<data>")
+def test_http2_post_request(h2_server):
+ with Client(http_versions=["HTTP/2"], verify=False) as client:
+ response = client.post(h2_server.url, data=b"<data>")
 
  assert response.status_code == 200
  assert json.loads(response.content) == {
@@ -55,11 +50,11 @@ def test_http2_post_request():
  }
 
 
-async def test_async_http2_post_request(backend):
-backend = MockHTTP2Backend(app=app, backend=backend)
-
-async with AsyncClient(backend=backend) as client:
- response = await client.post("http://example.org", data=b"<data>")
+async def test_async_http2_post_request(backend, h2_server):
+async with AsyncClient(
+ backend=backend, http_versions=["HTTP/2"], verify=False
+ ) as client:
+ response = await client.post(h2_server.url, data=b"<data>")
 
  assert response.status_code == 200
  assert json.loads(response.content) == {
@@ -69,12 +64,10 @@ async def test_async_http2_post_request(backend):
  }
 
 
-def test_http2_large_post_request():
- backend = MockHTTP2Backend(app=app)
-
+def test_http2_large_post_request(h2_server):
  data = b"a" * 100000
- with Client(backend=backend) as client:
- response = client.post("http://example.org", data=data)
+ with Client(http_versions=["HTTP/2"], verify=False) as client:
+ response = client.post(h2_server.url, data=data)
  assert response.status_code == 200
  assert json.loads(response.content) == {
  "method": "POST",
@@ -83,12 +76,12 @@ def test_http2_large_post_request():
  }
 
 
-async def test_async_http2_large_post_request(backend):
- backend = MockHTTP2Backend(app=app, backend=backend)
-
+async def test_async_http2_large_post_request(backend, h2_server):
  data = b"a" * 100000
- async with AsyncClient(backend=backend) as client:
- response = await client.post("http://example.org", data=data)
+ async with AsyncClient(
+ backend=backend, http_versions=["HTTP/2"], verify=False
+ ) as client:
+ response = await client.post(h2_server.url, data=data)
  assert response.status_code == 200
  assert json.loads(response.content) == {
  "method": "POST",
@@ -97,13 +90,11 @@ async def test_async_http2_large_post_request(backend):
  }
 
 
-def test_http2_multiple_requests():
- backend = MockHTTP2Backend(app=app)
-
- with Client(backend=backend) as client:
- response_1 = client.get("http://example.org/1")
- response_2 = client.get("http://example.org/2")
- response_3 = client.get("http://example.org/3")
+def test_http2_multiple_requests(h2_server):
+ with Client(http_versions=["HTTP/2"], verify=False) as client:
+ response_1 = client.get(h2_server.url.copy_with(path="/1"))
+ response_2 = client.get(h2_server.url.copy_with(path="/2"))
+ response_3 = client.get(h2_server.url.copy_with(path="/3"))
 
  assert response_1.status_code == 200
  assert json.loads(response_1.content) == {"method": "GET", "path": "/1", "body": ""}
@@ -115,13 +106,13 @@ def test_http2_multiple_requests():
  assert json.loads(response_3.content) == {"method": "GET", "path": "/3", "body": ""}
 
 
-async def test_async_http2_multiple_requests(backend):
-backend = MockHTTP2Backend(app=app, backend=backend)
-
-async with AsyncClient(backend=backend) as client:
- response_1 = await client.get("http://example.org/1")
- response_2 = await client.get("http://example.org/2")
- response_3 = await client.get("http://example.org/3")
+async def test_async_http2_multiple_requests(backend, h2_server):
+async with AsyncClient(
+ backend=backend, http_versions=["HTTP/2"], verify=False
+ ) as client:
+ response_1 = await client.get(h2_server.url.copy_with(path="/1"))
+ response_2 = await client.get(h2_server.url.copy_with(path="/2"))
+ response_3 = await client.get(h2_server.url.copy_with(path="/3"))
 
  assert response_1.status_code == 200
  assert json.loads(response_1.content) == {"method": "GET", "path": "/1", "body": ""}