Reduce sync/async test code duplication (#351)

Author: mattgd

tests/conftest.py

@@ -1,72 +1,137 @@
-from typing import Any, Callable, Mapping, Optional
+from typing import (
+    Any,
+    Awaitable,
+    Callable,
+    Literal,
+    Mapping,
+    Optional,
+    Sequence,
+    Tuple,
+    Union,
+    cast,
+)
 from unittest.mock import AsyncMock, MagicMock
 
 import httpx
 import pytest
 
 from tests.utils.client_configuration import ClientConfiguration
 from tests.utils.list_resource import list_data_to_dicts, list_response_of
+from tests.utils.syncify import syncify
+from tests.types.test_auto_pagination_function import TestAutoPaginationFunction
 from workos.types.list_resource import WorkOSListResource
 from workos.utils._base_http_client import DEFAULT_REQUEST_TIMEOUT
 from workos.utils.http_client import AsyncHTTPClient, HTTPClient, SyncHTTPClient
 from workos.utils.request_helper import DEFAULT_LIST_RESPONSE_LIMIT
 
 
-@pytest.fixture
-def sync_http_client_for_test():
-    return SyncHTTPClient(
-        api_key="sk_test",
-        base_url="https://api.workos.test/",
-        client_id="client_b27needthisforssotemxo",
-        version="test",
-    )
-
-
-@pytest.fixture
-def async_http_client_for_test():
-    return AsyncHTTPClient(
-        api_key="sk_test",
-        base_url="https://api.workos.test/",
-        client_id="client_b27needthisforssotemxo",
-        version="test",
-    )
-
-
-@pytest.fixture
-def sync_client_configuration_and_http_client_for_test():
+def _get_test_client_setup(
+    http_client_class_name: str,
+) -> Tuple[Literal["async", "sync"], ClientConfiguration, HTTPClient]:
     base_url = "https://api.workos.test/"
     client_id = "client_b27needthisforssotemxo"
 
+    setup_name = None
+    if http_client_class_name == "AsyncHTTPClient":
+        http_client = AsyncHTTPClient(
+            api_key="sk_test",
+            base_url=base_url,
+            client_id=client_id,
+            version="test",
+        )
+        setup_name = "async"
+    elif http_client_class_name == "SyncHTTPClient":
+        http_client = SyncHTTPClient(
+            api_key="sk_test",
+            base_url=base_url,
+            client_id=client_id,
+            version="test",
+        )
+        setup_name = "sync"
+    else:
+        raise ValueError(
+            f"Invalid HTTP client for test module setup: {http_client_class_name}"
+        )
+
     client_configuration = ClientConfiguration(
         base_url=base_url, client_id=client_id, request_timeout=DEFAULT_REQUEST_TIMEOUT
     )
 
-    http_client = SyncHTTPClient(
-        api_key="sk_test",
-        base_url=base_url,
-        client_id=client_id,
-        version="test",
+    return setup_name, client_configuration, http_client
+
+
+def pytest_configure(config) -> None:
+    config.addinivalue_line(
+        "markers",
+        "sync_and_async(): mark test to run both sync and async module versions",
     )
 
-    return client_configuration, http_client
+
+def pytest_generate_tests(metafunc: pytest.Metafunc):
+    for marker in metafunc.definition.iter_markers(name="sync_and_async"):
+        if marker.name == "sync_and_async":
+            if len(marker.args) == 0:
+                raise ValueError(
+                    "sync_and_async marker requires argument representing list of modules."
+                )
+
+            # Take in args as a list of module classes. For example:
+            # @pytest.mark.sync_and_async(Events, AsyncEvents) -> [Events, AsyncEvents]
+            module_classes = marker.args
+            ids = []
+            arg_values = []
+
+            for module_class in module_classes:
+                if module_class is None:
+                    raise ValueError(
+                        f"Invalid module class for sync_and_async marker: {module_class}"
+                    )
+
+                # Pull the HTTP client type from the module class annotations and use that
+                # to pass in the proper test HTTP client
+                http_client_name = module_class.__annotations__["_http_client"].__name__
+                setup_name, client_configuration, http_client = _get_test_client_setup(
+                    http_client_name
+                )
+
+                class_kwargs: Mapping[str, Any] = {"http_client": http_client}
+                if module_class.__init__.__annotations__.get(
+                    "client_configuration", None
+                ):
+                    class_kwargs["client_configuration"] = client_configuration
+
+                module_instance = module_class(**class_kwargs)
+
+                ids.append(setup_name)  # sync or async will be the test ID
+                arg_names = ["module_instance"]
+                arg_values.append([module_instance])
+
+            metafunc.parametrize(
+                argnames=arg_names, argvalues=arg_values, ids=ids, scope="class"
+            )
 
 
 @pytest.fixture
-def async_client_configuration_and_http_client_for_test():
-    base_url = "https://api.workos.test/"
-    client_id = "client_b27needthisforssotemxo"
+def sync_http_client_for_test():
+    _, _, http_client = _get_test_client_setup("SyncHTTPClient")
+    return http_client
 
-    client_configuration = ClientConfiguration(
-        base_url=base_url, client_id=client_id, request_timeout=DEFAULT_REQUEST_TIMEOUT
-    )
 
-    http_client = AsyncHTTPClient(
-        api_key="sk_test",
-        base_url=base_url,
-        client_id=client_id,
-        version="test",
-    )
+@pytest.fixture
+def async_http_client_for_test():
+    _, _, http_client = _get_test_client_setup("AsyncHTTPClient")
+    return http_client
+
 
+@pytest.fixture
+def sync_client_configuration_and_http_client_for_test():
+    _, client_configuration, http_client = _get_test_client_setup("SyncHTTPClient")
+    return client_configuration, http_client
+
+
+@pytest.fixture
+def async_client_configuration_and_http_client_for_test():
+    _, client_configuration, http_client = _get_test_client_setup("AsyncHTTPClient")
     return client_configuration, http_client
 
 
@@ -177,24 +242,62 @@ def mock_function(*args, **kwargs):
 
 
 @pytest.fixture
-def test_sync_auto_pagination(capture_and_mock_pagination_request_for_http_client):
-    def inner(
-        http_client: SyncHTTPClient,
+def test_auto_pagination(
+    capture_and_mock_pagination_request_for_http_client,
+) -> TestAutoPaginationFunction:
+    def _iterate_results_sync(
         list_function: Callable[[], WorkOSListResource],
+        list_function_params: Optional[Mapping[str, Any]] = None,
+    ) -> Sequence[Any]:
+        results = list_function(**list_function_params or {})
+        all_results = []
+
+        for result in results:
+            all_results.append(result)
+
+        return all_results
+
+    async def _iterate_results_async(
+        list_function: Callable[[], Awaitable[WorkOSListResource]],
+        list_function_params: Optional[Mapping[str, Any]] = None,
+    ) -> Sequence[Any]:
+        results = await list_function(**list_function_params or {})
+        all_results = []
+
+        async for result in results:
+            all_results.append(result)
+
+        return all_results
+
+    def inner(
+        http_client: HTTPClient,
+        list_function: Union[
+            Callable[[], WorkOSListResource],
+            Callable[[], Awaitable[WorkOSListResource]],
+        ],
         expected_all_page_data: dict,
         list_function_params: Optional[Mapping[str, Any]] = None,
-    ):
+        url_path_keys: Optional[Sequence[str]] = None,
+    ) -> None:
         request_kwargs = capture_and_mock_pagination_request_for_http_client(
             http_client=http_client,
             data_list=expected_all_page_data,
             status_code=200,
         )
 
-        results = list_function(**list_function_params or {})
         all_results = []
-
-        for result in results:
-            all_results.append(result)
+        if isinstance(http_client, AsyncHTTPClient):
+            all_results = syncify(
+                _iterate_results_async(
+                    cast(Callable[[], Awaitable[WorkOSListResource]], list_function),
+                    list_function_params,
+                )
+            )
+        else:
+            all_results = _iterate_results_sync(
+                cast(Callable[[], WorkOSListResource], list_function),
+                list_function_params,
+            )
 
         assert len(list(all_results)) == len(expected_all_page_data)
         assert (list_data_to_dicts(all_results)) == expected_all_page_data
@@ -207,6 +310,7 @@ def inner(
 
         params = list_function_params or {}
         for param in params:
-            assert request_kwargs["params"][param] == params[param]
+            if url_path_keys is not None and param not in url_path_keys:
+                assert request_kwargs["params"][param] == params[param]
 
     return inner

tests/test_directory_sync.py

@@ -1,10 +1,11 @@
 import pytest
 
+from tests.types.test_auto_pagination_function import TestAutoPaginationFunction
 from tests.utils.list_resource import list_data_to_dicts, list_response_of
-from workos.directory_sync import AsyncDirectorySync, DirectorySync
 from tests.utils.fixtures.mock_directory import MockDirectory
 from tests.utils.fixtures.mock_directory_user import MockDirectoryUser
 from tests.utils.fixtures.mock_directory_group import MockDirectoryGroup
+from workos.directory_sync import AsyncDirectorySync, DirectorySync
 
 
 def api_directory_to_sdk(directory):
@@ -295,27 +296,33 @@ def test_primary_email_none(
         assert me == None
 
     def test_list_directories_auto_pagination(
-        self, mock_directories_multiple_data_pages, test_sync_auto_pagination
+        self,
+        mock_directories_multiple_data_pages,
+        test_auto_pagination: TestAutoPaginationFunction,
     ):
-        test_sync_auto_pagination(
+        test_auto_pagination(
             http_client=self.http_client,
             list_function=self.directory_sync.list_directories,
             expected_all_page_data=mock_directories_multiple_data_pages,
         )
 
     def test_directory_users_auto_pagination(
-        self, mock_directory_users_multiple_data_pages, test_sync_auto_pagination
+        self,
+        mock_directory_users_multiple_data_pages,
+        test_auto_pagination: TestAutoPaginationFunction,
     ):
-        test_sync_auto_pagination(
+        test_auto_pagination(
             http_client=self.http_client,
             list_function=self.directory_sync.list_users,
             expected_all_page_data=mock_directory_users_multiple_data_pages,
         )
 
     def test_directory_user_groups_auto_pagination(
-        self, mock_directory_groups_multiple_data_pages, test_sync_auto_pagination
+        self,
+        mock_directory_groups_multiple_data_pages,
+        test_auto_pagination: TestAutoPaginationFunction,
     ):
-        test_sync_auto_pagination(
+        test_auto_pagination(
             http_client=self.http_client,
             list_function=self.directory_sync.list_groups,
             expected_all_page_data=mock_directory_groups_multiple_data_pages,

tests/test_events.py

@@ -1,15 +1,13 @@
+from typing import Union
 import pytest
 
 from tests.utils.fixtures.mock_event import MockEvent
-from workos.events import AsyncEvents, Events
+from tests.utils.syncify import syncify
+from workos.events import AsyncEvents, Events, EventsListResource
 
 
+@pytest.mark.sync_and_async(Events, AsyncEvents)
 class TestEvents(object):
-    @pytest.fixture(autouse=True)
-    def setup(self, sync_http_client_for_test):
-        self.http_client = sync_http_client_for_test
-        self.events = Events(http_client=self.http_client)
-
     @pytest.fixture
     def mock_events(self):
         events = [MockEvent(id=str(i)).dict() for i in range(10)]
@@ -22,49 +20,22 @@ def mock_events(self):
             },
         }
 
-    def test_list_events(self, mock_events, capture_and_mock_http_client_request):
+    def test_list_events(
+        self,
+        module_instance: Union[Events, AsyncEvents],
+        mock_events: EventsListResource,
+        capture_and_mock_http_client_request,
+    ):
         request_kwargs = capture_and_mock_http_client_request(
-            http_client=self.http_client,
+            http_client=module_instance._http_client,
             status_code=200,
             response_dict=mock_events,
         )
 
-        events = self.events.list_events(events=["dsync.activated"])
-
-        assert request_kwargs["url"].endswith("/events")
-        assert request_kwargs["method"] == "get"
-        assert request_kwargs["params"] == {"events": ["dsync.activated"], "limit": 10}
-        assert events.dict() == mock_events
-
-
-@pytest.mark.asyncio
-class TestAsyncEvents(object):
-    @pytest.fixture(autouse=True)
-    def setup(self, async_http_client_for_test):
-        self.http_client = async_http_client_for_test
-        self.events = AsyncEvents(http_client=self.http_client)
-
-    @pytest.fixture
-    def mock_events(self):
-        events = [MockEvent(id=str(i)).dict() for i in range(10)]
-
-        return {
-            "object": "list",
-            "data": events,
-            "list_metadata": {
-                "after": None,
-            },
-        }
-
-    async def test_list_events(self, mock_events, capture_and_mock_http_client_request):
-        request_kwargs = capture_and_mock_http_client_request(
-            http_client=self.http_client,
-            status_code=200,
-            response_dict=mock_events,
+        events: EventsListResource = syncify(
+            module_instance.list_events(events=["dsync.activated"])
         )
 
-        events = await self.events.list_events(events=["dsync.activated"])
-
         assert request_kwargs["url"].endswith("/events")
         assert request_kwargs["method"] == "get"
         assert request_kwargs["params"] == {"events": ["dsync.activated"], "limit": 10}