fix: align WSGI/ASGI test infrastructure and handler with spec

requirements/adapter_dev.txt

@@ -28,6 +28,4 @@ starlette>=0.19.1,<0.45; python_version<"3.9"
 starlette>=0.49.3,<1; python_version>="3.9"
 tornado>=6.2,<7; python_version<"3.9"
 tornado>=6.5.6,<7; python_version>="3.9"
-uvicorn<1                                # The oldest version can vary among Python runtime versions
-gunicorn>=23.0.0,<24
 websocket_client>=1.2.3,<2               # Socket Mode 3rd party implementation

requirements/test_adapter.txt

@@ -1,5 +1,4 @@
 # pip install -r requirements/test_adapter.txt
 moto>=3,<6                               # For AWS tests
-docker>=5,<8                             # Used by moto
 boddle>=0.2.9,<0.3                         # For Bottle app tests
 sanic-testing>=0.7

requirements/test_async.txt

@@ -1,4 +1,6 @@
 # pip install -r requirements/test_async.txt
 -r test.txt
 -r async_dev.txt
+asgiref>=3.7.2,<3.8; python_version<"3.9"
+asgiref>=3.8,<4; python_version>="3.9"
 pytest-asyncio<2;

slack_bolt/adapter/asgi/base_handler.py

@@ -1,4 +1,4 @@
-from typing import Callable, Dict, Union
+from typing import Callable, Union
 
 from .http_request import AsgiHttpRequest
 from .http_response import AsgiHttpResponse
@@ -47,15 +47,13 @@ async def _get_http_response(self, method: str, path: str, request: AsgiHttpRequ
             return AsgiHttpResponse(status=bolt_response.status, headers=bolt_response.headers, body=bolt_response.body)
         return AsgiHttpResponse(status=404, headers={"content-type": ["text/plain;charset=utf-8"]}, body="Not Found")
 
-    async def _handle_lifespan(self, receive: Callable) -> Dict[str, str]:
-        while True:
-            lifespan = await receive()
-            if lifespan["type"] == "lifespan.startup":
-                """Do something before startup"""
-                return {"type": "lifespan.startup.complete"}
-            if lifespan["type"] == "lifespan.shutdown":
-                """Do something before shutdown"""
-                return {"type": "lifespan.shutdown.complete"}
+    async def _handle_lifespan(self, receive: Callable, send: Callable) -> None:
+        message = await receive()
+        if message["type"] == "lifespan.startup":
+            await send({"type": "lifespan.startup.complete"})
+            message = await receive()
+        if message["type"] == "lifespan.shutdown":
+            await send({"type": "lifespan.shutdown.complete"})
 
     async def __call__(self, scope: scope_type, receive: Callable, send: Callable) -> None:
         if scope["type"] == "http":
@@ -66,6 +64,6 @@ async def __call__(self, scope: scope_type, receive: Callable, send: Callable) -
             await send(response.get_response_body())
             return
         if scope["type"] == "lifespan":
-            await send(await self._handle_lifespan(receive))
+            await self._handle_lifespan(receive, send)
             return
         raise TypeError(f"Unsupported scope type: {scope['type']!r}")

slack_bolt/adapter/asgi/http_response.py

@@ -8,11 +8,14 @@ class AsgiHttpResponse:
 
     def __init__(self, status: int, headers: Dict[str, Sequence[str]] = {}, body: str = ""):
         self.status: int = status
-        self.raw_headers: List[Tuple[bytes, bytes]] = [
-            (bytes(key, ENCODING), bytes(value[0], ENCODING)) for key, value in headers.items()
-        ]
-        self.raw_headers.append((b"content-length", bytes(str(len(body)), ENCODING)))
         self.body: bytes = bytes(body, ENCODING)
+        self.raw_headers: List[Tuple[bytes, bytes]] = []
+        for key, values in headers.items():
+            if key.lower() == "content-length":
+                continue
+            for v in values:
+                self.raw_headers.append((bytes(key, ENCODING), bytes(v, ENCODING)))
+        self.raw_headers.append((b"content-length", bytes(str(len(self.body)), ENCODING)))
 
     def get_response_start(self) -> Dict[str, Union[str, int, Iterable[Tuple[bytes, bytes]]]]:
         return {

slack_bolt/adapter/wsgi/handler.py

@@ -1,6 +1,10 @@
-from typing import Any, Callable, Dict, Iterable, List, Tuple
+from typing import TYPE_CHECKING, Iterable
 
 from slack_bolt import App
+
+if TYPE_CHECKING:
+    from wsgiref.types import StartResponse, WSGIEnvironment
+
 from slack_bolt.adapter.wsgi.http_request import WsgiHttpRequest
 from slack_bolt.adapter.wsgi.http_response import WsgiHttpResponse
 from slack_bolt.request import BoltRequest
@@ -69,14 +73,17 @@ def _get_http_response(self, request: WsgiHttpRequest) -> WsgiHttpResponse:
 
     def __call__(
         self,
-        environ: Dict[str, Any],
-        start_response: Callable[[str, List[Tuple[str, str]]], None],
+        environ: "WSGIEnvironment",
+        start_response: "StartResponse",
     ) -> Iterable[bytes]:
         request = WsgiHttpRequest(environ)
-        if "HTTP" in request.protocol:
+        if request.protocol.startswith("HTTP"):
             response: WsgiHttpResponse = self._get_http_response(
                 request=request,
             )
-            start_response(response.status, response.get_headers())
-            return response.get_body()
-        raise TypeError(f"Unsupported SERVER_PROTOCOL: {request.protocol}")
+        else:
+            response = WsgiHttpResponse(
+                status=400, headers={"content-type": ["text/plain;charset=utf-8"]}, body="Bad Request"
+            )
+        start_response(response.status, response.get_headers())
+        return response.get_body()

slack_bolt/adapter/wsgi/http_request.py

@@ -1,4 +1,7 @@
-from typing import Any, Dict, Sequence, Union
+from typing import TYPE_CHECKING, Dict, Sequence, Union
+
+if TYPE_CHECKING:
+    from wsgiref.types import WSGIEnvironment
 
 from .internals import ENCODING
 
@@ -12,7 +15,7 @@ class WsgiHttpRequest:
 
     __slots__ = ("method", "path", "query_string", "protocol", "environ")
 
-    def __init__(self, environ: Dict[str, Any]):
+    def __init__(self, environ: "WSGIEnvironment"):
         self.method: str = environ.get("REQUEST_METHOD", "GET")
         self.path: str = environ.get("PATH_INFO", "")
         self.query_string: str = environ.get("QUERY_STRING", "")
@@ -33,5 +36,5 @@ def get_headers(self) -> Dict[str, Union[str, Sequence[str]]]:
     def get_body(self) -> str:
         if "wsgi.input" not in self.environ:
             return ""
-        content_length = int(self.environ.get("CONTENT_LENGTH", 0))
+        content_length = int(self.environ.get("CONTENT_LENGTH") or 0)
         return self.environ["wsgi.input"].read(content_length).decode(ENCODING)

slack_bolt/adapter/wsgi/http_response.py

@@ -1,5 +1,5 @@
 from http import HTTPStatus
-from typing import Dict, Iterable, List, Sequence, Tuple
+from typing import Dict, Iterable, List, Optional, Sequence, Tuple
 
 from .internals import ENCODING
 
@@ -13,18 +13,19 @@ class WsgiHttpResponse:
 
     __slots__ = ("status", "_headers", "_body")
 
-    def __init__(self, status: int, headers: Dict[str, Sequence[str]] = {}, body: str = ""):
+    def __init__(self, status: int, headers: Optional[Dict[str, Sequence[str]]] = None, body: str = ""):
         _status = HTTPStatus(status)
         self.status = f"{_status.value} {_status.phrase}"
-        self._headers = headers
+        self._headers = headers or {}
         self._body = bytes(body, ENCODING)
 
     def get_headers(self) -> List[Tuple[str, str]]:
         headers: List[Tuple[str, str]] = []
-        for key, value in self._headers.items():
+        for key, values in self._headers.items():
             if key.lower() == "content-length":
                 continue
-            headers.append((key, value[0]))
+            for v in values:
+                headers.append((key, v))
 
         headers.append(("content-length", str(len(self._body))))
         return headers

tests/adapter_tests/asgi/test_asgi_http.py

@@ -223,6 +223,59 @@ async def test_url_verification(self):
         assert response.headers.get("content-type") == "application/json;charset=utf-8"
         assert_auth_test_count(self, 1)
 
+    @pytest.mark.asyncio
+    async def test_content_length_multibyte_body(self):
+        app = App(
+            client=self.web_client,
+            signing_secret=self.signing_secret,
+        )
+
+        def command_handler(ack):
+            ack(text="Hello ☃")  # snowman is 3 bytes in UTF-8
+
+        app.command("/hello-world")(command_handler)
+
+        body = (
+            "token=verification_token"
+            "&team_id=T111"
+            "&team_domain=test-domain"
+            "&channel_id=C111"
+            "&channel_name=random"
+            "&user_id=W111"
+            "&user_name=primary-owner"
+            "&command=%2Fhello-world"
+            "&text=Hi"
+            "&enterprise_id=E111"
+            "&enterprise_name=Org+Name"
+            "&response_url=https%3A%2F%2Fhooks.slack.com%2Fcommands%2FT111%2F111%2Fxxxxx"
+            "&trigger_id=111.111.xxx"
+        )
+
+        headers = self.build_raw_headers(str(int(time())), body)
+
+        asgi_server = AsgiTestServer(SlackRequestHandler(app))
+        response = await asgi_server.http("POST", headers, body)
+
+        assert response.status_code == 200
+        content_length = int(response.headers.get("content-length"))
+        actual_bytes = len(response.body.encode("utf-8"))
+        assert content_length == actual_bytes
+
+    @pytest.mark.asyncio
+    async def test_multi_value_headers(self):
+        from slack_bolt.adapter.asgi.http_response import AsgiHttpResponse
+
+        headers = {
+            "set-cookie": ["cookie1=value1; Path=/", "cookie2=value2; Path=/"],
+            "content-type": ["text/html; charset=utf-8"],
+        }
+        response = AsgiHttpResponse(status=200, headers=headers, body="OK")
+
+        set_cookie_headers = [(name, value) for name, value in response.raw_headers if name == b"set-cookie"]
+        assert len(set_cookie_headers) == 2
+        assert set_cookie_headers[0] == (b"set-cookie", b"cookie1=value1; Path=/")
+        assert set_cookie_headers[1] == (b"set-cookie", b"cookie2=value2; Path=/")
+
     @pytest.mark.asyncio
     async def test_unsupported_method(self):
         app = App(

tests/adapter_tests/asgi/test_asgi_lifespan.py

@@ -1,5 +1,6 @@
 import pytest
 
+from asgiref.testing import ApplicationCommunicator
 from slack_sdk.signature import SignatureVerifier
 from slack_sdk.web import WebClient
 
@@ -59,6 +60,24 @@ async def test_shutdown(self):
         assert response.type == "lifespan.shutdown.complete"
         assert response.message == ""
 
+    @pytest.mark.asyncio
+    async def test_full_lifespan_cycle(self):
+        app = App(
+            client=self.web_client,
+            signing_secret=self.signing_secret,
+        )
+
+        scope = {"type": "lifespan", "asgi": {"version": "3.0", "spec_version": "2.3"}}
+        communicator = ApplicationCommunicator(SlackRequestHandler(app), scope)
+
+        await communicator.send_input({"type": "lifespan.startup"})
+        startup_response = await communicator.receive_output(timeout=1)
+        assert startup_response["type"] == "lifespan.startup.complete"
+
+        await communicator.send_input({"type": "lifespan.shutdown"})
+        shutdown_response = await communicator.receive_output(timeout=1)
+        assert shutdown_response["type"] == "lifespan.shutdown.complete"
+
     @pytest.mark.asyncio
     async def test_failed_event(self):
         app = App(

tests/mock_asgi_server.py

@@ -1,28 +1,44 @@
-from typing import Iterable, Tuple, Union
+from typing import Iterable, Tuple
+
+from asgiref.testing import ApplicationCommunicator
+
 from slack_bolt.adapter.asgi.base_handler import BaseSlackRequestHandler
 
 ENCODING = "utf-8"
 
 
 class AsgiTestServerResponse:
-    def __init__(self):
-        self.status_code: int = None
-        self._headers: Iterable[Tuple[bytes, bytes]] = []
-        self._body: bytearray = bytearray(b"")
+    def __init__(
+        self,
+        status_code: int,
+        headers: Iterable[Tuple[bytes, bytes]] = (),
+        body: bytes = b"",
+    ):
+        self.status_code = status_code
+        self._headers = headers
+        self._body = body
 
     @property
-    def body(self):
+    def body(self) -> str:
         return self._body.decode(ENCODING)
 
     @property
-    def headers(self):
-        return {header[0].decode(ENCODING): header[1].decode(ENCODING) for header in self._headers}
+    def headers(self) -> dict:
+        result = {}
+        for header in self._headers:
+            key = header[0].decode(ENCODING)
+            if key not in result:
+                result[key] = header[1].decode(ENCODING)
+        return result
+
+    def get_headers_list(self, name: str) -> list:
+        return [header[1].decode(ENCODING) for header in self._headers if header[0].decode(ENCODING) == name]
 
 
 class AsgiTestServerLifespanResponse:
-    def __init__(self):
-        self.type: str = None
-        self.message: str = ""
+    def __init__(self, type: str, message: str = ""):
+        self.type = type
+        self.message = message
 
 
 class AsgiTestServer:
@@ -61,22 +77,17 @@ async def http(
             },
         )
 
-        async def receive():
-            return {"type": "http.request", "body": bytes(body, ENCODING), "more_body": False}
+        communicator = ApplicationCommunicator(self.asgi_app, scope)
+        await communicator.send_input({"type": "http.request", "body": bytes(body, ENCODING), "more_body": False})
 
-        response = AsgiTestServerResponse()
+        response_start = await communicator.receive_output(timeout=1)
+        response_body = await communicator.receive_output(timeout=1)
 
-        async def send(event):
-            if event["type"] == "http.response.start":
-                response.status_code = event["status"]
-                response._headers = event["headers"]
-            elif event["type"] == "http.response.body":
-                response._body.extend(event["body"])
-            else:
-                raise TypeError(f"Sent type {event['type']} in response {event} is not valid")
-
-        await self.asgi_app(scope, receive, send)
-        return response
+        return AsgiTestServerResponse(
+            status_code=response_start["status"],
+            headers=response_start.get("headers", []),
+            body=response_body.get("body", b""),
+        )
 
     async def lifespan(self, event: str) -> AsgiTestServerLifespanResponse:
         """This implements the server side behavior of the lifespan event
@@ -92,17 +103,20 @@ async def lifespan(self, event: str) -> AsgiTestServerLifespanResponse:
             },
         )
 
-        async def receive():
-            return {"type": f"lifespan.{event}"}
+        communicator = ApplicationCommunicator(self.asgi_app, scope)
+        await communicator.send_input({"type": f"lifespan.{event}"})
 
-        response = AsgiTestServerLifespanResponse()
+        result = await communicator.receive_output(timeout=1)
 
-        async def send(event: dict):
-            response.type = event["type"]
-            response.message = event.get("message", "")
+        # Send shutdown so the handler exits cleanly
+        if event == "startup":
+            await communicator.send_input({"type": "lifespan.shutdown"})
+            await communicator.receive_output(timeout=1)
 
-        await self.asgi_app(scope, receive, send)
-        return response
+        return AsgiTestServerLifespanResponse(
+            type=result["type"],
+            message=result.get("message", ""),
+        )
 
     async def websocket(self) -> None:
         """This is not implemented"""
@@ -113,10 +127,6 @@ async def websocket(self) -> None:
             },
         )
 
-        async def receive():
-            return {}
-
-        async def send(event: dict):
-            print(event)
-
-        await self.asgi_app(scope, receive, send)
+        communicator = ApplicationCommunicator(self.asgi_app, scope)
+        await communicator.send_input({})
+        await communicator.receive_output(timeout=1)