ScadaBridge/tests/ZB.MOM.WW.ScadaBridge.DataConnectionLayer.Tests/Adapters/FakeMxGatewayClient.cs

using ZB.MOM.WW.ScadaBridge.DataConnectionLayer.Adapters;

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

/// <summary>
/// In-memory fake <see cref="IMxGatewayClient"/> for adapter unit tests. Lets tests
/// drive the event loop (push updates / fault the stream) and stub read/write/browse.
/// </summary>
public sealed class FakeMxGatewayClient : IMxGatewayClient, IMxGatewayClientFactory
{
    public MxGatewayConnectionOptions? ConnectedWith;
    public readonly List<string> Subscribed = new();
    public readonly List<string> Unsubscribed = new();
    /// <summary>One entry per SubscribeBulkAsync call, carrying that call's tag list.</summary>
    public readonly List<IReadOnlyList<string>> BulkSubscribeCalls = new();
    /// <summary>One entry per UnsubscribeBulkAsync call, carrying that call's id list.</summary>
    public readonly List<IReadOnlyList<string>> BulkUnsubscribeCalls = new();
    /// <summary>Tags the fake reports as failed rows from a bulk subscribe.</summary>
    public readonly HashSet<string> BulkSubscribeFailures = new(StringComparer.Ordinal);
    /// <summary>Every alarm-stream prefix the adapter opened a stream with (null = gateway-wide).</summary>
    public readonly List<string?> AlarmStreamPrefixes = new();
    public readonly TaskCompletionSource EventLoopGate = new(TaskCreationOptions.RunContinuationsAsynchronously);
    public Action<MxValueUpdate>? OnUpdate;
    public Func<IReadOnlyList<string>, IReadOnlyList<MxReadOutcome>>? ReadHandler;
    public Func<IReadOnlyList<(string TagPath, object? Value)>, IReadOnlyList<MxWriteOutcome>>? WriteHandler;
    public Func<string?, (IReadOnlyList<MxBrowseChild>, bool)>? BrowseHandler;
    private int _nextHandle;

    /// <inheritdoc />
    public IMxGatewayClient Create() => this;

    /// <inheritdoc />
    public Task ConnectAsync(MxGatewayConnectionOptions o, CancellationToken ct = default)
    {
        ConnectedWith = o;
        return Task.CompletedTask;
    }

    /// <inheritdoc />
    public Task DisconnectAsync(CancellationToken ct = default) => Task.CompletedTask;

    /// <inheritdoc />
    public Task<string> SubscribeAsync(string tag, CancellationToken ct = default)
    {
        var id = (++_nextHandle).ToString();
        Subscribed.Add(tag);
        return Task.FromResult(id);
    }

    /// <inheritdoc />
    public Task UnsubscribeAsync(string id, CancellationToken ct = default)
    {
        Unsubscribed.Add(id);
        return Task.CompletedTask;
    }

    /// <inheritdoc />
    public Task<IReadOnlyList<MxSubscribeOutcome>> SubscribeBulkAsync(
        IReadOnlyList<string> tagPaths, CancellationToken ct = default)
    {
        BulkSubscribeCalls.Add(tagPaths.ToList());
        var outcomes = new List<MxSubscribeOutcome>(tagPaths.Count);
        foreach (var tag in tagPaths)
        {
            if (BulkSubscribeFailures.Contains(tag))
            {
                outcomes.Add(new MxSubscribeOutcome(tag, false, null, "not found"));
                continue;
            }

            Subscribed.Add(tag);
            outcomes.Add(new MxSubscribeOutcome(
                tag, true, (++_nextHandle).ToString(), null));
        }

        return Task.FromResult<IReadOnlyList<MxSubscribeOutcome>>(outcomes);
    }

    /// <inheritdoc />
    public Task UnsubscribeBulkAsync(IReadOnlyList<string> subscriptionIds, CancellationToken ct = default)
    {
        BulkUnsubscribeCalls.Add(subscriptionIds.ToList());
        Unsubscribed.AddRange(subscriptionIds);
        return Task.CompletedTask;
    }

    /// <inheritdoc />
    public Task<IReadOnlyList<MxReadOutcome>> ReadAsync(IReadOnlyList<string> tags, CancellationToken ct = default)
        => Task.FromResult(ReadHandler!(tags));

    /// <inheritdoc />
    public Task<IReadOnlyList<MxWriteOutcome>> WriteAsync(IReadOnlyList<(string TagPath, object? Value)> w, CancellationToken ct = default)
        => Task.FromResult(WriteHandler!(w));

    /// <inheritdoc />
    public Task<(IReadOnlyList<MxBrowseChild> Children, bool Truncated)> BrowseChildrenAsync(string? p, CancellationToken ct = default)
        => Task.FromResult(BrowseHandler!(p));

    /// <inheritdoc />
    public async Task RunEventLoopAsync(Action<MxValueUpdate> onUpdate, CancellationToken ct = default)
    {
        OnUpdate = onUpdate;
        using var reg = ct.Register(() => EventLoopGate.TrySetResult());
        await EventLoopGate.Task;          // test completes this to end the loop…
        ct.ThrowIfCancellationRequested(); // …or FaultEventLoop() faults it to simulate a stream break
    }

    /// <inheritdoc />
    public Task RunAlarmStreamAsync(
        string? alarmFilterPrefix,
        Action<ZB.MOM.WW.ScadaBridge.Commons.Types.Alarms.NativeAlarmTransition> onTransition,
        CancellationToken ct = default)
    {
        // No alarm feed in the fake — but the prefix each stream is opened with is
        // recorded so the union-filter (longest-common-prefix) behaviour is testable.
        lock (AlarmStreamPrefixes)
            AlarmStreamPrefixes.Add(alarmFilterPrefix);
        return Task.CompletedTask;
    }

    /// <summary>Releases the resources used by this instance asynchronously.</summary>
    /// <returns>A task that represents the asynchronous operation.</returns>
    public ValueTask DisposeAsync() => ValueTask.CompletedTask;

    /// <summary>Simulate a stream break so the adapter raises Disconnected.</summary>
    public void FaultEventLoop() => EventLoopGate.TrySetException(new Exception("stream broke"));
}