ScadaBridge/tests/ZB.MOM.WW.ScadaBridge.AuditLog.Tests/Site/SiteAuditBacklogReporterCadenceTests.cs

using System.Diagnostics;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.Options;
using NSubstitute;
using ZB.MOM.WW.ScadaBridge.AuditLog.Site;
using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Services;
using ZB.MOM.WW.ScadaBridge.Commons.Types;
using ZB.MOM.WW.ScadaBridge.HealthMonitoring;

namespace ZB.MOM.WW.ScadaBridge.AuditLog.Tests.Site;

/// <summary>
/// Deferred-work #21: the backlog reporter's poll cadence is configurable via
/// <see cref="SqliteAuditWriterOptions.BacklogPollIntervalSeconds"/> instead of the
/// old hard-coded 30 s constant.
/// </summary>
public class SiteAuditBacklogReporterCadenceTests
{
    private static SiteAuditBacklogReporter Create(
        IOptions<SqliteAuditWriterOptions>? options, TimeSpan? explicitInterval = null) =>
        new(
            Substitute.For<ISiteAuditQueue>(),
            Substitute.For<ISiteHealthCollector>(),
            NullLogger<SiteAuditBacklogReporter>.Instance,
            explicitInterval,
            options);

    [Fact]
    public async Task StopAsync_WhileProbeInFlight_LoopCompletesCleanly()
    {
        // SafeProbeAsync rethrows OperationCanceledException by design so a shutdown
        // aborts the probe promptly — but RunLoopAsync must absorb it, because StopAsync
        // hands _loop straight to the host and a canceled task there throws out of
        // Host.StopAsync. Mirrors the guard SiteAuditRetentionService already carries
        // (arch-review 04 round 2, R7).
        var probeStarted = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
        var queue = Substitute.For<ISiteAuditQueue>();
        queue.GetBacklogStatsAsync(Arg.Any<CancellationToken>())
            .Returns(ci => BlockUntilCancelledAsync(probeStarted, ci.Arg<CancellationToken>()));

        var reporter = new SiteAuditBacklogReporter(
            queue,
            Substitute.For<ISiteHealthCollector>(),
            NullLogger<SiteAuditBacklogReporter>.Instance,
            TimeSpan.FromHours(1),
            null);

        await reporter.StartAsync(CancellationToken.None);
        await probeStarted.Task; // the immediate first probe is now in flight

        // The assertion is that awaiting the loop task does not throw.
        await reporter.StopAsync(CancellationToken.None);
        reporter.Dispose();
    }

    private static async Task<SiteAuditBacklogSnapshot> BlockUntilCancelledAsync(
        TaskCompletionSource started, CancellationToken ct)
    {
        started.TrySetResult();
        await Task.Delay(Timeout.Infinite, ct);
        throw new UnreachableException("the delay above always throws on cancellation");
    }

    [Fact]
    public async Task StopAsync_AfterDispose_DoesNotThrow()
    {
        // Regression (Gitea #15 follow-up): Dispose tears down the CTS StopAsync
        // cancels, and the host does not guarantee StopAsync is driven before the DI
        // container is disposed. Cancel() on a disposed CTS throws, and letting that
        // escape an IHostedService aborts the host's whole shutdown sequence.
        var reporter = Create(Options.Create(new SqliteAuditWriterOptions()), TimeSpan.FromHours(1));

        await reporter.StartAsync(CancellationToken.None);
        reporter.Dispose();

        // The assertion is the absence of ObjectDisposedException.
        await reporter.StopAsync(CancellationToken.None);
        reporter.Dispose();
    }

    [Fact]
    public void Cadence_ComesFromOptions_WhenConfigured()
    {
        var options = Options.Create(new SqliteAuditWriterOptions { BacklogPollIntervalSeconds = 12 });

        var reporter = Create(options);

        Assert.Equal(TimeSpan.FromSeconds(12), reporter.RefreshInterval);
    }

    [Fact]
    public void Cadence_FallsBackToDefault_WhenOptionsNonPositive()
    {
        var options = Options.Create(new SqliteAuditWriterOptions { BacklogPollIntervalSeconds = 0 });

        var reporter = Create(options);

        Assert.Equal(SiteAuditBacklogReporter.DefaultRefreshInterval, reporter.RefreshInterval);
    }

    [Fact]
    public void Cadence_FallsBackToDefault_WhenNoOptions()
    {
        var reporter = Create(options: null);

        Assert.Equal(SiteAuditBacklogReporter.DefaultRefreshInterval, reporter.RefreshInterval);
    }

    [Fact]
    public void ExplicitInterval_WinsOverOptions()
    {
        var options = Options.Create(new SqliteAuditWriterOptions { BacklogPollIntervalSeconds = 12 });

        var reporter = Create(options, explicitInterval: TimeSpan.FromSeconds(3));

        Assert.Equal(TimeSpan.FromSeconds(3), reporter.RefreshInterval);
    }
}