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;
namespace ZB.MOM.WW.OtOpcUa.Driver.Historian.Gateway.Tests;
///
/// lmxopcua#694: the gateway sends AVEVA the native interval in WHOLE milliseconds (max(1, round(ms))) and AVEVA
/// clips its last interval at the request's end — both observed live (a 1.5 ms interval answers on a 2 ms grid; a 0.4 ms
/// window answers one row over exactly 0.4 ms). So a multi-interval request is only correct for a whole-millisecond
/// interval: a fractional one is read one interval per request, up to
/// , and every one-interval request is sent with its width
/// rounded UP to whole milliseconds so AVEVA answers it as ONE clipped row. The fake models exactly that gateway + AVEVA
/// behaviour (the gateway's round-half-to-even included) over a step-held series.
///
public sealed class GatewayNativeWholeMillisecondGridTests
{
private static readonly CancellationToken Ct = CancellationToken.None;
private static readonly DateTime T0 = new(2026, 11, 11, 14, 2, 3, DateTimeKind.Utc);
private const uint GoodCalc = 0x00000401u;
private const uint Partial = 0x4u;
/// A value that changes every 0.5 ms (1, 2, 3, …): any wrong grid shows in the values.
private static double ValueAt(DateTime t) => 1 + Math.Floor((t - T0).Ticks / 5000.0);
private static double Integral(DateTime a, DateTime b)
{
double sum = 0;
for (var t = a; t < b;)
{
var next = T0.AddTicks(((t - T0).Ticks / 5000 + 1) * 5000);
if (next > b) next = b;
sum += ValueAt(t) * (next - t).TotalSeconds;
t = next;
}
return sum;
}
private static double Expected(RetrievalMode mode, DateTime a, DateTime b) =>
mode == RetrievalMode.Integral ? Integral(a, b) : Integral(a, b) / (b - a).TotalSeconds;
/// The gateway (whole-ms interval) in front of AVEVA (grid anchored at the request start, last interval clipped).
private static FakeHistorianGatewayClient GatewayAndAveva() => new()
{
AggregateSource = (s, e, mode, interval) =>
{
var wire = TimeSpan.FromMilliseconds(Math.Max(1, Math.Round(interval.TotalMilliseconds)));
var rows = new List();
for (var lo = s - wire; lo < e; lo += wire) // AVEVA's extra pre-window row first
{
var hi = lo + wire > e && lo >= s ? e : lo + wire;
rows.Add(new HistorianAggregateSample
{
Tag = "T",
StartTime = Timestamp.FromDateTime(lo),
EndTime = Timestamp.FromDateTime(hi),
Value = Expected(mode, lo, hi),
OpcQuality = 192,
RetrievalMode = mode,
});
}
return rows;
},
};
private static GatewayHistorianDataSource Source(FakeHistorianGatewayClient fake) =>
new(fake, NullLogger.Instance);
[Theory]
[InlineData(HistoryAggregateType.TimeAverage, RetrievalMode.TimeWeightedAverage)]
[InlineData(HistoryAggregateType.Total, RetrievalMode.Integral)]
public async Task A_fractional_millisecond_interval_is_read_one_interval_per_request(HistoryAggregateType agg, RetrievalMode mode)
{
var fake = GatewayAndAveva();
var interval = TimeSpan.FromTicks(15_000); // 1.5 ms — the gateway would send 2 ms
var s = (await Source(fake).ReadProcessedAsync("T", T0, T0.AddMilliseconds(6), interval, agg, Ct)).Samples;
s.Select(x => x.SourceTimestampUtc).ShouldBe(new DateTime?[] { T0, T0.AddTicks(15_000), T0.AddTicks(30_000), T0.AddTicks(45_000) });
s.Select(x => (double)x.Value!).ShouldBe(
Enumerable.Range(0, 4).Select(i => Expected(mode, T0.AddTicks(i * 15_000L), T0.AddTicks((i + 1) * 15_000L))).ToList(),
tolerance: 1e-9);
s.ShouldAllBe(x => x.StatusCode == GoodCalc);
fake.AggregateCalls.Select(c => (c.Start, c.End)).ShouldBe(
Enumerable.Range(0, 4).Select(i => (T0.AddTicks(i * 15_000L), T0.AddTicks((i + 1) * 15_000L))).ToList());
}
[Fact]
public async Task A_fractional_interval_reverse_read_is_exact_too()
{
var fake = GatewayAndAveva();
var m = RetrievalMode.TimeWeightedAverage;
var s = (await Source(fake).ReadProcessedAsync("T", T0.AddTicks(40_000), T0, TimeSpan.FromTicks(15_000),
HistoryAggregateType.TimeAverage, Ct)).Samples;
// (0, 4 ms] stepping back from 4 ms: (2.5, 4], (1, 2.5], and the clipped (0, 1] — newest first, later edges.
s.Select(x => x.SourceTimestampUtc).ShouldBe(new DateTime?[] { T0.AddTicks(40_000), T0.AddTicks(25_000), T0.AddTicks(10_000) });
s.Select(x => (double)x.Value!).ShouldBe(
[Expected(m, T0.AddTicks(25_000), T0.AddTicks(40_000)), Expected(m, T0.AddTicks(10_000), T0.AddTicks(25_000)),
Expected(m, T0, T0.AddTicks(10_000))],
tolerance: 1e-9);
s.Select(x => x.StatusCode).ShouldBe([GoodCalc, GoodCalc, GoodCalc | Partial]);
fake.ReadAggregateCallCount.ShouldBe(3);
}
[Fact]
public async Task A_whole_millisecond_interval_stays_one_request_with_a_sub_millisecond_clipped_interval()
{
var fake = GatewayAndAveva();
var m = RetrievalMode.Integral;
var s = (await Source(fake).ReadProcessedAsync("T", T0, T0.AddTicks(30_004), TimeSpan.FromMilliseconds(1),
HistoryAggregateType.Total, Ct)).Samples;
s.Count.ShouldBe(4);
s.Select(x => (double)x.Value!).ShouldBe(
[Expected(m, T0, T0.AddMilliseconds(1)), Expected(m, T0.AddMilliseconds(1), T0.AddMilliseconds(2)),
Expected(m, T0.AddMilliseconds(2), T0.AddMilliseconds(3)), Expected(m, T0.AddMilliseconds(3), T0.AddTicks(30_004))],
tolerance: 1e-12);
s[^1].StatusCode.ShouldBe(GoodCalc | Partial);
fake.AggregateCalls.Select(c => (c.Start, c.End, c.Interval)).ShouldBe([
(T0, T0.AddMilliseconds(3), TimeSpan.FromMilliseconds(1)),
(T0.AddMilliseconds(3), T0.AddTicks(30_004), TimeSpan.FromMilliseconds(1)), // the 0.4 µs width, rounded UP to 1 ms
]);
}
[Theory]
[InlineData(HistoryAggregateType.TimeAverage, RetrievalMode.TimeWeightedAverage)]
[InlineData(HistoryAggregateType.Total, RetrievalMode.Integral)]
public async Task A_clipped_interval_that_is_not_whole_milliseconds_is_one_row_over_its_whole_span(HistoryAggregateType agg,
RetrievalMode mode)
{
// Live (lmxopcua#694): [40 s, 43.0004 s) sent at its own width reached AVEVA as 3,000 ms and answered a 3 s row plus a
// 0.4 ms one; the first won, so the clipped Total lost its last 0.4 ms. Here: 4 ms intervals, a 2.0004 ms clipped one.
var fake = GatewayAndAveva();
var end = T0.AddTicks(60_004);
var s = (await Source(fake).ReadProcessedAsync("T", T0, end, TimeSpan.FromMilliseconds(4), agg, Ct)).Samples;
s.Count.ShouldBe(2);
((double)s[1].Value!).ShouldBe(Expected(mode, T0.AddMilliseconds(4), end), 1e-12);
s[1].StatusCode.ShouldBe(GoodCalc | Partial);
fake.AggregateCalls[^1].ShouldBe((T0.AddMilliseconds(4), end, mode, TimeSpan.FromMilliseconds(3)));
}
[Fact]
public async Task A_half_millisecond_interval_rounding_to_even_still_reads_each_interval_whole()
{
// 2.5 ms rounds (to even) to 2 ms on the gateway: sent at its width, each interval would answer a 2 ms row + 0.5 ms.
var fake = GatewayAndAveva();
var m = RetrievalMode.Integral;
var s = (await Source(fake).ReadProcessedAsync("T", T0, T0.AddMilliseconds(5), TimeSpan.FromTicks(25_000),
HistoryAggregateType.Total, Ct)).Samples;
s.Select(x => (double)x.Value!).ShouldBe(
[Expected(m, T0, T0.AddTicks(25_000)), Expected(m, T0.AddTicks(25_000), T0.AddMilliseconds(5))], tolerance: 1e-12);
fake.AggregateCalls.Select(c => c.Interval).ShouldAllBe(i => i == TimeSpan.FromMilliseconds(3));
}
[Fact]
public async Task Too_many_fractional_intervals_are_a_request_limit_unsent_and_not_a_backend_failure()
{
var fake = GatewayAndAveva();
var ds = Source(fake);
var interval = TimeSpan.FromTicks(15_000);
var end = T0.AddTicks(15_000L * (NativeAggregatePlan.MaxPerIntervalRequests + 1));
var ex = await Should.ThrowAsync(
() => ds.ReadProcessedAsync("T", T0, end, interval, HistoryAggregateType.TimeAverage, Ct));
ex.Limit.ShouldBe(NativeAggregatePlan.MaxPerIntervalRequests);
fake.ReadAggregateCallCount.ShouldBe(0);
fake.TagExistsCallCount.ShouldBe(0);
ds.GetHealthSnapshot().TotalFailures.ShouldBe(0);
// Positive control: exactly the limit is served.
var ok = await ds.ReadProcessedAsync("T", T0, T0.AddTicks(15_000L * NativeAggregatePlan.MaxPerIntervalRequests), interval,
HistoryAggregateType.TimeAverage, Ct);
ok.Samples.Count.ShouldBe(NativeAggregatePlan.MaxPerIntervalRequests);
}
}