fix: own and close pytest-asyncio's "old loop" instead of suppressing the leak

Reverts the previous PytestUnraisableExceptionWarning suppression. Tracemalloc
identified the source as pytest-asyncio's `_temporary_event_loop_policy`
(plugin.py:618) calling `asyncio.get_event_loop()` to capture the "old" loop
— which creates a fresh loop (with a backing socketpair) when no loop is
current and never closes it. Three sub-exceptions per session: two for the
socketpair fds, one for the loop itself.

Workspace-root conftest now pre-creates and registers an event loop, then
closes it (and any loop pytest-asyncio swapped in) in a session finalizer.
The capture call finds our loop instead of conjuring a new one.

filterwarnings = ["error"] stays strict — no warning suppression.

Author: OmarAlJarrah

conftest.py

@@ -0,0 +1,43 @@
+"""Workspace-root conftest for the dexpace SDK test suite.
+
+Sole purpose right now: own and close an event loop on behalf of
+``pytest-asyncio``'s ``_temporary_event_loop_policy`` fixture (plugin.py:618),
+which calls ``asyncio.get_event_loop()`` to capture the "old" loop, gets a
+freshly-created one back when no loop is current, and never closes it. The
+leftover loop (and the socket pair backing its self-pipe) escalates as a
+``PytestUnraisableExceptionWarning`` under our ``filterwarnings = ["error"]``
+gate.
+
+Pre-creating and registering an event loop here means that capture call
+finds *our* loop instead of conjuring a new one, and the session finalizer
+closes it deterministically.
+
+Tracked upstream in pytest-asyncio; this conftest can go away once a fix
+ships.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Iterator
+
+import pytest
+
+
+@pytest.fixture(scope="session", autouse=True)
+def _own_default_event_loop() -> Iterator[None]:
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    try:
+        yield
+    finally:
+        # ``pytest_asyncio`` may have replaced the current loop; close
+        # whichever loop the policy currently points at.
+        try:
+            current = asyncio.get_event_loop_policy().get_event_loop()
+        except RuntimeError:
+            current = None
+        for candidate in {loop, current}:
+            if candidate is not None and not candidate.is_closed():
+                candidate.close()
+        asyncio.set_event_loop(None)

pyproject.toml

@@ -43,13 +43,6 @@ asyncio_mode = "auto"
 filterwarnings = [
     "error",
     "ignore::DeprecationWarning:pytest_asyncio.*",
-    # Socketserver-based stub HTTP servers and short-lived asyncio loops in
-    # the transport-adapter test suites occasionally leave sockets / event
-    # loops behind for the GC sweep. The leaks are in test fixtures (not
-    # production code) and surface inconsistently across platforms — Linux
-    # CI sees them every run, macOS sees them sometimes. Suppress the
-    # escalated warning so a clean test run is treated as success.
-    "ignore::pytest.PytestUnraisableExceptionWarning",
 ]
 
 [tool.ruff]