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

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using ZB.MOM.WW.LmxOpcUa.Host.Domain;

namespace ZB.MOM.WW.LmxOpcUa.Tests.Helpers
{
    public class FakeMxAccessClient : IMxAccessClient
    {
        public ConnectionState State { get; set; } = ConnectionState.Connected;
        public int ActiveSubscriptionCount => _subscriptions.Count;
        public int ReconnectCount { get; set; }

        public event EventHandler<ConnectionStateChangedEventArgs>? ConnectionStateChanged;
        public event Action<string, Vtq>? OnTagValueChanged;

        private readonly ConcurrentDictionary<string, Action<string, Vtq>> _subscriptions = new(StringComparer.OrdinalIgnoreCase);
        public ConcurrentDictionary<string, Vtq> TagValues { get; } = new(StringComparer.OrdinalIgnoreCase);
        public List<(string Tag, object Value)> WrittenValues { get; } = new();
        public bool WriteResult { get; set; } = true;

        public Task ConnectAsync(CancellationToken ct = default)
        {
            State = ConnectionState.Connected;
            return Task.CompletedTask;
        }

        public Task DisconnectAsync()
        {
            State = ConnectionState.Disconnected;
            return Task.CompletedTask;
        }

        public Task SubscribeAsync(string fullTagReference, Action<string, Vtq> callback)
        {
            _subscriptions[fullTagReference] = callback;
            return Task.CompletedTask;
        }

        public Task UnsubscribeAsync(string fullTagReference)
        {
            _subscriptions.TryRemove(fullTagReference, out _);
            return Task.CompletedTask;
        }

        public Task<Vtq> ReadAsync(string fullTagReference, CancellationToken ct = default)
        {
            if (TagValues.TryGetValue(fullTagReference, out var vtq))
                return Task.FromResult(vtq);
            return Task.FromResult(Vtq.Bad(Quality.BadNotConnected));
        }

        public Task<bool> WriteAsync(string fullTagReference, object value, CancellationToken ct = default)
        {
            WrittenValues.Add((fullTagReference, value));
            if (WriteResult)
                TagValues[fullTagReference] = Vtq.Good(value);
            return Task.FromResult(WriteResult);
        }

        public void SimulateDataChange(string address, Vtq vtq)
        {
            OnTagValueChanged?.Invoke(address, vtq);
            if (_subscriptions.TryGetValue(address, out var callback))
                callback(address, vtq);
        }

        public void RaiseConnectionStateChanged(ConnectionState prev, ConnectionState curr)
        {
            State = curr;
            ConnectionStateChanged?.Invoke(this, new ConnectionStateChangedEventArgs(prev, curr));
        }

        public void Dispose() { }
    }
}