dohertj2/lmxopcua
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

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

Browse Source 
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>
This commit is contained in:
Joseph Doherty
2026-03-30 15:49:42 -04:00
parent 50b85d41bd
commit a2883b82d9
109 changed files with 8571 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
tests/ZB.MOM.WW.LmxOpcUa.Client.Shared.Tests/Fakes/FakeApplicationConfigurationFactory.cs Normal file
View File

@@ -0,0 +1,38 @@
using Opc.Ua;
using ZB.MOM.WW.LmxOpcUa.Client.Shared.Adapters;
using ZB.MOM.WW.LmxOpcUa.Client.Shared.Models;
namespace ZB.MOM.WW.LmxOpcUa.Client.Shared.Tests.Fakes;
internal sealed class FakeApplicationConfigurationFactory : IApplicationConfigurationFactory
{
public bool ThrowOnCreate { get; set; }
public int CreateCallCount { get; private set; }
public ConnectionSettings? LastSettings { get; private set; }
public Task<ApplicationConfiguration> CreateAsync(ConnectionSettings settings, CancellationToken ct)
{
CreateCallCount++;
LastSettings = settings;
if (ThrowOnCreate)
throw new InvalidOperationException("FakeApplicationConfigurationFactory configured to fail.");
var config = new ApplicationConfiguration
{
ApplicationName = "FakeClient",
ApplicationUri = "urn:localhost:FakeClient",
ApplicationType = ApplicationType.Client,
SecurityConfiguration = new SecurityConfiguration
{
AutoAcceptUntrustedCertificates = true
},
ClientConfiguration = new ClientConfiguration
{
DefaultSessionTimeout = settings.SessionTimeoutSeconds * 1000
}
};
return Task.FromResult(config);
}
}

34
tests/ZB.MOM.WW.LmxOpcUa.Client.Shared.Tests/Fakes/FakeEndpointDiscovery.cs Normal file
View File

@@ -0,0 +1,34 @@
using Opc.Ua;
using ZB.MOM.WW.LmxOpcUa.Client.Shared.Adapters;
namespace ZB.MOM.WW.LmxOpcUa.Client.Shared.Tests.Fakes;
internal sealed class FakeEndpointDiscovery : IEndpointDiscovery
{
public bool ThrowOnSelect { get; set; }
public int SelectCallCount { get; private set; }
public string? LastEndpointUrl { get; private set; }
public EndpointDescription SelectEndpoint(ApplicationConfiguration config, string endpointUrl, MessageSecurityMode requestedMode)
{
SelectCallCount++;
LastEndpointUrl = endpointUrl;
if (ThrowOnSelect)
throw new InvalidOperationException($"No endpoint found for {endpointUrl}");
return new EndpointDescription
{
EndpointUrl = endpointUrl,
SecurityMode = requestedMode,
SecurityPolicyUri = requestedMode == MessageSecurityMode.None
? SecurityPolicies.None
: SecurityPolicies.Basic256Sha256,
Server = new ApplicationDescription
{
ApplicationName = "FakeServer",
ApplicationUri = "urn:localhost:FakeServer"
}
};
}
}

150
tests/ZB.MOM.WW.LmxOpcUa.Client.Shared.Tests/Fakes/FakeSessionAdapter.cs Normal file
View File

@@ -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;
}
}

56
tests/ZB.MOM.WW.LmxOpcUa.Client.Shared.Tests/Fakes/FakeSessionFactory.cs Normal file
View File

@@ -0,0 +1,56 @@
using Opc.Ua;
using ZB.MOM.WW.LmxOpcUa.Client.Shared.Adapters;
namespace ZB.MOM.WW.LmxOpcUa.Client.Shared.Tests.Fakes;
internal sealed class FakeSessionFactory : ISessionFactory
{
private readonly Queue<FakeSessionAdapter> _sessions = new();
private readonly List<FakeSessionAdapter> _createdSessions = new();
public int CreateCallCount { get; private set; }
public bool ThrowOnCreate { get; set; }
public string? LastEndpointUrl { get; private set; }
/// <summary>
/// Enqueues a session adapter to be returned on the next call to CreateSessionAsync.
/// </summary>
public void EnqueueSession(FakeSessionAdapter session)
{
_sessions.Enqueue(session);
}
public IReadOnlyList<FakeSessionAdapter> CreatedSessions => _createdSessions;
public Task<ISessionAdapter> CreateSessionAsync(
ApplicationConfiguration config, EndpointDescription endpoint, string sessionName,
uint sessionTimeoutMs, UserIdentity identity, CancellationToken ct)
{
CreateCallCount++;
LastEndpointUrl = endpoint.EndpointUrl;
if (ThrowOnCreate)
throw new InvalidOperationException("FakeSessionFactory configured to fail.");
FakeSessionAdapter session;
if (_sessions.Count > 0)
{
session = _sessions.Dequeue();
}
else
{
session = new FakeSessionAdapter
{
EndpointUrl = endpoint.EndpointUrl,
ServerName = endpoint.Server?.ApplicationName?.Text ?? "FakeServer",
SecurityMode = endpoint.SecurityMode.ToString(),
SecurityPolicyUri = endpoint.SecurityPolicyUri ?? string.Empty
};
}
// Ensure endpoint URL matches
session.EndpointUrl = endpoint.EndpointUrl;
_createdSessions.Add(session);
return Task.FromResult<ISessionAdapter>(session);
}
}

88
tests/ZB.MOM.WW.LmxOpcUa.Client.Shared.Tests/Fakes/FakeSubscriptionAdapter.cs Normal file
View File

@@ -0,0 +1,88 @@
using Opc.Ua;
using ZB.MOM.WW.LmxOpcUa.Client.Shared.Adapters;
namespace ZB.MOM.WW.LmxOpcUa.Client.Shared.Tests.Fakes;
internal sealed class FakeSubscriptionAdapter : ISubscriptionAdapter
{
private uint _nextHandle = 100;
private readonly Dictionary<uint, (NodeId NodeId, Action<string, DataValue>? DataCallback, Action<EventFieldList>? EventCallback)> _items = new();
public uint SubscriptionId { get; set; } = 42;
public bool Deleted { get; private set; }
public bool ConditionRefreshCalled { get; private set; }
public bool ThrowOnConditionRefresh { get; set; }
public int AddDataChangeCount { get; private set; }
public int AddEventCount { get; private set; }
public int RemoveCount { get; private set; }
public Task<uint> AddDataChangeMonitoredItemAsync(NodeId nodeId, int samplingIntervalMs, Action<string, DataValue> onDataChange, CancellationToken ct)
{
AddDataChangeCount++;
var handle = _nextHandle++;
_items[handle] = (nodeId, onDataChange, null);
return Task.FromResult(handle);
}
public Task RemoveMonitoredItemAsync(uint clientHandle, CancellationToken ct)
{
RemoveCount++;
_items.Remove(clientHandle);
return Task.CompletedTask;
}
public Task<uint> AddEventMonitoredItemAsync(NodeId nodeId, int samplingIntervalMs, EventFilter filter, Action<EventFieldList> onEvent, CancellationToken ct)
{
AddEventCount++;
var handle = _nextHandle++;
_items[handle] = (nodeId, null, onEvent);
return Task.FromResult(handle);
}
public Task ConditionRefreshAsync(CancellationToken ct)
{
ConditionRefreshCalled = true;
if (ThrowOnConditionRefresh)
throw new InvalidOperationException("Condition refresh not supported");
return Task.CompletedTask;
}
public Task DeleteAsync(CancellationToken ct)
{
Deleted = true;
_items.Clear();
return Task.CompletedTask;
}
public void Dispose()
{
_items.Clear();
}
/// <summary>
/// Simulates a data change notification for testing.
/// </summary>
public void SimulateDataChange(uint handle, DataValue value)
{
if (_items.TryGetValue(handle, out var item) && item.DataCallback != null)
{
item.DataCallback(item.NodeId.ToString(), value);
}
}
/// <summary>
/// Simulates an event notification for testing.
/// </summary>
public void SimulateEvent(uint handle, EventFieldList eventFields)
{
if (_items.TryGetValue(handle, out var item) && item.EventCallback != null)
{
item.EventCallback(eventFields);
}
}
/// <summary>
/// Gets the handles of all active items.
/// </summary>
public IReadOnlyCollection<uint> ActiveHandles => _items.Keys.ToList();
}