239 lines
10 KiB
C#
239 lines
10 KiB
C#
using Shouldly;
|
|
using Xunit;
|
|
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
|
|
using ZB.MOM.WW.OtOpcUa.Driver.TwinCAT;
|
|
|
|
namespace ZB.MOM.WW.OtOpcUa.Driver.TwinCAT.Tests;
|
|
|
|
/// <summary>
|
|
/// PR 2.1 — bulk read / write contract via Sum-command surface. Verifies that
|
|
/// <see cref="TwinCATDriver.ReadAsync"/> + <see cref="TwinCATDriver.WriteAsync"/>
|
|
/// bucket scalar requests by device + dispatch each bucket as a single
|
|
/// <see cref="ITwinCATClient.ReadValuesAsync"/> / <see cref="ITwinCATClient.WriteValuesAsync"/>
|
|
/// call. Ordering preservation, partial failure mapping, empty input + cancellation
|
|
/// all live here. Per-tag fallback for bit-BOOL + whole-array tags is covered in
|
|
/// <see cref="TwinCATBitWriteTests"/> / <see cref="TwinCATArrayReadTests"/>.
|
|
/// </summary>
|
|
[Trait("Category", "Unit")]
|
|
public sealed class TwinCATSumCommandTests
|
|
{
|
|
private const string DevA = "ads://5.23.91.23.1.1:851";
|
|
private const string DevB = "ads://5.23.91.23.1.1:852";
|
|
|
|
private static (TwinCATDriver drv, FakeTwinCATClientFactory factory) NewDriver(params TwinCATTagDefinition[] tags)
|
|
{
|
|
var factory = new FakeTwinCATClientFactory();
|
|
var hosts = tags.Select(t => t.DeviceHostAddress).Distinct().ToArray();
|
|
if (hosts.Length == 0) hosts = [DevA];
|
|
var drv = new TwinCATDriver(new TwinCATDriverOptions
|
|
{
|
|
Devices = [.. hosts.Select(h => new TwinCATDeviceOptions(h))],
|
|
Tags = tags,
|
|
Probe = new TwinCATProbeOptions { Enabled = false },
|
|
}, "drv-bulk", factory);
|
|
return (drv, factory);
|
|
}
|
|
|
|
// ---- Bulk read ----
|
|
|
|
[Fact]
|
|
public async Task Bulk_read_dispatches_single_call_per_device_bucket()
|
|
{
|
|
var (drv, factory) = NewDriver(
|
|
new TwinCATTagDefinition("A", DevA, "GVL.A", TwinCATDataType.DInt),
|
|
new TwinCATTagDefinition("B", DevA, "GVL.B", TwinCATDataType.Real),
|
|
new TwinCATTagDefinition("C", DevA, "GVL.C", TwinCATDataType.Bool));
|
|
await drv.InitializeAsync("{}", TestContext.Current.CancellationToken);
|
|
factory.Customise = () => new FakeTwinCATClient
|
|
{
|
|
Values = { ["GVL.A"] = 1, ["GVL.B"] = 2.5f, ["GVL.C"] = true },
|
|
};
|
|
|
|
var snapshots = await drv.ReadAsync(["A", "B", "C"], TestContext.Current.CancellationToken);
|
|
|
|
snapshots.Count.ShouldBe(3);
|
|
// One bulk-read call carrying all 3 tags — the throughput win this PR exists for.
|
|
factory.Clients[0].BulkReadInvocations.Count.ShouldBe(1);
|
|
factory.Clients[0].BulkReadInvocations[0].Count.ShouldBe(3);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Bulk_read_preserves_request_order_with_mixed_outcomes()
|
|
{
|
|
var (drv, factory) = NewDriver(
|
|
new TwinCATTagDefinition("A", DevA, "GVL.A", TwinCATDataType.DInt),
|
|
new TwinCATTagDefinition("B", DevA, "GVL.Missing", TwinCATDataType.DInt),
|
|
new TwinCATTagDefinition("C", DevA, "GVL.C", TwinCATDataType.String));
|
|
await drv.InitializeAsync("{}", TestContext.Current.CancellationToken);
|
|
factory.Customise = () =>
|
|
{
|
|
var c = new FakeTwinCATClient
|
|
{
|
|
Values = { ["GVL.A"] = 7, ["GVL.C"] = "ok" },
|
|
};
|
|
c.BulkReadStatuses["GVL.Missing"] = TwinCATStatusMapper.BadNodeIdUnknown;
|
|
return c;
|
|
};
|
|
|
|
var snapshots = await drv.ReadAsync(["A", "B", "C"], TestContext.Current.CancellationToken);
|
|
|
|
snapshots[0].StatusCode.ShouldBe(TwinCATStatusMapper.Good);
|
|
snapshots[0].Value.ShouldBe(7);
|
|
snapshots[1].StatusCode.ShouldBe(TwinCATStatusMapper.BadNodeIdUnknown);
|
|
snapshots[1].Value.ShouldBeNull();
|
|
snapshots[2].StatusCode.ShouldBe(TwinCATStatusMapper.Good);
|
|
snapshots[2].Value.ShouldBe("ok");
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Bulk_read_buckets_per_device()
|
|
{
|
|
var (drv, factory) = NewDriver(
|
|
new TwinCATTagDefinition("A", DevA, "GVL.A", TwinCATDataType.DInt),
|
|
new TwinCATTagDefinition("X", DevB, "GVL.X", TwinCATDataType.DInt),
|
|
new TwinCATTagDefinition("B", DevA, "GVL.B", TwinCATDataType.DInt));
|
|
await drv.InitializeAsync("{}", TestContext.Current.CancellationToken);
|
|
factory.Customise = () => new FakeTwinCATClient
|
|
{
|
|
Values = { ["GVL.A"] = 1, ["GVL.B"] = 2, ["GVL.X"] = 99 },
|
|
};
|
|
|
|
var snapshots = await drv.ReadAsync(["A", "X", "B"], TestContext.Current.CancellationToken);
|
|
|
|
snapshots[0].Value.ShouldBe(1);
|
|
snapshots[1].Value.ShouldBe(99);
|
|
snapshots[2].Value.ShouldBe(2);
|
|
// Two clients (one per device); each bucket made a single bulk-read call.
|
|
factory.Clients.Count.ShouldBe(2);
|
|
factory.Clients[0].BulkReadInvocations.Count.ShouldBe(1);
|
|
factory.Clients[1].BulkReadInvocations.Count.ShouldBe(1);
|
|
factory.Clients.Sum(c => c.BulkReadInvocations.Sum(i => i.Count)).ShouldBe(3);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Empty_input_returns_empty_result_without_wire_call()
|
|
{
|
|
var (drv, factory) = NewDriver(
|
|
new TwinCATTagDefinition("A", DevA, "GVL.A", TwinCATDataType.DInt));
|
|
await drv.InitializeAsync("{}", TestContext.Current.CancellationToken);
|
|
|
|
var snapshots = await drv.ReadAsync([], TestContext.Current.CancellationToken);
|
|
|
|
snapshots.Count.ShouldBe(0);
|
|
// No client created — driver short-circuits before EnsureConnectedAsync.
|
|
factory.Clients.Count.ShouldBe(0);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Bulk_read_whole_batch_failure_marks_every_slot_BadCommunicationError()
|
|
{
|
|
var (drv, factory) = NewDriver(
|
|
new TwinCATTagDefinition("A", DevA, "GVL.A", TwinCATDataType.DInt),
|
|
new TwinCATTagDefinition("B", DevA, "GVL.B", TwinCATDataType.DInt));
|
|
await drv.InitializeAsync("{}", TestContext.Current.CancellationToken);
|
|
factory.Customise = () => new FakeTwinCATClient { ThrowOnBulkRead = true };
|
|
|
|
var snapshots = await drv.ReadAsync(["A", "B"], TestContext.Current.CancellationToken);
|
|
|
|
snapshots[0].StatusCode.ShouldBe(TwinCATStatusMapper.BadCommunicationError);
|
|
snapshots[1].StatusCode.ShouldBe(TwinCATStatusMapper.BadCommunicationError);
|
|
drv.GetHealth().State.ShouldBe(DriverState.Degraded);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Read_cancellation_propagates_through_bulk_path()
|
|
{
|
|
var (drv, factory) = NewDriver(
|
|
new TwinCATTagDefinition("A", DevA, "GVL.A", TwinCATDataType.DInt));
|
|
await drv.InitializeAsync("{}", TestContext.Current.CancellationToken);
|
|
factory.Customise = () => new FakeTwinCATClient
|
|
{
|
|
ThrowOnBulkRead = true,
|
|
Exception = new OperationCanceledException(),
|
|
};
|
|
|
|
await Should.ThrowAsync<OperationCanceledException>(
|
|
() => drv.ReadAsync(["A"], TestContext.Current.CancellationToken));
|
|
}
|
|
|
|
// ---- Bulk write ----
|
|
|
|
[Fact]
|
|
public async Task Bulk_write_dispatches_single_call_per_device_bucket()
|
|
{
|
|
var (drv, factory) = NewDriver(
|
|
new TwinCATTagDefinition("A", DevA, "GVL.A", TwinCATDataType.DInt),
|
|
new TwinCATTagDefinition("B", DevA, "GVL.B", TwinCATDataType.DInt),
|
|
new TwinCATTagDefinition("C", DevA, "GVL.C", TwinCATDataType.DInt));
|
|
await drv.InitializeAsync("{}", TestContext.Current.CancellationToken);
|
|
|
|
var results = await drv.WriteAsync(
|
|
[new WriteRequest("A", 1), new WriteRequest("B", 2), new WriteRequest("C", 3)],
|
|
TestContext.Current.CancellationToken);
|
|
|
|
results.Count.ShouldBe(3);
|
|
results.ShouldAllBe(r => r.StatusCode == TwinCATStatusMapper.Good);
|
|
factory.Clients[0].BulkWriteInvocations.Count.ShouldBe(1);
|
|
factory.Clients[0].BulkWriteInvocations[0].Count.ShouldBe(3);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Bulk_write_preserves_request_order_across_outcomes()
|
|
{
|
|
var (drv, factory) = NewDriver(
|
|
new TwinCATTagDefinition("A", DevA, "GVL.A", TwinCATDataType.DInt),
|
|
new TwinCATTagDefinition("B", DevA, "GVL.B", TwinCATDataType.DInt, Writable: false),
|
|
new TwinCATTagDefinition("C", DevA, "GVL.C", TwinCATDataType.DInt));
|
|
await drv.InitializeAsync("{}", TestContext.Current.CancellationToken);
|
|
factory.Customise = () =>
|
|
{
|
|
var c = new FakeTwinCATClient();
|
|
c.WriteStatuses["GVL.C"] = TwinCATStatusMapper.BadOutOfRange;
|
|
return c;
|
|
};
|
|
|
|
var results = await drv.WriteAsync(
|
|
[
|
|
new WriteRequest("A", 1),
|
|
new WriteRequest("B", 2), // pre-bulk reject (read-only)
|
|
new WriteRequest("Unknown", 3),
|
|
new WriteRequest("C", 4), // mapped per-symbol error
|
|
], TestContext.Current.CancellationToken);
|
|
|
|
results[0].StatusCode.ShouldBe(TwinCATStatusMapper.Good);
|
|
results[1].StatusCode.ShouldBe(TwinCATStatusMapper.BadNotWritable);
|
|
results[2].StatusCode.ShouldBe(TwinCATStatusMapper.BadNodeIdUnknown);
|
|
results[3].StatusCode.ShouldBe(TwinCATStatusMapper.BadOutOfRange);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Bulk_write_whole_batch_failure_marks_every_slot_BadCommunicationError()
|
|
{
|
|
var (drv, factory) = NewDriver(
|
|
new TwinCATTagDefinition("A", DevA, "GVL.A", TwinCATDataType.DInt),
|
|
new TwinCATTagDefinition("B", DevA, "GVL.B", TwinCATDataType.DInt));
|
|
await drv.InitializeAsync("{}", TestContext.Current.CancellationToken);
|
|
factory.Customise = () => new FakeTwinCATClient { ThrowOnBulkWrite = true };
|
|
|
|
var results = await drv.WriteAsync(
|
|
[new WriteRequest("A", 1), new WriteRequest("B", 2)],
|
|
TestContext.Current.CancellationToken);
|
|
|
|
results[0].StatusCode.ShouldBe(TwinCATStatusMapper.BadCommunicationError);
|
|
results[1].StatusCode.ShouldBe(TwinCATStatusMapper.BadCommunicationError);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Empty_write_input_returns_empty_result_without_wire_call()
|
|
{
|
|
var (drv, factory) = NewDriver(
|
|
new TwinCATTagDefinition("A", DevA, "GVL.A", TwinCATDataType.DInt));
|
|
await drv.InitializeAsync("{}", TestContext.Current.CancellationToken);
|
|
|
|
var results = await drv.WriteAsync([], TestContext.Current.CancellationToken);
|
|
|
|
results.Count.ShouldBe(0);
|
|
factory.Clients.Count.ShouldBe(0);
|
|
}
|
|
}
|