bf329b05d8
Interface additions use C# default interface implementations that throw NotSupportedException — existing IHistoryProvider implementations keep compiling, only drivers whose backend carries the relevant capability override. This matches the 'capabilities are optional per driver' design already used by IHistoryProvider.ReadProcessedAsync's docs (Modbus / OPC UA Client drivers never had an event historian and the default-throw path lets callers see BadHistoryOperationUnsupported naturally). New HistoricalEvent record models one historian row (EventId, SourceName, EventTimeUtc + ReceivedTimeUtc — process vs historian-persist timestamps, Message, Severity mapped to OPC UA's 1-1000 range); HistoricalEventsResult pairs the event list with a continuation-point token for future batching. Both live in Core.Abstractions so downstream (Proxy, Host, Server) reference a single domain shape — no Shared-contract leak into the driver-facing interface. GalaxyProxyDriver.ReadAtTimeAsync maps the domain DateTime[] to Unix-ms longs, calls CallAsync on the existing MessageKind.HistoryReadAtTimeRequest, and trusts the Host's one-sample-per-requested-timestamp contract (the Host pads with bad-quality snapshots for timestamps it can't interpolate; re-aligning on the Proxy side would duplicate the Host's interpolation policy logic). ReadEventsAsync does the same for HistoryReadEventsRequest; ToHistoricalEvent translates GalaxyHistoricalEvent (MessagePack-annotated, Unix-ms) to the domain record, explicitly tagging DateTimeKind.Utc on both timestamp fields so downstream serializers (JSON, OPC UA types) don't apply an unexpected local-time offset. Tests — HistoricalEventMappingTests (3 new Proxy.Tests unit cases): every field maps correctly from wire to domain; null SourceName and null DisplayText preserve through the mapping (system events without a source come out with null so callers can distinguish them from alarm events); both timestamps come out as DateTimeKind.Utc (regression guard against a future refactor using DateTime.FromFileTimeUtc or similar that defaults to Unspecified). Driver.Galaxy.Proxy.Tests Unit suite: 17 pass / 0 fail (14 prior + 3 new). Full solution build clean, 0 errors. Scope exclusions — DriverNodeManager HistoryRead service-handler wiring (on the OPC UA Server side, where HistoryReadAtTime and HistoryReadEvents service requests land) and the full-loop integration test (OPC UA client → server → IPC → Host → HistorianDataSource → back) are deferred to a focused follow-up PR. The capability surface is the load-bearing change; wiring the service handlers is mechanical in comparison and worth its own PR for reviewability. docs/v2/lmx-followups.md #1 updated with the split. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
82 lines
3.0 KiB
C#
82 lines
3.0 KiB
C#
using Shouldly;
|
|
using Xunit;
|
|
using ZB.MOM.WW.OtOpcUa.Driver.Galaxy.Proxy;
|
|
using ZB.MOM.WW.OtOpcUa.Driver.Galaxy.Shared.Contracts;
|
|
|
|
namespace ZB.MOM.WW.OtOpcUa.Driver.Galaxy.Proxy.Tests;
|
|
|
|
/// <summary>
|
|
/// Pins <see cref="GalaxyProxyDriver.ToHistoricalEvent"/> — the wire-to-domain mapping
|
|
/// from <see cref="GalaxyHistoricalEvent"/> (MessagePack-annotated IPC contract,
|
|
/// Unix-ms timestamps) to <c>Core.Abstractions.HistoricalEvent</c> (domain record,
|
|
/// <see cref="DateTime"/> timestamps). Added in PR 35 alongside the new
|
|
/// <c>IHistoryProvider.ReadEventsAsync</c> method.
|
|
/// </summary>
|
|
[Trait("Category", "Unit")]
|
|
public sealed class HistoricalEventMappingTests
|
|
{
|
|
[Fact]
|
|
public void Maps_every_field_from_wire_to_domain_record()
|
|
{
|
|
var wire = new GalaxyHistoricalEvent
|
|
{
|
|
EventId = "evt-42",
|
|
SourceName = "Tank1.HiAlarm",
|
|
EventTimeUtcUnixMs = 1_700_000_000_000L, // 2023-11-14T22:13:20.000Z
|
|
ReceivedTimeUtcUnixMs = 1_700_000_000_500L,
|
|
DisplayText = "High level reached",
|
|
Severity = 750,
|
|
};
|
|
|
|
var domain = GalaxyProxyDriver.ToHistoricalEvent(wire);
|
|
|
|
domain.EventId.ShouldBe("evt-42");
|
|
domain.SourceName.ShouldBe("Tank1.HiAlarm");
|
|
domain.EventTimeUtc.ShouldBe(new DateTime(2023, 11, 14, 22, 13, 20, DateTimeKind.Utc));
|
|
domain.ReceivedTimeUtc.ShouldBe(new DateTime(2023, 11, 14, 22, 13, 20, 500, DateTimeKind.Utc));
|
|
domain.Message.ShouldBe("High level reached");
|
|
domain.Severity.ShouldBe((ushort)750);
|
|
}
|
|
|
|
[Fact]
|
|
public void Preserves_null_SourceName_and_DisplayText()
|
|
{
|
|
// Historical rows from the Galaxy event historian often omit source or message for
|
|
// system events (e.g. time sync). The mapping must preserve null — callers use it to
|
|
// distinguish system events from alarm events.
|
|
var wire = new GalaxyHistoricalEvent
|
|
{
|
|
EventId = "sys-1",
|
|
SourceName = null,
|
|
EventTimeUtcUnixMs = 0,
|
|
ReceivedTimeUtcUnixMs = 0,
|
|
DisplayText = null,
|
|
Severity = 1,
|
|
};
|
|
|
|
var domain = GalaxyProxyDriver.ToHistoricalEvent(wire);
|
|
|
|
domain.SourceName.ShouldBeNull();
|
|
domain.Message.ShouldBeNull();
|
|
}
|
|
|
|
[Fact]
|
|
public void EventTime_and_ReceivedTime_are_produced_as_DateTimeKind_Utc()
|
|
{
|
|
// Unix-ms timestamps come off the wire timezone-agnostic; the mapping must tag the
|
|
// resulting DateTime as Utc so downstream serializers (JSON, OPC UA types) don't apply
|
|
// an unexpected local-time offset.
|
|
var wire = new GalaxyHistoricalEvent
|
|
{
|
|
EventId = "e",
|
|
EventTimeUtcUnixMs = 1_000L,
|
|
ReceivedTimeUtcUnixMs = 2_000L,
|
|
};
|
|
|
|
var domain = GalaxyProxyDriver.ToHistoricalEvent(wire);
|
|
|
|
domain.EventTimeUtc.Kind.ShouldBe(DateTimeKind.Utc);
|
|
domain.ReceivedTimeUtc.Kind.ShouldBe(DateTimeKind.Utc);
|
|
}
|
|
}
|