Add unit tests

seratch · seratch · commit 4a85b3a9354d · 2020-07-28T20:12:49.000+09:00
diff --git a/.travis.yml b/.travis.yml
@@ -0,0 +1,14 @@
+language:
+  python
+sudo:
+  false
+python:
+  - "3.6"
+  - "3.7"
+  - "3.8"
+  - "3.8-dev"  # 3.8 development branch
+  - "nightly"  # nightly build
+install:
+  - python setup.py install
+script:
+  - python setup.py test
diff --git a/logs/.gitkeep b/logs/.gitkeep
diff --git a/pytest.ini b/pytest.ini
@@ -0,0 +1,7 @@
+[pytest]
+log_file = logs/pytest.log
+log_file_level = DEBUG
+log_format = %(asctime)s %(levelname)s %(message)s
+log_date_format = %Y-%m-%d %H:%M:%S
+filterwarnings =
+    ignore:"@coroutine" decorator is deprecated since Python 3.8, use "async def" instead:DeprecationWarning
diff --git a/setup.cfg b/setup.cfg
@@ -0,0 +1,5 @@
+[bdist_wheel]
+universal = 1
+
+[aliases]
+test=pytest
diff --git a/setup.py b/setup.py
@@ -25,8 +25,8 @@
     setup_requires=["pytest-runner==5.2"],
     tests_require=["pytest==3.8.2"],
     install_requires=[
-        "slackclient>=2,<3", # TODO: will be replaced with slack_sdk==3.0.0
-        "aiohttp>=3,<4", # slackclient depends on aiohttp
+        "slackclient>=2,<3",  # TODO: will be replaced with slack_sdk==3.0.0
+        "aiohttp>=3,<4",  # slackclient depends on aiohttp
     ],
     extra_requires=[
         # used only under src/slack_bolt/adapter
diff --git a/src/slack_bolt/app/app.py b/src/slack_bolt/app/app.py
@@ -45,6 +45,7 @@ def __init__(
         signing_secret: str = os.environ["SLACK_SIGNING_SECRET"],
         # for single-workspace apps
         token: Optional[str] = os.environ.get("SLACK_BOT_TOKEN", None),
+        client: Optional[WebClient] = None,
         # for multi-workspace apps
         installation_store: Optional[InstallationStore] = None,
         oauth_state_store: Optional[OAuthStateStore] = None,
@@ -67,10 +68,16 @@ def __init__(
         self.name = name or inspect.stack()[1].filename.split(os.path.sep)[-1]
         self._signing_secret: str = signing_secret
         self._verification_token: Optional[str] = verification_token
-
-        self._client = WebClient(token=token)  # NOTE: the token here can be None
         self._framework_logger = get_bolt_logger(App)
 
+        if client is not None:
+            self._client = client
+            if token is not None:
+                self._framework_logger.warning(
+                    "As you gave client as well, the bot token will be unused.")
+        else:
+            self._client = WebClient(token=token)  # NOTE: the token here can be None
+
         self._token: Optional[str] = token
         self._installation_store: Optional[InstallationStore] = installation_store
         self._oauth_state_store: Optional[OAuthStateStore] = oauth_state_store
@@ -166,6 +173,10 @@ def _sync_client_logger_with_oauth_flow(self):
     # -------------------------
     # accessors
 
+    @property
+    def client(self) -> WebClient:
+        return self._client
+
     @property
     def installation_store(self) -> Optional[InstallationStore]:
         return self._installation_store
diff --git a/src/slack_bolt/middleware/ssl_check.py b/src/slack_bolt/middleware/ssl_check.py
@@ -22,6 +22,6 @@ def process(
             if self.verification_token and \
                 self.verification_token == req.payload["token"]:
                 return BoltResponse(status=401, body={"error": "invalid verification token"})
-            return BoltResponse(status=200, body={})
+            return BoltResponse(status=200, body="")
         else:
             return next()
diff --git a/tests/__init__.py b/tests/__init__.py
diff --git a/tests/conftest.py b/tests/conftest.py
@@ -0,0 +1,4 @@
+import sys
+from os.path import dirname
+
+sys.path.append(f"{dirname(__file__)}/../src")
diff --git a/tests/fixture/__init__.py b/tests/fixture/__init__.py
diff --git a/tests/mock_web_api_server.py b/tests/mock_web_api_server.py
@@ -0,0 +1,114 @@
+import json
+import logging
+import threading
+from http import HTTPStatus
+from http.server import HTTPServer, SimpleHTTPRequestHandler
+from typing import Type
+from unittest import TestCase
+from urllib.parse import urlparse, parse_qs
+
+
+class MockHandler(SimpleHTTPRequestHandler):
+    protocol_version = "HTTP/1.1"
+    default_request_version = "HTTP/1.1"
+    logger = logging.getLogger(__name__)
+
+    def is_valid_token(self):
+        return "Authorization" in self.headers \
+               and str(self.headers["Authorization"]).startswith("Bearer xoxb-")
+
+    def set_common_headers(self):
+        self.send_header("content-type", "application/json;charset=utf-8")
+        self.send_header("connection", "close")
+        self.end_headers()
+
+    invalid_auth = {
+        "ok": False,
+        "error": "invalid_auth",
+    }
+
+    def _handle(self):
+        try:
+            body = {"ok": True}
+            if self.is_valid_token():
+                parsed_path = urlparse(self.path)
+
+                len_header = self.headers.get('Content-Length') or 0
+                content_len = int(len_header)
+                post_body = self.rfile.read(content_len)
+                request_body = None
+                if post_body:
+                    try:
+                        post_body = post_body.decode("utf-8")
+                        if post_body.startswith("{"):
+                            request_body = json.loads(post_body)
+                        else:
+                            request_body = {k: v[0] for k, v in parse_qs(post_body).items()}
+                    except UnicodeDecodeError:
+                        pass
+                else:
+                    if parsed_path and parsed_path.query:
+                        request_body = {k: v[0] for k, v in parse_qs(parsed_path.query).items()}
+
+                self.logger.info(f"request body: {request_body}")
+
+                header = self.headers["authorization"]
+                pattern = str(header).split("xoxb-", 1)[1]
+                if pattern.isnumeric():
+                    self.send_response(int(pattern))
+                    self.set_common_headers()
+                    self.wfile.write("""{"ok":false}""".encode("utf-8"))
+                    return
+            else:
+                body = self.invalid_auth
+
+            self.send_response(HTTPStatus.OK)
+            self.set_common_headers()
+            self.wfile.write(json.dumps(body).encode("utf-8"))
+            self.wfile.close()
+
+        except Exception as e:
+            self.logger.error(str(e), exc_info=True)
+            raise
+
+    def do_GET(self):
+        self._handle()
+
+    def do_POST(self):
+        self._handle()
+
+
+class MockServerThread(threading.Thread):
+
+    def __init__(self, test: TestCase, handler: Type[SimpleHTTPRequestHandler] = MockHandler):
+        threading.Thread.__init__(self)
+        self.handler = handler
+        self.test = test
+
+    def run(self):
+        self.server = HTTPServer(('localhost', 8888), self.handler)
+        self.test.server_url = "http://localhost:8888"
+        self.test.host, self.test.port = self.server.socket.getsockname()
+        self.test.server_started.set()  # threading.Event()
+
+        self.test = None
+        try:
+            self.server.serve_forever(0.05)
+        finally:
+            self.server.server_close()
+
+    def stop(self):
+        self.server.shutdown()
+        self.join()
+
+
+def setup_mock_web_api_server(test: TestCase):
+    test.server_started = threading.Event()
+    test.thread = MockServerThread(test)
+    test.thread.start()
+    test.server_started.wait()
+
+
+def cleanup_mock_web_api_server(test: TestCase):
+    test.thread.stop()
+    test.thread = None
diff --git a/tests/scenario_tests/__init__.py b/tests/scenario_tests/__init__.py
diff --git a/tests/scenario_tests/conftest.py b/tests/scenario_tests/conftest.py
@@ -0,0 +1,4 @@
+import sys
+from os.path import dirname
+
+sys.path.append(f"{dirname(__file__)}/../../src")
diff --git a/tests/scenario_tests/test_ssl_check.py b/tests/scenario_tests/test_ssl_check.py
@@ -0,0 +1,55 @@
+import unittest
+from time import time
+
+from slack_bolt import App, BoltRequest
+from slack_sdk.signature import SignatureVerifier
+from slack_sdk.web import WebClient
+from tests.mock_web_api_server import \
+    setup_mock_web_api_server, cleanup_mock_web_api_server
+
+
+class TestSSLCheck(unittest.TestCase):
+    signing_secret = "secret"
+    valid_token = "xoxb-valid"
+    mock_api_server_base_url = "http://localhost:8888"
+    signature_verifier = SignatureVerifier(signing_secret)
+    web_client = WebClient(
+        token=valid_token,
+        base_url=mock_api_server_base_url,
+    )
+
+    def setUp(self):
+        setup_mock_web_api_server(self)
+
+    def tearDown(self):
+        cleanup_mock_web_api_server(self)
+
+    def generate_signature(self, body: str, timestamp: str):
+        return self.signature_verifier.generate_signature(
+            body=body,
+            timestamp=timestamp,
+        )
+
+    def test_mock_server_is_running(self):
+        resp = self.web_client.api_test()
+        assert resp != None
+
+    def test_ssl_check(self):
+        app = App(
+            client=self.web_client,
+            signing_secret=self.signing_secret
+        )
+
+        timestamp, body = str(int(time())), "token=random&ssl_check=1"
+        request: BoltRequest = BoltRequest(
+            body=body,
+            query={},
+            headers={
+                "content-type": ["application/x-www-form-urlencoded"],
+                "x-slack-signature": [self.generate_signature(body, timestamp)],
+                "x-slack-request-timestamp": [timestamp]
+            }
+        )
+        response = app.dispatch(request)
+        assert response.status == 200
+        assert response.body == ""
