Add more fields to context for Bolt JS compatibility

Author: seratch

slack_bolt/authorization/authorize_result.py

@@ -53,12 +53,22 @@ def from_auth_test_response(
         user_token: Optional[str] = None,
         auth_test_response: SlackResponse,
     ) -> "AuthorizeResult":
+        bot_user_id: Optional[str] = (  # type:ignore
+            auth_test_response.get("user_id")
+            if auth_test_response.get("bot_id") is not None
+            else None
+        )
+        user_id: Optional[str] = (  # type:ignore
+            auth_test_response.get("user_id")
+            if auth_test_response.get("bot_id") is None
+            else None
+        )
         return AuthorizeResult(
             enterprise_id=auth_test_response.get("enterprise_id"),
             team_id=auth_test_response.get("team_id"),
-            bot_user_id=auth_test_response.get("user_id"),
             bot_id=auth_test_response.get("bot_id"),
-            user_id=auth_test_response.get("user_id"),
+            bot_user_id=bot_user_id,
+            user_id=user_id,
             bot_token=bot_token,
             user_token=user_token,
         )

slack_bolt/context/base_context.py

@@ -5,10 +5,6 @@
 
 
 class BaseContext(dict):
-    @property
-    def authorize_result(self) -> Optional[AuthorizeResult]:
-        return self.get("authorize_result")
-
     @property
     def logger(self) -> Logger:
         return self["logger"]
@@ -41,3 +37,38 @@ def response_url(self) -> Optional[str]:
     def matches(self) -> Optional[Tuple]:
         """Returns all the matched parts in message listener's regexp"""
         return self.get("matches")
+
+    # --------------------------------
+
+    @property
+    def authorize_result(self) -> Optional[AuthorizeResult]:
+        return self.get("authorize_result")
+
+    @property
+    def bot_token(self) -> Optional[str]:
+        return self.get("bot_token")
+
+    @property
+    def bot_id(self) -> Optional[str]:
+        return self.get("bot_id")
+
+    @property
+    def bot_user_id(self) -> Optional[str]:
+        return self.get("bot_user_id")
+
+    @property
+    def user_token(self) -> Optional[str]:
+        return self.get("user_token")
+
+    def set_authorize_result(self, authorize_result: AuthorizeResult):
+        self["authorize_result"] = authorize_result
+        if authorize_result.bot_id is not None:
+            self["bot_id"] = authorize_result.bot_id
+        if authorize_result.bot_user_id is not None:
+            self["bot_user_id"] = authorize_result.bot_user_id
+        if authorize_result.bot_token is not None:
+            self["bot_token"] = authorize_result.bot_token
+        if authorize_result.user_id is not None:
+            self["user_id"] = authorize_result.user_id
+        if authorize_result.user_token is not None:
+            self["user_token"] = authorize_result.user_token

slack_bolt/middleware/authorization/async_multi_teams_authorization.py

@@ -39,7 +39,7 @@ async def async_process(
                 user_id=req.context.user_id,
             )
             if auth_result:
-                req.context["authorize_result"] = auth_result
+                req.context.set_authorize_result(auth_result)
                 token = auth_result.bot_token or auth_result.user_token
                 req.context["token"] = token
                 req.context["client"] = create_async_web_client(token)

slack_bolt/middleware/authorization/async_single_team_authorization.py

@@ -13,7 +13,7 @@
 class AsyncSingleTeamAuthorization(AsyncAuthorization):
     def __init__(self):
         """Single-workspace authorization."""
-        self.auth_result: Optional[AsyncSlackResponse] = None
+        self.auth_test_result: Optional[AsyncSlackResponse] = None
         self.logger = get_bolt_logger(AsyncSingleTeamAuthorization)
 
     async def async_process(
@@ -27,14 +27,16 @@ async def async_process(
             return await next()
 
         try:
-            if self.auth_result is None:
-                self.auth_result = await req.context.client.auth_test()
+            if self.auth_test_result is None:
+                self.auth_test_result = await req.context.client.auth_test()
 
-            if self.auth_result:
-                req.context["authorize_result"] = _to_authorize_result(
-                    auth_test_result=self.auth_result,
-                    token=req.context.client.token,
-                    request_user_id=req.context.user_id,
+            if self.auth_test_result:
+                req.context.set_authorize_result(
+                    _to_authorize_result(
+                        auth_test_result=self.auth_test_result,
+                        token=req.context.client.token,
+                        request_user_id=req.context.user_id,
+                    )
                 )
                 return await next()
             else:

slack_bolt/middleware/authorization/multi_teams_authorization.py

@@ -37,7 +37,7 @@ def process(
                 user_id=req.context.user_id,
             )
             if auth_result is not None:
-                req.context["authorize_result"] = auth_result
+                req.context.set_authorize_result(auth_result)
                 token = auth_result.bot_token or auth_result.user_token
                 req.context["token"] = token
                 req.context["client"] = create_web_client(token)

slack_bolt/middleware/authorization/single_team_authorization.py

@@ -33,10 +33,12 @@ def process(
                 self.auth_test_result = req.context.client.auth_test()
 
             if self.auth_test_result:
-                req.context["authorize_result"] = _to_authorize_result(
-                    auth_test_result=self.auth_test_result,
-                    token=req.context.client.token,
-                    request_user_id=req.context.user_id,
+                req.context.set_authorize_result(
+                    _to_authorize_result(
+                        auth_test_result=self.auth_test_result,
+                        token=req.context.client.token,
+                        request_user_id=req.context.user_id,
+                    )
                 )
                 return next()
             else:

tests/mock_web_api_server.py

@@ -19,6 +19,11 @@ def is_valid_token(self):
             self.headers["Authorization"]
         ).startswith("Bearer xoxb-")
 
+    def is_valid_user_token(self):
+        return "Authorization" in self.headers and str(
+            self.headers["Authorization"]
+        ).startswith("Bearer xoxp-")
+
     def set_common_headers(self):
         self.send_header("content-type", "application/json;charset=utf-8")
         self.send_header("connection", "close")
@@ -53,7 +58,7 @@ def set_common_headers(self):
     }
 }
                 """
-    auth_test_response = """
+    bot_auth_test_response = """
 {
     "ok": true,
     "url": "https://subarachnoid.slack.com/",
@@ -63,6 +68,17 @@ def set_common_headers(self):
     "user_id": "W23456789",
     "bot_id": "BZYBOTHED"
 }
+"""
+
+    user_auth_test_response = """
+{
+    "ok": true,
+    "url": "https://subarachnoid.slack.com/",
+    "team": "Subarachnoid Workspace",
+    "user": "some-user",
+    "team_id": "T0G9PQBBK",
+    "user_id": "W99999"
+}
 """
 
     def _handle(self):
@@ -75,13 +91,20 @@ def _handle(self):
                 self.wfile.write(self.oauth_v2_access_response.encode("utf-8"))
                 return
 
+            if self.is_valid_user_token():
+                if self.path == "/auth.test":
+                    self.send_response(200)
+                    self.set_common_headers()
+                    self.wfile.write(self.user_auth_test_response.encode("utf-8"))
+                    return
+
             if self.is_valid_token():
                 parsed_path = urlparse(self.path)
 
                 if self.path == "/auth.test":
                     self.send_response(200)
                     self.set_common_headers()
-                    self.wfile.write(self.auth_test_response.encode("utf-8"))
+                    self.wfile.write(self.bot_auth_test_response.encode("utf-8"))
                     return
 
                 len_header = self.headers.get("Content-Length") or 0

tests/scenario_tests/test_authorize.py

@@ -15,22 +15,33 @@
 from tests.utils import remove_os_env_temporarily, restore_os_env
 
 valid_token = "xoxb-valid"
+valid_user_token = "xoxp-valid"
 
 
 def authorize(enterprise_id, team_id, user_id, client: WebClient):
     assert enterprise_id == "E111"
     assert team_id == "T111"
-    assert user_id == "W111"
+    assert user_id == "W99999"
     auth_test = client.auth_test(token=valid_token)
     return AuthorizeResult.from_auth_test_response(
         auth_test_response=auth_test, bot_token=valid_token,
     )
 
 
+def user_authorize(enterprise_id, team_id, user_id, client: WebClient):
+    assert enterprise_id == "E111"
+    assert team_id == "T111"
+    assert user_id == "W99999"
+    auth_test = client.auth_test(token=valid_user_token)
+    return AuthorizeResult.from_auth_test_response(
+        auth_test_response=auth_test, user_token=valid_user_token,
+    )
+
+
 def error_authorize(enterprise_id, team_id, user_id):
     assert enterprise_id == "E111"
     assert team_id == "T111"
-    assert user_id == "W111"
+    assert user_id == "W99999"
     return None
 
 
@@ -94,11 +105,39 @@ def test_failure(self):
         assert response.body == ":x: Please install this app into the workspace :bow:"
         assert self.mock_received_requests.get("/auth.test") == None
 
+    def test_bot_context_attributes(self):
+        app = App(
+            client=self.web_client,
+            authorize=authorize,
+            signing_secret=self.signing_secret,
+        )
+        app.action("a")(assert_bot_context_attributes)
+
+        request = self.build_valid_request()
+        response = app.dispatch(request)
+        assert response.status == 200
+        assert response.body == ""
+        assert self.mock_received_requests["/auth.test"] == 1
+
+    def test_user_context_attributes(self):
+        app = App(
+            client=self.web_client,
+            authorize=user_authorize,
+            signing_secret=self.signing_secret,
+        )
+        app.action("a")(assert_user_context_attributes)
+
+        request = self.build_valid_request()
+        response = app.dispatch(request)
+        assert response.status == 200
+        assert response.body == ""
+        assert self.mock_received_requests["/auth.test"] == 1
+
 
 body = {
     "type": "block_actions",
     "user": {
-        "id": "W111",
+        "id": "W99999",
         "username": "primary-owner",
         "name": "primary-owner",
         "team_id": "T111",
@@ -141,3 +180,23 @@ def simple_listener(ack, body, payload, action):
     assert payload == action
     assert action["action_id"] == "a"
     ack()
+
+
+def assert_bot_context_attributes(ack, context):
+    assert context["bot_id"] == "BZYBOTHED"
+    assert context["bot_user_id"] == "W23456789"
+    assert context["bot_token"] == "xoxb-valid"
+    assert context["token"] == "xoxb-valid"
+    assert context["user_id"] == "W99999"
+    assert context.get("user_token") is None
+    ack()
+
+
+def assert_user_context_attributes(ack, context):
+    assert context.get("bot_id") is None
+    assert context.get("bot_user_id") is None
+    assert context.get("bot_token") is None
+    assert context["token"] == "xoxp-valid"
+    assert context["user_id"] == "W99999"
+    assert context["user_token"] == "xoxp-valid"
+    ack()

tests/scenario_tests/test_block_actions.py

@@ -5,7 +5,7 @@
 from slack_sdk import WebClient
 from slack_sdk.signature import SignatureVerifier
 
-from slack_bolt import BoltRequest
+from slack_bolt import BoltRequest, BoltContext
 from slack_bolt.app import App
 from tests.mock_web_api_server import (
     setup_mock_web_api_server,
@@ -174,9 +174,15 @@ def test_failure_2(self):
 raw_body = f"payload={quote(json.dumps(body))}"
 
 
-def simple_listener(ack, body, payload, action):
+def simple_listener(ack, body, payload, action, context: BoltContext):
     assert body["trigger_id"] == "111.222.valid"
     assert body["actions"][0] == payload
     assert payload == action
     assert action["action_id"] == "a"
+    assert context.bot_id == "BZYBOTHED"
+    assert context.bot_user_id == "W23456789"
+    assert context.bot_token == "xoxb-valid"
+    assert context.token == "xoxb-valid"
+    assert context.user_id == "W111"
+    assert context.user_token is None
     ack()