clear test registry with dedicated user ids and request ids

Signed-off-by: Jordan Dubrick <jdubrick@redhat.com>

Author: Jdubrick

tests/integration/endpoints/test_stream_interrupt_integration.py

@@ -10,35 +10,35 @@
 from models.requests import StreamingInterruptRequest
 from utils.stream_interrupts import StreamInterruptRegistry
 
+TEST_REQUEST_ID = "123e4567-e89b-12d3-a456-426614174003"
+OWNER_USER_ID = "00000001-0001-0001-0001-000000000001"
+
 
 @pytest.fixture(name="registry")
 def registry_fixture() -> Generator[StreamInterruptRegistry, None, None]:
-    """Provide the shared registry, cleared before and after each test."""
+    """Provide singleton registry with deterministic per-test cleanup."""
     registry = StreamInterruptRegistry()
-    registry._streams.clear()
+    registry.deregister_stream(TEST_REQUEST_ID)
     yield registry
-    registry._streams.clear()
+    registry.deregister_stream(TEST_REQUEST_ID)
 
 
 @pytest.mark.asyncio
 async def test_stream_interrupt_full_round_trip(
     registry: StreamInterruptRegistry,
 ) -> None:
     """Full lifecycle: register, interrupt, then verify deregistration."""
-    request_id = "123e4567-e89b-12d3-a456-426614174003"
-    user_id = "00000001-0001-0001-0001-000000000001"
-
     async def pending_stream() -> None:
         await asyncio.sleep(10)
 
     task = asyncio.create_task(pending_stream())
-    registry.register_stream(request_id, user_id, task)
+    registry.register_stream(TEST_REQUEST_ID, OWNER_USER_ID, task)
 
-    assert registry.get_stream(request_id) is not None
+    assert registry.get_stream(TEST_REQUEST_ID) is not None
 
     response = await stream_interrupt_endpoint_handler(
-        interrupt_request=StreamingInterruptRequest(request_id=request_id),
-        auth=(user_id, "mock_username", False, "mock_token"),
+        interrupt_request=StreamingInterruptRequest(request_id=TEST_REQUEST_ID),
+        auth=(OWNER_USER_ID, "mock_username", False, "mock_token"),
         registry=registry,
     )
     assert response.interrupted is True
@@ -47,19 +47,19 @@ async def pending_stream() -> None:
         await task
 
     completed_response = await stream_interrupt_endpoint_handler(
-        interrupt_request=StreamingInterruptRequest(request_id=request_id),
-        auth=(user_id, "mock_username", False, "mock_token"),
+        interrupt_request=StreamingInterruptRequest(request_id=TEST_REQUEST_ID),
+        auth=(OWNER_USER_ID, "mock_username", False, "mock_token"),
         registry=registry,
     )
     assert completed_response.interrupted is False
 
-    registry.deregister_stream(request_id)
-    assert registry.get_stream(request_id) is None
+    registry.deregister_stream(TEST_REQUEST_ID)
+    assert registry.get_stream(TEST_REQUEST_ID) is None
 
     with pytest.raises(HTTPException) as exc_info:
         await stream_interrupt_endpoint_handler(
-            interrupt_request=StreamingInterruptRequest(request_id=request_id),
-            auth=(user_id, "mock_username", False, "mock_token"),
+            interrupt_request=StreamingInterruptRequest(request_id=TEST_REQUEST_ID),
+            auth=(OWNER_USER_ID, "mock_username", False, "mock_token"),
             registry=registry,
         )
     assert exc_info.value.status_code == 404

tests/unit/app/endpoints/test_stream_interrupt.py

@@ -11,38 +11,52 @@
 from models.responses import StreamingInterruptResponse
 from utils.stream_interrupts import StreamInterruptRegistry
 
+REQUEST_ID_SUCCESS = "123e4567-e89b-12d3-a456-426614174000"
+REQUEST_ID_NOT_FOUND = "123e4567-e89b-12d3-a456-426614174001"
+REQUEST_ID_WRONG_USER = "123e4567-e89b-12d3-a456-426614174002"
+REQUEST_ID_ALREADY_COMPLETED = "123e4567-e89b-12d3-a456-426614174004"
+
+OWNER_USER_ID = "00000001-0001-0001-0001-000000000001"
+NON_OWNER_USER_ID = "00000001-0001-0001-0001-000000000999"
+
+TEST_REQUEST_IDS = (
+    REQUEST_ID_SUCCESS,
+    REQUEST_ID_NOT_FOUND,
+    REQUEST_ID_WRONG_USER,
+    REQUEST_ID_ALREADY_COMPLETED,
+)
+
 
 @pytest.fixture(name="registry")
 def registry_fixture() -> Generator[StreamInterruptRegistry, None, None]:
-    """Provide the shared registry, cleared before and after each test."""
+    """Provide singleton registry with deterministic per-test cleanup."""
     registry = StreamInterruptRegistry()
-    registry._streams.clear()
+    for request_id in TEST_REQUEST_IDS:
+        registry.deregister_stream(request_id)
     yield registry
-    registry._streams.clear()
+    for request_id in TEST_REQUEST_IDS:
+        registry.deregister_stream(request_id)
 
 
 @pytest.mark.asyncio
 async def test_stream_interrupt_endpoint_success(
     registry: StreamInterruptRegistry,
 ) -> None:
     """Interrupt endpoint cancels an active stream for the same user."""
-    request_id = "123e4567-e89b-12d3-a456-426614174000"
-    user_id = "00000001-0001-0001-0001-000000000001"
-
     async def pending_stream() -> None:
         await asyncio.sleep(10)
 
     task = asyncio.create_task(pending_stream())
-    registry.register_stream(request_id, user_id, task)
+    registry.register_stream(REQUEST_ID_SUCCESS, OWNER_USER_ID, task)
 
     response = await stream_interrupt_endpoint_handler(
-        interrupt_request=StreamingInterruptRequest(request_id=request_id),
-        auth=(user_id, "mock_username", False, "mock_token"),
+        interrupt_request=StreamingInterruptRequest(request_id=REQUEST_ID_SUCCESS),
+        auth=(OWNER_USER_ID, "mock_username", False, "mock_token"),
         registry=registry,
     )
 
     assert isinstance(response, StreamingInterruptResponse)
-    assert response.request_id == request_id
+    assert response.request_id == REQUEST_ID_SUCCESS
     assert response.interrupted is True
 
     with pytest.raises(asyncio.CancelledError):
@@ -54,13 +68,11 @@ async def test_stream_interrupt_endpoint_not_found(
     registry: StreamInterruptRegistry,
 ) -> None:
     """Interrupt endpoint returns 404 for unknown request id."""
-    request_id = "123e4567-e89b-12d3-a456-426614174001"
-
     with pytest.raises(HTTPException) as exc_info:
         await stream_interrupt_endpoint_handler(
-            interrupt_request=StreamingInterruptRequest(request_id=request_id),
+            interrupt_request=StreamingInterruptRequest(request_id=REQUEST_ID_NOT_FOUND),
             auth=(
-                "00000001-0001-0001-0001-000000000001",
+                OWNER_USER_ID,
                 "mock_username",
                 False,
                 "mock_token",
@@ -76,23 +88,21 @@ async def test_stream_interrupt_endpoint_wrong_user(
     registry: StreamInterruptRegistry,
 ) -> None:
     """Interrupt endpoint does not cancel streams owned by other users."""
-    request_id = "123e4567-e89b-12d3-a456-426614174002"
-
     async def pending_stream() -> None:
         await asyncio.sleep(10)
 
     task = asyncio.create_task(pending_stream())
     registry.register_stream(
-        request_id=request_id,
-        user_id="00000001-0001-0001-0001-000000000001",
+        request_id=REQUEST_ID_WRONG_USER,
+        user_id=OWNER_USER_ID,
         task=task,
     )
 
     with pytest.raises(HTTPException) as exc_info:
         await stream_interrupt_endpoint_handler(
-            interrupt_request=StreamingInterruptRequest(request_id=request_id),
+            interrupt_request=StreamingInterruptRequest(request_id=REQUEST_ID_WRONG_USER),
             auth=(
-                "00000001-0001-0001-0001-000000000999",
+                NON_OWNER_USER_ID,
                 "mock_username",
                 False,
                 "mock_token",
@@ -113,22 +123,21 @@ async def test_stream_interrupt_endpoint_already_completed(
     registry: StreamInterruptRegistry,
 ) -> None:
     """Interrupt endpoint reports already-completed streams without error."""
-    request_id = "123e4567-e89b-12d3-a456-426614174004"
-    user_id = "00000001-0001-0001-0001-000000000001"
-
     async def completed_stream() -> None:
         return None
 
     task = asyncio.create_task(completed_stream())
     await task
-    registry.register_stream(request_id, user_id, task)
+    registry.register_stream(REQUEST_ID_ALREADY_COMPLETED, OWNER_USER_ID, task)
 
     response = await stream_interrupt_endpoint_handler(
-        interrupt_request=StreamingInterruptRequest(request_id=request_id),
-        auth=(user_id, "mock_username", False, "mock_token"),
+        interrupt_request=StreamingInterruptRequest(
+            request_id=REQUEST_ID_ALREADY_COMPLETED
+        ),
+        auth=(OWNER_USER_ID, "mock_username", False, "mock_token"),
         registry=registry,
     )
 
     assert isinstance(response, StreamingInterruptResponse)
-    assert response.request_id == request_id
+    assert response.request_id == REQUEST_ID_ALREADY_COMPLETED
     assert response.interrupted is False