test: Restructure parity guard with pytest.param to satisfy mypy

Author: jsonbailey

ld_eventsource/testing/test_sync_async_parity.py

@@ -20,63 +20,38 @@
                                                     ConnectStrategy)
 from ld_eventsource.sse_client import SSEClient
 
-# Each entry pairs a public synchronous class with its asynchronous counterpart, plus
-# allowlists of names that are intentionally present on only one side. Every allowlisted
-# name must carry a justification; if the test flags a genuinely one-sided member, add it
-# here with a comment rather than weakening the comparison.
-_PAIRS = [
-    {
-        "sync": SSEClient,
-        "async": AsyncSSEClient,
-        # Names allowed to exist only on the sync class.
-        "sync_only": set(),
-        # Names allowed to exist only on the async class.
-        "async_only": set(),
-    },
-    {
-        "sync": ConnectStrategy,
-        "async": AsyncConnectStrategy,
-        "sync_only": set(),
-        "async_only": set(),
-    },
-    {
-        "sync": ConnectionClient,
-        "async": AsyncConnectionClient,
-        "sync_only": set(),
-        "async_only": set(),
-    },
-    {
-        "sync": ConnectionResult,
-        "async": AsyncConnectionResult,
-        "sync_only": set(),
-        "async_only": set(),
-    },
-]
-
 
 def _public_names(cls):
     return {name for name in dir(cls) if not name.startswith("_")} - set(dir(object))
 
 
+# Each param pairs a public synchronous class with its asynchronous counterpart, plus
+# allowlists of names intentionally present on only one side. Every allowlisted name must
+# carry a justification; if the test flags a genuinely one-sided member, add it here with a
+# comment rather than weakening the comparison.
 @pytest.mark.parametrize(
-    "pair",
-    _PAIRS,
-    ids=[f"{p['sync'].__name__}/{p['async'].__name__}" for p in _PAIRS],
+    "sync_cls, async_cls, sync_only, async_only",
+    [
+        pytest.param(SSEClient, AsyncSSEClient, set(), set(), id="SSEClient/AsyncSSEClient"),
+        pytest.param(ConnectStrategy, AsyncConnectStrategy, set(), set(), id="ConnectStrategy/AsyncConnectStrategy"),
+        pytest.param(ConnectionClient, AsyncConnectionClient, set(), set(), id="ConnectionClient/AsyncConnectionClient"),
+        pytest.param(ConnectionResult, AsyncConnectionResult, set(), set(), id="ConnectionResult/AsyncConnectionResult"),
+    ],
 )
-def test_sync_async_public_surface_matches(pair):
-    sync_names = _public_names(pair["sync"])
-    async_names = _public_names(pair["async"])
+def test_sync_async_public_surface_matches(sync_cls, async_cls, sync_only, async_only):
+    sync_names = _public_names(sync_cls)
+    async_names = _public_names(async_cls)
 
-    sync_only = sync_names - async_names - pair["sync_only"]
-    async_only = async_names - sync_names - pair["async_only"]
+    sync_only_diff = sync_names - async_names - sync_only
+    async_only_diff = async_names - sync_names - async_only
 
-    assert not sync_only, (
-        f"{pair['sync'].__name__} exposes public names with no counterpart on "
-        f"{pair['async'].__name__}: {sorted(sync_only)}. Add the missing member to the "
+    assert not sync_only_diff, (
+        f"{sync_cls.__name__} exposes public names with no counterpart on "
+        f"{async_cls.__name__}: {sorted(sync_only_diff)}. Add the missing member to the "
         f"async class, or allowlist it in 'sync_only' with a justification."
     )
-    assert not async_only, (
-        f"{pair['async'].__name__} exposes public names with no counterpart on "
-        f"{pair['sync'].__name__}: {sorted(async_only)}. Add the missing member to the "
+    assert not async_only_diff, (
+        f"{async_cls.__name__} exposes public names with no counterpart on "
+        f"{sync_cls.__name__}: {sorted(async_only_diff)}. Add the missing member to the "
         f"sync class, or allowlist it in 'async_only' with a justification."
     )