chore: improve unit test speed (#1109)

Author: WilliamBergamin

tests/mock_web_api_server/__init__.py

@@ -0,0 +1,85 @@
+import asyncio
+import threading
+import time
+from queue import Queue
+from unittest import TestCase
+
+from .mock_server_thread import MockServerThread
+from .received_requests import ReceivedRequests
+
+
+def setup_mock_web_api_server(test: TestCase):
+    test.server_started = threading.Event()
+    test.received_requests = ReceivedRequests(Queue())
+    test.thread = MockServerThread(test.received_requests.queue, test)
+    test.thread.start()
+    test.server_started.wait()
+
+
+def cleanup_mock_web_api_server(test: TestCase):
+    test.thread.stop()
+    test.thread = None
+
+
+def assert_received_request_count(test: TestCase, path: str, min_count: int, timeout: float = 1):
+    start_time = time.time()
+    error = None
+    while time.time() - start_time < timeout:
+        try:
+            received_count = test.received_requests.get(path, 0)
+            assert (
+                received_count == min_count
+            ), f"Expected {min_count} '{path}' {'requests' if min_count > 1 else 'request'}, but got {received_count}!"
+            return
+        except Exception as e:
+            error = e
+            # waiting for some requests to be received
+            time.sleep(0.05)
+
+    if error is not None:
+        raise error
+
+
+def assert_auth_test_count(test: TestCase, expected_count: int):
+    assert_received_request_count(test, "/auth.test", expected_count, 0.5)
+
+
+#########
+# async #
+#########
+
+
+def setup_mock_web_api_server_async(test: TestCase):
+    test.server_started = threading.Event()
+    test.received_requests = ReceivedRequests(asyncio.Queue())
+    test.thread = MockServerThread(test.received_requests.queue, test)
+    test.thread.start()
+    test.server_started.wait()
+
+
+def cleanup_mock_web_api_server_async(test: TestCase):
+    test.thread.stop_unsafe()
+    test.thread = None
+
+
+async def assert_received_request_count_async(test: TestCase, path: str, min_count: int, timeout: float = 1):
+    start_time = time.time()
+    error = None
+    while time.time() - start_time < timeout:
+        try:
+            received_count = await test.received_requests.get_async(path, 0)
+            assert (
+                received_count == min_count
+            ), f"Expected {min_count} '{path}' {'requests' if min_count > 1 else 'request'}, but got {received_count}!"
+            return
+        except Exception as e:
+            error = e
+            # waiting for mock_received_requests updates
+            await asyncio.sleep(0.05)
+
+    if error is not None:
+        raise error
+
+
+async def assert_auth_test_count_async(test: TestCase, expected_count: int):
+    await assert_received_request_count_async(test, "/auth.test", expected_count, 0.5)

tests/mock_web_api_server.py tests/mock_web_api_server/mock_handler.pytests/mock_web_api_server.py renamed to tests/mock_web_api_server/mock_handler.py

@@ -1,14 +1,9 @@
-import asyncio
 import json
 import logging
-from queue import Queue
-import threading
-import time
 from http import HTTPStatus
-from http.server import HTTPServer, SimpleHTTPRequestHandler
-from typing import Type, Optional
-from unittest import TestCase
-from urllib.parse import urlparse, parse_qs, ParseResult
+from http.server import SimpleHTTPRequestHandler
+from typing import Optional
+from urllib.parse import ParseResult, parse_qs, urlparse
 
 INVALID_AUTH = json.dumps(
     {
@@ -93,7 +88,6 @@ class MockHandler(SimpleHTTPRequestHandler):
     protocol_version = "HTTP/1.1"
     default_request_version = "HTTP/1.1"
     logger = logging.getLogger(__name__)
-    received_requests = {}
 
     def is_valid_token(self):
         return "Authorization" in self.headers and str(self.headers["Authorization"]).startswith("Bearer xoxb-")
@@ -109,8 +103,8 @@ def set_common_headers(self, content_length: int = 0):
     def _handle(self):
         parsed_path: ParseResult = urlparse(self.path)
         path = parsed_path.path
-        self.server.queue.put(path)
-        self.received_requests[path] = self.received_requests.get(path, 0) + 1
+        # put_nowait is common between Queue & asyncio.Queue, it does not need to be awaited
+        self.server.queue.put_nowait(path)
         try:
             if path == "/webhook":
                 self.send_response(200)
@@ -208,95 +202,3 @@ def _parse_request_body(self, parsed_path: str, content_len: int) -> Optional[di
             if parsed_path and parsed_path.query:
                 request_body = {k: v[0] for k, v in parse_qs(parsed_path.query).items()}
         return request_body
-
-
-class MockServerThread(threading.Thread):
-    def __init__(self, queue: Queue, test: TestCase, handler: Type[SimpleHTTPRequestHandler] = MockHandler):
-        threading.Thread.__init__(self)
-        self.handler = handler
-        self.test = test
-        self.queue = queue
-
-    def run(self):
-        self.server = HTTPServer(("localhost", 8888), self.handler)
-        self.server.queue = self.queue
-        self.test.mock_received_requests = self.handler.received_requests
-        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.handler.received_requests = {}
-        with self.server.queue.mutex:
-            del self.server.queue
-        self.server.shutdown()
-        self.join()
-
-
-class ReceivedRequests:
-    def __init__(self, queue: Queue):
-        self.queue = queue
-        self.received_requests = {}
-
-    def get(self, key: str, default: Optional[int] = None) -> Optional[int]:
-        while not self.queue.empty():
-            path = self.queue.get()
-            self.received_requests[path] = self.received_requests.get(path, 0) + 1
-        return self.received_requests.get(key, default)
-
-
-def setup_mock_web_api_server(test: TestCase):
-    test.server_started = threading.Event()
-    test.received_requests = ReceivedRequests(Queue())
-    test.thread = MockServerThread(test.received_requests.queue, test)
-    test.thread.start()
-    test.server_started.wait()
-
-
-def cleanup_mock_web_api_server(test: TestCase):
-    test.thread.stop()
-    test.thread = None
-
-
-def assert_received_request_count(test: TestCase, path: str, min_count: int, timeout: float = 1):
-    start_time = time.time()
-    error = None
-    while time.time() - start_time < timeout:
-        try:
-            assert test.received_requests.get(path, 0) == min_count
-            return
-        except Exception as e:
-            error = e
-            # waiting for some requests to be received
-            time.sleep(0.05)
-
-    if error is not None:
-        raise error
-
-
-def assert_auth_test_count(test: TestCase, expected_count: int):
-    assert_received_request_count(test, "/auth.test", expected_count, 0.5)
-
-
-async def assert_auth_test_count_async(test: TestCase, expected_count: int):
-    await asyncio.sleep(0.1)
-    retry_count = 0
-    error = None
-    while retry_count < 3:
-        try:
-            test.mock_received_requests.get("/auth.test", 0) == expected_count
-            break
-        except Exception as e:
-            error = e
-            retry_count += 1
-            # waiting for mock_received_requests updates
-            await asyncio.sleep(0.1)
-
-    if error is not None:
-        raise error

tests/mock_web_api_server/mock_server_thread.py

@@ -0,0 +1,42 @@
+import asyncio
+import threading
+from http.server import HTTPServer, SimpleHTTPRequestHandler
+from queue import Queue
+from typing import Type, Union
+from unittest import TestCase
+
+from .mock_handler import MockHandler
+
+
+class MockServerThread(threading.Thread):
+    def __init__(
+        self, queue: Union[Queue, asyncio.Queue], test: TestCase, handler: Type[SimpleHTTPRequestHandler] = MockHandler
+    ):
+        threading.Thread.__init__(self)
+        self.handler = handler
+        self.test = test
+        self.queue = queue
+
+    def run(self):
+        self.server = HTTPServer(("localhost", 8888), self.handler)
+        self.server.queue = self.queue
+        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):
+        with self.server.queue.mutex:
+            del self.server.queue
+        self.server.shutdown()
+        self.join()
+
+    def stop_unsafe(self):
+        del self.server.queue
+        self.server.shutdown()
+        self.join()

tests/mock_web_api_server/received_requests.py

@@ -0,0 +1,21 @@
+import asyncio
+from queue import Queue
+from typing import Optional, Union
+
+
+class ReceivedRequests:
+    def __init__(self, queue: Union[Queue, asyncio.Queue]):
+        self.queue = queue
+        self.received_requests = {}
+
+    def get(self, key: str, default: Optional[int] = None) -> Optional[int]:
+        while not self.queue.empty():
+            path = self.queue.get()
+            self.received_requests[path] = self.received_requests.get(path, 0) + 1
+        return self.received_requests.get(key, default)
+
+    async def get_async(self, key: str, default: Optional[int] = None) -> Optional[int]:
+        while not self.queue.empty():
+            path = await self.queue.get()
+            self.received_requests[path] = self.received_requests.get(path, 0) + 1
+        return self.received_requests.get(key, default)

tests/scenario_tests_async/test_app.py

@@ -16,8 +16,8 @@
 from slack_bolt.oauth.async_oauth_settings import AsyncOAuthSettings
 from slack_bolt.request.async_request import AsyncBoltRequest
 from tests.mock_web_api_server import (
-    setup_mock_web_api_server,
-    cleanup_mock_web_api_server,
+    cleanup_mock_web_api_server_async,
+    setup_mock_web_api_server_async,
 )
 from tests.utils import remove_os_env_temporarily, restore_os_env, get_event_loop
 
@@ -31,11 +31,11 @@ class TestAsyncApp:
     def event_loop(self):
         old_os_env = remove_os_env_temporarily()
         try:
-            setup_mock_web_api_server(self)
+            setup_mock_web_api_server_async(self)
             loop = get_event_loop()
             yield loop
             loop.close()
-            cleanup_mock_web_api_server(self)
+            cleanup_mock_web_api_server_async(self)
         finally:
             restore_os_env(old_os_env)
 

tests/scenario_tests_async/test_app_actor_user_token.py

@@ -1,4 +1,3 @@
-import asyncio
 import datetime
 import json
 import logging
@@ -19,9 +18,10 @@
 from slack_bolt.oauth.async_oauth_settings import AsyncOAuthSettings
 from slack_bolt.request.async_request import AsyncBoltRequest
 from tests.mock_web_api_server import (
-    setup_mock_web_api_server,
-    cleanup_mock_web_api_server,
+    assert_received_request_count_async,
+    cleanup_mock_web_api_server_async,
     assert_auth_test_count_async,
+    setup_mock_web_api_server_async,
 )
 from tests.utils import remove_os_env_temporarily, restore_os_env, get_event_loop
 
@@ -40,11 +40,11 @@ class TestApp:
     def event_loop(self):
         old_os_env = remove_os_env_temporarily()
         try:
-            setup_mock_web_api_server(self)
+            setup_mock_web_api_server_async(self)
             loop = get_event_loop()
             yield loop
             loop.close()
-            cleanup_mock_web_api_server(self)
+            cleanup_mock_web_api_server_async(self)
         finally:
             restore_os_env(old_os_env)
 
@@ -128,9 +128,8 @@ async def handle_events(context: AsyncBoltContext, say: AsyncSay):
         request = self.build_request()
         response = await app.async_dispatch(request)
         assert response.status == 200
-        await assert_auth_test_count_async(self, 1)
-        await asyncio.sleep(1)  # wait a bit after auto ack()
-        assert self.mock_received_requests["/chat.postMessage"] == 1
+        await assert_auth_test_count_async(self, 2)
+        await assert_received_request_count_async(self, "/chat.postMessage", 1)
 
     @pytest.mark.asyncio
     async def test_authorize_result_no_user_token(self):
@@ -164,8 +163,7 @@ async def handle_events(context: AsyncBoltContext, say: AsyncSay):
         response = await app.async_dispatch(request)
         assert response.status == 200
         await assert_auth_test_count_async(self, 1)
-        await asyncio.sleep(1)  # wait a bit after auto ack()
-        assert self.mock_received_requests["/chat.postMessage"] == 1
+        await assert_received_request_count_async(self, "/chat.postMessage", 1)
 
 
 class MemoryInstallationStore(AsyncInstallationStore):