Add cache_enabled option to InstallationStoreAuthorize

Author: seratch

slack_bolt/authorization/async_authorize.py

@@ -91,11 +91,18 @@ async def __call__(
 
 
 class AsyncInstallationStoreAuthorize(AsyncAuthorize):
+    authorize_result_cache: Dict[str, AuthorizeResult] = {}
+
     def __init__(
-        self, *, logger: Logger, installation_store: AsyncInstallationStore,
+        self,
+        *,
+        logger: Logger,
+        installation_store: AsyncInstallationStore,
+        cache_enabled: bool = False,
     ):
         self.logger = logger
         self.installation_store = installation_store
+        self.cache_enabled = cache_enabled
 
     async def __call__(
         self,
@@ -115,13 +122,18 @@ async def __call__(
             )
             return None
 
+        if self.cache_enabled and bot.bot_token in self.authorize_result_cache:
+            return self.authorize_result_cache[bot.bot_token]
         try:
             auth_result = await context.client.auth_test(token=bot.bot_token)
-            return AuthorizeResult.from_auth_test_response(
+            authorize_result = AuthorizeResult.from_auth_test_response(
                 auth_test_response=auth_result,
                 bot_token=bot.bot_token,
                 user_token=None,  # Not yet supported
             )
+            if self.cache_enabled:
+                self.authorize_result_cache[bot.bot_token] = authorize_result
+            return authorize_result
         except SlackApiError as err:
             self.logger.debug(
                 f"The stored bot token for enterprise_id: {enterprise_id} team_id: {team_id} "

slack_bolt/authorization/authorize.py

@@ -89,11 +89,18 @@ def __call__(
 
 
 class InstallationStoreAuthorize(Authorize):
+    authorize_result_cache: Dict[str, AuthorizeResult] = {}
+
     def __init__(
-        self, *, logger: Logger, installation_store: InstallationStore,
+        self,
+        *,
+        logger: Logger,
+        installation_store: InstallationStore,
+        cache_enabled: bool = False,
     ):
         self.logger = logger
         self.installation_store = installation_store
+        self.cache_enabled = cache_enabled
 
     def __call__(
         self,
@@ -113,13 +120,18 @@ def __call__(
             )
             return None
 
+        if self.cache_enabled and bot.bot_token in self.authorize_result_cache:
+            return self.authorize_result_cache[bot.bot_token]
         try:
             auth_result = context.client.auth_test(token=bot.bot_token)
-            return AuthorizeResult.from_auth_test_response(
+            authorize_result = AuthorizeResult.from_auth_test_response(
                 auth_test_response=auth_result,
                 bot_token=bot.bot_token,
                 user_token=None,  # Not yet supported
             )
+            if self.cache_enabled:
+                self.authorize_result_cache[bot.bot_token] = authorize_result
+            return authorize_result
         except SlackApiError as err:
             self.logger.debug(
                 f"The stored bot token for enterprise_id: {enterprise_id} team_id: {team_id} "

tests/slack_bolt/authorization/__init__.py

@@ -0,0 +1,92 @@
+import datetime
+import logging
+from logging import Logger
+from typing import Optional
+
+from slack_sdk import WebClient
+from slack_sdk.oauth import InstallationStore
+from slack_sdk.oauth.installation_store import Bot, Installation
+
+from slack_bolt import BoltContext
+from slack_bolt.authorization.authorize import InstallationStoreAuthorize
+from tests.mock_web_api_server import (
+    cleanup_mock_web_api_server,
+    setup_mock_web_api_server,
+)
+
+
+class TestAuthorize:
+    mock_api_server_base_url = "http://localhost:8888"
+
+    def setup_method(self):
+        setup_mock_web_api_server(self)
+
+    def teardown_method(self):
+        cleanup_mock_web_api_server(self)
+
+    def test_installation_store(self):
+        installation_store = MemoryInstallationStore()
+        authorize = InstallationStoreAuthorize(
+            logger=installation_store.logger, installation_store=installation_store
+        )
+        context = BoltContext()
+        context["client"] = WebClient(base_url=self.mock_api_server_base_url)
+        result = authorize(
+            context=context, enterprise_id="E111", team_id="T0G9PQBBK", user_id="W11111"
+        )
+        assert result.bot_id == "BZYBOTHED"
+        assert result.bot_user_id == "W23456789"
+        assert self.mock_received_requests["/auth.test"] == 1
+
+        result = authorize(
+            context=context, enterprise_id="E111", team_id="T0G9PQBBK", user_id="W11111"
+        )
+        assert result.bot_id == "BZYBOTHED"
+        assert result.bot_user_id == "W23456789"
+        assert self.mock_received_requests["/auth.test"] == 2
+
+    def test_installation_store_cached(self):
+        installation_store = MemoryInstallationStore()
+        authorize = InstallationStoreAuthorize(
+            logger=installation_store.logger,
+            installation_store=installation_store,
+            cache_enabled=True,
+        )
+        context = BoltContext()
+        context["client"] = WebClient(base_url=self.mock_api_server_base_url)
+        result = authorize(
+            context=context, enterprise_id="E111", team_id="T0G9PQBBK", user_id="W11111"
+        )
+        assert result.bot_id == "BZYBOTHED"
+        assert result.bot_user_id == "W23456789"
+        assert self.mock_received_requests["/auth.test"] == 1
+
+        result = authorize(
+            context=context, enterprise_id="E111", team_id="T0G9PQBBK", user_id="W11111"
+        )
+        assert result.bot_id == "BZYBOTHED"
+        assert result.bot_user_id == "W23456789"
+        assert self.mock_received_requests["/auth.test"] == 1  # cached
+
+
+class MemoryInstallationStore(InstallationStore):
+    @property
+    def logger(self) -> Logger:
+        return logging.getLogger(__name__)
+
+    def save(self, installation: Installation):
+        pass
+
+    def find_bot(
+        self, *, enterprise_id: Optional[str], team_id: Optional[str]
+    ) -> Optional[Bot]:
+        return Bot(
+            app_id="A111",
+            enterprise_id="E111",
+            team_id="T0G9PQBBK",
+            bot_token="xoxb-valid",
+            bot_id="B",
+            bot_user_id="W",
+            bot_scopes=["commands", "chat:write"],
+            installed_at=datetime.datetime.now().timestamp(),
+        )

tests/slack_bolt/authorization/test_authorize.py

@@ -0,0 +1,106 @@
+import asyncio
+import datetime
+import logging
+from logging import Logger
+from typing import Optional
+
+import pytest
+from slack_sdk.oauth.installation_store import Bot, Installation
+from slack_sdk.oauth.installation_store.async_installation_store import (
+    AsyncInstallationStore,
+)
+from slack_sdk.web.async_client import AsyncWebClient
+
+from slack_bolt.authorization.async_authorize import AsyncInstallationStoreAuthorize
+from slack_bolt.context.async_context import AsyncBoltContext
+from tests.mock_web_api_server import (
+    setup_mock_web_api_server,
+    cleanup_mock_web_api_server,
+)
+from tests.utils import remove_os_env_temporarily, restore_os_env
+
+
+class TestAsyncAuthorize:
+    mock_api_server_base_url = "http://localhost:8888"
+    client = AsyncWebClient(base_url=mock_api_server_base_url,)
+
+    @pytest.fixture
+    def event_loop(self):
+        old_os_env = remove_os_env_temporarily()
+        try:
+            setup_mock_web_api_server(self)
+            loop = asyncio.get_event_loop()
+            yield loop
+            loop.close()
+            cleanup_mock_web_api_server(self)
+        finally:
+            restore_os_env(old_os_env)
+
+    @pytest.mark.asyncio
+    async def test_installation_store(self):
+        installation_store = MemoryInstallationStore()
+        authorize = AsyncInstallationStoreAuthorize(
+            logger=installation_store.logger, installation_store=installation_store
+        )
+        context = AsyncBoltContext()
+        context["client"] = self.client
+        result = await authorize(
+            context=context, enterprise_id="E111", team_id="T0G9PQBBK", user_id="W11111"
+        )
+        assert result.bot_id == "BZYBOTHED"
+        assert result.bot_user_id == "W23456789"
+        assert self.mock_received_requests["/auth.test"] == 1
+
+        result = await authorize(
+            context=context, enterprise_id="E111", team_id="T0G9PQBBK", user_id="W11111"
+        )
+        assert result.bot_id == "BZYBOTHED"
+        assert result.bot_user_id == "W23456789"
+        assert self.mock_received_requests["/auth.test"] == 2
+
+    @pytest.mark.asyncio
+    async def test_installation_store_cached(self):
+        installation_store = MemoryInstallationStore()
+        authorize = AsyncInstallationStoreAuthorize(
+            logger=installation_store.logger,
+            installation_store=installation_store,
+            cache_enabled=True,
+        )
+        context = AsyncBoltContext()
+        context["client"] = self.client
+        result = await authorize(
+            context=context, enterprise_id="E111", team_id="T0G9PQBBK", user_id="W11111"
+        )
+        assert result.bot_id == "BZYBOTHED"
+        assert result.bot_user_id == "W23456789"
+        assert self.mock_received_requests["/auth.test"] == 1
+
+        result = await authorize(
+            context=context, enterprise_id="E111", team_id="T0G9PQBBK", user_id="W11111"
+        )
+        assert result.bot_id == "BZYBOTHED"
+        assert result.bot_user_id == "W23456789"
+        assert self.mock_received_requests["/auth.test"] == 1  # cached
+
+
+class MemoryInstallationStore(AsyncInstallationStore):
+    @property
+    def logger(self) -> Logger:
+        return logging.getLogger(__name__)
+
+    async def async_save(self, installation: Installation):
+        pass
+
+    async def async_find_bot(
+        self, *, enterprise_id: Optional[str], team_id: Optional[str]
+    ) -> Optional[Bot]:
+        return Bot(
+            app_id="A111",
+            enterprise_id="E111",
+            team_id="T0G9PQBBK",
+            bot_token="xoxb-valid",
+            bot_id="B",
+            bot_user_id="W",
+            bot_scopes=["commands", "chat:write"],
+            installed_at=datetime.datetime.now().timestamp(),
+        )