make the tests work

Author: WilliamBergamin

tests/helpers.py

@@ -1,7 +1,9 @@
 import asyncio
 import os
+from queue import Queue
 import sys
 from types import ModuleType
+from typing import Optional, Union
 
 
 def async_test(coro):
@@ -47,17 +49,19 @@ def is_ci_unstable_test_skip_enabled() -> bool:
     return os.environ.get("CI_UNSTABLE_TESTS_SKIP_ENABLED") == "1"
 
 
-def reload_module(root_module: ModuleType):
-    package_name = root_module.__name__
-    loaded_package_modules = {
-        key: value for key, value in sys.modules.items() if key.startswith(package_name) and isinstance(value, ModuleType)
-    }
+class ReceivedRequests:
+    def __init__(self, queue: Union[Queue, asyncio.Queue]):
+        self.queue = queue
+        self.received_requests: dict = {}
 
-    for key in loaded_package_modules:
-        del sys.modules[key]
+    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)
 
-    for key in loaded_package_modules:
-        new_module = __import__(key)
-        old_module = loaded_package_modules[key]
-        old_module.__dict__.clear()
-        old_module.__dict__.update(new_module.__dict__)
+    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/slack_sdk/web/mock_web_api_server.py

@@ -8,12 +8,13 @@
 from http import HTTPStatus
 from http.server import HTTPServer, SimpleHTTPRequestHandler
 from multiprocessing.context import Process
-from typing import Type
+from queue import Queue
+from typing import Type, Union
 from unittest import TestCase
-from urllib.parse import urlparse, parse_qs
+from urllib.parse import parse_qs, urlparse
 from urllib.request import Request, urlopen
 
-from tests.helpers import get_mock_server_mode
+from tests.helpers import ReceivedRequests, get_mock_server_mode
 
 
 class MockHandler(SimpleHTTPRequestHandler):
@@ -78,6 +79,8 @@ def set_common_headers(self):
 
     def _handle(self):
         try:
+            # put_nowait is common between Queue & asyncio.Queue, it does not need to be awaited
+            self.server.queue.put_nowait(self.path)
             if self.path == "/received_requests.json":
                 self.send_response(200)
                 self.set_common_headers()
@@ -313,32 +316,44 @@ def stop(self):
 
 
 class MockServerThread(threading.Thread):
-    def __init__(self, test: TestCase, handler: Type[SimpleHTTPRequestHandler] = MockHandler):
+    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()
+            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()
 
 
 def setup_mock_web_api_server(test: TestCase):
     if get_mock_server_mode() == "threading":
         test.server_started = threading.Event()
-        test.thread = MockServerThread(test)
+        test.received_requests = ReceivedRequests(Queue())
+        test.thread = MockServerThread(test.received_requests.queue, test)
         test.thread.start()
         test.server_started.wait()
     else:
@@ -389,37 +404,65 @@ def cleanup_mock_web_api_server(test: TestCase):
         test.process = None
 
 
-def assert_auth_test_count(test: TestCase, expected_count: int):
-    time.sleep(0.1)
-    retry_count = 0
+def assert_received_request_count(test: TestCase, path: str, min_count: int, timeout: float = 1):
+    start_time = time.time()
     error = None
-    while retry_count < 3:
+    while time.time() - start_time < timeout:
         try:
-            test.mock_received_requests["/auth.test"] == expected_count
-            break
+            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
-            retry_count += 1
-            # waiting for mock_received_requests updates
-            time.sleep(0.1)
+            # waiting for some requests to be received
+            time.sleep(0.05)
 
     if error is not None:
         raise error
 
 
-async def assert_auth_test_count_async(test: TestCase, expected_count: int):
-    await asyncio.sleep(0.1)
-    retry_count = 0
+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 retry_count < 3:
+    while time.time() - start_time < timeout:
         try:
-            test.mock_received_requests["/auth.test"] == expected_count
-            break
+            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
-            retry_count += 1
             # waiting for mock_received_requests updates
-            await asyncio.sleep(0.1)
+            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/slack_sdk/web/test_legacy_web_client_url_format.py

@@ -0,0 +1,38 @@
+from unittest import TestCase
+
+from slack_sdk.web.legacy_client import LegacyWebClient
+from tests.slack_sdk.web.mock_web_api_server import (
+    assert_received_request_count,
+    cleanup_mock_web_api_server,
+    setup_mock_web_api_server,
+)
+
+
+class TestLegacyWebClientUrlFormat(TestCase):
+    def setUp(self):
+        setup_mock_web_api_server(self)
+        self.client = LegacyWebClient(token="xoxb-api_test", base_url="http://localhost:8888")
+        self.client_base_url_slash = LegacyWebClient(token="xoxb-api_test", base_url="http://localhost:8888/")
+
+    def tearDown(self):
+        cleanup_mock_web_api_server(self)
+
+    def test_base_url_without_slash_api_method_without_slash(self):
+        self.client.api_call("chat.postMessage")
+        assert_received_request_count(self, "/chat.postMessage", 1)
+
+    def test_base_url_without_slash_api_method_with_slash(self):
+        self.client.api_call("/chat.postMessage")
+        assert_received_request_count(self, "/chat.postMessage", 1)
+
+    def test_base_url_with_slash_api_method_without_slash(self):
+        self.client_base_url_slash.api_call("chat.postMessage")
+        assert_received_request_count(self, "/chat.postMessage", 1)
+
+    def test_base_url_with_slash_api_method_with_slash(self):
+        self.client_base_url_slash.api_call("/chat.postMessage")
+        assert_received_request_count(self, "/chat.postMessage", 1)
+
+    def test_base_url_without_slash_api_method_with_slash_and_trailing_slash(self):
+        self.client.api_call("/chat.postMessage/")
+        assert_received_request_count(self, "/chat.postMessage/", 1)

tests/slack_sdk/web/test_web_client_url_format.py

@@ -1,64 +1,38 @@
 from unittest import TestCase
-from unittest.mock import patch
-from urllib import request
-from urllib.request import Request, urlopen
 
-import slack_sdk.web
-from tests.helpers import reload_module
+from slack_sdk.web import WebClient
 from tests.slack_sdk.web.mock_web_api_server import (
-    setup_mock_web_api_server,
+    assert_received_request_count,
     cleanup_mock_web_api_server,
+    setup_mock_web_api_server,
 )
 
 
-def build_spy_urlopen(test: TestCase):
-    def spy_urlopen(*args, **kwargs):
-        test.urlopen_spy_args = args
-        test.urlopen_spy_kwargs = kwargs
-        return urlopen(*args, **kwargs)
-
-    return spy_urlopen
-
-
 class TestWebClientUrlFormat(TestCase):
     def setUp(self):
         setup_mock_web_api_server(self)
-        with patch.object(request, "urlopen") as mock_urlopen:
-            mock_urlopen.side_effect = build_spy_urlopen(self)
-            reload_module(slack_sdk.web)
-        self.client = slack_sdk.web.WebClient(token="xoxb-api_test", base_url="http://localhost:8888")
-        self.client_base_url_slash = slack_sdk.web.WebClient(token="xoxb-api_test", base_url="http://localhost:8888/")
+        self.client = WebClient(token="xoxb-api_test", base_url="http://localhost:8888")
+        self.client_base_url_slash = WebClient(token="xoxb-api_test", base_url="http://localhost:8888/")
 
     def tearDown(self):
         cleanup_mock_web_api_server(self)
-        self.urlopen_spy_args = None
-        self.urlopen_spy_kwargs = None
-
-    @classmethod
-    def tearDownClass(cls):
-        reload_module(slack_sdk.web)
 
     def test_base_url_without_slash_api_method_without_slash(self):
-        self.client.api_call("api.test")
-        self.assertIsInstance(self.urlopen_spy_args[0], Request)
-        self.assertEqual(self.urlopen_spy_args[0].full_url, "http://localhost:8888/api.test")
+        self.client.api_call("chat.postMessage")
+        assert_received_request_count(self, "/chat.postMessage", 1)
 
     def test_base_url_without_slash_api_method_with_slash(self):
-        self.client.api_call("/api.test")
-        self.assertIsInstance(self.urlopen_spy_args[0], Request)
-        self.assertEqual(self.urlopen_spy_args[0].full_url, "http://localhost:8888/api.test")
+        self.client.api_call("/chat.postMessage")
+        assert_received_request_count(self, "/chat.postMessage", 1)
 
     def test_base_url_with_slash_api_method_without_slash(self):
-        self.client_base_url_slash.api_call("api.test")
-        self.assertIsInstance(self.urlopen_spy_args[0], Request)
-        self.assertEqual(self.urlopen_spy_args[0].full_url, "http://localhost:8888/api.test")
+        self.client_base_url_slash.api_call("chat.postMessage")
+        assert_received_request_count(self, "/chat.postMessage", 1)
 
     def test_base_url_with_slash_api_method_with_slash(self):
-        self.client_base_url_slash.api_call("/api.test")
-        self.assertIsInstance(self.urlopen_spy_args[0], Request)
-        self.assertEqual(self.urlopen_spy_args[0].full_url, "http://localhost:8888/api.test")
+        self.client_base_url_slash.api_call("/chat.postMessage")
+        assert_received_request_count(self, "/chat.postMessage", 1)
 
     def test_base_url_without_slash_api_method_with_slash_and_trailing_slash(self):
-        self.client.api_call("/api.test/")
-        self.assertIsInstance(self.urlopen_spy_args[0], Request)
-        self.assertEqual(self.urlopen_spy_args[0].full_url, "http://localhost:8888/api.test/")
+        self.client.api_call("/chat.postMessage/")
+        assert_received_request_count(self, "/chat.postMessage/", 1)