iris: auto-cleanup managed threads in tests via thread_container_scope

Tests that construct Controller but never call controller.stop() were
leaking the log-server uvicorn thread (and other managed threads registered
with the process-wide default ThreadContainer). These non-daemon threads
survived the test and were dumped by pytest_sessionfinish.

Wrap the autouse _thread_cleanup fixture with thread_container_scope() so
every iris test runs with a fresh ThreadContainer that is stopped on
teardown. The container's stop() signals server.should_exit on any
spawn_server threads and joins them. The existing thread-snapshot leak
warning remains as a safety net for threads created outside any container.

Fixes #4871.

Co-authored-by: Russell Power <rjpower@users.noreply.github.com>

Author: github-actions[bot]

lib/iris/tests/conftest.py

@@ -15,6 +15,7 @@
 
 import pytest
 from iris.cluster.config import load_config, make_local_config
+from iris.managed_thread import thread_container_scope
 from iris.rpc import config_pb2
 from iris.test_util import SentinelFile
 from rigging.timing import Duration, ExponentialBackoff
@@ -107,18 +108,22 @@ def sentinel(tmp_path) -> SentinelFile:
 
 
 @pytest.fixture(autouse=True)
-def _thread_cleanup():
-    """Ensure no new non-daemon threads leak from each test.
-
-    Takes a snapshot of threads before the test and checks that no new
-    non-daemon threads remain after teardown. Waits briefly for threads
-    that are in the process of shutting down.
-
-    This fixture helps catch tests that don't properly clean up their threads,
-    which can cause tests to hang or interfere with each other.
+def _thread_cleanup(request):
+    """Isolate each test's managed threads and warn on leaks.
+
+    Installs a fresh ThreadContainer via thread_container_scope() so every
+    component that calls get_thread_container() (e.g. Controller._start_local_log_server)
+    registers its threads into a per-test container that is stopped on teardown.
+    This ensures log-server uvicorn threads and other managed threads are joined
+    even when a test constructs a Controller without calling stop().
+
+    As a safety net, takes a snapshot of threads before the test and warns
+    about any non-daemon threads created outside any container that survive
+    teardown.
     """
     before = {t.ident for t in threading.enumerate()}
-    yield
+    with thread_container_scope(name=f"test:{request.node.name}"):
+        yield
 
     def _no_leaked_threads() -> bool:
         return not any(