Fix #121 by changing the built-in middleware

Author: seratch

slack_bolt/middleware/authorization/async_multi_teams_authorization.py

@@ -6,6 +6,7 @@
 from slack_bolt.response import BoltResponse
 from .async_authorization import AsyncAuthorization
 from .async_internals import _build_error_response, _is_no_auth_required
+from .internals import _is_no_auth_test_call_required
 from ...authorization import AuthorizeResult
 from ...authorization.async_authorize import AsyncAuthorize
 from ...util.async_utils import create_async_web_client
@@ -31,6 +32,17 @@ async def async_process(
     ) -> BoltResponse:
         if _is_no_auth_required(req):
             return await next()
+
+        if _is_no_auth_test_call_required(req):
+            req.context.set_authorize_result(
+                AuthorizeResult(
+                    enterprise_id=req.context.enterprise_id,
+                    team_id=req.context.team_id,
+                    user_id=req.context.user_id,
+                )
+            )
+            return await next()
+
         try:
             auth_result: Optional[AuthorizeResult] = await self.authorize(
                 context=req.context,

slack_bolt/middleware/authorization/async_single_team_authorization.py

@@ -7,7 +7,8 @@
 from slack_sdk.web.async_slack_response import AsyncSlackResponse
 from slack_sdk.errors import SlackApiError
 from .async_internals import _build_error_response, _is_no_auth_required
-from .internals import _to_authorize_result
+from .internals import _to_authorize_result, _is_no_auth_test_call_required
+from ...authorization import AuthorizeResult
 
 
 class AsyncSingleTeamAuthorization(AsyncAuthorization):
@@ -26,6 +27,16 @@ async def async_process(
         if _is_no_auth_required(req):
             return await next()
 
+        if _is_no_auth_test_call_required(req):
+            req.context.set_authorize_result(
+                AuthorizeResult(
+                    enterprise_id=req.context.enterprise_id,
+                    team_id=req.context.team_id,
+                    user_id=req.context.user_id,
+                )
+            )
+            return await next()
+
         try:
             if self.auth_test_result is None:
                 self.auth_test_result = await req.context.client.auth_test()

slack_bolt/middleware/authorization/internals.py

@@ -21,10 +21,32 @@ def _is_ssl_check(req: BoltRequest) -> bool:
     )
 
 
+def _is_uninstallation_event(req: BoltRequest) -> bool:
+    return (
+        req is not None
+        and req.body is not None
+        and req.body.get("type") == "event_callback"
+        and req.body.get("event", {}).get("type") == "app_uninstalled"
+    )
+
+
+def _is_tokens_revoked_event(req: BoltRequest) -> bool:
+    return (
+        req is not None
+        and req.body is not None
+        and req.body.get("type") == "event_callback"
+        and req.body.get("event", {}).get("type") == "tokens_revoked"
+    )
+
+
 def _is_no_auth_required(req: BoltRequest) -> bool:
     return _is_url_verification(req) or _is_ssl_check(req)
 
 
+def _is_no_auth_test_call_required(req: BoltRequest) -> bool:
+    return _is_uninstallation_event(req) or _is_tokens_revoked_event(req)
+
+
 def _build_error_response() -> BoltResponse:
     # show an ephemeral message to the end-user
     return BoltResponse(

slack_bolt/middleware/authorization/multi_teams_authorization.py

@@ -5,7 +5,11 @@
 from slack_bolt.response import BoltResponse
 from slack_sdk.errors import SlackApiError
 from .authorization import Authorization
-from .internals import _build_error_response, _is_no_auth_required
+from .internals import (
+    _build_error_response,
+    _is_no_auth_required,
+    _is_no_auth_test_call_required,
+)
 from ...authorization import AuthorizeResult
 from ...authorization.authorize import Authorize
 from ...util.utils import create_web_client
@@ -29,6 +33,17 @@ def process(
     ) -> BoltResponse:
         if _is_no_auth_required(req):
             return next()
+
+        if _is_no_auth_test_call_required(req):
+            req.context.set_authorize_result(
+                AuthorizeResult(
+                    enterprise_id=req.context.enterprise_id,
+                    team_id=req.context.team_id,
+                    user_id=req.context.user_id,
+                )
+            )
+            return next()
+
         try:
             auth_result: Optional[AuthorizeResult] = self.authorize(
                 context=req.context,

slack_bolt/middleware/authorization/single_team_authorization.py

@@ -10,7 +10,9 @@
     _build_error_response,
     _is_no_auth_required,
     _to_authorize_result,
+    _is_no_auth_test_call_required,
 )
+from ...authorization import AuthorizeResult
 
 
 class SingleTeamAuthorization(Authorization):
@@ -28,6 +30,16 @@ def process(
         if _is_no_auth_required(req):
             return next()
 
+        if _is_no_auth_test_call_required(req):
+            req.context.set_authorize_result(
+                AuthorizeResult(
+                    enterprise_id=req.context.enterprise_id,
+                    team_id=req.context.team_id,
+                    user_id=req.context.user_id,
+                )
+            )
+            return next()
+
         try:
             if not self.auth_test_result:
                 self.auth_test_result = req.context.client.auth_test()

slack_bolt/middleware/ignoring_self_events/ignoring_self_events.py

@@ -36,6 +36,7 @@ def _is_self_event(
     ):
         return (
             auth_result is not None
+            and user_id is not None
             and user_id == auth_result.bot_user_id
             and body.get("event") is not None
             and body.get("event", {}).get("type") not in cls.events_that_should_be_kept

tests/scenario_tests/test_events.py

@@ -4,7 +4,7 @@
 from slack_sdk.signature import SignatureVerifier
 from slack_sdk.web import WebClient
 
-from slack_bolt import App, BoltRequest
+from slack_bolt import App, BoltRequest, Say
 from tests.mock_web_api_server import (
     setup_mock_web_api_server,
     cleanup_mock_web_api_server,
@@ -335,3 +335,60 @@ def handle_app_mention(say):
         sleep(1)  # wait a bit after auto ack()
         # the listeners should not be executed
         assert self.mock_received_requests["/chat.postMessage"] == 2
+
+    def test_uninstallation_and_revokes(self):
+        app = App(client=self.web_client, signing_secret=self.signing_secret)
+        app._client = WebClient(
+            token="uninstalled-revoked", base_url=self.mock_api_server_base_url
+        )
+
+        @app.event("app_uninstalled")
+        def handler1(say: Say):
+            say(channel="C111", text="What's up?")
+
+        @app.event("tokens_revoked")
+        def handler2(say: Say):
+            say(channel="C111", text="What's up?")
+
+        app_uninstalled_body = {
+            "token": "verification_token",
+            "team_id": "T111",
+            "enterprise_id": "E111",
+            "api_app_id": "A111",
+            "event": {"type": "app_uninstalled"},
+            "type": "event_callback",
+            "event_id": "Ev111",
+            "event_time": 1599616881,
+        }
+
+        timestamp, body = str(int(time())), json.dumps(app_uninstalled_body)
+        request: BoltRequest = BoltRequest(
+            body=body, headers=self.build_headers(timestamp, body)
+        )
+        response = app.dispatch(request)
+        assert response.status == 200
+
+        tokens_revoked_body = {
+            "token": "verification_token",
+            "team_id": "T111",
+            "enterprise_id": "E111",
+            "api_app_id": "A111",
+            "event": {
+                "type": "tokens_revoked",
+                "tokens": {"oauth": ["UXXXXXXXX"], "bot": ["UXXXXXXXX"]},
+            },
+            "type": "event_callback",
+            "event_id": "Ev111",
+            "event_time": 1599616881,
+        }
+
+        timestamp, body = str(int(time())), json.dumps(tokens_revoked_body)
+        request: BoltRequest = BoltRequest(
+            body=body, headers=self.build_headers(timestamp, body)
+        )
+        response = app.dispatch(request)
+        assert response.status == 200
+
+        assert self.mock_received_requests["/auth.test"] == 1
+        sleep(1)  # wait a bit after auto ack()
+        assert self.mock_received_requests["/chat.postMessage"] == 2

tests/scenario_tests_async/test_events.py

@@ -8,6 +8,7 @@
 from slack_sdk.web.async_client import AsyncWebClient
 
 from slack_bolt.app.async_app import AsyncApp
+from slack_bolt.context.say.async_say import AsyncSay
 from slack_bolt.request.async_request import AsyncBoltRequest
 from tests.mock_web_api_server import (
     setup_mock_web_api_server,
@@ -315,6 +316,65 @@ async def handle_member_left_channel(say):
         # The listeners should be executed
         assert self.mock_received_requests.get("/chat.postMessage") == 2
 
+    @pytest.mark.asyncio
+    async def test_uninstallation_and_revokes(self):
+        app = AsyncApp(client=self.web_client, signing_secret=self.signing_secret)
+        app._client = AsyncWebClient(
+            token="uninstalled-revoked", base_url=self.mock_api_server_base_url
+        )
+
+        @app.event("app_uninstalled")
+        async def handler1(say: AsyncSay):
+            await say(channel="C111", text="What's up?")
+
+        @app.event("tokens_revoked")
+        async def handler2(say: AsyncSay):
+            await say(channel="C111", text="What's up?")
+
+        app_uninstalled_body = {
+            "token": "verification_token",
+            "team_id": "T111",
+            "enterprise_id": "E111",
+            "api_app_id": "A111",
+            "event": {"type": "app_uninstalled"},
+            "type": "event_callback",
+            "event_id": "Ev111",
+            "event_time": 1599616881,
+        }
+
+        timestamp, body = str(int(time())), json.dumps(app_uninstalled_body)
+        request: AsyncBoltRequest = AsyncBoltRequest(
+            body=body, headers=self.build_headers(timestamp, body)
+        )
+        response = await app.async_dispatch(request)
+        assert response.status == 200
+
+        tokens_revoked_body = {
+            "token": "verification_token",
+            "team_id": "T111",
+            "enterprise_id": "E111",
+            "api_app_id": "A111",
+            "event": {
+                "type": "tokens_revoked",
+                "tokens": {"oauth": ["UXXXXXXXX"], "bot": ["UXXXXXXXX"]},
+            },
+            "type": "event_callback",
+            "event_id": "Ev111",
+            "event_time": 1599616881,
+        }
+
+        timestamp, body = str(int(time())), json.dumps(tokens_revoked_body)
+        request: AsyncBoltRequest = AsyncBoltRequest(
+            body=body, headers=self.build_headers(timestamp, body)
+        )
+        response = await app.async_dispatch(request)
+        assert response.status == 200
+
+        # AsyncApp doesn't call auth.test when booting
+        assert self.mock_received_requests.get("/auth.test") is None
+        await asyncio.sleep(1)  # wait a bit after auto ack()
+        assert self.mock_received_requests["/chat.postMessage"] == 2
+
 
 app_mention_body = {
     "token": "verification_token",