Extend the per-test GC fixture to the SSE and Unicode HTTP test modules

tests/shared/test_sse.py and tests/client/test_http_unicode.py carry the
same scoped MemoryObject*Stream filterwarnings marks as
tests/shared/test_streamable_http.py and had the same gap: the leaked
streams sit in reference cycles, so their deallocator warnings fired at
pytest's session-unconfigure unraisable sweep, exiting 1 after all tests
passed when run without xdist (-n 0). Both files documented this in
their filter-mark comments.

Apply the same autouse fixture that fixed test_streamable_http.py — a
gc.collect() in each test's teardown, where the item-scoped ignores
still apply — and update the comments to describe the fixed behavior.

Verified: -n 0 runs of each file now exit 0 (previously 26 passed/exit 1
and 2 passed/exit 1), and five consecutive default-option runs of both
files together pass.

Author: maxisbey

tests/client/test_http_unicode.py

@@ -5,6 +5,7 @@
 (server→client and client→server) using the streamable HTTP transport.
 """
 
+import gc
 from collections.abc import AsyncIterator, Iterator
 from contextlib import asynccontextmanager
 from typing import Any
@@ -30,17 +31,33 @@
 # run in process; the old subprocess harness never observed them. The interaction suite registers
 # the same two scoped filters globally from tests/interaction/conftest.py (see the comment there),
 # but they only take effect when that package's conftest is loaded; these markers keep the tests
-# themselves passing in isolated runs. Markers are item-scoped, so they cannot cover the GC
-# flush at session cleanup: an isolated run without xdist (`-n 0`) still exits nonzero after all
-# tests pass. The default xdist runs (addopts has `-n auto`) are unaffected, as are full-suite
-# runs, where the interaction conftest's ini-level filters apply. The filters are scoped to
-# anyio's MemoryObject*Stream leak signature so an unrelated leak still fails the suite.
+# themselves passing in isolated runs. Markers are item-scoped, so the autouse
+# `_collect_leaked_streams` fixture below garbage-collects each test's leaks inside its own
+# teardown, where these filters apply; without it, leaks GC'd at session cleanup escape the
+# scoped ignores. The filters are scoped to anyio's MemoryObject*Stream leak signature so an
+# unrelated leak still fails the suite.
 pytestmark = [
     pytest.mark.filterwarnings("ignore:.*MemoryObject(Send|Receive)Stream:pytest.PytestUnraisableExceptionWarning"),
     pytest.mark.filterwarnings("ignore:.*MemoryObject(Send|Receive)Stream:ResourceWarning"),
 ]
 
 
+@pytest.fixture(autouse=True)
+def _collect_leaked_streams() -> Iterator[None]:
+    """Garbage-collect each test's leaked memory streams inside its own teardown.
+
+    The filterwarnings marks above only apply while a test in this file is the
+    active warning context. The leaked streams sit in reference cycles, so without
+    a forced collection their deallocator warnings fire wherever the garbage
+    collector happens to run next: during an unrelated test (failing it, since the
+    global ``filterwarnings = ["error"]`` has no ignore there) or at pytest's
+    session-unconfigure unraisable sweep (exit code 1 after all tests passed when
+    running without xdist, e.g. ``-n 0`` for ``--pdb`` debugging).
+    """
+    yield
+    gc.collect()
+
+
 @pytest.fixture(autouse=True)
 def _reset_sse_starlette_exit_event() -> Iterator[None]:
     """Reset sse-starlette's module-global exit Event around each test.

tests/shared/test_sse.py

@@ -1,5 +1,6 @@
 """Tests for the SSE client and server transports, driven entirely in process."""
 
+import gc
 import json
 from collections.abc import AsyncGenerator, Iterable, Iterator
 from typing import Any
@@ -50,17 +51,33 @@
 # process; the old subprocess harness never observed them. The interaction suite registers the
 # same two scoped filters globally from tests/interaction/conftest.py (see the comment there),
 # but they only take effect when that package's conftest is loaded; these markers keep the tests
-# themselves passing in isolated runs. Markers are item-scoped, so they cannot cover the GC
-# flush at session cleanup: an isolated run without xdist (`-n 0`) still exits nonzero after all
-# tests pass. The default xdist runs (addopts has `-n auto`) are unaffected, as are full-suite
-# runs, where the interaction conftest's ini-level filters apply. The filters are scoped to
-# anyio's MemoryObject*Stream leak signature so an unrelated leak still fails the suite.
+# themselves passing in isolated runs. Markers are item-scoped, so the autouse
+# `_collect_leaked_streams` fixture below garbage-collects each test's leaks inside its own
+# teardown, where these filters apply; without it, leaks GC'd at session cleanup escape the
+# scoped ignores. The filters are scoped to anyio's MemoryObject*Stream leak signature so an
+# unrelated leak still fails the suite.
 pytestmark = [
     pytest.mark.filterwarnings("ignore:.*MemoryObject(Send|Receive)Stream:pytest.PytestUnraisableExceptionWarning"),
     pytest.mark.filterwarnings("ignore:.*MemoryObject(Send|Receive)Stream:ResourceWarning"),
 ]
 
 
+@pytest.fixture(autouse=True)
+def _collect_leaked_streams() -> Iterator[None]:
+    """Garbage-collect each test's leaked memory streams inside its own teardown.
+
+    The filterwarnings marks above only apply while a test in this file is the
+    active warning context. The leaked streams sit in reference cycles, so without
+    a forced collection their deallocator warnings fire wherever the garbage
+    collector happens to run next: during an unrelated test (failing it, since the
+    global ``filterwarnings = ["error"]`` has no ignore there) or at pytest's
+    session-unconfigure unraisable sweep (exit code 1 after all tests passed when
+    running without xdist, e.g. ``-n 0`` for ``--pdb`` debugging).
+    """
+    yield
+    gc.collect()
+
+
 @pytest.fixture(autouse=True)
 def _reset_sse_starlette_exit_event() -> Iterator[None]:
     """Reset sse-starlette's module-global exit Event around each test.