ScadaBridge/tests/ZB.MOM.WW.ScadaBridge.Communication.Tests/CommunicationOptionsValidatorTests.cs

using Microsoft.Extensions.Options;

namespace ZB.MOM.WW.ScadaBridge.Communication.Tests;

/// <summary>
/// Regression: <see cref="CommunicationOptions"/> timeouts feed per-pattern Ask
/// deadlines and gRPC keepalive/stream-lifetime settings; a zero/negative value
/// (or a non-positive <c>GrpcMaxConcurrentStreams</c>) must be rejected at startup
/// by an <see cref="IValidateOptions{TOptions}"/> with a clear, key-naming message
/// rather than surfacing at first Ask/gRPC use.
/// </summary>
public class CommunicationOptionsValidatorTests
{
    private static ValidateOptionsResult Validate(CommunicationOptions options) =>
        new CommunicationOptionsValidator().Validate(Options.DefaultName, options);

    /// <summary>Verifies that the default options are valid.</summary>
    [Fact]
    public void DefaultOptions_AreValid()
    {
        var result = Validate(new CommunicationOptions());
        Assert.True(result.Succeeded, result.FailureMessage);
    }

    /// <summary>Verifies that a zero deployment timeout is rejected.</summary>
    [Fact]
    public void ZeroDeploymentTimeout_IsRejected()
    {
        var result = Validate(new CommunicationOptions { DeploymentTimeout = TimeSpan.Zero });
        Assert.True(result.Failed);
        Assert.Contains("DeploymentTimeout", result.FailureMessage);
    }

    // ── Audit-ingest timeout ladder ────────────

    /// <summary>Verifies that the audit ingest timeout ladder is strictly monotonic end to end.</summary>
    [Fact]
    public void TheAuditIngestTimeoutLadder_IsStrictlyMonotonic_EndToEnd()
    {
        // 35 (site forward Ask) > 30 (gRPC deadline AND central's Ask of the ingest singleton)
        // > 20 (actor budget) > 15 (SQL command). Ties are the bug this closes: the site Ask
        // used to reuse NotificationForwardTimeout (30 s), so a slow-but-succeeding central
        // write could be acked to a caller that had already given up and re-sent the batch.
        var options = new CommunicationOptions();

        Assert.Equal(TimeSpan.FromSeconds(35), options.AuditForwardTimeout);
        Assert.True(options.AuditForwardTimeout > ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteStreamGrpcServer.AuditIngestAskTimeout);
        Assert.Equal(TimeSpan.FromSeconds(30), ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteStreamGrpcServer.AuditIngestAskTimeout);
    }

    /// <summary>Verifies that an audit forward timeout equal to the ask timeout is rejected.</summary>
    [Fact]
    public void AuditForwardTimeout_EqualToTheAskTimeout_IsRejected()
    {
        // Equality is precisely the pre-fix state, so the validator must refuse it, not just
        // refuse something smaller.
        var result = Validate(new CommunicationOptions
        {
            AuditForwardTimeout = ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteStreamGrpcServer.AuditIngestAskTimeout,
        });

        Assert.True(result.Failed);
        Assert.Contains("AuditForwardTimeout", result.FailureMessage);
    }

    /// <summary>Verifies that an audit forward timeout shorter than the ask timeout is rejected.</summary>
    [Fact]
    public void AuditForwardTimeout_ShorterThanTheAskTimeout_IsRejected()
    {
        var result = Validate(new CommunicationOptions
        {
            AuditForwardTimeout = TimeSpan.FromSeconds(5),
        });

        Assert.True(result.Failed);
        Assert.Contains("AuditForwardTimeout", result.FailureMessage);
    }

    /// <summary>Verifies that the audit forward timeout is still configurable upwards.</summary>
    [Fact]
    public void AuditForwardTimeout_IsStillConfigurableUpwards()
    {
        var result = Validate(new CommunicationOptions
        {
            AuditForwardTimeout = TimeSpan.FromMinutes(2),
        });

        Assert.True(result.Succeeded, result.FailureMessage);
    }

    /// <summary>Verifies that a non-positive gRPC max concurrent streams value is rejected.</summary>
    [Fact]
    public void NonPositiveGrpcMaxConcurrentStreams_IsRejected()
    {
        var result = Validate(new CommunicationOptions { GrpcMaxConcurrentStreams = 0 });
        Assert.True(result.Failed);
        Assert.Contains("GrpcMaxConcurrentStreams", result.FailureMessage);
    }

    // ── R2: site→central stream event batching ──────────────────────────────────

    /// <summary>Verifies that the default stream batch options are valid.</summary>
    [Fact]
    public void DefaultStreamBatchOptions_AreValid()
    {
        var options = new CommunicationOptions();
        Assert.Equal(100, options.GrpcStreamBatchMaxEvents);
        Assert.Equal(TimeSpan.FromMilliseconds(25), options.GrpcStreamBatchWindow);
        Assert.True(Validate(options).Succeeded);
    }

    /// <summary>Verifies that a stream batch max events value of one is valid and means batching is disabled.</summary>
    [Fact]
    public void StreamBatchMaxEventsOfOne_IsValid_AndMeansBatchingDisabled()
    {
        var result = Validate(new CommunicationOptions { GrpcStreamBatchMaxEvents = 1 });
        Assert.True(result.Succeeded, result.FailureMessage);
    }

    /// <summary>Verifies that a non-positive stream batch max events value is rejected.</summary>
    [Fact]
    public void NonPositiveStreamBatchMaxEvents_IsRejected()
    {
        var result = Validate(new CommunicationOptions { GrpcStreamBatchMaxEvents = 0 });
        Assert.True(result.Failed);
        Assert.Contains("GrpcStreamBatchMaxEvents", result.FailureMessage);
    }

    /// <summary>Verifies that a zero stream batch window is valid.</summary>
    [Fact]
    public void ZeroStreamBatchWindow_IsValid()
    {
        // Zero = "pack only what is already queued, never wait" — a legitimate posture for
        // a latency-critical deployment that still wants the framing saving.
        var result = Validate(new CommunicationOptions { GrpcStreamBatchWindow = TimeSpan.Zero });
        Assert.True(result.Succeeded, result.FailureMessage);
    }

    /// <summary>Verifies that a negative stream batch window is rejected.</summary>
    [Fact]
    public void NegativeStreamBatchWindow_IsRejected()
    {
        var result = Validate(new CommunicationOptions
        {
            GrpcStreamBatchWindow = TimeSpan.FromMilliseconds(-1)
        });
        Assert.True(result.Failed);
        Assert.Contains("GrpcStreamBatchWindow", result.FailureMessage);
    }

    /// <summary>Verifies that a stream batch window at or above the latency budget is rejected.</summary>
    [Fact]
    public void StreamBatchWindowAtOrAboveTheLatencyBudget_IsRejected()
    {
        // The coalescing window is the only latency batching adds and the target-scale
        // load test holds end-to-end stream latency to a 250 ms P99 — a window that could
        // spend the whole budget must not boot.
        foreach (var window in new[] { TimeSpan.FromMilliseconds(250), TimeSpan.FromSeconds(1) })
        {
            var result = Validate(new CommunicationOptions { GrpcStreamBatchWindow = window });
            Assert.True(result.Failed, $"{window} was accepted");
            Assert.Contains("GrpcStreamBatchWindow", result.FailureMessage);
        }

        // Just inside the ceiling is accepted — the bound is exclusive, not a round-down.
        Assert.True(Validate(new CommunicationOptions
        {
            GrpcStreamBatchWindow = CommunicationOptionsValidator.StreamBatchWindowCeiling
                - TimeSpan.FromMilliseconds(1)
        }).Succeeded);
    }

    // ── Aggregated live alarm cache options ───────────────────

    /// <summary>Verifies that a zero live alarm cache linger is valid.</summary>
    [Fact]
    public void ZeroLiveAlarmCacheLinger_IsValid()
    {
        // Zero linger = stop the aggregator immediately when the last viewer leaves.
        var result = Validate(new CommunicationOptions { LiveAlarmCacheLinger = TimeSpan.Zero });
        Assert.True(result.Succeeded, result.FailureMessage);
    }

    /// <summary>Verifies that a negative live alarm cache linger is rejected.</summary>
    [Fact]
    public void NegativeLiveAlarmCacheLinger_IsRejected()
    {
        var result = Validate(new CommunicationOptions { LiveAlarmCacheLinger = TimeSpan.FromSeconds(-1) });
        Assert.True(result.Failed);
        Assert.Contains("LiveAlarmCacheLinger", result.FailureMessage);
    }

    /// <summary>Verifies that a zero live alarm cache reconcile interval is rejected.</summary>
    [Fact]
    public void ZeroLiveAlarmCacheReconcileInterval_IsRejected()
    {
        var result = Validate(new CommunicationOptions { LiveAlarmCacheReconcileInterval = TimeSpan.Zero });
        Assert.True(result.Failed);
        Assert.Contains("LiveAlarmCacheReconcileInterval", result.FailureMessage);
    }

    /// <summary>Verifies that a zero live alarm cache seed concurrency is rejected.</summary>
    [Fact]
    public void ZeroLiveAlarmCacheSeedConcurrency_IsRejected()
    {
        var result = Validate(new CommunicationOptions { LiveAlarmCacheSeedConcurrency = 0 });
        Assert.True(result.Failed);
        Assert.Contains("LiveAlarmCacheSeedConcurrency", result.FailureMessage);
    }

    /// <summary>Verifies that an excessive live alarm cache seed concurrency is rejected.</summary>
    [Fact]
    public void ExcessiveLiveAlarmCacheSeedConcurrency_IsRejected()
    {
        var result = Validate(new CommunicationOptions { LiveAlarmCacheSeedConcurrency = 65 });
        Assert.True(result.Failed);
        Assert.Contains("LiveAlarmCacheSeedConcurrency", result.FailureMessage);
    }

    /// <summary>Verifies that a zero live alarm cache max subscribers per site is rejected.</summary>
    [Fact]
    public void ZeroLiveAlarmCacheMaxSubscribersPerSite_IsRejected()
    {
        var result = Validate(new CommunicationOptions { LiveAlarmCacheMaxSubscribersPerSite = 0 });
        Assert.True(result.Failed);
        Assert.Contains("LiveAlarmCacheMaxSubscribersPerSite", result.FailureMessage);
    }

    // ── R2 T10: live-delta publish-coalescing window (N6) ────────────────────────

    /// <summary>Verifies that a zero live alarm cache publish coalesce is valid.</summary>
    [Fact]
    public void ZeroLiveAlarmCachePublishCoalesce_IsValid()
    {
        // Zero = publish per delta (legacy behavior).
        var result = Validate(new CommunicationOptions { LiveAlarmCachePublishCoalesce = TimeSpan.Zero });
        Assert.True(result.Succeeded, result.FailureMessage);
    }

    /// <summary>Verifies that a negative live alarm cache publish coalesce is rejected.</summary>
    [Fact]
    public void NegativeLiveAlarmCachePublishCoalesce_IsRejected()
    {
        var result = Validate(new CommunicationOptions { LiveAlarmCachePublishCoalesce = TimeSpan.FromMilliseconds(-1) });
        Assert.True(result.Failed);
        Assert.Contains("LiveAlarmCachePublishCoalesce", result.FailureMessage);
    }

    // ── gRPC central transport endpoints ─────────────────────────────────────────
    // gRPC (CentralControlService) is the only site→central transport after the
    // ClusterClient→gRPC migration's Phase 4. This role-agnostic validator only rejects BLANK
    // entries; an EMPTY list is valid (central nodes legitimately declare none). The role-aware
    // "a Site must list at least one endpoint" rule lives in StartupValidator, tested there.

    /// <summary>Verifies that an empty endpoint list is valid.</summary>
    [Fact]
    public void EmptyEndpoints_IsValid()
    {
        // A central node hosts CentralControlService; it does not dial it, so it declares none.
        var result = Validate(new CommunicationOptions
        {
            CentralGrpcEndpoints = new List<string>(),
        });
        Assert.True(result.Succeeded, result.FailureMessage);
    }

    /// <summary>Verifies that a blank endpoint is rejected.</summary>
    [Fact]
    public void BlankEndpoint_IsRejected()
    {
        var result = Validate(new CommunicationOptions
        {
            CentralGrpcEndpoints = new List<string> { "   " },
        });
        Assert.True(result.Failed);
        Assert.Contains("CentralGrpcEndpoints", result.FailureMessage);
    }

    /// <summary>Verifies that a configured endpoint list is valid.</summary>
    [Fact]
    public void Endpoints_IsValid()
    {
        var result = Validate(new CommunicationOptions
        {
            CentralGrpcEndpoints = new List<string>
            {
                "http://scadabridge-central-a:8083",
                "http://scadabridge-central-b:8083",
            },
        });
        Assert.True(result.Succeeded, result.FailureMessage);
    }
}