Increase testing coverage for ASGI

Beautify

Specify websockets version

tests/test_asgi.py

@@ -1,5 +1,203 @@
-from sanic.testing import SanicASGITestClient
+import asyncio
+
+from collections import deque
+
+import pytest
+import uvicorn
+
+from sanic.asgi import MockTransport
+from sanic.exceptions import InvalidUsage
+from sanic.websocket import WebSocketConnection
 
 
-def test_asgi_client_instantiation(app):
-    assert isinstance(app.asgi_client, SanicASGITestClient)
+@pytest.fixture
+def message_stack():
+    return deque()
+
+
+@pytest.fixture
+def receive(message_stack):
+    async def _receive():
+        return message_stack.popleft()
+
+    return _receive
+
+
+@pytest.fixture
+def send(message_stack):
+    async def _send(message):
+        message_stack.append(message)
+
+    return _send
+
+
+@pytest.fixture
+def transport(message_stack, receive, send):
+    return MockTransport({}, receive, send)
+
+
+@pytest.fixture
+# @pytest.mark.asyncio
+def protocol(transport, loop):
+    return transport.get_protocol()
+
+
+def test_listeners_triggered(app):
+    before_server_start = False
+    after_server_start = False
+    before_server_stop = False
+    after_server_stop = False
+
+    @app.listener("before_server_start")
+    def do_before_server_start(*args, **kwargs):
+        nonlocal before_server_start
+        before_server_start = True
+
+    @app.listener("after_server_start")
+    def do_after_server_start(*args, **kwargs):
+        nonlocal after_server_start
+        after_server_start = True
+
+    @app.listener("before_server_stop")
+    def do_before_server_stop(*args, **kwargs):
+        nonlocal before_server_stop
+        before_server_stop = True
+
+    @app.listener("after_server_stop")
+    def do_after_server_stop(*args, **kwargs):
+        nonlocal after_server_stop
+        after_server_stop = True
+
+    class CustomServer(uvicorn.Server):
+        def install_signal_handlers(self):
+            pass
+
+    config = uvicorn.Config(app=app, loop="asyncio", limit_max_requests=0)
+    server = CustomServer(config=config)
+
+    with pytest.warns(UserWarning):
+        server.run()
+
+    for task in asyncio.Task.all_tasks():
+        task.cancel()
+
+    assert before_server_start
+    assert after_server_start
+    assert before_server_stop
+    assert after_server_stop
+
+
+def test_listeners_triggered_async(app):
+    before_server_start = False
+    after_server_start = False
+    before_server_stop = False
+    after_server_stop = False
+
+    @app.listener("before_server_start")
+    async def do_before_server_start(*args, **kwargs):
+        nonlocal before_server_start
+        before_server_start = True
+
+    @app.listener("after_server_start")
+    async def do_after_server_start(*args, **kwargs):
+        nonlocal after_server_start
+        after_server_start = True
+
+    @app.listener("before_server_stop")
+    async def do_before_server_stop(*args, **kwargs):
+        nonlocal before_server_stop
+        before_server_stop = True
+
+    @app.listener("after_server_stop")
+    async def do_after_server_stop(*args, **kwargs):
+        nonlocal after_server_stop
+        after_server_stop = True
+
+    class CustomServer(uvicorn.Server):
+        def install_signal_handlers(self):
+            pass
+
+    config = uvicorn.Config(app=app, loop="asyncio", limit_max_requests=0)
+    server = CustomServer(config=config)
+
+    with pytest.warns(UserWarning):
+        server.run()
+
+    for task in asyncio.Task.all_tasks():
+        task.cancel()
+
+    assert before_server_start
+    assert after_server_start
+    assert before_server_stop
+    assert after_server_stop
+
+
+@pytest.mark.asyncio
+async def test_mockprotocol_events(protocol):
+    assert protocol._not_paused.is_set()
+    protocol.pause_writing()
+    assert not protocol._not_paused.is_set()
+    protocol.resume_writing()
+    assert protocol._not_paused.is_set()
+
+
+@pytest.mark.asyncio
+async def test_protocol_push_data(protocol, message_stack):
+    text = b"hello"
+
+    await protocol.push_data(text)
+    await protocol.complete()
+
+    assert len(message_stack) == 2
+
+    message = message_stack.popleft()
+    assert message["type"] == "http.response.body"
+    assert message["more_body"]
+    assert message["body"] == text
+
+    message = message_stack.popleft()
+    assert message["type"] == "http.response.body"
+    assert not message["more_body"]
+    assert message["body"] == b""
+
+
+@pytest.mark.asyncio
+async def test_websocket_send(send, receive, message_stack):
+    text_string = "hello"
+    text_bytes = b"hello"
+
+    ws = WebSocketConnection(send, receive)
+    await ws.send(text_string)
+    await ws.send(text_bytes)
+
+    assert len(message_stack) == 2
+
+    message = message_stack.popleft()
+    assert message["type"] == "websocket.send"
+    assert message["text"] == text_string
+    assert "bytes" not in message
+
+    message = message_stack.popleft()
+    assert message["type"] == "websocket.send"
+    assert message["bytes"] == text_bytes
+    assert "text" not in message
+
+
+@pytest.mark.asyncio
+async def test_websocket_receive(send, receive, message_stack):
+    msg = {"text": "hello", "type": "websocket.receive"}
+    message_stack.append(msg)
+
+    ws = WebSocketConnection(send, receive)
+    text = await ws.receive()
+
+    assert text == msg["text"]
+
+
+def test_improper_websocket_connection(transport, send, receive):
+    with pytest.raises(InvalidUsage):
+        transport.get_websocket_connection()
+
+    transport.create_websocket_connection(send, receive)
+    connection = transport.get_websocket_connection()
+    assert isinstance(connection, WebSocketConnection)

tests/test_asgi_client.py

@@ -0,0 +1,5 @@
+from sanic.testing import SanicASGITestClient
+
+
+def test_asgi_client_instantiation(app):
+    assert isinstance(app.asgi_client, SanicASGITestClient)

tests/test_request_stream.py

@@ -197,6 +197,121 @@ def test_request_stream_app(app):
     assert response.text == data
 
 
+@pytest.mark.asyncio
+async def test_request_stream_app_asgi(app):
+    """for self.is_request_stream = True and decorators"""
+
+    @app.get("/get")
+    async def get(request):
+        assert request.stream is None
+        return text("GET")
+
+    @app.head("/head")
+    async def head(request):
+        assert request.stream is None
+        return text("HEAD")
+
+    @app.delete("/delete")
+    async def delete(request):
+        assert request.stream is None
+        return text("DELETE")
+
+    @app.options("/options")
+    async def options(request):
+        assert request.stream is None
+        return text("OPTIONS")
+
+    @app.post("/_post/<id>")
+    async def _post(request, id):
+        assert request.stream is None
+        return text("_POST")
+
+    @app.post("/post/<id>", stream=True)
+    async def post(request, id):
+        assert isinstance(request.stream, StreamBuffer)
+        result = ""
+        while True:
+            body = await request.stream.read()
+            if body is None:
+                break
+            result += body.decode("utf-8")
+        return text(result)
+
+    @app.put("/_put")
+    async def _put(request):
+        assert request.stream is None
+        return text("_PUT")
+
+    @app.put("/put", stream=True)
+    async def put(request):
+        assert isinstance(request.stream, StreamBuffer)
+        result = ""
+        while True:
+            body = await request.stream.read()
+            if body is None:
+                break
+            result += body.decode("utf-8")
+        return text(result)
+
+    @app.patch("/_patch")
+    async def _patch(request):
+        assert request.stream is None
+        return text("_PATCH")
+
+    @app.patch("/patch", stream=True)
+    async def patch(request):
+        assert isinstance(request.stream, StreamBuffer)
+        result = ""
+        while True:
+            body = await request.stream.read()
+            if body is None:
+                break
+            result += body.decode("utf-8")
+        return text(result)
+
+    assert app.is_request_stream is True
+
+    request, response = await app.asgi_client.get("/get")
+    assert response.status == 200
+    assert response.text == "GET"
+
+    request, response = await app.asgi_client.head("/head")
+    assert response.status == 200
+    assert response.text == ""
+
+    request, response = await app.asgi_client.delete("/delete")
+    assert response.status == 200
+    assert response.text == "DELETE"
+
+    request, response = await app.asgi_client.options("/options")
+    assert response.status == 200
+    assert response.text == "OPTIONS"
+
+    request, response = await app.asgi_client.post("/_post/1", data=data)
+    assert response.status == 200
+    assert response.text == "_POST"
+
+    request, response = await app.asgi_client.post("/post/1", data=data)
+    assert response.status == 200
+    assert response.text == data
+
+    request, response = await app.asgi_client.put("/_put", data=data)
+    assert response.status == 200
+    assert response.text == "_PUT"
+
+    request, response = await app.asgi_client.put("/put", data=data)
+    assert response.status == 200
+    assert response.text == data
+
+    request, response = await app.asgi_client.patch("/_patch", data=data)
+    assert response.status == 200
+    assert response.text == "_PATCH"
+
+    request, response = await app.asgi_client.patch("/patch", data=data)
+    assert response.status == 200
+    assert response.text == data
+
+
 def test_request_stream_handle_exception(app):
     """for handling exceptions properly"""
 

tests/test_routes.py

@@ -474,6 +474,19 @@ def test_websocket_route(app, url):
     assert ev.is_set()
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize("url", ["/ws", "ws"])
+async def test_websocket_route_asgi(app, url):
+    ev = asyncio.Event()
+
+    @app.websocket(url)
+    async def handler(request, ws):
+        ev.set()
+
+    request, response = await app.asgi_client.websocket(url)
+    assert ev.is_set()
+
+
 def test_websocket_route_with_subprotocols(app):
     results = []