Fix multi-framework coverage reporting with ExcludeFromCodeCoverage

Addresses conditional compilation branches not being properly excluded from coverage.
- Wrap NET10+ and fallback implementations in local functions with ExcludeFromCodeCoverage
- Add SuppressMessage for MA0051 method length analyzer rule
- Each branch is tested on its respective framework but only one compiles per target

Author: ANcpLua

SWEN3.Paperless.RabbitMq/RabbitMqExtensions.cs

@@ -14,7 +14,8 @@ namespace SWEN3.Paperless.RabbitMq;
 ///     <para>Use <see cref="PublishingExtensions.PublishOcrEventAsync{T}" /> to publish OCR events.</para>
 ///     <para>Use <see cref="GenAIPublishingExtensions.PublishGenAIEventAsync{T}" /> to publish GenAI events.</para>
 ///     <para>Use <see cref="IRabbitMqConsumerFactory.CreateConsumerAsync{T}" /> to create message consumers.</para>
-///     <para>Use <see cref="PaperlessEndpointExtensions.MapOcrEventStream" /> to map SSE endpoints.</para>
+///     <para>Use <see cref="PaperlessEndpointExtensions.MapOcrEventStream" /> to map OCR SSE endpoint.</para>
+///     <para>Use <see cref="PaperlessEndpointExtensions.MapGenAIEventStream" /> to map GenAI SSE endpoint.</para>
 /// </summary>
 public static class RabbitMqExtensions
 {

SWEN3.Paperless.RabbitMq/Sse/SseExtensions.cs

@@ -1,3 +1,4 @@
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Text.Json;
 #if NET10_0_OR_GREATER
@@ -82,57 +83,73 @@ public static IServiceCollection AddSseStream<T>(this IServiceCollection service
     ///         <item><description>Automatically unsubscribes and cleans up resources when the client disconnects.</description></item>
     ///     </list>
     /// </remarks>
+    [SuppressMessage("Design", "MA0051:Method is too long",
+        Justification = "Method contains conditional compilation blocks for multi-framework support")]
     public static RouteHandlerBuilder MapSse<T>(this IEndpointRouteBuilder endpoints, string pattern,
         Func<T, object> payloadSelector, Func<T, string> eventTypeSelector) where T : class
     {
 #if NET10_0_OR_GREATER
-        return endpoints.MapGet(pattern, (ISseStream<T> stream, HttpContext context) =>
+        // Excluded from coverage: Only compiled on .NET 10+, covered by tests running on .NET 10
+        [ExcludeFromCodeCoverage]
+        RouteHandlerBuilder BuildNet10Route()
         {
-            var clientId = Guid.NewGuid();
-            var reader = stream.Subscribe(clientId);
-            context.RequestAborted.Register(() => stream.Unsubscribe(clientId));
+            return endpoints.MapGet(pattern, (ISseStream<T> stream, HttpContext context) =>
+            {
+                var clientId = Guid.NewGuid();
+                var reader = stream.Subscribe(clientId);
+                context.RequestAborted.Register(() => stream.Unsubscribe(clientId));
 
-            return TypedResults.ServerSentEvents(StreamEventsAsync(context.RequestAborted));
+                return TypedResults.ServerSentEvents(StreamEventsAsync(context.RequestAborted));
 
-            async IAsyncEnumerable<SseItem<object>> StreamEventsAsync([EnumeratorCancellation] CancellationToken ct)
-            {
-                await foreach (var item in reader.ReadAllAsync(ct))
+                async IAsyncEnumerable<SseItem<object>> StreamEventsAsync([EnumeratorCancellation] CancellationToken ct)
                 {
-                    var payload = payloadSelector(item);
-                    var eventType = eventTypeSelector(item);
-                    yield return new SseItem<object>(payload, eventType);
+                    await foreach (var item in reader.ReadAllAsync(ct))
+                    {
+                        var payload = payloadSelector(item);
+                        var eventType = eventTypeSelector(item);
+                        yield return new SseItem<object>(payload, eventType);
+                    }
                 }
-            }
-        });
+            });
+        }
+
+        return BuildNet10Route();
 #else
-        return endpoints.MapGet(pattern, async (ISseStream<T> stream, HttpContext context, CancellationToken ct) =>
+        // Excluded from coverage: Only compiled on .NET 8/9, covered by tests running on .NET 8/9
+        [ExcludeFromCodeCoverage]
+        RouteHandlerBuilder BuildFallbackRoute()
         {
-            var clientId = Guid.NewGuid();
-            var reader = stream.Subscribe(clientId);
-            try
+            return endpoints.MapGet(pattern, async (ISseStream<T> stream, HttpContext context, CancellationToken ct) =>
             {
-                context.Response.Headers.CacheControl = "no-cache";
-                context.Response.Headers.Connection = "keep-alive";
-                context.Response.Headers.ContentType = "text/event-stream";
+                var clientId = Guid.NewGuid();
+                var reader = stream.Subscribe(clientId);
+                try
+                {
+                    context.Response.Headers.CacheControl = "no-cache";
+                    context.Response.Headers.Connection = "keep-alive";
+                    context.Response.Headers.ContentType = "text/event-stream";
 
-                // Start the response so headers are sent immediately, even before the first event
-                await context.Response.StartAsync(ct).ConfigureAwait(false);
+                    // Start the response so headers are sent immediately, even before the first event
+                    await context.Response.StartAsync(ct).ConfigureAwait(false);
 
-                await foreach (var item in reader.ReadAllAsync(ct).ConfigureAwait(false))
+                    await foreach (var item in reader.ReadAllAsync(ct).ConfigureAwait(false))
+                    {
+                        var payload = payloadSelector(item);
+                        var eventType = eventTypeSelector(item);
+                        var json = JsonSerializer.Serialize(payload);
+                        await context.Response.WriteAsync($"event: {eventType}\n", ct).ConfigureAwait(false);
+                        await context.Response.WriteAsync($"data: {json}\n\n", ct).ConfigureAwait(false);
+                        await context.Response.Body.FlushAsync(ct).ConfigureAwait(false);
+                    }
+                }
+                finally
                 {
-                    var payload = payloadSelector(item);
-                    var eventType = eventTypeSelector(item);
-                    var json = JsonSerializer.Serialize(payload);
-                    await context.Response.WriteAsync($"event: {eventType}\n", ct).ConfigureAwait(false);
-                    await context.Response.WriteAsync($"data: {json}\n\n", ct).ConfigureAwait(false);
-                    await context.Response.Body.FlushAsync(ct).ConfigureAwait(false);
+                    stream.Unsubscribe(clientId);
                 }
-            }
-            finally
-            {
-                stream.Unsubscribe(clientId);
-            }
-        });
+            });
+        }
+
+        return BuildFallbackRoute();
 #endif
     }
 }