Joseph Doherty
235 lines
10 KiB
C#
235 lines
10 KiB
C#
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;
|
|
|
|
namespace ZB.MOM.WW.ScadaBridge.CentralUI.Tests.Services;
|
|
|
|
/// <summary>
|
|
/// Unit tests for <see cref="PendingUpdatesCache"/> — the same single-flight TTL contract as
|
|
/// <see cref="SingleFlightMemoTests"/> proves for the primitive, exercised here through the
|
|
/// full DI-scope-per-flight shape: N concurrent callers before the evaluator resolves must
|
|
/// share ONE fleet flatten, a value produced inside the TTL is served without re-evaluating,
|
|
/// <c>forceRefresh</c> bypasses a fresh value but still joins an in-flight round, and a
|
|
/// faulted evaluation is never memoized.
|
|
/// </summary>
|
|
public class PendingUpdatesCacheTests : IDisposable
|
|
{
|
|
private static readonly DateTimeOffset T0 = new(2026, 9, 14, 9, 0, 0, TimeSpan.Zero);
|
|
|
|
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()
|
|
{
|
|
var services = new ServiceCollection();
|
|
services.AddScoped(_ => _evaluator);
|
|
_provider = services.BuildServiceProvider();
|
|
}
|
|
|
|
// A generous TTL (1h) so every test's timing is driven by task completion, not the clock.
|
|
private static IOptions<DeploymentManagerOptions> Options(TimeSpan? ttl = null) =>
|
|
Microsoft.Extensions.Options.Options.Create(
|
|
new DeploymentManagerOptions { PendingUpdatesCacheTtl = ttl ?? TimeSpan.FromHours(1) });
|
|
|
|
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>());
|
|
|
|
/// <summary>Verifies that concurrent callers share a single evaluation.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task ConcurrentCallers_ShareOneEvaluation()
|
|
{
|
|
var released = new TaskCompletionSource<PendingUpdatesSnapshot>(
|
|
TaskCreationOptions.RunContinuationsAsynchronously);
|
|
_evaluator.EvaluateAsync(Arg.Any<CancellationToken>()).Returns(released.Task);
|
|
var sut = CreateSut();
|
|
|
|
var waiters = Enumerable.Range(0, 10).Select(_ => sut.GetAsync()).ToArray();
|
|
released.SetResult(Snapshot());
|
|
var results = await Task.WhenAll(waiters);
|
|
|
|
await _evaluator.Received(1).EvaluateAsync(Arg.Any<CancellationToken>());
|
|
Assert.All(results, r => Assert.Same(results[0], r));
|
|
}
|
|
|
|
/// <summary>Verifies that a call within the TTL serves the memoized value without re-evaluating.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task WithinTtl_ServesTheMemoizedValue_WithoutReEvaluating()
|
|
{
|
|
_evaluator.EvaluateAsync(Arg.Any<CancellationToken>()).Returns(Snapshot());
|
|
var sut = CreateSut();
|
|
|
|
var first = await sut.GetAsync();
|
|
var second = await sut.GetAsync();
|
|
|
|
await _evaluator.Received(1).EvaluateAsync(Arg.Any<CancellationToken>());
|
|
Assert.Same(first, second);
|
|
}
|
|
|
|
/// <summary>Verifies that a forced refresh bypasses a still-fresh cached value.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task ForceRefresh_BypassesAFreshValue()
|
|
{
|
|
var snapshotA = Snapshot();
|
|
var snapshotB = new PendingUpdatesSnapshot(T0.AddMinutes(1), Array.Empty<SitePendingUpdates>());
|
|
_evaluator.EvaluateAsync(Arg.Any<CancellationToken>()).Returns(snapshotA, snapshotB);
|
|
var sut = CreateSut();
|
|
|
|
var first = await sut.GetAsync();
|
|
var forced = await sut.GetAsync(forceRefresh: true);
|
|
|
|
await _evaluator.Received(2).EvaluateAsync(Arg.Any<CancellationToken>());
|
|
Assert.Same(snapshotA, first);
|
|
Assert.Same(snapshotB, forced);
|
|
}
|
|
|
|
/// <summary>Verifies that a forced refresh still joins an evaluation that is already in flight.</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task ForceRefresh_StillJoinsAnInFlightRound()
|
|
{
|
|
var released = new TaskCompletionSource<PendingUpdatesSnapshot>(
|
|
TaskCreationOptions.RunContinuationsAsynchronously);
|
|
_evaluator.EvaluateAsync(Arg.Any<CancellationToken>()).Returns(released.Task);
|
|
var sut = CreateSut();
|
|
|
|
var first = sut.GetAsync();
|
|
var forcedA = sut.GetAsync(forceRefresh: true);
|
|
var forcedB = sut.GetAsync(forceRefresh: true);
|
|
|
|
var snapshot = Snapshot();
|
|
released.SetResult(snapshot);
|
|
|
|
Assert.Same(snapshot, await first);
|
|
Assert.Same(snapshot, await forcedA);
|
|
Assert.Same(snapshot, await forcedB);
|
|
await _evaluator.Received(1).EvaluateAsync(Arg.Any<CancellationToken>());
|
|
}
|
|
|
|
/// <summary>Verifies that a failed evaluation surfaces to the caller and is remembered only for the short back-off (review 2026-10-21 04/C4).</summary>
|
|
/// <returns>A task that represents the asynchronous operation.</returns>
|
|
[Fact]
|
|
public async Task FailedEvaluation_SurfacesToTheCaller_AndIsBackedOffNotRetriedPerPoll()
|
|
{
|
|
_evaluator.EvaluateAsync(Arg.Any<CancellationToken>())
|
|
.Returns(
|
|
Task.FromException<PendingUpdatesSnapshot>(new InvalidOperationException("flatten failed")),
|
|
Task.FromResult(Snapshot()));
|
|
var sut = CreateSut();
|
|
|
|
await Assert.ThrowsAsync<InvalidOperationException>(() => sut.GetAsync());
|
|
|
|
// Inside the negative TTL a poll is served the same fault with no new flatten.
|
|
await Assert.ThrowsAsync<InvalidOperationException>(() => sut.GetAsync());
|
|
await _evaluator.Received(1).EvaluateAsync(Arg.Any<CancellationToken>());
|
|
|
|
// An operator Re-check bypasses the back-off.
|
|
var recovered = await sut.GetAsync(forceRefresh: true);
|
|
Assert.NotNull(recovered);
|
|
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();
|
|
}
|