feat(notification-outbox): operator Retry/Discard emit audit rows with operator identity

Additive RequestedBy on Retry/DiscardNotificationRequest, plumbed from the Central UI. RetryAsync emits a NotifyDeliver Submitted row (records who un-parked); Discard stamps the operator on the Terminal row. Best-effort — audit failure never aborts the action.
2026-07-09 08:12:47 -04:00
parent f2f196aa6d
commit 50bb1ef8ab
5 changed files with 226 additions and 14 deletions
@@ -0,0 +1,155 @@
+using Akka.Actor;
+using Akka.TestKit.Xunit2;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging.Abstractions;
+using NSubstitute;
+using ZB.MOM.WW.Audit;
+using ZB.MOM.WW.ScadaBridge.Commons.Entities.Notifications;
+using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Repositories;
+using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Services;
+using ZB.MOM.WW.ScadaBridge.Commons.Messages.Notification;
+using ZB.MOM.WW.ScadaBridge.Commons.Types.Audit;
+using ZB.MOM.WW.ScadaBridge.Commons.Types.Enums;
+using ZB.MOM.WW.ScadaBridge.NotificationOutbox.Delivery;
+
+namespace ZB.MOM.WW.ScadaBridge.NotificationOutbox.Tests;
+
+/// <summary>
+/// Task 13 (arch-review 04) — verifies that an operator-initiated Retry on a parked
+/// notification emits a <see cref="AuditChannel.Notification"/>/<see cref="AuditKind.NotifyDeliver"/>
+/// audit row with status <see cref="AuditStatus.Submitted"/> and the operator as
+/// <c>Actor</c>, closing the forensic gap (previously the lifecycle read
+/// <c>Parked → Attempted → Delivered</c> with no record of who un-parked it). Also
+/// asserts the audit write is best-effort — a throwing writer never fails the retry.
+/// </summary>
+public class NotificationOutboxActorRetryEmissionTests : TestKit
+{
+    private readonly INotificationOutboxRepository _outboxRepository =
+        Substitute.For<INotificationOutboxRepository>();
+
+    private readonly RecordingCentralAuditWriter _auditWriter = new();
+
+    private sealed class RecordingCentralAuditWriter : ICentralAuditWriter
+    {
+        public List<AuditRowProjection.AuditRowValues> Events { get; } = new();
+        public Func<AuditEvent, Task>? OnWrite { get; set; }
+
+        public Task WriteAsync(AuditEvent evt, CancellationToken ct = default)
+        {
+            lock (Events)
+            {
+                Events.Add(evt.AsRow());
+            }
+
+            return OnWrite?.Invoke(evt) ?? Task.CompletedTask;
+        }
+    }
+
+    private IServiceProvider BuildServiceProvider()
+    {
+        var services = new ServiceCollection();
+        services.AddScoped(_ => _outboxRepository);
+        return services.BuildServiceProvider();
+    }
+
+    private IActorRef CreateActor()
+    {
+        return Sys.ActorOf(Props.Create(() => new NotificationOutboxActor(
+            BuildServiceProvider(),
+            new NotificationOutboxOptions { DispatchInterval = TimeSpan.FromHours(1) },
+            (ICentralAuditWriter)_auditWriter,
+            NullLogger<NotificationOutboxActor>.Instance)));
+    }
+
+    private static Notification MakeParked(Guid? notificationId = null)
+    {
+        return new Notification(
+            (notificationId ?? Guid.NewGuid()).ToString("D"),
+            NotificationType.Email,
+            "ops-team",
+            "Tank overflow",
+            "Tank 3 level critical",
+            "site-1")
+        {
+            Status = NotificationStatus.Parked,
+            RetryCount = 5,
+            CreatedAt = DateTimeOffset.UtcNow,
+        };
+    }
+
+    private List<AuditRowProjection.AuditRowValues> EventsByStatus(AuditStatus status)
+    {
+        lock (_auditWriter.Events)
+        {
+            return _auditWriter.Events.Where(e => e.Status == status).ToList();
+        }
+    }
+
+    [Fact]
+    public void Retry_OnParked_Emits_Submitted_NotifyDeliver_AuditRow_With_Operator()
+    {
+        var notificationId = Guid.NewGuid();
+        var notification = MakeParked(notificationId);
+        _outboxRepository.GetByIdAsync(notification.NotificationId, Arg.Any<CancellationToken>())
+            .Returns(notification);
+        var actor = CreateActor();
+
+        actor.Tell(new RetryNotificationRequest(
+            CorrelationId: "test-corr", NotificationId: notification.NotificationId, RequestedBy: "jdoe"));
+
+        ExpectMsg<RetryNotificationResponse>(r => r.Success);
+        AwaitAssert(() =>
+        {
+            var submitted = EventsByStatus(AuditStatus.Submitted);
+            Assert.Single(submitted);
+            var evt = submitted[0];
+            Assert.Equal(AuditChannel.Notification, evt.Channel);
+            Assert.Equal(AuditKind.NotifyDeliver, evt.Kind);
+            Assert.Equal("jdoe", evt.Actor);
+            Assert.Equal(notificationId, evt.CorrelationId);
+        });
+    }
+
+    [Fact]
+    public void Discard_OnParked_Emits_Discarded_AuditRow_With_Operator()
+    {
+        var notification = MakeParked();
+        _outboxRepository.GetByIdAsync(notification.NotificationId, Arg.Any<CancellationToken>())
+            .Returns(notification);
+        var actor = CreateActor();
+
+        actor.Tell(new DiscardNotificationRequest(
+            CorrelationId: "test-corr", NotificationId: notification.NotificationId, RequestedBy: "jdoe"));
+
+        ExpectMsg<DiscardNotificationResponse>(r => r.Success);
+        AwaitAssert(() =>
+        {
+            var discarded = EventsByStatus(AuditStatus.Discarded);
+            Assert.Single(discarded);
+            Assert.Equal("jdoe", discarded[0].Actor);
+        });
+    }
+
+    [Fact]
+    public void Retry_AuditFailure_DoesNotFail_TheRetry()
+    {
+        // Audit is best-effort: a throwing writer must NOT abort the retry — the
+        // row is still flipped back to Pending and the response reports Success.
+        var notification = MakeParked();
+        _outboxRepository.GetByIdAsync(notification.NotificationId, Arg.Any<CancellationToken>())
+            .Returns(notification);
+        _auditWriter.OnWrite = _ => throw new InvalidOperationException("audit dead");
+        var actor = CreateActor();
+
+        actor.Tell(new RetryNotificationRequest(
+            CorrelationId: "test-corr", NotificationId: notification.NotificationId, RequestedBy: "jdoe"));
+
+        ExpectMsg<RetryNotificationResponse>(r => r.Success);
+        AwaitAssert(() =>
+        {
+            _outboxRepository.Received(1).UpdateAsync(
+                Arg.Is<Notification>(n => n.Status == NotificationStatus.Pending),
+                Arg.Any<CancellationToken>());
+        });
+    }
+}