test(historian): #691 Gateway bounding values over the real source and an AVEVA-shaped wire

The start bound is the stored prior sample at its own time (walked back), never the synthetic boundary row stamped at the query start; a stored NULL is a Bad bound; reverse end bound walks back too.
2026-10-12 16:26:54 -04:00
parent 60febbf2dc
commit 92aab7282c
1 changed files with 136 additions and 0 deletions
@@ -0,0 +1,136 @@
+using Google.Protobuf.WellKnownTypes;
+using Microsoft.Extensions.Logging.Abstractions;
+using Shouldly;
+using Xunit;
+using ZB.MOM.WW.HistorianGateway.Contracts.Grpc;
+using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
+using ZB.MOM.WW.OtOpcUa.OpcUaServer;
+
+namespace ZB.MOM.WW.OtOpcUa.Driver.Historian.Gateway.Tests;
+
+/// <summary>
+///     Gitea #691: Part 11 bounding values on the Gateway, composed by the server's <see cref="HistoryBounds"/> over the REAL
+///     source and an AVEVA-shaped fake (the live gate's wire shape). The start bound of a forward read must be the stored
+///     sample before StartTime, at ITS OWN time — never AVEVA's synthetic boundary row, which is stamped at the query start
+///     and carries the value in effect there (<c>Quality = 133</c>). The Gateway reads forward only, so "at or before" is
+///     served by the walk-back (<see cref="ReverseRawReader"/>), and no reverse window is ever sent.
+/// </summary>
+public sealed class GatewayBoundingValueTests
+{
+    private static CancellationToken Ct => TestContext.Current.CancellationToken;
+
+    private static readonly DateTime T0 = new(2026, 10, 12, 18, 6, 0, DateTimeKind.Utc);
+    private static readonly DateTime Now = T0.AddHours(1);
+
+    /// <summary>The live gate's tag <c>HistGW.LiveTest.Gate681</c> (18:06:40 is a stored NULL).</summary>
+    private static readonly (double Sec, double Value, bool Null)[] Gate681 =
+    [
+        (0, 10, false), (5, 20, false), (20, 30, false), (40, 0, true), (50, 5, false), (60, 1, false), (90, 1, false),
+        (100, 7, false),
+    ];
+
+    private static DateTime At(double seconds) => T0.AddTicks((long)(seconds * TimeSpan.TicksPerSecond));
+
+    private static HistorianSample Stored(DateTime t, double v, bool isNull) => new()
+    {
+        Tag = "T",
+        Timestamp = Timestamp.FromDateTime(t),
+        NumericValue = isNull ? 0 : v,
+        OpcQuality = isNull ? 0u : 192u,
+        Quality = isNull ? 1u : 0u,
+    };
+
+    /// <summary>ReadRaw over <c>[start, end]</c> ascending, capped, led by AVEVA's boundary row at the query start.</summary>
+    private static FakeHistorianGatewayClient Aveva()
+    {
+        var sorted = Gate681.Select(x => (T: At(x.Sec), V: x.Value, x.Null)).ToList();
+        return new FakeHistorianGatewayClient
+        {
+            RawSource = (start, end, max) =>
+            {
+                var rows = new List<HistorianSample>();
+                if (sorted.All(d => d.T != start))
+                {
+                    var prior = sorted.Where(d => d.T < start).Select(d => ((DateTime T, double V, bool Null)?)d).LastOrDefault();
+                    HistorianSample boundary;
+                    if (prior is { } p)
+                    {
+                        boundary = Stored(start, p.V, p.Null);
+                        if (!p.Null) boundary.Quality = 133;
+                    }
+                    else
+                    {
+                        boundary = new HistorianSample { Tag = "T", Timestamp = Timestamp.FromDateTime(start), NumericValue = 0, OpcQuality = 0, Quality = 1 };
+                    }
+
+                    rows.Add(boundary);
+                }
+
+                rows.AddRange(sorted.Where(d => d.T >= start && d.T <= end).Select(d => Stored(d.T, d.V, d.Null)));
+                return max > 0 ? rows.Take(max) : rows;
+            },
+        };
+    }
+
+    private static GatewayHistorianDataSource Source(FakeHistorianGatewayClient fake) =>
+        new(fake, NullLogger<GatewayHistorianDataSource>.Instance);
+
+    [Fact]
+    public async Task The_start_bound_is_the_stored_prior_sample_at_its_own_time_not_the_synthetic_row()
+    {
+        var bound = await HistoryBounds.StartBoundAsync(Source(Aveva()), "T", At(21), reverse: false, 65536, Now, Ct);
+
+        bound.ShouldNotBeNull();
+        bound.SourceTimestampUtc.ShouldBe(At(20)); // the synthetic row would be stamped At(21)
+        bound.Value.ShouldBe(30d);
+        bound.StatusCode.ShouldBe(0u);
+    }
+
+    [Fact]
+    public async Task A_stored_NULL_prior_sample_is_the_start_bound_as_the_Bad_sample_it_is()
+    {
+        var bound = await HistoryBounds.StartBoundAsync(Source(Aveva()), "T", At(45), reverse: false, 65536, Now, Ct);
+
+        bound!.SourceTimestampUtc.ShouldBe(At(40));
+        bound.StatusCode.ShouldBe(0x80000000u);
+    }
+
+    [Fact]
+    public async Task Before_the_first_sample_the_start_bound_is_not_found_at_the_start_time()
+    {
+        var bound = await HistoryBounds.StartBoundAsync(Source(Aveva()), "T", At(-30), reverse: false, 65536, Now, Ct);
+
+        bound!.StatusCode.ShouldBe(Opc.Ua.StatusCodes.BadBoundNotFound);
+        bound.SourceTimestampUtc.ShouldBe(At(-30));
+        bound.Value.ShouldBeNull();
+    }
+
+    [Fact]
+    public async Task A_sample_exactly_on_the_start_time_is_the_bound_and_already_the_data()
+    {
+        (await HistoryBounds.StartBoundAsync(Source(Aveva()), "T", At(20), reverse: false, 65536, Now, Ct)).ShouldBeNull();
+    }
+
+    [Fact]
+    public async Task The_end_bound_is_the_first_stored_sample_at_or_after_the_end_time()
+    {
+        var source = Source(Aveva());
+        var after = await HistoryBounds.EndBoundAsync(source, "T", HistoryBounds.For(At(0), At(41)), At(40), 65536, Now, Ct);
+        after.SourceTimestampUtc.ShouldBe(At(50));
+        after.Value.ShouldBe(5d);
+
+        var missing = await HistoryBounds.EndBoundAsync(source, "T", HistoryBounds.For(At(0), At(101)), At(100), 65536, Now, Ct);
+        missing.StatusCode.ShouldBe(Opc.Ua.StatusCodes.BadBoundNotFound);
+        missing.SourceTimestampUtc.ShouldBe(At(101));
+    }
+
+    [Fact]
+    public async Task A_reverse_read_end_bound_walks_back_to_the_stored_sample_at_or_before_the_end_time()
+    {
+        var fake = Aveva();
+        var bound = await HistoryBounds.EndBoundAsync(Source(fake), "T", HistoryBounds.For(At(100), At(55)), At(60), 65536, Now, Ct);
+
+        bound.SourceTimestampUtc.ShouldBe(At(50));
+        bound.Value.ShouldBe(5d);
+    }
+}