Joseph Doherty
399 lines
17 KiB
C#
399 lines
17 KiB
C#
using Microsoft.Extensions.Logging.Abstractions;
|
|
using Opc.Ua;
|
|
using Opc.Ua.Server;
|
|
using Shouldly;
|
|
using Xunit;
|
|
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
|
|
using HistorianRead = ZB.MOM.WW.OtOpcUa.Core.Abstractions.HistoryReadResult;
|
|
using SdkHistoryReadResult = Opc.Ua.HistoryReadResult;
|
|
|
|
namespace ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests;
|
|
|
|
/// <summary>
|
|
/// Phase C Task 4 — the node-manager's OPC UA HistoryReadEvents override over equipment-folder
|
|
/// event-notifier nodes. Boots a real <see cref="OtOpcUaSdkServer"/> (the same harness Task 3 uses),
|
|
/// wires a recording fake <see cref="IHistorianDataSource"/> BEFORE materialising an alarm condition
|
|
/// (so the alarm-owning equipment folder is promoted to an event notifier WITH the HistoryRead bit),
|
|
/// then invokes the node manager's PUBLIC <c>HistoryRead(OperationContext, …)</c> with a
|
|
/// <see cref="ReadEventDetails"/>. The base CustomNodeManager2 builds the node handles + dispatches to
|
|
/// the protected <c>HistoryReadEvents</c> override, so this exercises the real dispatch path
|
|
/// in-process — fast + deterministic, no client socket.
|
|
/// </summary>
|
|
public sealed class NodeManagerHistoryReadEventsTests : IDisposable
|
|
{
|
|
private static CancellationToken Ct => TestContext.Current.CancellationToken;
|
|
|
|
private readonly string _pkiRoot = Path.Combine(
|
|
Path.GetTempPath(),
|
|
$"otopcua-historyreadevents-{Guid.NewGuid():N}");
|
|
|
|
/// <summary>Happy path: the fake receives (sourceName == the equipment-folder id, StartTime, EndTime,
|
|
/// maxEvents), and each returned event decodes to a HistoryEventFieldList whose EventFields are in
|
|
/// SelectClause ORDER with correctly-typed Variants (EventId ByteString, SourceName string, Time
|
|
/// DateTime, Message LocalizedText, Severity UInt16). StatusCode is Good when events are present.</summary>
|
|
[Fact]
|
|
public async Task Events_dispatches_to_source_and_projects_fields_in_select_order()
|
|
{
|
|
var (host, server) = await BootAsync();
|
|
var nm = server.NodeManager!;
|
|
var fake = new RecordingHistorianDataSource();
|
|
// Wire the source BEFORE materialising the alarm so the folder gets the HistoryRead bit.
|
|
nm.HistorianDataSource = fake;
|
|
|
|
const string equipmentId = "eq-evt";
|
|
nm.EnsureFolder(equipmentId, parentNodeId: null, displayName: "Equipment");
|
|
nm.MaterialiseAlarmCondition("alarm-1", equipmentId, "HighTemp", "OffNormalAlarm", severity: 700);
|
|
var notifierNodeId = nm.TryGetFolder(equipmentId)!.NodeId;
|
|
|
|
var evtTime = new DateTime(2026, 6, 14, 10, 0, 0, DateTimeKind.Utc);
|
|
var rcvTime = new DateTime(2026, 6, 14, 10, 0, 1, DateTimeKind.Utc);
|
|
fake.EventsResult = new HistoricalEventsResult(
|
|
new[] { new HistoricalEvent("evt-42", "Pump_001", evtTime, rcvTime, "Pump tripped", 700) }, null);
|
|
|
|
var start = DateTime.UtcNow.AddHours(-1);
|
|
var end = DateTime.UtcNow;
|
|
var details = new ReadEventDetails
|
|
{
|
|
StartTime = start,
|
|
EndTime = end,
|
|
NumValuesPerNode = 50,
|
|
Filter = SelectFilter("EventId", "SourceName", "Time", "Message", "Severity"),
|
|
};
|
|
|
|
var (results, errors) = InvokeHistoryRead(server, nm, details, notifierNodeId);
|
|
|
|
// The source saw the equipment/folder id as the sourceName + the request window + cap.
|
|
fake.LastSourceName.ShouldBe(equipmentId);
|
|
fake.LastStart.ShouldBe(start);
|
|
fake.LastEnd.ShouldBe(end);
|
|
fake.LastMaxEvents.ShouldBe(50);
|
|
|
|
errors[0].StatusCode.Code.ShouldBe(StatusCodes.Good);
|
|
results[0].StatusCode.Code.ShouldBe(StatusCodes.Good);
|
|
|
|
var history = (HistoryEvent)ExtensionObject.ToEncodeable(results[0].HistoryData);
|
|
history.Events.Count.ShouldBe(1);
|
|
var fields = history.Events[0].EventFields;
|
|
fields.Count.ShouldBe(5);
|
|
|
|
// EventId ⇒ ByteString (UTF-8 of "evt-42").
|
|
fields[0].Value.ShouldBeOfType<byte[]>().ShouldBe(System.Text.Encoding.UTF8.GetBytes("evt-42"));
|
|
// SourceName ⇒ string.
|
|
fields[1].Value.ShouldBe("Pump_001");
|
|
// Time ⇒ DateTime.
|
|
fields[2].Value.ShouldBe(evtTime);
|
|
// Message ⇒ LocalizedText.
|
|
fields[3].Value.ShouldBeOfType<LocalizedText>().Text.ShouldBe("Pump tripped");
|
|
// Severity ⇒ UInt16.
|
|
fields[4].Value.ShouldBe((ushort)700);
|
|
|
|
await host.DisposeAsync();
|
|
}
|
|
|
|
/// <summary>An unsupported select operand (BrowsePath ["EventType"]) projects to Variant.Null — a field
|
|
/// the server can't supply is null (spec-conformant) — while supported siblings still project.</summary>
|
|
[Fact]
|
|
public async Task Events_unsupported_select_field_projects_null()
|
|
{
|
|
var (host, server) = await BootAsync();
|
|
var nm = server.NodeManager!;
|
|
var fake = new RecordingHistorianDataSource();
|
|
nm.HistorianDataSource = fake;
|
|
|
|
const string equipmentId = "eq-unsupported";
|
|
nm.EnsureFolder(equipmentId, parentNodeId: null, displayName: "Equipment");
|
|
nm.MaterialiseAlarmCondition("alarm-2", equipmentId, "Cond", "OffNormalAlarm", severity: 500);
|
|
var notifierNodeId = nm.TryGetFolder(equipmentId)!.NodeId;
|
|
|
|
fake.EventsResult = new HistoricalEventsResult(
|
|
new[] { new HistoricalEvent("evt-1", "Src", DateTime.UtcNow, DateTime.UtcNow, "msg", 500) }, null);
|
|
|
|
var details = new ReadEventDetails
|
|
{
|
|
StartTime = DateTime.UtcNow.AddHours(-1),
|
|
EndTime = DateTime.UtcNow,
|
|
NumValuesPerNode = 10,
|
|
// EventType is a real BaseEventType field we cannot supply from a HistoricalEvent; EventId is.
|
|
Filter = SelectFilter("EventType", "EventId"),
|
|
};
|
|
|
|
var (results, errors) = InvokeHistoryRead(server, nm, details, notifierNodeId);
|
|
|
|
errors[0].StatusCode.Code.ShouldBe(StatusCodes.Good);
|
|
var history = (HistoryEvent)ExtensionObject.ToEncodeable(results[0].HistoryData);
|
|
var fields = history.Events[0].EventFields;
|
|
fields.Count.ShouldBe(2);
|
|
// EventType ⇒ Variant.Null.
|
|
fields[0].Value.ShouldBeNull();
|
|
// EventId still projects to a ByteString.
|
|
fields[1].Value.ShouldBeOfType<byte[]>().ShouldBe(System.Text.Encoding.UTF8.GetBytes("evt-1"));
|
|
|
|
await host.DisposeAsync();
|
|
}
|
|
|
|
/// <summary>Empty events ⇒ the notifier's StatusCode is GoodNoData (the source is wired, the window
|
|
/// just held no events).</summary>
|
|
[Fact]
|
|
public async Task Events_empty_yields_GoodNoData()
|
|
{
|
|
var (host, server) = await BootAsync();
|
|
var nm = server.NodeManager!;
|
|
var fake = new RecordingHistorianDataSource
|
|
{
|
|
EventsResult = new HistoricalEventsResult(Array.Empty<HistoricalEvent>(), null),
|
|
};
|
|
nm.HistorianDataSource = fake;
|
|
|
|
const string equipmentId = "eq-empty";
|
|
nm.EnsureFolder(equipmentId, parentNodeId: null, displayName: "Equipment");
|
|
nm.MaterialiseAlarmCondition("alarm-3", equipmentId, "Cond", "OffNormalAlarm", severity: 300);
|
|
var notifierNodeId = nm.TryGetFolder(equipmentId)!.NodeId;
|
|
|
|
var details = new ReadEventDetails
|
|
{
|
|
StartTime = DateTime.UtcNow.AddHours(-1),
|
|
EndTime = DateTime.UtcNow,
|
|
NumValuesPerNode = 10,
|
|
Filter = SelectFilter("EventId"),
|
|
};
|
|
|
|
var (results, errors) = InvokeHistoryRead(server, nm, details, notifierNodeId);
|
|
|
|
errors[0].StatusCode.Code.ShouldBe(StatusCodes.Good);
|
|
results[0].StatusCode.Code.ShouldBe(StatusCodes.GoodNoData);
|
|
var history = (HistoryEvent)ExtensionObject.ToEncodeable(results[0].HistoryData);
|
|
history.Events.ShouldBeEmpty();
|
|
|
|
await host.DisposeAsync();
|
|
}
|
|
|
|
/// <summary>A folder promoted to an event notifier while NO historian was wired (Null source at
|
|
/// materialise time) is NOT registered as an event-history source ⇒ a HistoryReadEvents over it yields
|
|
/// BadHistoryOperationUnsupported, and the (later-wired) source is never invoked.</summary>
|
|
[Fact]
|
|
public async Task Events_folder_promoted_without_source_yields_BadHistoryOperationUnsupported()
|
|
{
|
|
var (host, server) = await BootAsync();
|
|
var nm = server.NodeManager!;
|
|
|
|
// Materialise the alarm while the source is still the Null default — the folder is promoted to
|
|
// SubscribeToEvents but DOES NOT get the HistoryRead bit / source registration.
|
|
const string equipmentId = "eq-nosrc";
|
|
nm.EnsureFolder(equipmentId, parentNodeId: null, displayName: "Equipment");
|
|
nm.MaterialiseAlarmCondition("alarm-4", equipmentId, "Cond", "OffNormalAlarm", severity: 200);
|
|
var notifierNodeId = nm.TryGetFolder(equipmentId)!.NodeId;
|
|
|
|
// Wire a real source AFTER promotion — it must NOT retroactively make the folder a source.
|
|
var fake = new RecordingHistorianDataSource();
|
|
nm.HistorianDataSource = fake;
|
|
|
|
var details = new ReadEventDetails
|
|
{
|
|
StartTime = DateTime.UtcNow.AddHours(-1),
|
|
EndTime = DateTime.UtcNow,
|
|
NumValuesPerNode = 10,
|
|
Filter = SelectFilter("EventId"),
|
|
};
|
|
|
|
var (_, errors) = InvokeHistoryRead(server, nm, details, notifierNodeId);
|
|
|
|
errors[0].StatusCode.Code.ShouldBe(StatusCodes.BadHistoryOperationUnsupported);
|
|
fake.LastSourceName.ShouldBeNull(); // source never reached
|
|
fake.EventsCalled.ShouldBeFalse();
|
|
|
|
await host.DisposeAsync();
|
|
}
|
|
|
|
/// <summary>A node we own that is NOT a registered event-notifier source (a plain variable node) ⇒
|
|
/// BadHistoryOperationUnsupported; the source is never invoked.</summary>
|
|
[Fact]
|
|
public async Task Events_non_source_node_yields_BadHistoryOperationUnsupported()
|
|
{
|
|
var (host, server) = await BootAsync();
|
|
var nm = server.NodeManager!;
|
|
var fake = new RecordingHistorianDataSource();
|
|
nm.HistorianDataSource = fake;
|
|
|
|
// A historized variable node — owns the HistoryRead bit (so the base hands it to us) but is NOT an
|
|
// event-notifier source, so the Events arm must reject it.
|
|
nm.EnsureVariable("eq-1/temp", parentFolderNodeId: null, displayName: "Temp", dataType: "Float",
|
|
writable: false, historianTagname: "WW.Temp");
|
|
var nodeId = nm.TryGetVariable("eq-1/temp")!.NodeId;
|
|
|
|
var details = new ReadEventDetails
|
|
{
|
|
StartTime = DateTime.UtcNow.AddHours(-1),
|
|
EndTime = DateTime.UtcNow,
|
|
NumValuesPerNode = 10,
|
|
Filter = SelectFilter("EventId"),
|
|
};
|
|
|
|
var (_, errors) = InvokeHistoryRead(server, nm, details, nodeId);
|
|
|
|
errors[0].StatusCode.Code.ShouldBe(StatusCodes.BadHistoryOperationUnsupported);
|
|
fake.EventsCalled.ShouldBeFalse();
|
|
|
|
await host.DisposeAsync();
|
|
}
|
|
|
|
/// <summary>A backend that throws ⇒ that node's error is Bad and no exception escapes the
|
|
/// HistoryRead call.</summary>
|
|
[Fact]
|
|
public async Task Events_backend_throw_yields_bad_status_and_does_not_escape()
|
|
{
|
|
var (host, server) = await BootAsync();
|
|
var nm = server.NodeManager!;
|
|
var fake = new RecordingHistorianDataSource { ThrowOnRead = true };
|
|
nm.HistorianDataSource = fake;
|
|
|
|
const string equipmentId = "eq-boom";
|
|
nm.EnsureFolder(equipmentId, parentNodeId: null, displayName: "Equipment");
|
|
nm.MaterialiseAlarmCondition("alarm-5", equipmentId, "Cond", "OffNormalAlarm", severity: 900);
|
|
var notifierNodeId = nm.TryGetFolder(equipmentId)!.NodeId;
|
|
|
|
var details = new ReadEventDetails
|
|
{
|
|
StartTime = DateTime.UtcNow.AddHours(-1),
|
|
EndTime = DateTime.UtcNow,
|
|
NumValuesPerNode = 10,
|
|
Filter = SelectFilter("EventId"),
|
|
};
|
|
|
|
// The call must not throw even though the backend does.
|
|
var (results, errors) = InvokeHistoryRead(server, nm, details, notifierNodeId);
|
|
|
|
StatusCode.IsBad(errors[0].StatusCode).ShouldBeTrue();
|
|
errors[0].StatusCode.Code.ShouldBe(StatusCodes.BadHistoryOperationUnsupported);
|
|
(results[0].StatusCode.Code == StatusCodes.GoodNoData).ShouldBeFalse();
|
|
|
|
await host.DisposeAsync();
|
|
}
|
|
|
|
/// <summary>Build a HistoryReadEvents-style event filter whose select clauses are single-element
|
|
/// BrowsePaths over the supplied BaseEventType leaf field names, in order.</summary>
|
|
private static EventFilter SelectFilter(params string[] leafFieldNames)
|
|
{
|
|
var filter = new EventFilter();
|
|
foreach (var name in leafFieldNames)
|
|
{
|
|
filter.SelectClauses.Add(
|
|
new SimpleAttributeOperand(ObjectTypeIds.BaseEventType, new QualifiedName(name))
|
|
{
|
|
AttributeId = Attributes.Value,
|
|
});
|
|
}
|
|
|
|
return filter;
|
|
}
|
|
|
|
/// <summary>Invoke the node manager's public HistoryRead with a single node, returning the filled
|
|
/// results + errors — same session-less <see cref="OperationContext"/> pattern as Task 3's tests.</summary>
|
|
private static (IList<SdkHistoryReadResult> Results, IList<ServiceResult> Errors) InvokeHistoryRead(
|
|
OtOpcUaSdkServer server, OtOpcUaNodeManager nm, HistoryReadDetails details, NodeId nodeId)
|
|
{
|
|
var context = new OperationContext(
|
|
new RequestHeader(), secureChannelContext: null, RequestType.HistoryRead, identity: null);
|
|
|
|
var nodesToRead = new List<HistoryReadValueId> { new() { NodeId = nodeId } };
|
|
var results = new List<SdkHistoryReadResult> { null! };
|
|
var errors = new List<ServiceResult> { null! };
|
|
|
|
nm.HistoryRead(
|
|
context,
|
|
details,
|
|
TimestampsToReturn.Both,
|
|
releaseContinuationPoints: false,
|
|
nodesToRead,
|
|
results,
|
|
errors);
|
|
|
|
return (results, errors);
|
|
}
|
|
|
|
/// <summary>A recording fake historian source — captures the last ReadEventsAsync call's arguments and
|
|
/// returns a configured result (or throws when <see cref="ThrowOnRead"/> is set). The Raw/Processed/
|
|
/// AtTime reads delegate to the Null source (unused by these tests).</summary>
|
|
private sealed class RecordingHistorianDataSource : IHistorianDataSource
|
|
{
|
|
public bool ThrowOnRead { get; init; }
|
|
public HistoricalEventsResult EventsResult { get; set; } =
|
|
new(Array.Empty<HistoricalEvent>(), null);
|
|
|
|
public bool EventsCalled { get; private set; }
|
|
public string? LastSourceName { get; private set; }
|
|
public DateTime LastStart { get; private set; }
|
|
public DateTime LastEnd { get; private set; }
|
|
public int LastMaxEvents { get; private set; }
|
|
|
|
public Task<HistorianRead> ReadRawAsync(
|
|
string fullReference, DateTime startUtc, DateTime endUtc, uint maxValuesPerNode,
|
|
CancellationToken cancellationToken) =>
|
|
NullHistorianDataSource.Instance.ReadRawAsync(fullReference, startUtc, endUtc, maxValuesPerNode, cancellationToken);
|
|
|
|
public Task<HistorianRead> ReadProcessedAsync(
|
|
string fullReference, DateTime startUtc, DateTime endUtc, TimeSpan interval,
|
|
HistoryAggregateType aggregate, CancellationToken cancellationToken) =>
|
|
NullHistorianDataSource.Instance.ReadProcessedAsync(fullReference, startUtc, endUtc, interval, aggregate, cancellationToken);
|
|
|
|
public Task<HistorianRead> ReadAtTimeAsync(
|
|
string fullReference, IReadOnlyList<DateTime> timestampsUtc, CancellationToken cancellationToken) =>
|
|
NullHistorianDataSource.Instance.ReadAtTimeAsync(fullReference, timestampsUtc, cancellationToken);
|
|
|
|
public Task<HistoricalEventsResult> ReadEventsAsync(
|
|
string? sourceName, DateTime startUtc, DateTime endUtc, int maxEvents,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (ThrowOnRead) throw new InvalidOperationException("backend boom for events");
|
|
EventsCalled = true;
|
|
LastSourceName = sourceName;
|
|
LastStart = startUtc;
|
|
LastEnd = endUtc;
|
|
LastMaxEvents = maxEvents;
|
|
return Task.FromResult(EventsResult);
|
|
}
|
|
|
|
public HistorianHealthSnapshot GetHealthSnapshot() => NullHistorianDataSource.Instance.GetHealthSnapshot();
|
|
|
|
public void Dispose()
|
|
{
|
|
}
|
|
}
|
|
|
|
private async Task<(OpcUaApplicationHost Host, OtOpcUaSdkServer Server)> BootAsync()
|
|
{
|
|
var host = new OpcUaApplicationHost(
|
|
new OpcUaApplicationHostOptions
|
|
{
|
|
ApplicationName = "OtOpcUa.HistoryReadEventsTest",
|
|
ApplicationUri = $"urn:OtOpcUa.HistoryReadEventsTest:{Guid.NewGuid():N}",
|
|
OpcUaPort = AllocateFreePort(),
|
|
PublicHostname = "localhost",
|
|
PkiStoreRoot = _pkiRoot,
|
|
},
|
|
NullLogger<OpcUaApplicationHost>.Instance);
|
|
|
|
var server = new OtOpcUaSdkServer();
|
|
await host.StartAsync(server, Ct);
|
|
return (host, server);
|
|
}
|
|
|
|
private static int AllocateFreePort()
|
|
{
|
|
using var listener = new System.Net.Sockets.TcpListener(System.Net.IPAddress.Loopback, 0);
|
|
listener.Start();
|
|
var port = ((System.Net.IPEndPoint)listener.LocalEndpoint).Port;
|
|
listener.Stop();
|
|
return port;
|
|
}
|
|
|
|
/// <summary>Cleans up the PKI root directory.</summary>
|
|
public void Dispose()
|
|
{
|
|
if (Directory.Exists(_pkiRoot))
|
|
{
|
|
try { Directory.Delete(_pkiRoot, recursive: true); }
|
|
catch { /* best-effort cleanup */ }
|
|
}
|
|
}
|
|
}
|