Add SQLAlchemy implementation to OAuth stores

Also, this pull request updates the structure of unit tests/integration tests

Author: seratch

integration_tests/helpers.py

@@ -21,7 +21,7 @@ def is_not_specified() -> bool:
     module = inspect.getmodule(frame[0])
     filepath: str = module.__file__
 
-    # python setup.py run_all_tests --integration-test-target=web/test_issue_560.py
-    test_target: str = sys.argv[3]  # e.g., web/test_issue_560.py
+    # python setup.py integration_tests --test-target=web/test_issue_560.py
+    test_target: str = sys.argv[1]  # e.g., web/test_issue_560.py
     return not test_target or \
            not filepath.endswith(test_target)

setup.py

@@ -24,6 +24,7 @@
     "flake8>=3,<4",
     "black==19.10b0",
     "psutil>=5,<6",
+    "databases>=0.3",
 ]
 codegen_dependencies = [
     "black==19.10b0",
@@ -182,7 +183,9 @@ def run(self):
             [sys.executable, "-m", "pip", "install"] + validate_dependencies,
         )
         self._run("Running black ...", [sys.executable, "-m", "black", f"{here}/slack"])
-        self._run("Running black ...", [sys.executable, "-m", "black", f"{here}/slack_sdk"])
+        self._run(
+            "Running black ...", [sys.executable, "-m", "black", f"{here}/slack_sdk"]
+        )
         self._run(
             "Running flake8 ...", [sys.executable, "-m", "flake8", f"{here}/slack"]
         )
@@ -204,14 +207,30 @@ def run(self):
         )
 
 
+class UnitTestsCommand(BaseCommand):
+    """Support setup.py validate."""
+
+    description = "Run unit tests (pytest)."
+    user_options = [("test-target=", "i", "tests/{test-target}")]
+
+    def initialize_options(self):
+        self.test_target = ""
+
+    def run(self):
+        target = self.test_target.replace("tests/", "", 1)
+        self._run(
+            "Running unit tests ...",
+            [sys.executable, "-m", "pytest", f"tests/{target}",],
+        )
+
+
 class IntegrationTestsCommand(BaseCommand):
     """Support setup.py run_integration_tests"""
 
     description = "Run integration tests (pytest)."
 
     user_options = [
         ("test-target=", "i", "integration_tests/{test-target}"),
-        ("legacy=", "i", "1"),
     ]
 
     def initialize_options(self):
@@ -220,19 +239,9 @@ def initialize_options(self):
 
     def run(self):
         target = self.test_target.replace("integration_tests/", "", 1)
-        path = (
-            f"integration_tests_legacy/{target}"
-            if self.legacy
-            else f"integration_tests/{target}"
-        )
+        path = f"integration_tests/{target}"
         self._run(
-            "Running integration tests ...",
-            [
-                sys.executable,
-                "-m",
-                "pytest",
-                path,
-            ],
+            "Running integration tests ...", [sys.executable, "-m", "pytest", path,],
         )
 
 
@@ -286,6 +295,8 @@ def run(self):
             "aiohttp>=3,<4",
             # used only under slack_sdk/*_store
             "boto3<=2",
+            # InstallationStore/OAuthStateStore
+            "SQLAlchemy>=1,<2",
         ],
     },
     setup_requires=pytest_runner,
@@ -295,6 +306,7 @@ def run(self):
         "upload": UploadCommand,
         "codegen": CodegenCommand,
         "validate": ValidateCommand,
+        "unit_tests": UnitTestsCommand,
         "integration_tests": IntegrationTestsCommand,
     },
 )

slack_sdk/oauth/installation_store/models/bot.py

@@ -1,4 +1,5 @@
-from typing import Optional, Union, List
+from datetime import datetime
+from typing import Optional, Union, List, Dict, Any
 
 
 class Bot:
@@ -29,3 +30,15 @@ def __init__(
         else:
             self.bot_scopes = bot_scopes
         self.installed_at = installed_at
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "app_id": self.app_id,
+            "enterprise_id": self.enterprise_id,
+            "team_id": self.team_id,
+            "bot_token": self.bot_token,
+            "bot_id": self.bot_id,
+            "bot_user_id": self.bot_user_id,
+            "bot_scopes": ",".join(self.bot_scopes) if self.bot_scopes else None,
+            "installed_at": datetime.utcfromtimestamp(self.installed_at),
+        }

slack_sdk/oauth/installation_store/models/installation.py

@@ -1,5 +1,6 @@
+from datetime import datetime
 from time import time
-from typing import Optional, List, Union
+from typing import Optional, List, Union, Dict, Any
 
 from slack_sdk.oauth.installation_store.models.bot import Bot
 
@@ -64,3 +65,21 @@ def to_bot(self) -> Bot:
             bot_scopes=self.bot_scopes,
             installed_at=self.installed_at,
         )
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "app_id": self.app_id,
+            "enterprise_id": self.enterprise_id,
+            "team_id": self.team_id,
+            "bot_token": self.bot_token,
+            "bot_id": self.bot_id,
+            "bot_user_id": self.bot_user_id,
+            "bot_scopes": ",".join(self.bot_scopes) if self.bot_scopes else None,
+            "user_id": self.user_id,
+            "user_token": self.user_token,
+            "user_scopes": ",".join(self.user_scopes) if self.user_scopes else None,
+            "incoming_webhook_url": self.incoming_webhook_url,
+            "incoming_webhook_channel_id": self.incoming_webhook_channel_id,
+            "incoming_webhook_configuration_url": self.incoming_webhook_configuration_url,
+            "installed_at": datetime.utcfromtimestamp(self.installed_at),
+        }

slack_sdk/oauth/installation_store/sqlalchemy/__init__.py

@@ -0,0 +1,111 @@
+import logging
+from logging import Logger
+from typing import Optional
+
+from sqlalchemy.engine import Engine
+from slack_sdk.oauth.installation_store.installation_store import InstallationStore
+from slack_sdk.oauth.installation_store.models.bot import Bot
+from slack_sdk.oauth.installation_store.models.installation import Installation
+
+import sqlalchemy
+from sqlalchemy import Table, Column, Integer, String, DateTime, Index, and_, desc
+
+
+class SQLAlchemyInstallationStore(InstallationStore):
+    engine: Engine
+    client_id: str
+
+    metadata = sqlalchemy.MetaData()
+    installations: Table = sqlalchemy.Table(
+        "installations",
+        metadata,
+        Column("id", Integer, primary_key=True, autoincrement=True),
+        Column("client_id", String, nullable=False),
+        Column("app_id", String, nullable=False),
+        Column("enterprise_id", String),
+        Column("team_id", String),
+        Column("bot_token", String),
+        Column("bot_id", String),
+        Column("bot_user_id", String),
+        Column("bot_scopes", String),
+        Column("user_id", String, nullable=False),
+        Column("user_token", String),
+        Column("user_scopes", String),
+        Column("incoming_webhook_url", String),
+        Column("incoming_webhook_channel_id", String),
+        Column("incoming_webhook_configuration_url", String),
+        Column(
+            "installed_at", DateTime, nullable=False, default=sqlalchemy.sql.func.now()
+        ),
+        Index("installations_idx", "client_id", "enterprise_id", "team_id", "user_id",),
+    )
+
+    bots = Table(
+        "bots",
+        metadata,
+        Column("id", Integer, primary_key=True, autoincrement=True),
+        Column("client_id", String, nullable=False),
+        Column("app_id", String, nullable=False),
+        Column("enterprise_id", String),
+        Column("team_id", String),
+        Column("bot_token", String),
+        Column("bot_id", String),
+        Column("bot_user_id", String),
+        Column("bot_scopes", String),
+        Column(
+            "installed_at", DateTime, nullable=False, default=sqlalchemy.sql.func.now()
+        ),
+        Index("bots_idx", "client_id", "enterprise_id", "team_id",),
+    )
+
+    def __init__(
+        self,
+        client_id: str,
+        engine: Engine,
+        logger: Logger = logging.getLogger(__name__),
+    ):
+        self.client_id = client_id
+        self._logger = logger
+        self.engine = engine
+
+    def create_tables(self):
+        self.metadata.create_all(self.engine)
+
+    @property
+    def logger(self) -> Logger:
+        return self._logger
+
+    def save(self, installation: Installation):
+        with self.engine.begin() as conn:
+            i = installation.to_dict()
+            i["client_id"] = self.client_id
+            conn.execute(self.installations.insert(), i)
+            b = installation.to_bot().to_dict()
+            b["client_id"] = self.client_id
+            conn.execute(self.bots.insert(), b)
+
+    def find_bot(
+        self, *, enterprise_id: Optional[str], team_id: Optional[str]
+    ) -> Optional[Bot]:
+        c = self.bots.c
+        query = (
+            self.bots.select()
+            .where(and_(c.enterprise_id == enterprise_id, c.team_id == team_id))
+            .order_by(desc(c.installed_at))
+            .limit(1)
+        )
+
+        with self.engine.connect() as conn:
+            result: object = conn.execute(query)
+            for row in result:
+                return Bot(
+                    app_id=row["app_id"],
+                    enterprise_id=row["enterprise_id"],
+                    team_id=row["team_id"],
+                    bot_token=row["bot_token"],
+                    bot_id=row["bot_id"],
+                    bot_user_id=row["bot_user_id"],
+                    bot_scopes=row["bot_scopes"],
+                    installed_at=row["installed_at"],
+                )
+            return None

slack_sdk/oauth/installation_store/sqlite3/__init__.py

@@ -62,9 +62,9 @@ def create_tables(self):
                 bot_id text not null,
                 bot_user_id text not null,
                 bot_scopes text,
-                installer_user_id text not null,
-                installer_user_token text,
-                installer_user_scopes text,
+                user_id text not null,
+                user_token text,
+                user_scopes text,
                 incoming_webhook_url text,
                 incoming_webhook_channel_id text,
                 incoming_webhook_configuration_url text,
@@ -74,7 +74,7 @@ def create_tables(self):
             )
             conn.execute(
                 """
-            create index installations_idx on installations (client_id, enterprise_id, team_id, installer_user_id);
+            create index installations_idx on installations (client_id, enterprise_id, team_id, user_id);
             """
             )
             conn.execute(
@@ -152,9 +152,9 @@ def save(self, installation: Installation):
                     bot_id,
                     bot_user_id,
                     bot_scopes,
-                    installer_user_id,
-                    installer_user_token,
-                    installer_user_scopes,
+                    user_id,
+                    user_token,
+                    user_scopes,
                     incoming_webhook_url,
                     incoming_webhook_channel_id,
                     incoming_webhook_configuration_url

slack_sdk/oauth/state_store/sqlalchemy/__init__.py

@@ -0,0 +1,67 @@
+import logging
+import time
+from datetime import datetime
+from logging import Logger
+from uuid import uuid4
+
+from ..state_store import OAuthStateStore
+import sqlalchemy
+from sqlalchemy import Table, Column, Integer, String, DateTime, and_
+from sqlalchemy.engine import Engine
+
+
+class SQLAlchemyOAuthStateStore(OAuthStateStore):
+    engine: Engine
+    expiration_seconds: int
+
+    metadata = sqlalchemy.MetaData()
+    oauth_states: Table = sqlalchemy.Table(
+        "oauth_states",
+        metadata,
+        Column("id", Integer, primary_key=True, autoincrement=True),
+        Column("state", String, nullable=False),
+        Column("expire_at", DateTime, nullable=False),
+    )
+
+    def __init__(
+        self,
+        expiration_seconds: int,
+        engine: Engine,
+        logger: Logger = logging.getLogger(__name__),
+    ):
+        self.expiration_seconds = expiration_seconds
+        self._logger = logger
+        self.engine = engine
+
+    @property
+    def logger(self) -> Logger:
+        if self._logger is None:
+            self._logger = logging.getLogger(__name__)
+        return self._logger
+
+    def issue(self) -> str:
+        state: str = str(uuid4())
+        now = datetime.utcfromtimestamp(time.time() + self.expiration_seconds)
+        with self.engine.begin() as conn:
+            conn.execute(
+                self.oauth_states.insert(), {"state": state, "expire_at": now},
+            )
+        return state
+
+    def consume(self, state: str) -> bool:
+        try:
+            with self.engine.begin() as conn:
+                c = self.oauth_states.c
+                query = self.oauth_states.select().where(
+                    and_(c.state == state, c.expire_at > datetime.utcnow())
+                )
+                result = conn.execute(query)
+                for row in result:
+                    self.logger.debug(f"consume's query result: {row}")
+                    conn.execute(self.oauth_states.delete().where(c.id == row["id"]))
+                    return True
+            return False
+        except Exception as e:  # skipcq: PYL-W0703
+            message = f"Failed to find any persistent data for state: {state} - {e}"
+            self.logger.warning(message)
+            return False