feat(comms): site-side PullAuditEvents handler (#23 M6)

tests/ScadaLink.Communication.Tests/SiteStreamPullAuditEventsTests.cs

@@ -0,0 +1,185 @@
+using Akka.TestKit.Xunit2;
+using Google.Protobuf.WellKnownTypes;
+using Grpc.Core;
+using Microsoft.Extensions.Logging.Abstractions;
+using NSubstitute;
+using NSubstitute.ExceptionExtensions;
+using ScadaLink.Commons.Entities.Audit;
+using ScadaLink.Commons.Interfaces.Services;
+using ScadaLink.Commons.Types.Enums;
+using ScadaLink.Communication.Grpc;
+
+namespace ScadaLink.Communication.Tests;
+
+/// <summary>
+/// Bundle A A2 tests for <see cref="SiteStreamGrpcServer.PullAuditEvents"/>.
+/// Verifies the request → ISiteAuditQueue.ReadPendingSinceAsync → response →
+/// MarkReconciledAsync round-trip through the gRPC handler. The queue is an
+/// NSubstitute stub so the tests never touch SQLite.
+/// </summary>
+public class SiteStreamPullAuditEventsTests : TestKit
+{
+    private readonly ISiteStreamSubscriber _subscriber = Substitute.For<ISiteStreamSubscriber>();
+
+    private SiteStreamGrpcServer CreateServer() =>
+        new(_subscriber, NullLogger<SiteStreamGrpcServer>.Instance);
+
+    private static ServerCallContext NewContext(CancellationToken ct = default)
+    {
+        var context = Substitute.For<ServerCallContext>();
+        context.CancellationToken.Returns(ct);
+        return context;
+    }
+
+    private static AuditEvent NewEvent(DateTime? occurredAt = null) => new()
+    {
+        EventId = Guid.NewGuid(),
+        OccurredAtUtc = occurredAt
+            ?? DateTime.SpecifyKind(new DateTime(2026, 5, 20, 10, 0, 0), DateTimeKind.Utc),
+        Channel = AuditChannel.ApiOutbound,
+        Kind = AuditKind.ApiCall,
+        Status = AuditStatus.Delivered,
+        SourceSiteId = "site-1",
+        PayloadTruncated = false,
+        ForwardState = AuditForwardState.Pending,
+    };
+
+    [Fact]
+    public async Task PullAuditEvents_NoQueueWired_ReturnsEmptyResponse()
+    {
+        var server = CreateServer();
+        // Intentionally do NOT call SetSiteAuditQueue — simulates a central-only
+        // host or a wiring-incomplete startup window.
+
+        var request = new PullAuditEventsRequest
+        {
+            SinceUtc = Timestamp.FromDateTime(DateTime.UtcNow.AddMinutes(-5)),
+            BatchSize = 100,
+        };
+
+        var response = await server.PullAuditEvents(request, NewContext());
+
+        Assert.Empty(response.Events);
+        Assert.False(response.MoreAvailable);
+    }
+
+    [Fact]
+    public async Task PullAuditEvents_With5PendingRows_ReturnsAllFiveDtos_AndFlipsToReconciled()
+    {
+        var queue = Substitute.For<ISiteAuditQueue>();
+        var events = Enumerable.Range(0, 5).Select(_ => NewEvent()).ToList();
+        queue.ReadPendingSinceAsync(Arg.Any<DateTime>(), Arg.Any<int>(), Arg.Any<CancellationToken>())
+            .Returns((IReadOnlyList<AuditEvent>)events);
+
+        var server = CreateServer();
+        server.SetSiteAuditQueue(queue);
+
+        var request = new PullAuditEventsRequest
+        {
+            SinceUtc = Timestamp.FromDateTime(DateTime.UtcNow.AddHours(-1)),
+            BatchSize = 100, // larger than returned count so MoreAvailable should be false
+        };
+
+        var response = await server.PullAuditEvents(request, NewContext());
+
+        Assert.Equal(5, response.Events.Count);
+        Assert.False(response.MoreAvailable); // 5 < 100
+        var expectedIds = events.Select(e => e.EventId.ToString()).ToHashSet();
+        Assert.True(expectedIds.SetEquals(response.Events.Select(d => d.EventId).ToHashSet()));
+
+        // Verify MarkReconciledAsync received the same 5 ids (best-effort flip).
+        await queue.Received(1).MarkReconciledAsync(
+            Arg.Is<IReadOnlyList<Guid>>(ids => ids.Count == 5 &&
+                                               ids.ToHashSet().SetEquals(events.Select(e => e.EventId))),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task PullAuditEvents_RowsOlderThanSinceUtc_Excluded()
+    {
+        // The handler delegates the since-utc filter to ReadPendingSinceAsync;
+        // this test verifies it passes the request value through verbatim
+        // (no clock skew, no off-by-one) and that an empty queue response
+        // yields an empty gRPC response.
+        var queue = Substitute.For<ISiteAuditQueue>();
+        var capturedSince = DateTime.MinValue;
+        queue.ReadPendingSinceAsync(Arg.Any<DateTime>(), Arg.Any<int>(), Arg.Any<CancellationToken>())
+            .Returns(call =>
+            {
+                capturedSince = call.ArgAt<DateTime>(0);
+                return (IReadOnlyList<AuditEvent>)Array.Empty<AuditEvent>();
+            });
+
+        var server = CreateServer();
+        server.SetSiteAuditQueue(queue);
+
+        var since = DateTime.SpecifyKind(new DateTime(2026, 5, 20, 9, 30, 0), DateTimeKind.Utc);
+        var request = new PullAuditEventsRequest
+        {
+            SinceUtc = Timestamp.FromDateTime(since),
+            BatchSize = 50,
+        };
+
+        var response = await server.PullAuditEvents(request, NewContext());
+
+        Assert.Empty(response.Events);
+        Assert.False(response.MoreAvailable);
+        Assert.Equal(since, capturedSince);
+        // Empty result → no MarkReconciledAsync call (no rows to flip).
+        await queue.DidNotReceive().MarkReconciledAsync(
+            Arg.Any<IReadOnlyList<Guid>>(), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task PullAuditEvents_BatchSize3_Returns3Rows_MoreAvailableTrue()
+    {
+        var queue = Substitute.For<ISiteAuditQueue>();
+        var events = Enumerable.Range(0, 3).Select(_ => NewEvent()).ToList();
+        queue.ReadPendingSinceAsync(Arg.Any<DateTime>(), Arg.Any<int>(), Arg.Any<CancellationToken>())
+            .Returns((IReadOnlyList<AuditEvent>)events);
+
+        var server = CreateServer();
+        server.SetSiteAuditQueue(queue);
+
+        var request = new PullAuditEventsRequest
+        {
+            SinceUtc = Timestamp.FromDateTime(DateTime.UtcNow.AddHours(-1)),
+            BatchSize = 3,
+        };
+
+        var response = await server.PullAuditEvents(request, NewContext());
+
+        Assert.Equal(3, response.Events.Count);
+        // saturated batch → central needs to know to issue a follow-up pull
+        Assert.True(response.MoreAvailable);
+    }
+
+    [Fact]
+    public async Task PullAuditEvents_MarkReconciledThrows_ResponseStillReturned()
+    {
+        // The Reconciled flip is best-effort — if it fails, the response must
+        // still surface so central can ingest the rows (and dedup on EventId
+        // when it pulls them again).
+        var queue = Substitute.For<ISiteAuditQueue>();
+        var events = Enumerable.Range(0, 2).Select(_ => NewEvent()).ToList();
+        queue.ReadPendingSinceAsync(Arg.Any<DateTime>(), Arg.Any<int>(), Arg.Any<CancellationToken>())
+            .Returns((IReadOnlyList<AuditEvent>)events);
+        queue.MarkReconciledAsync(Arg.Any<IReadOnlyList<Guid>>(), Arg.Any<CancellationToken>())
+            .ThrowsAsync(new InvalidOperationException("SQLite disposed mid-call"));
+
+        var server = CreateServer();
+        server.SetSiteAuditQueue(queue);
+
+        var request = new PullAuditEventsRequest
+        {
+            SinceUtc = Timestamp.FromDateTime(DateTime.UtcNow.AddHours(-1)),
+            BatchSize = 100,
+        };
+
+        // Must NOT throw — the response is built before the flip and returned
+        // regardless of the flip outcome.
+        var response = await server.PullAuditEvents(request, NewContext());
+
+        Assert.Equal(2, response.Events.Count);
+    }
+}