fix(centralui): pending-updates rail refreshes as soon as a deployment finishes — cache drops its snapshot on Success/Failed and signals the indicator, instead of serving the pre-deploy count for up to TTL + one poll

tests/ZB.MOM.WW.ScadaBridge.CentralUI.Tests/Services/PendingUpdatesCacheTests.cs

@@ -1,6 +1,8 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
+using Microsoft.Extensions.Logging.Abstractions;
 using NSubstitute;
+using ZB.MOM.WW.ScadaBridge.Commons.Types.Enums;
 using ZB.MOM.WW.ScadaBridge.CentralUI.Services;
 using ZB.MOM.WW.ScadaBridge.DeploymentManager;
 using ZB.MOM.WW.ScadaBridge.DeploymentManager.PendingUpdates;
@@ -21,6 +23,8 @@ public class PendingUpdatesCacheTests : IDisposable
 
     private readonly IPendingUpdatesEvaluator _evaluator = Substitute.For<IPendingUpdatesEvaluator>();
     private readonly ServiceProvider _provider;
+    private readonly DeploymentStatusNotifier _statusNotifier =
+        new(NullLogger<DeploymentStatusNotifier>.Instance);
 
     /// <summary>Initializes a service provider that resolves the substitute pending-updates evaluator.</summary>
     public PendingUpdatesCacheTests()
@@ -35,8 +39,15 @@ public class PendingUpdatesCacheTests : IDisposable
         Microsoft.Extensions.Options.Options.Create(
             new DeploymentManagerOptions { PendingUpdatesCacheTtl = ttl ?? TimeSpan.FromHours(1) });
 
-    private PendingUpdatesCache CreateSut(TimeSpan? ttl = null) =>
-        new(_provider.GetRequiredService<IServiceScopeFactory>(), Options(ttl));
+    private PendingUpdatesCache CreateSut(TimeSpan? ttl = null, TimeSpan? invalidationQuietPeriod = null) =>
+        new(
+            _provider.GetRequiredService<IServiceScopeFactory>(),
+            Options(ttl),
+            _statusNotifier,
+            invalidationQuietPeriod ?? TimeSpan.FromMilliseconds(20));
+
+    private void Finish(int instanceId, DeploymentStatus status) =>
+        _statusNotifier.NotifyStatusChanged(new DeploymentStatusChange($"dep-{instanceId}", instanceId, status));
 
     private static PendingUpdatesSnapshot Snapshot() =>
         new(T0, Array.Empty<SitePendingUpdates>());
@@ -138,6 +149,86 @@ public class PendingUpdatesCacheTests : IDisposable
         await _evaluator.Received(2).EvaluateAsync(Arg.Any<CancellationToken>());
     }
 
+    /// <summary>
+    /// Verifies that a finished deployment drops the memoized snapshot — a deploy is exactly the
+    /// event that changes the answer, so serving the pre-deploy count for the rest of the TTL
+    /// window left the rail showing stale "pending" counts after a successful Deploy all.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    [Theory]
+    [InlineData(DeploymentStatus.Success)]
+    [InlineData(DeploymentStatus.Failed)]
+    public async Task FinishedDeployment_InvalidatesTheMemoizedSnapshot(DeploymentStatus status)
+    {
+        _evaluator.EvaluateAsync(Arg.Any<CancellationToken>()).Returns(_ => Snapshot());
+        using var sut = CreateSut();
+
+        await sut.GetAsync();
+        Finish(1, status);
+        await sut.GetAsync();
+
+        await _evaluator.Received(2).EvaluateAsync(Arg.Any<CancellationToken>());
+    }
+
+    /// <summary>Verifies that a deployment that has only started does not invalidate the snapshot.</summary>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    [Fact]
+    public async Task StartedDeployment_DoesNotInvalidate()
+    {
+        _evaluator.EvaluateAsync(Arg.Any<CancellationToken>()).Returns(_ => Snapshot());
+        using var sut = CreateSut();
+
+        await sut.GetAsync();
+        Finish(1, DeploymentStatus.InProgress);
+        await sut.GetAsync();
+
+        await _evaluator.Received(1).EvaluateAsync(Arg.Any<CancellationToken>());
+    }
+
+    /// <summary>
+    /// Verifies that a burst of completions — one per instance in a bulk deploy — raises
+    /// <c>Invalidated</c> once, after the burst goes quiet, so every open rail re-reads once
+    /// instead of once per instance.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    [Fact]
+    public async Task BurstOfFinishedDeployments_RaisesInvalidatedOnceAfterItGoesQuiet()
+    {
+        using var sut = CreateSut(invalidationQuietPeriod: TimeSpan.FromMilliseconds(100));
+        var raised = 0;
+        var signal = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        sut.Invalidated += () =>
+        {
+            Interlocked.Increment(ref raised);
+            signal.TrySetResult();
+        };
+
+        for (var i = 1; i <= 9; i++)
+        {
+            Finish(i, DeploymentStatus.Success);
+        }
+
+        await signal.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        await Task.Delay(300);
+        Assert.Equal(1, Volatile.Read(ref raised));
+    }
+
+    /// <summary>Verifies that the cache stops listening to deployment status changes once disposed.</summary>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    [Fact]
+    public async Task Dispose_UnsubscribesFromStatusChanges()
+    {
+        var sut = CreateSut();
+        var raised = 0;
+        sut.Invalidated += () => Interlocked.Increment(ref raised);
+
+        sut.Dispose();
+        Finish(1, DeploymentStatus.Success);
+        await Task.Delay(150);
+
+        Assert.Equal(0, Volatile.Read(ref raised));
+    }
+
     /// <summary>Releases the resources held by the test fixture.</summary>
     public void Dispose() => _provider.Dispose();
 }