refactor(tests): use CreateLinkedTokenSource for timeout patterns

Replace manual DateTime-based timeout loops with the built-in
CancellationTokenSource.CreateLinkedTokenSource pattern for cleaner,
more efficient timeout handling in SSE tests.

- Add WaitForClientsAsync<T> helper to SseTestHelpers with:
  - Configurable timeout (default 10s) and polling interval (50ms)
  - Optional stabilization delay (100ms)
  - Proper OperationCanceledException → TimeoutException translation
- Update OcrEventStreamIntegrationTests to use shared helper
- Update GenAIEventStreamIntegrationTests to use shared helper
- Remove duplicate private helper from SseExtensionsNet10Tests

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: ANcpLua

SWEN3.Paperless.RabbitMq.Tests/Helpers/SseTestHelpers.cs

@@ -5,6 +5,60 @@ namespace SWEN3.Paperless.RabbitMq.Tests.Helpers;
 /// </summary>
 internal static class SseTestHelpers
 {
+    /// <summary>
+    ///     Default polling interval for client connection checks.
+    /// </summary>
+    private const int PollingIntervalMs = 50;
+
+    /// <summary>
+    ///     Default timeout for waiting for clients to connect.
+    /// </summary>
+    private static readonly TimeSpan DefaultClientTimeout = TimeSpan.FromSeconds(10);
+
+    /// <summary>
+    ///     Default stabilization delay after client connects.
+    /// </summary>
+    private static readonly TimeSpan ConnectionStabilizationDelay = TimeSpan.FromMilliseconds(100);
+
+    /// <summary>
+    ///     Waits for expected number of clients to connect to the SSE stream using linked cancellation tokens.
+    /// </summary>
+    /// <typeparam name="T">The event type of the stream</typeparam>
+    /// <param name="stream">The SSE stream to monitor</param>
+    /// <param name="expectedClients">Number of clients to wait for (default: 1)</param>
+    /// <param name="timeout">Timeout duration (default: 10 seconds)</param>
+    /// <param name="stabilize">Whether to add stabilization delay after connection (default: true)</param>
+    /// <param name="cancellationToken">Parent cancellation token</param>
+    /// <exception cref="TimeoutException">Thrown when clients don't connect within timeout</exception>
+    public static async Task WaitForClientsAsync<T>(
+        ISseStream<T> stream,
+        int expectedClients = 1,
+        TimeSpan? timeout = null,
+        bool stabilize = true,
+        CancellationToken cancellationToken = default) where T : class
+    {
+        using var timeoutCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+        timeoutCts.CancelAfter(timeout ?? DefaultClientTimeout);
+
+        try
+        {
+            while (stream.ClientCount < expectedClients)
+            {
+                await Task.Delay(PollingIntervalMs, timeoutCts.Token);
+            }
+
+            if (stabilize)
+            {
+                await Task.Delay(ConnectionStabilizationDelay, timeoutCts.Token);
+            }
+        }
+        catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
+        {
+            throw new TimeoutException(
+                $"Expected {expectedClients} client(s) but only {stream.ClientCount} connected within timeout");
+        }
+    }
+
     /// <summary>
     ///     Creates a test server with SSE stream configured, using modern IHost and TestServer.
     /// </summary>

SWEN3.Paperless.RabbitMq.Tests/Integration/GenAIEventStreamIntegrationTests.cs

@@ -33,8 +33,7 @@ public async Task MapGenAIEventStream_ShouldEmitCorrectEventType(string status,
             }
         }, ct);
 
-        while (sseStream.ClientCount == 0)
-            await Task.Delay(50, ct);
+        await SseTestHelpers.WaitForClientsAsync(sseStream, stabilize: false, cancellationToken: ct);
 
         var genAiEvent = status == "Completed"
             ? new GenAIEvent(Guid.NewGuid(), "Test summary", DateTimeOffset.UtcNow)
@@ -60,17 +59,7 @@ public async Task MapGenAIEventStream_WithMultipleEvents_ShouldStreamInOrder()
 
         var readTask = Task.Run(() => ReadEventsAsync(client, 3, ct), ct);
 
-        // Wait for client to connect with timeout
-        var waitStart = DateTime.UtcNow;
-        while (sseStream.ClientCount == 0)
-        {
-            if (DateTime.UtcNow - waitStart > TimeSpan.FromSeconds(10))
-                throw new TimeoutException("Client did not connect within timeout");
-            await Task.Delay(50, ct);
-        }
-
-        // Give the HTTP connection a moment to stabilize
-        await Task.Delay(100, ct);
+        await SseTestHelpers.WaitForClientsAsync(sseStream, cancellationToken: ct);
 
         sseStream.Publish(new GenAIEvent(Guid.NewGuid(), "Summary 1", DateTimeOffset.UtcNow));
         await Task.Delay(50, ct);

SWEN3.Paperless.RabbitMq.Tests/Integration/OcrEventStreamIntegrationTests.cs

@@ -34,17 +34,7 @@ public async Task MapOcrEventStream_ShouldEmitCorrectEventType(string status, st
             }
         }, ct);
 
-        // Wait for client to connect with timeout
-        var waitStart = DateTime.UtcNow;
-        while (sseStream.ClientCount == 0)
-        {
-            if (DateTime.UtcNow - waitStart > TimeSpan.FromSeconds(10))
-                throw new TimeoutException("Client did not connect within timeout");
-            await Task.Delay(50, ct);
-        }
-
-        // Give the HTTP connection a moment to stabilize
-        await Task.Delay(100, ct);
+        await SseTestHelpers.WaitForClientsAsync(sseStream, cancellationToken: ct);
 
         var ocrEvent = new OcrEvent(Guid.NewGuid(), status, status is "Completed" ? "Text" : null,
             DateTimeOffset.UtcNow);

SWEN3.Paperless.RabbitMq.Tests/Unit/SseExtensionsNet10Tests.cs

@@ -4,20 +4,6 @@ namespace SWEN3.Paperless.RabbitMq.Tests.Unit;
 public static class SseExtensionsNet10Tests
 {
 #if NET10_0_OR_GREATER
-    private static async Task WaitForClientsAsync(ISseStream<Messages.SseTestEvent> stream, int expected, CancellationToken ct)
-    {
-        var start = DateTime.UtcNow;
-        while (stream.ClientCount < expected)
-        {
-            if (DateTime.UtcNow - start > TimeSpan.FromSeconds(5))
-            {
-                throw new TimeoutException("Client did not connect within timeout");
-            }
-
-            await Task.Delay(50, ct);
-        }
-    }
-
     [Fact]
     public static async Task MapSse_Net10_ShouldStreamEventsUsingNativeApi()
     {
@@ -39,7 +25,7 @@ public static async Task MapSse_Net10_ShouldStreamEventsUsingNativeApi()
         // Act
         var responseTask = client.GetAsync("/sse", HttpCompletionOption.ResponseHeadersRead, cts.Token);
 
-        await WaitForClientsAsync(sseStream, 1, cts.Token);
+        await SseTestHelpers.WaitForClientsAsync(sseStream, cancellationToken: cts.Token);
 
         // Publish once
         sseStream.Publish(new Messages.SseTestEvent { Id = 1, Message = "Hello" });
@@ -88,7 +74,7 @@ public static async Task MapSse_Net10_ShouldStreamMultipleEvents()
             new Messages.SseTestEvent { Id = 3, Message = "Third" }
         };
 
-        await WaitForClientsAsync(sseStream, 1, cts.Token);
+        await SseTestHelpers.WaitForClientsAsync(sseStream, cancellationToken: cts.Token);
 
         // Publish events once
         foreach (var evt in events)
@@ -202,7 +188,7 @@ public static async Task MapSse_Net10_RequestAborted_CompletesStream()
 
         var responseTask = client.GetAsync("/sse", HttpCompletionOption.ResponseHeadersRead, cts.Token);
 
-        await WaitForClientsAsync(sseStream, 1, cts.Token);
+        await SseTestHelpers.WaitForClientsAsync(sseStream, cancellationToken: cts.Token);
 
         sseStream.Publish(new Messages.SseTestEvent { Id = 2, Message = "Abort" });
 
@@ -249,8 +235,7 @@ public static async Task MapSse_Net10_CompletesNaturallyWhenStreamEnds()
         // Act - Connect without cancellation token to avoid cancellation-based termination
         var responseTask = client.GetAsync("/sse", HttpCompletionOption.ResponseHeadersRead, CancellationToken.None);
 
-        // Wait for connection to establish
-        await Task.Delay(100, cts.Token);
+        await SseTestHelpers.WaitForClientsAsync(fakeStream, cancellationToken: cts.Token);
 
         // Publish one event
         fakeStream.Publish(new Messages.SseTestEvent { Id = 99, Message = "Done" });