Add cross-platform OPC UA client stack: shared library, CLI tool, and Avalonia UI

Implements Client.Shared (IOpcUaClientService with connection lifecycle, failover, browse, read/write, subscriptions, alarms, history, redundancy), Client.CLI (8 CliFx commands mirroring tools/opcuacli-dotnet), and Client.UI (Avalonia desktop app with tree browser, read/write, subscriptions, alarms, and history tabs). All three target .NET 10 and are covered by 249 unit tests. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
2026-03-30 15:49:42 -04:00
parent 50b85d41bd
commit a2883b82d9
109 changed files with 8571 additions and 0 deletions
--- a/tests/ZB.MOM.WW.LmxOpcUa.Client.Shared.Tests/Fakes/FakeSessionAdapter.cs
+++ b/tests/ZB.MOM.WW.LmxOpcUa.Client.Shared.Tests/Fakes/FakeSessionAdapter.cs
@@ -0,0 +1,150 @@
+using Opc.Ua;
+using ZB.MOM.WW.LmxOpcUa.Client.Shared.Adapters;
+
+namespace ZB.MOM.WW.LmxOpcUa.Client.Shared.Tests.Fakes;
+
+internal sealed class FakeSessionAdapter : ISessionAdapter
+{
+    private Action<bool>? _keepAliveCallback;
+    private readonly List<FakeSubscriptionAdapter> _createdSubscriptions = new();
+
+    public bool Connected { get; set; } = true;
+    public string SessionId { get; set; } = "ns=0;i=12345";
+    public string SessionName { get; set; } = "FakeSession";
+    public string EndpointUrl { get; set; } = "opc.tcp://localhost:4840";
+    public string ServerName { get; set; } = "FakeServer";
+    public string SecurityMode { get; set; } = "None";
+    public string SecurityPolicyUri { get; set; } = "http://opcfoundation.org/UA/SecurityPolicy#None";
+    public NamespaceTable NamespaceUris { get; set; } = new();
+
+    public bool Closed { get; private set; }
+    public bool Disposed { get; private set; }
+    public int ReadCount { get; private set; }
+    public int WriteCount { get; private set; }
+    public int BrowseCount { get; private set; }
+    public int BrowseNextCount { get; private set; }
+    public int HasChildrenCount { get; private set; }
+    public int HistoryReadRawCount { get; private set; }
+    public int HistoryReadAggregateCount { get; private set; }
+
+    // Configurable responses
+    public DataValue? ReadResponse { get; set; }
+    public Func<NodeId, DataValue>? ReadResponseFunc { get; set; }
+    public StatusCode WriteResponse { get; set; } = StatusCodes.Good;
+    public bool ThrowOnRead { get; set; }
+    public bool ThrowOnWrite { get; set; }
+    public bool ThrowOnBrowse { get; set; }
+
+    public ReferenceDescriptionCollection BrowseResponse { get; set; } = new();
+    public byte[]? BrowseContinuationPoint { get; set; }
+    public ReferenceDescriptionCollection BrowseNextResponse { get; set; } = new();
+    public byte[]? BrowseNextContinuationPoint { get; set; }
+    public bool HasChildrenResponse { get; set; } = false;
+
+    public List<DataValue> HistoryReadRawResponse { get; set; } = new();
+    public List<DataValue> HistoryReadAggregateResponse { get; set; } = new();
+    public bool ThrowOnHistoryReadRaw { get; set; }
+    public bool ThrowOnHistoryReadAggregate { get; set; }
+
+    /// <summary>
+    /// The next FakeSubscriptionAdapter to return from CreateSubscriptionAsync.
+    /// If null, a new one is created automatically.
+    /// </summary>
+    public FakeSubscriptionAdapter? NextSubscription { get; set; }
+
+    public IReadOnlyList<FakeSubscriptionAdapter> CreatedSubscriptions => _createdSubscriptions;
+
+    public void RegisterKeepAliveHandler(Action<bool> callback)
+    {
+        _keepAliveCallback = callback;
+    }
+
+    /// <summary>
+    /// Simulates a keep-alive event.
+    /// </summary>
+    public void SimulateKeepAlive(bool isGood)
+    {
+        _keepAliveCallback?.Invoke(isGood);
+    }
+
+    public Task<DataValue> ReadValueAsync(NodeId nodeId, CancellationToken ct)
+    {
+        ReadCount++;
+        if (ThrowOnRead)
+            throw new ServiceResultException(StatusCodes.BadNodeIdUnknown, "Node not found");
+
+        if (ReadResponseFunc != null)
+            return Task.FromResult(ReadResponseFunc(nodeId));
+
+        return Task.FromResult(ReadResponse ?? new DataValue(new Variant(0), StatusCodes.Good));
+    }
+
+    public Task<StatusCode> WriteValueAsync(NodeId nodeId, DataValue value, CancellationToken ct)
+    {
+        WriteCount++;
+        if (ThrowOnWrite)
+            throw new ServiceResultException(StatusCodes.BadNodeIdUnknown, "Node not found");
+        return Task.FromResult(WriteResponse);
+    }
+
+    public Task<(byte[]? ContinuationPoint, ReferenceDescriptionCollection References)> BrowseAsync(
+        NodeId nodeId, uint nodeClassMask, CancellationToken ct)
+    {
+        BrowseCount++;
+        if (ThrowOnBrowse)
+            throw new ServiceResultException(StatusCodes.BadNodeIdUnknown, "Node not found");
+        return Task.FromResult((BrowseContinuationPoint, BrowseResponse));
+    }
+
+    public Task<(byte[]? ContinuationPoint, ReferenceDescriptionCollection References)> BrowseNextAsync(
+        byte[] continuationPoint, CancellationToken ct)
+    {
+        BrowseNextCount++;
+        return Task.FromResult((BrowseNextContinuationPoint, BrowseNextResponse));
+    }
+
+    public Task<bool> HasChildrenAsync(NodeId nodeId, CancellationToken ct)
+    {
+        HasChildrenCount++;
+        return Task.FromResult(HasChildrenResponse);
+    }
+
+    public Task<IReadOnlyList<DataValue>> HistoryReadRawAsync(
+        NodeId nodeId, DateTime startTime, DateTime endTime, int maxValues, CancellationToken ct)
+    {
+        HistoryReadRawCount++;
+        if (ThrowOnHistoryReadRaw)
+            throw new ServiceResultException(StatusCodes.BadHistoryOperationUnsupported, "History not supported");
+        return Task.FromResult<IReadOnlyList<DataValue>>(HistoryReadRawResponse);
+    }
+
+    public Task<IReadOnlyList<DataValue>> HistoryReadAggregateAsync(
+        NodeId nodeId, DateTime startTime, DateTime endTime, NodeId aggregateId, double intervalMs, CancellationToken ct)
+    {
+        HistoryReadAggregateCount++;
+        if (ThrowOnHistoryReadAggregate)
+            throw new ServiceResultException(StatusCodes.BadHistoryOperationUnsupported, "History not supported");
+        return Task.FromResult<IReadOnlyList<DataValue>>(HistoryReadAggregateResponse);
+    }
+
+    public Task<ISubscriptionAdapter> CreateSubscriptionAsync(int publishingIntervalMs, CancellationToken ct)
+    {
+        var sub = NextSubscription ?? new FakeSubscriptionAdapter();
+        NextSubscription = null;
+        _createdSubscriptions.Add(sub);
+        return Task.FromResult<ISubscriptionAdapter>(sub);
+    }
+
+    public Task CloseAsync(CancellationToken ct)
+    {
+        Closed = true;
+        Connected = false;
+        return Task.CompletedTask;
+    }
+
+    public void Dispose()
+    {
+        Disposed = true;
+        Connected = false;
+    }
+}