ScadaBridge/tests/ZB.MOM.WW.ScadaBridge.DataConnectionLayer.Tests/Actors/FakeServiceLevelConnection.cs

using System.Collections.Concurrent;
using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Protocol;
using ZB.MOM.WW.ScadaBridge.Commons.Types.Enums;

namespace ZB.MOM.WW.ScadaBridge.DataConnectionLayer.Tests.Actors;

/// <summary>
/// The two OPC UA servers of a redundant pair as the ScadaBridge#138 tests see them: a
/// ServiceLevel per endpoint (changeable at any time, null = unreadable), whether each endpoint
/// accepts a session, and a record of what the actor did to them.
/// </summary>
internal sealed class ServiceLevelRig
{
    private readonly ConcurrentDictionary<string, Func<byte?>> _levels = new();
    private readonly ConcurrentDictionary<string, bool> _unreachable = new();

    /// <summary>Every endpoint a session was opened on, in order — live sessions and probes alike.</summary>
    public ConcurrentQueue<string> Connects { get; } = new();

    /// <summary>Every tag subscribed, as "endpoint|tag" — only a live session receives these.</summary>
    public ConcurrentQueue<string> Subscribes { get; } = new();

    /// <summary>Number of ServiceLevel reads, per endpoint.</summary>
    public ConcurrentDictionary<string, int> Reads { get; } = new();

    /// <summary>Sets a fixed ServiceLevel for <paramref name="endpoint"/>.</summary>
    public void SetLevel(string endpoint, byte? level) => _levels[endpoint] = () => level;

    /// <summary>Sets a ServiceLevel source evaluated on every read of <paramref name="endpoint"/>.</summary>
    public void SetLevel(string endpoint, Func<byte?> level) => _levels[endpoint] = level;

    /// <summary>Makes <paramref name="endpoint"/> refuse (or accept again) new sessions.</summary>
    public void SetReachable(string endpoint, bool reachable) => _unreachable[endpoint] = !reachable;

    public bool IsReachable(string endpoint) => !_unreachable.GetValueOrDefault(endpoint);

    public byte? Read(string endpoint)
    {
        Reads.AddOrUpdate(endpoint, 1, (_, n) => n + 1);
        return _levels.TryGetValue(endpoint, out var level) ? level() : null;
    }

    public int ConnectCount(string endpoint) => Connects.Count(e => e == endpoint);

    /// <summary>Every adapter that opened a session, so a test can kill the live one (ScadaBridge#141).</summary>
    public ConcurrentQueue<FakeServiceLevelConnection> Sessions { get; } = new();

    /// <summary>
    /// The server at <paramref name="endpoint"/> goes away: it refuses new sessions and every live
    /// session on it raises <c>Disconnected</c> — what a stopped OtOpcUa node looks like to the client.
    /// </summary>
    public void Stop(string endpoint)
    {
        SetReachable(endpoint, false);
        foreach (var session in Sessions.Where(s => s.Endpoint == endpoint && s.IsConnected))
            session.RaiseDisconnected();
    }

    /// <summary>The endpoints sessions were opened on after the first <paramref name="skip"/> connects.</summary>
    public string[] ConnectsAfter(int skip) => Connects.Skip(skip).ToArray();

    public int ReadCount(string endpoint) => Reads.GetValueOrDefault(endpoint);
}

/// <summary>
/// An <see cref="IDataConnection"/> with the <see cref="IServiceLevelReadable"/> capability, bound to
/// one endpoint of a <see cref="ServiceLevelRig"/>. Subscriptions and reads always succeed.
/// </summary>
internal sealed class FakeServiceLevelConnection : IDataConnection, IServiceLevelReadable
{
    private readonly ServiceLevelRig _rig;
    private volatile bool _connected;

    public FakeServiceLevelConnection(ServiceLevelRig rig, string endpoint)
    {
        _rig = rig;
        Endpoint = endpoint;
    }

    public string Endpoint { get; }

    public ConnectionHealth Status => _connected ? ConnectionHealth.Connected : ConnectionHealth.Disconnected;

    public event Action? Disconnected;

    public Task ConnectAsync(IDictionary<string, string> connectionDetails, CancellationToken cancellationToken = default)
    {
        _rig.Connects.Enqueue(Endpoint);
        if (!_rig.IsReachable(Endpoint))
            return Task.FromException(new InvalidOperationException($"{Endpoint} refused the session"));
        _connected = true;
        _rig.Sessions.Enqueue(this);
        return Task.CompletedTask;
    }

    public bool IsConnected => _connected;

    public Task DisconnectAsync(CancellationToken cancellationToken = default)
    {
        _connected = false;
        return Task.CompletedTask;
    }

    public Task<byte?> ReadServiceLevelAsync(CancellationToken cancellationToken = default) =>
        Task.FromResult(_connected ? _rig.Read(Endpoint) : null);

    public Task<string> SubscribeAsync(string tagPath, SubscriptionCallback callback, CancellationToken cancellationToken = default)
    {
        _rig.Subscribes.Enqueue($"{Endpoint}|{tagPath}");
        return Task.FromResult($"{Endpoint}:{tagPath}");
    }

    public Task UnsubscribeAsync(string subscriptionId, CancellationToken cancellationToken = default) => Task.CompletedTask;

    public Task<ReadResult> ReadAsync(string tagPath, CancellationToken cancellationToken = default) =>
        Task.FromResult(new ReadResult(true, new TagValue(1, QualityCode.Good, DateTimeOffset.UtcNow), null));

    public Task<IReadOnlyDictionary<string, ReadResult>> ReadBatchAsync(IEnumerable<string> tagPaths, CancellationToken cancellationToken = default) =>
        Task.FromResult<IReadOnlyDictionary<string, ReadResult>>(tagPaths.ToDictionary(
            t => t, _ => new ReadResult(true, new TagValue(1, QualityCode.Good, DateTimeOffset.UtcNow), null)));

    public Task<WriteResult> WriteAsync(string tagPath, object? value, CancellationToken cancellationToken = default) =>
        Task.FromResult(new WriteResult(true, null));

    public Task<IReadOnlyDictionary<string, WriteResult>> WriteBatchAsync(IDictionary<string, object?> values, CancellationToken cancellationToken = default) =>
        Task.FromResult<IReadOnlyDictionary<string, WriteResult>>(values.ToDictionary(v => v.Key, _ => new WriteResult(true, null)));

    public void RaiseDisconnected()
    {
        _connected = false;
        Disconnected?.Invoke();
    }

    public ValueTask DisposeAsync()
    {
        _connected = false;
        return ValueTask.CompletedTask;
    }
}