Improve asgi adapter behavior

Author: WilliamBergamin

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.body: bytes = bytes(body, ENCODING)
         self.raw_headers: List[Tuple[bytes, bytes]] = [
-            (bytes(key, ENCODING), bytes(value[0], ENCODING)) for key, value in headers.items()
+            (bytes(key, ENCODING), bytes(v, ENCODING))
+            for key, values in headers.items()
+            if key.lower() != "content-length"
+            for v in values
         ]
-        self.raw_headers.append((b"content-length", bytes(str(len(body)), ENCODING)))
-        self.body: bytes = bytes(body, 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 {

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

@@ -24,7 +24,15 @@ def body(self) -> str:
 
     @property
     def headers(self) -> dict:
-        return {header[0].decode(ENCODING): header[1].decode(ENCODING) for header in self._headers}
+        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:
@@ -99,6 +107,12 @@ async def lifespan(self, event: str) -> AsgiTestServerLifespanResponse:
         await communicator.send_input({"type": f"lifespan.{event}"})
 
         result = await communicator.receive_output(timeout=1)
+
+        # Send shutdown so the handler exits cleanly
+        if event == "startup":
+            await communicator.send_input({"type": "lifespan.shutdown"})
+            await communicator.receive_output(timeout=1)
+
         return AsgiTestServerLifespanResponse(
             type=result["type"],
             message=result.get("message", ""),