test: improve the mock serve experience

Author: WilliamBergamin

.github/workflows/ci-build.yml

@@ -3,7 +3,7 @@ name: CI Build
 
 on:
   push:
-    branches: [ main ]
+    branches: [main]
   pull_request:
 
 jobs:
@@ -15,47 +15,46 @@ jobs:
       fail-fast: false
       matrix:
         python-version:
-          - '3.12'
-          - '3.11'
-          - '3.10'
-          - '3.9'
-          - '3.8'
-          - '3.7'
-          - '3.6'
-          - 'pypy3.10'
+          - "3.12"
+          - "3.11"
+          - "3.10"
+          - "3.9"
+          - "3.8"
+          - "3.7"
+          - "3.6"
+          - "pypy3.10"
     env:
-      PYTHON_SLACK_SDK_MOCK_SERVER_MODE: 'threading'
-      CI_LARGE_SOCKET_MODE_PAYLOAD_TESTING_DISABLED: '1'
-      CI_UNSTABLE_TESTS_SKIP_ENABLED: '1'
-      FORCE_COLOR: '1'
+      CI_LARGE_SOCKET_MODE_PAYLOAD_TESTING_DISABLED: "1"
+      CI_UNSTABLE_TESTS_SKIP_ENABLED: "1"
+      FORCE_COLOR: "1"
     steps:
-    - uses: actions/checkout@v4
-    - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v5
-      with:
-        python-version: ${{ matrix.python-version }}
-        cache: pip
-    - name: Install dependencies
-      run: |
-        pip install -U pip setuptools wheel
-        pip install -r requirements/testing.txt
-        pip install -r requirements/optional.txt
-    - name: Run codegen
-      run: |
-        python setup.py codegen
-    - name: Run validation (black/flake8/pytest)
-      run: |
-        python setup.py validate
-    - name: Run tests for SQLAlchemy v1.4 (backward-compatibility)
-      run: |
-        # Install v1.4 for testing
-        pip install "SQLAlchemy>=1.4,<2"
-        python setup.py unit_tests --test-target tests/slack_sdk/oauth/installation_store/test_sqlalchemy.py && \
-        python setup.py unit_tests --test-target tests/slack_sdk/oauth/state_store/test_sqlalchemy.py
-    - name: Run codecov (only 3.9)
-      if: startsWith(matrix.python-version, '3.9')
-      uses: codecov/codecov-action@v4
-      with:
-        token: ${{ secrets.CODECOV_TOKEN }}
-        # python setup.py validate generates the coverage file
-        files: ./coverage.xml
+      - uses: actions/checkout@v4
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: pip
+      - name: Install dependencies
+        run: |
+          pip install -U pip setuptools wheel
+          pip install -r requirements/testing.txt
+          pip install -r requirements/optional.txt
+      - name: Run codegen
+        run: |
+          python setup.py codegen
+      - name: Run validation (black/flake8/pytest)
+        run: |
+          python setup.py validate
+      - name: Run tests for SQLAlchemy v1.4 (backward-compatibility)
+        run: |
+          # Install v1.4 for testing
+          pip install "SQLAlchemy>=1.4,<2"
+          python setup.py unit_tests --test-target tests/slack_sdk/oauth/installation_store/test_sqlalchemy.py && \
+          python setup.py unit_tests --test-target tests/slack_sdk/oauth/state_store/test_sqlalchemy.py
+      - name: Run codecov (only 3.9)
+        if: startsWith(matrix.python-version, '3.9')
+        uses: codecov/codecov-action@v4
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          # python setup.py validate generates the coverage file
+          files: ./coverage.xml

tests/helpers.py

@@ -26,20 +26,5 @@ def restore_os_env(old_env: dict) -> None:
     os.environ.update(old_env)
 
 
-def get_mock_server_mode() -> str:
-    """Returns a str representing the mode.
-
-    :return: threading/multiprocessing
-    """
-    mode = os.environ.get("PYTHON_SLACK_SDK_MOCK_SERVER_MODE")
-    if mode is None:
-        # We used to use "multiprocessing"" for macOS until Big Sur 11.1
-        # Since 11.1, the "multiprocessing" mode started failing a lot...
-        # Therefore, we switched the default mode back to "threading".
-        return "threading"
-    else:
-        return mode
-
-
 def is_ci_unstable_test_skip_enabled() -> bool:
     return os.environ.get("CI_UNSTABLE_TESTS_SKIP_ENABLED") == "1"

tests/mock_web_api_server/__init__.py

@@ -0,0 +1,87 @@
+import asyncio
+from http.server import SimpleHTTPRequestHandler
+from queue import Queue
+import threading
+import time
+from typing import Type
+from unittest import TestCase
+
+from tests.mock_web_api_server.received_requests import ReceivedRequests
+from tests.mock_web_api_server.mock_server_thread import MockServerThread
+
+
+def setup_mock_web_api_server(test: TestCase, handler: Type[SimpleHTTPRequestHandler], port: int = 8888):
+    test.server_started = threading.Event()
+    test.received_requests = ReceivedRequests(Queue())
+    test.thread = MockServerThread(queue=test.received_requests.queue, test=test, handler=handler, port=port)
+    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, handler: Type[SimpleHTTPRequestHandler], port: int = 8888):
+    test.server_started = threading.Event()
+    test.received_requests = ReceivedRequests(asyncio.Queue())
+    test.thread = MockServerThread(queue=test.received_requests.queue, test=test, handler=handler, port=port)
+    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/mock_server_thread.py

@@ -0,0 +1,41 @@
+from asyncio import Queue
+import asyncio
+from http.server import HTTPServer, SimpleHTTPRequestHandler
+import threading
+from typing import Type, Union
+from unittest import TestCase
+
+
+class MockServerThread(threading.Thread):
+    def __init__(
+        self, queue: Union[Queue, asyncio.Queue], test: TestCase, handler: Type[SimpleHTTPRequestHandler], port: int = 8888
+    ):
+        threading.Thread.__init__(self)
+        self.handler = handler
+        self.test = test
+        self.queue = queue
+        self.port = port
+
+    def run(self):
+        self.server = HTTPServer(("localhost", self.port), self.handler)
+        self.server.queue = self.queue
+        self.test.server_url = f"http://localhost:{str(self.port)}"
+        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: dict = {}
+
+    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)