Expand XML docs across bridge and test code

tests/ZB.MOM.WW.LmxOpcUa.Tests/Helpers/FakeMxAccessClient.cs

@@ -7,44 +7,99 @@ using ZB.MOM.WW.LmxOpcUa.Host.Domain;
 
 namespace ZB.MOM.WW.LmxOpcUa.Tests.Helpers
 {
+    /// <summary>
+    /// In-memory IMxAccessClient used by tests to drive connection, read, write, and subscription scenarios without COM runtime dependencies.
+    /// </summary>
     public class FakeMxAccessClient : IMxAccessClient
     {
+        /// <summary>
+        /// Gets or sets the connection state returned to the system under test.
+        /// </summary>
         public ConnectionState State { get; set; } = ConnectionState.Connected;
+
+        /// <summary>
+        /// Gets the number of active subscriptions currently stored by the fake client.
+        /// </summary>
         public int ActiveSubscriptionCount => _subscriptions.Count;
+
+        /// <summary>
+        /// Gets or sets the reconnect count exposed to health and dashboard tests.
+        /// </summary>
         public int ReconnectCount { get; set; }
 
+        /// <summary>
+        /// Occurs when tests explicitly simulate a connection-state transition.
+        /// </summary>
         public event EventHandler<ConnectionStateChangedEventArgs>? ConnectionStateChanged;
+
+        /// <summary>
+        /// Occurs when tests publish a simulated runtime value change.
+        /// </summary>
         public event Action<string, Vtq>? OnTagValueChanged;
 
         private readonly ConcurrentDictionary<string, Action<string, Vtq>> _subscriptions = new(StringComparer.OrdinalIgnoreCase);
+
+        /// <summary>
+        /// Gets the in-memory tag-value table returned by fake reads.
+        /// </summary>
         public ConcurrentDictionary<string, Vtq> TagValues { get; } = new(StringComparer.OrdinalIgnoreCase);
+
+        /// <summary>
+        /// Gets the values written through the fake client so tests can assert write behavior.
+        /// </summary>
         public List<(string Tag, object Value)> WrittenValues { get; } = new();
+
+        /// <summary>
+        /// Gets or sets the result returned by fake writes to simulate success or failure.
+        /// </summary>
         public bool WriteResult { get; set; } = true;
 
+        /// <summary>
+        /// Simulates establishing a healthy runtime connection.
+        /// </summary>
+        /// <param name="ct">A cancellation token that is ignored by the in-memory fake.</param>
         public Task ConnectAsync(CancellationToken ct = default)
         {
             State = ConnectionState.Connected;
             return Task.CompletedTask;
         }
 
+        /// <summary>
+        /// Simulates disconnecting from the runtime.
+        /// </summary>
         public Task DisconnectAsync()
         {
             State = ConnectionState.Disconnected;
             return Task.CompletedTask;
         }
 
+        /// <summary>
+        /// Stores a subscription callback so later simulated data changes can target it.
+        /// </summary>
+        /// <param name="fullTagReference">The Galaxy attribute reference to monitor.</param>
+        /// <param name="callback">The callback that should receive simulated value changes.</param>
         public Task SubscribeAsync(string fullTagReference, Action<string, Vtq> callback)
         {
             _subscriptions[fullTagReference] = callback;
             return Task.CompletedTask;
         }
 
+        /// <summary>
+        /// Removes a stored subscription callback for the specified tag reference.
+        /// </summary>
+        /// <param name="fullTagReference">The Galaxy attribute reference to stop monitoring.</param>
         public Task UnsubscribeAsync(string fullTagReference)
         {
             _subscriptions.TryRemove(fullTagReference, out _);
             return Task.CompletedTask;
         }
 
+        /// <summary>
+        /// Returns the current in-memory VTQ for a tag reference or a bad-quality placeholder when none has been seeded.
+        /// </summary>
+        /// <param name="fullTagReference">The Galaxy attribute reference to read.</param>
+        /// <param name="ct">A cancellation token that is ignored by the in-memory fake.</param>
+        /// <returns>The seeded VTQ value or a bad not-connected VTQ when the tag was not populated.</returns>
         public Task<Vtq> ReadAsync(string fullTagReference, CancellationToken ct = default)
         {
             if (TagValues.TryGetValue(fullTagReference, out var vtq))
@@ -52,6 +107,13 @@ namespace ZB.MOM.WW.LmxOpcUa.Tests.Helpers
             return Task.FromResult(Vtq.Bad(Quality.BadNotConnected));
         }
 
+        /// <summary>
+        /// Records a write request, optionally updates the in-memory tag table, and returns the configured write result.
+        /// </summary>
+        /// <param name="fullTagReference">The Galaxy attribute reference being written.</param>
+        /// <param name="value">The value supplied by the code under test.</param>
+        /// <param name="ct">A cancellation token that is ignored by the in-memory fake.</param>
+        /// <returns>A completed task returning the configured write outcome.</returns>
         public Task<bool> WriteAsync(string fullTagReference, object value, CancellationToken ct = default)
         {
             WrittenValues.Add((fullTagReference, value));
@@ -60,6 +122,11 @@ namespace ZB.MOM.WW.LmxOpcUa.Tests.Helpers
             return Task.FromResult(WriteResult);
         }
 
+        /// <summary>
+        /// Publishes a simulated tag-value change to both the event stream and any stored subscription callback.
+        /// </summary>
+        /// <param name="address">The Galaxy attribute reference whose value changed.</param>
+        /// <param name="vtq">The value, timestamp, and quality payload to publish.</param>
         public void SimulateDataChange(string address, Vtq vtq)
         {
             OnTagValueChanged?.Invoke(address, vtq);
@@ -67,12 +134,20 @@ namespace ZB.MOM.WW.LmxOpcUa.Tests.Helpers
                 callback(address, vtq);
         }
 
+        /// <summary>
+        /// Raises a simulated connection-state transition for health and reconnect tests.
+        /// </summary>
+        /// <param name="prev">The previous connection state.</param>
+        /// <param name="curr">The new connection state.</param>
         public void RaiseConnectionStateChanged(ConnectionState prev, ConnectionState curr)
         {
             State = curr;
             ConnectionStateChanged?.Invoke(this, new ConnectionStateChangedEventArgs(prev, curr));
         }
 
+        /// <summary>
+        /// Releases the fake client. No unmanaged resources are held.
+        /// </summary>
         public void Dispose() { }
     }
 }