histsdk/tests/AVEVA.Historian.Client.Tests/HistorianGrpcIntegrationTests.cs

using AVEVA.Historian.Client.Grpc;
using AVEVA.Historian.Client.Models;

namespace AVEVA.Historian.Client.Tests;

/// <summary>
/// Live integration tests for the 2023 R2 RemoteGrpc transport. Gated on a dedicated
/// <c>HISTORIAN_GRPC_HOST</c> env var (plus <c>HISTORIAN_TEST_TAG</c>) so they skip cleanly until
/// a 2023 R2 Historian is available. Optional:
///   HISTORIAN_GRPC_PORT (default 32565), HISTORIAN_GRPC_TLS (true/false),
///   HISTORIAN_USER / HISTORIAN_PASSWORD (explicit creds; otherwise IntegratedSecurity),
///   HISTORIAN_GRPC_DNSID (server certificate name when connecting by IP over TLS).
/// </summary>
public sealed class HistorianGrpcIntegrationTests
{
    [Fact]
    public async Task ProbeAsync_OverGrpc_ReturnsTrue()
    {
        string? host = Environment.GetEnvironmentVariable("HISTORIAN_GRPC_HOST");
        if (string.IsNullOrWhiteSpace(host))
        {
            return;
        }

        // ProbeAsync calls the unauthenticated GetInterfaceVersion RPCs, so it succeeds even when
        // credentials are unavailable — no HISTORIAN_USER/PASSWORD required.
        HistorianClient client = new(BuildOptions(host));
        Assert.True(await client.ProbeAsync(CancellationToken.None));
    }

    [Fact]
    public async Task ReadRawAsync_OverGrpc_ReturnsAtLeastOneRow()
    {
        string? host = Environment.GetEnvironmentVariable("HISTORIAN_GRPC_HOST");
        string? testTag = Environment.GetEnvironmentVariable("HISTORIAN_TEST_TAG");
        if (string.IsNullOrWhiteSpace(host) || string.IsNullOrWhiteSpace(testTag))
        {
            return;
        }

        HistorianClient client = new(BuildOptions(host));

        DateTime endUtc = DateTime.UtcNow;
        DateTime startUtc = endUtc - TimeSpan.FromDays(7);

        List<HistorianSample> samples = [];
        await foreach (HistorianSample sample in client.ReadRawAsync(testTag, startUtc, endUtc, maxValues: 8, CancellationToken.None))
        {
            samples.Add(sample);
        }

        Assert.NotEmpty(samples);
        Assert.All(samples, s => Assert.Equal(testTag, s.TagName));
    }

    [Fact]
    public async Task GetSystemParameterAsync_OverGrpc_ReturnsValue()
    {
        string? host = Environment.GetEnvironmentVariable("HISTORIAN_GRPC_HOST");
        if (string.IsNullOrWhiteSpace(host) || string.IsNullOrEmpty(Environment.GetEnvironmentVariable("HISTORIAN_USER")))
        {
            return;
        }

        HistorianClient client = new(BuildOptions(host));
        string? version = await client.GetSystemParameterAsync("HistorianVersion", CancellationToken.None);
        Assert.False(string.IsNullOrWhiteSpace(version));
    }

    [Fact]
    public async Task GetServerTimeZoneAsync_OverGrpc_ReturnsZone()
    {
        string? host = Environment.GetEnvironmentVariable("HISTORIAN_GRPC_HOST");
        if (string.IsNullOrWhiteSpace(host) || string.IsNullOrEmpty(Environment.GetEnvironmentVariable("HISTORIAN_USER")))
        {
            return;
        }

        // R1.3: gRPC StatusService.GetSystemTimeZoneName returns the real server zone (the 2020 WCF
        // op is a stub). Live-verified value: "Eastern Daylight Time".
        HistorianClient client = new(BuildOptions(host));
        string? zone = await client.GetServerTimeZoneAsync(CancellationToken.None);
        Assert.False(string.IsNullOrWhiteSpace(zone));
    }

    [Fact]
    public async Task GetTagMetadataAsync_OverGrpc_ReturnsRequestedTag()
    {
        string? host = Environment.GetEnvironmentVariable("HISTORIAN_GRPC_HOST");
        string? tag = Environment.GetEnvironmentVariable("HISTORIAN_TEST_TAG");
        if (string.IsNullOrWhiteSpace(host) || string.IsNullOrWhiteSpace(tag)
            || string.IsNullOrEmpty(Environment.GetEnvironmentVariable("HISTORIAN_USER")))
        {
            return;
        }

        HistorianClient client = new(BuildOptions(host));
        HistorianTagMetadata? metadata = await client.GetTagMetadataAsync(tag, CancellationToken.None);

        Assert.NotNull(metadata);
        Assert.Equal(tag, metadata!.Name);
        // A real metadata record decodes to a known data type (descriptor passed MapDataType).
        Assert.True(Enum.IsDefined(metadata.DataType));
    }

    [Fact]
    public async Task BrowseTagNamesAsync_OverGrpc_ReturnsSystemTags()
    {
        string? host = Environment.GetEnvironmentVariable("HISTORIAN_GRPC_HOST");
        if (string.IsNullOrWhiteSpace(host) || string.IsNullOrEmpty(Environment.GetEnvironmentVariable("HISTORIAN_USER")))
        {
            return;
        }

        // Full R0.1 browse over gRPC: StartTagQuery(OData) -> paged QueryTag(0x6752) -> EndTagQuery.
        HistorianClient client = new(BuildOptions(host));
        List<string> names = [];
        await foreach (string name in client.BrowseTagNamesAsync("Sys*", CancellationToken.None))
        {
            names.Add(name);
        }

        Assert.NotEmpty(names);
        Assert.All(names, n => Assert.StartsWith("Sys", n, StringComparison.Ordinal));
    }

    [Fact]
    public async Task NonStreamedWriteTransaction_OverGrpc_BeginsAndDiscards()
    {
        string? host = Environment.GetEnvironmentVariable("HISTORIAN_GRPC_HOST");
        if (string.IsNullOrWhiteSpace(host) || string.IsNullOrEmpty(Environment.GetEnvironmentVariable("HISTORIAN_USER")))
        {
            return;
        }

        // M3 reachability probe: on 2020 WCF this op group is walled (TransactionService relay
        // returns UnknownClient(51) — the storage-engine-pipe requirement, see
        // docs/plans/revision-write-path.md). On the 2023 R2 gRPC front door the native client
        // passes the Open2 storage-session GUID straight to TransactionService and it works.
        // This asserts the wall is gone: a write-enabled session opens and AddNonStreamValuesBegin
        // returns a transaction id, which we immediately End with bCommit=false (writes nothing).
        var probe = new HistorianGrpcRevisionProbe(BuildOptions(host));
        HistorianGrpcRevisionProbeResult result = await probe.ProbeBeginAsync(CancellationToken.None);

        Assert.True(result.OpenSucceeded);
        Assert.True(result.BeginSucceeded, "AddNonStreamValuesBegin should return a transaction id over gRPC.");
        Assert.False(string.IsNullOrEmpty(result.BeginTransactionId));
        Assert.True(result.EndDiscardSucceeded, "AddNonStreamValuesEnd(bCommit:false) should discard cleanly.");
    }

    [Fact]
    public async Task OpenStorageConnection_OverGrpc_RefusedAsNotRegistered()
    {
        string? host = Environment.GetEnvironmentVariable("HISTORIAN_GRPC_HOST");
        if (string.IsNullOrWhiteSpace(host) || string.IsNullOrEmpty(Environment.GetEnvironmentVariable("HISTORIAN_USER")))
        {
            return;
        }

        // M3 R3.1 follow-up finding (2026-06-21): StorageService.OpenStorageConnection is NOT the
        // missing non-streamed-write precondition. It's the storage engine's SF/snapshot channel
        // (separate GrpcStorageClient / service identity), and on the Historian front door it is
        // refused with native type=4 code=85 ("session not registered") for every parameter combo —
        // the same code the event read returns before RegisterTags2. The real precondition is the
        // front-door HistoryService.RegisterTags (RTag2-family). See docs/plans/revision-write-path.md
        // §"R3.1 follow-up". This test pins the refusal so a future server/behaviour change is noticed.
        var probe = new HistorianGrpcStorageConnectionProbe(BuildOptions(host));
        HistorianGrpcOpenStorageConnectionResult result = await probe.ProbeAsync(CancellationToken.None);

        Assert.True(result.OpenSucceeded, "the write-enabled gRPC session itself should still open.");
        Assert.False(result.OpenStorageSucceeded, "OpenStorageConnection is not a front-door client op (error 85).");
        Assert.NotEmpty(result.Attempts);
        Assert.All(result.Attempts, a => Assert.False(a.Succeeded));
    }

    [Fact]
    public async Task AddHistoricalValuesAsync_OverGrpc_WritesAndReadsBack()
    {
        string? host = Environment.GetEnvironmentVariable("HISTORIAN_GRPC_HOST");
        // Gated additionally on a dedicated sandbox-tag env var so this WRITE test never runs by
        // accident — set HISTORIAN_WRITE_SANDBOX_TAG to an existing Float tag you are happy to write
        // backfill samples to. M3 R3.2: HistoryService.AddStreamValues ("ON" buffer).
        string? sandboxTag = Environment.GetEnvironmentVariable("HISTORIAN_WRITE_SANDBOX_TAG");
        if (string.IsNullOrWhiteSpace(host) || string.IsNullOrWhiteSpace(sandboxTag)
            || string.IsNullOrEmpty(Environment.GetEnvironmentVariable("HISTORIAN_USER")))
        {
            return;
        }

        HistorianClient client = new(BuildOptions(host));

        // A backfill sample at a fixed historical second, with a distinctive whole-number value so
        // it round-trips for any analog tag type (Float/Double/Int2/Int4/UInt4).
        DateTime stamp = new DateTime(DateTime.UtcNow.Year, 1, 2, 3, 4, 5, DateTimeKind.Utc);
        const double expected = 7777;
        bool wrote = await client.AddHistoricalValuesAsync(
            sandboxTag!,
            [new HistorianHistoricalValue(stamp, expected)],
            CancellationToken.None);
        Assert.True(wrote);

        // Read the window around the sample back and confirm it landed.
        List<HistorianSample> samples = [];
        await foreach (HistorianSample s in client.ReadRawAsync(sandboxTag!, stamp.AddMinutes(-1), stamp.AddMinutes(1), maxValues: 16, CancellationToken.None))
        {
            samples.Add(s);
        }
        Assert.Contains(samples, s => s.NumericValue is { } v && Math.Abs(v - expected) < 0.01);
    }

    private static HistorianClientOptions BuildOptions(string host)
    {
        string? user = Environment.GetEnvironmentVariable("HISTORIAN_USER");
        string? password = Environment.GetEnvironmentVariable("HISTORIAN_PASSWORD");
        bool explicitCreds = !string.IsNullOrEmpty(user);
        int port = int.TryParse(Environment.GetEnvironmentVariable("HISTORIAN_GRPC_PORT"), out int parsed)
            ? parsed
            : HistorianClientOptions.DefaultGrpcPort;
        bool tls = string.Equals(Environment.GetEnvironmentVariable("HISTORIAN_GRPC_TLS"), "true", StringComparison.OrdinalIgnoreCase);

        return new HistorianClientOptions
        {
            Host = host,
            Port = port,
            Transport = HistorianTransport.RemoteGrpc,
            GrpcUseTls = tls,
            AllowUntrustedServerCertificate = tls,
            ServerDnsIdentity = Environment.GetEnvironmentVariable("HISTORIAN_GRPC_DNSID"),
            IntegratedSecurity = !explicitCreds,
            UserName = user ?? string.Empty,
            Password = password ?? string.Empty
        };
    }
}