Joseph Doherty
174 lines
10 KiB
C#
174 lines
10 KiB
C#
using Moq;
|
|
using Opc.Ua;
|
|
using Opc.Ua.Client;
|
|
using Shouldly;
|
|
using Xunit;
|
|
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
|
|
|
|
namespace ZB.MOM.WW.OtOpcUa.Driver.OpcUaClient.Tests;
|
|
|
|
[Trait("Category", "Unit")]
|
|
public sealed class OpcUaClientSdkValueBoundaryTests
|
|
{
|
|
private const string Reference = "Plant/Upstream/Value";
|
|
private static readonly RawTagEntry[] Tags = [new(Reference, """{"nodeId":"i=2258"}""", false)];
|
|
|
|
private static (OpcUaClientDriver Driver, Mock<ISession> Session) Connected()
|
|
{
|
|
var session = new Mock<ISession>();
|
|
session.SetupGet(s => s.MessageContext).Returns(ServiceMessageContext.Create(SdkTelemetry.Context));
|
|
session.SetupGet(s => s.NamespaceUris).Returns(new NamespaceTable());
|
|
var driver = new OpcUaClientDriver(new OpcUaClientDriverOptions { RawTags = Tags }, "sdk2-values");
|
|
driver.SetSessionForTest(session.Object);
|
|
driver.SetNamespaceMapForTest(NamespaceMap.FromTable(new NamespaceTable(), Tags));
|
|
return (driver, session);
|
|
}
|
|
|
|
public static TheoryData<Variant, object?> Payloads =>
|
|
[
|
|
new(Variant.From((sbyte)-3), (sbyte)-3),
|
|
new(Variant.From((byte)250), (byte)250),
|
|
new(Variant.From((short)-30), (short)-30),
|
|
new(Variant.From((ushort)60000), (ushort)60000),
|
|
new(Variant.From(-100), -100),
|
|
new(Variant.From(uint.MaxValue), uint.MaxValue),
|
|
new(Variant.From(long.MinValue), long.MinValue),
|
|
new(Variant.From(ulong.MaxValue), ulong.MaxValue),
|
|
new(Variant.From(1.5f), 1.5f),
|
|
new(Variant.From(1.5d), 1.5d),
|
|
new(Variant.From(true), true),
|
|
new(Variant.From("text"), "text"),
|
|
new(Variant.Null, null),
|
|
new(Variant.From(new DateTimeUtc(new DateTime(2026, 11, 10, 1, 2, 3, DateTimeKind.Utc))), new DateTime(2026, 11, 10, 1, 2, 3, DateTimeKind.Utc)),
|
|
new(Variant.From(new Uuid(Guid.Parse("db8d57c4-316f-4517-819f-194c3a6db955"))), Guid.Parse("db8d57c4-316f-4517-819f-194c3a6db955")),
|
|
new(Variant.From(new byte[] { 1, 2 }.ToByteString()), new byte[] { 1, 2 }),
|
|
new(Variant.From(default(ByteString)), null),
|
|
new(Variant.From(ByteString.Empty), Array.Empty<byte>()),
|
|
new(Variant.From((ArrayOf<bool>)[true, false]), new[] { true, false }),
|
|
new(Variant.From((ArrayOf<sbyte>)[-1, 2]), new sbyte[] { -1, 2 }),
|
|
new(Variant.From((ArrayOf<byte>)[1, 250]), new byte[] { 1, 250 }),
|
|
new(Variant.From((ArrayOf<short>)[1, 2]), new short[] { 1, 2 }),
|
|
new(Variant.From((ArrayOf<ushort>)[1, 60000]), new ushort[] { 1, 60000 }),
|
|
new(Variant.From((ArrayOf<int>)[-1, 2]), new int[] { -1, 2 }),
|
|
new(Variant.From((ArrayOf<long>)[long.MinValue, long.MaxValue]), new long[] { long.MinValue, long.MaxValue }),
|
|
new(Variant.From((ArrayOf<ulong>)[0, ulong.MaxValue]), new ulong[] { 0, ulong.MaxValue }),
|
|
new(Variant.From((ArrayOf<double>)[1, 2]), new double[] { 1, 2 }),
|
|
new(Variant.From((ArrayOf<uint>)[1, 2]), new uint[] { 1, 2 }),
|
|
new(Variant.From((ArrayOf<float>)[1, 2]), new float[] { 1, 2 }),
|
|
new(Variant.From((ArrayOf<string>)["a", "b"]), new[] { "a", "b" }),
|
|
new(Variant.From((ArrayOf<DateTimeUtc>)[new DateTimeUtc(new DateTime(2026, 11, 10, 1, 2, 3, DateTimeKind.Utc))]), new[] { new DateTime(2026, 11, 10, 1, 2, 3, DateTimeKind.Utc) }),
|
|
new(Variant.From((ArrayOf<Uuid>)[new Uuid(Guid.Empty)]), new[] { Guid.Empty }),
|
|
new(Variant.From((ArrayOf<ByteString>)[new byte[] { 3 }.ToByteString(), ByteString.Empty]), new byte[][] { [3], [] }),
|
|
new(Variant.From(default(ArrayOf<short>)), null),
|
|
new(Variant.From((ArrayOf<short>)[]), Array.Empty<short>()),
|
|
];
|
|
|
|
[Theory]
|
|
[MemberData(nameof(Payloads))]
|
|
public async Task Read_and_notification_preserve_CLR_type_status_and_timestamp_rules(Variant upstream, object? expected)
|
|
{
|
|
var (driver, session) = Connected();
|
|
using var _ = driver;
|
|
session.Setup(s => s.ReadAsync(It.IsAny<RequestHeader>(), It.IsAny<double>(), It.IsAny<TimestampsToReturn>(),
|
|
It.IsAny<ArrayOf<ReadValueId>>(), It.IsAny<CancellationToken>())).ReturnsAsync(new ReadResponse
|
|
{ Results = [new DataValue(upstream, StatusCodes.UncertainLastUsableValue, DateTimeUtc.MinValue, DateTimeUtc.MinValue)] });
|
|
var before = DateTime.UtcNow;
|
|
var read = (await driver.ReadAsync([Reference], TestContext.Current.CancellationToken)).Single();
|
|
AssertPayload(read, expected, before);
|
|
DataValueSnapshot? notified = null;
|
|
driver.OnDataChange += (_, e) => notified = e.Snapshot;
|
|
var handle = driver.AddSubscriptionForTest([Reference]);
|
|
driver.DeliverNotificationForTest(handle, Reference,
|
|
new DataValue(upstream, StatusCodes.UncertainLastUsableValue, DateTimeUtc.MinValue, DateTimeUtc.MinValue));
|
|
AssertPayload(notified.ShouldNotBeNull(), expected, before);
|
|
}
|
|
|
|
private static void AssertPayload(DataValueSnapshot snapshot, object? expected, DateTime before)
|
|
{
|
|
snapshot.Value.ShouldBe(expected);
|
|
snapshot.Value?.GetType().ShouldBe(expected?.GetType());
|
|
snapshot.StatusCode.ShouldBe(StatusCodes.UncertainLastUsableValue.Code);
|
|
snapshot.SourceTimestampUtc.ShouldBeNull();
|
|
snapshot.ServerTimestampUtc.ShouldBeGreaterThanOrEqualTo(before);
|
|
snapshot.ServerTimestampUtc.Kind.ShouldBe(DateTimeKind.Utc);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(0)]
|
|
[InlineData(1)]
|
|
[InlineData(2)]
|
|
public async Task Read_and_notification_detach_upstream_buffers(int shape)
|
|
{
|
|
var (driver, session) = Connected();
|
|
using var _ = driver;
|
|
byte[] bytes = [1, 2];
|
|
short[] numbers = [3, 4];
|
|
// ReadOnlyMemory constructors deliberately alias the backing SDK buffer. Copying the
|
|
// test input before the adapter sees it would make the ownership assertion vacuous.
|
|
var value = shape switch
|
|
{
|
|
0 => Variant.From(new ByteString(bytes.AsMemory())),
|
|
1 => Variant.From(new ArrayOf<short>(numbers.AsMemory())),
|
|
_ => Variant.From((ArrayOf<ByteString>)[new ByteString(bytes.AsMemory())]),
|
|
};
|
|
object expected = shape switch { 0 => new byte[] { 1, 2 }, 1 => new short[] { 3, 4 }, _ => new byte[][] { [1, 2] } };
|
|
session.Setup(s => s.ReadAsync(It.IsAny<RequestHeader>(), It.IsAny<double>(), It.IsAny<TimestampsToReturn>(),
|
|
It.IsAny<ArrayOf<ReadValueId>>(), It.IsAny<CancellationToken>())).ReturnsAsync(new ReadResponse { Results = [new DataValue(value)] });
|
|
var read = (await driver.ReadAsync([Reference], TestContext.Current.CancellationToken)).Single();
|
|
DataValueSnapshot? notified = null;
|
|
driver.OnDataChange += (_, e) => notified = e.Snapshot;
|
|
driver.DeliverNotificationForTest(driver.AddSubscriptionForTest([Reference]), Reference, new DataValue(value));
|
|
bytes[0] = 99;
|
|
numbers[0] = 99;
|
|
read.Value.ShouldBe(expected);
|
|
notified.ShouldNotBeNull().Value.ShouldBe(expected);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Matrix_read_and_notification_are_refused_per_item_without_materialization()
|
|
{
|
|
var (driver, session) = Connected();
|
|
using var _ = driver;
|
|
var sourceTime = new DateTime(2026, 11, 10, 1, 2, 3, DateTimeKind.Utc);
|
|
var serverTime = sourceTime.AddSeconds(1);
|
|
var matrix = Variant.From(new int[,] { { 1, 2 }, { 3, 4 } }.ToMatrixOf());
|
|
session.Setup(s => s.ReadAsync(It.IsAny<RequestHeader>(), It.IsAny<double>(), It.IsAny<TimestampsToReturn>(),
|
|
It.IsAny<ArrayOf<ReadValueId>>(), It.IsAny<CancellationToken>())).ReturnsAsync(new ReadResponse
|
|
{ Results = [new DataValue(matrix, StatusCodes.Good, sourceTime, serverTime),
|
|
new DataValue(Variant.From(42), StatusCodes.Good, sourceTime, serverTime)] });
|
|
var results = await driver.ReadAsync([Reference, Reference], TestContext.Current.CancellationToken);
|
|
results[0].Value.ShouldBeNull();
|
|
results[0].StatusCode.ShouldBe(StatusCodes.BadTypeMismatch.Code);
|
|
results[0].SourceTimestampUtc.ShouldBe(sourceTime);
|
|
results[0].ServerTimestampUtc.ShouldBe(serverTime);
|
|
results[1].Value.ShouldBe(42);
|
|
results[1].StatusCode.ShouldBe(StatusCodes.Good.Code);
|
|
DataValueSnapshot? notified = null;
|
|
driver.OnDataChange += (_, e) => notified = e.Snapshot;
|
|
driver.DeliverNotificationForTest(driver.AddSubscriptionForTest([Reference]), Reference,
|
|
new DataValue(matrix, StatusCodes.UncertainLastUsableValue, sourceTime, serverTime));
|
|
notified.ShouldNotBeNull().Value.ShouldBeNull();
|
|
notified.StatusCode.ShouldBe(StatusCodes.BadTypeMismatch.Code);
|
|
notified.SourceTimestampUtc.ShouldBe(sourceTime);
|
|
notified.ServerTimestampUtc.ShouldBe(serverTime);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Write_passes_scalar_shaped_arrays_once_and_rejects_unsupported_values_before_IO()
|
|
{
|
|
var (driver, session) = Connected();
|
|
using var _ = driver;
|
|
short[] caller = [7, 8];
|
|
ArrayOf<WriteValue> sent = default;
|
|
session.Setup(s => s.WriteAsync(It.IsAny<RequestHeader>(), It.IsAny<ArrayOf<WriteValue>>(), It.IsAny<CancellationToken>()))
|
|
.Callback<RequestHeader, ArrayOf<WriteValue>, CancellationToken>((_, writes, _) => { sent = writes; caller[0] = 99; })
|
|
.ReturnsAsync(new WriteResponse { Results = [StatusCodes.Good] });
|
|
var result = await driver.WriteAsync([new(Reference, caller), new(Reference, new object()), new(Reference, new int[1, 1])], TestContext.Current.CancellationToken);
|
|
result.Select(r => r.StatusCode).ShouldBe([StatusCodes.Good.Code, StatusCodes.BadTypeMismatch.Code, StatusCodes.BadTypeMismatch.Code]);
|
|
sent.Count.ShouldBe(1);
|
|
sent[0].Value.WrappedValue.TypeInfo.ValueRank.ShouldBe(ValueRanks.OneDimension);
|
|
UpstreamValueMapping.ToClr(sent[0].Value.WrappedValue).ShouldBe(new short[] { 7, 8 });
|
|
session.Verify(s => s.WriteAsync(It.IsAny<RequestHeader>(), It.IsAny<ArrayOf<WriteValue>>(), It.IsAny<CancellationToken>()), Times.Once);
|
|
}
|
|
}
|