lmxopcua/tests/Drivers/ZB.MOM.WW.OtOpcUa.Driver.AbCip.Tests/AbCipWriteHealthTests.cs

using Shouldly;
using Xunit;
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;

namespace ZB.MOM.WW.OtOpcUa.Driver.AbCip.Tests;

/// <summary>
///     Review 07 H19: write-side health. A client value that cannot be converted never touched the wire, so it must
///     not latch <c>Degraded</c>; and a good write must not overwrite a <c>Degraded</c> the read path just recorded
///     with <c>Healthy</c> (the batch read path is worst-wins for exactly this reason). A good write proves the device
///     answered, so it advances <c>LastSuccessfulRead</c> without touching the state.
/// </summary>
[Trait("Category", "Unit")]
public sealed class AbCipWriteHealthTests
{
    private const string Device = "ab://10.0.0.5/1,0";

    private sealed class ThrowingWriteTag(AbCipTagCreateParams p) : FakeAbCipTag(p)
    {
        public override Task WriteAsync(CancellationToken cancellationToken) =>
            throw new InvalidOperationException("socket reset");
    }

    private static async Task<(AbCipDriver Driver, FakeAbCipTagFactory Factory)> BuildAsync(
        Func<AbCipTagCreateParams, FakeAbCipTag>? make = null)
    {
        var factory = new FakeAbCipTagFactory
        {
            Customise = make ?? (p => p.TagName == "Broken"
                ? new FakeAbCipTag(p) { ThrowOnRead = true }
                : new RealEncodingTag(p) { Value = 0 }),
        };
        var drv = new AbCipDriver(new AbCipDriverOptions
        {
            Devices = [new AbCipDeviceOptions(Device)],
            RawTags = AbCipRawTags.From(
                new AbCipTagDefinition("D", Device, "D", AbCipDataType.DInt),
                new AbCipTagDefinition("I", Device, "I", AbCipDataType.Int),
                new AbCipTagDefinition("Broken", Device, "Broken", AbCipDataType.DInt)),
            Probe = new AbCipProbeOptions { Enabled = false },
        }, "abcip-write-health", factory);
        await drv.InitializeAsync("{}", CancellationToken.None);
        return (drv, factory);
    }

    /// <summary>A fake whose encode converts like the real runtimes do (Convert.ToInt32 / ToInt16).</summary>
    private sealed class RealEncodingTag(AbCipTagCreateParams p) : FakeAbCipTag(p)
    {
        public override void EncodeValue(AbCipDataType type, int? bitIndex, object? value) =>
            Value = type switch
            {
                AbCipDataType.Int => Convert.ToInt16(value),
                _ => Convert.ToInt32(value),
            };
    }

    /// <summary>Unconvertible / out-of-range client values: refused per tag, health untouched, nothing sent.</summary>
    [Fact]
    public async Task A_client_conversion_error_writes_no_health()
    {
        var (drv, factory) = await BuildAsync();
        var before = drv.GetHealth();

        var r = await drv.WriteAsync(
        [
            new WriteRequest("D", "not a number"),   // FormatException
            new WriteRequest("D", new object()),     // InvalidCastException
            new WriteRequest("I", 1_000_000),        // OverflowException
        ], CancellationToken.None);

        r[0].StatusCode.ShouldBe(AbCipStatusMapper.BadTypeMismatch);
        r[1].StatusCode.ShouldBe(AbCipStatusMapper.BadTypeMismatch);
        r[2].StatusCode.ShouldBe(AbCipStatusMapper.BadOutOfRange);
        drv.GetHealth().ShouldBe(before);
        factory.Tags["D"].WriteCount.ShouldBe(0);
        factory.Tags["I"].WriteCount.ShouldBe(0);
    }

    /// <summary>A good write keeps a Degraded the read path recorded, and advances LastSuccessfulRead.</summary>
    [Fact]
    public async Task A_good_write_does_not_overwrite_Degraded_with_Healthy()
    {
        var (drv, _) = await BuildAsync();
        await drv.ReadAsync(["Broken"], CancellationToken.None);
        var degraded = drv.GetHealth();
        degraded.State.ShouldBe(DriverState.Degraded);
        await Task.Delay(20);

        var r = await drv.WriteAsync([new WriteRequest("D", 5)], CancellationToken.None);

        r[0].StatusCode.ShouldBe(AbCipStatusMapper.Good);
        var after = drv.GetHealth();
        after.State.ShouldBe(DriverState.Degraded);
        after.LastError.ShouldBe(degraded.LastError);
        after.LastSuccessfulRead!.Value.ShouldBeGreaterThan(degraded.LastSuccessfulRead!.Value); // the device answered
    }

    /// <summary>Positive control: a genuine write transport fault still degrades and preserves LastSuccessfulRead.</summary>
    [Fact]
    public async Task A_write_transport_fault_still_degrades()
    {
        var (drv, factory) = await BuildAsync(p => new ThrowingWriteTag(p));
        var before = drv.GetHealth();

        var r = await drv.WriteAsync([new WriteRequest("D", 5)], CancellationToken.None);

        r[0].StatusCode.ShouldBe(AbCipStatusMapper.BadCommunicationError);
        var after = drv.GetHealth();
        after.State.ShouldBe(DriverState.Degraded);
        after.LastSuccessfulRead.ShouldBe(before.LastSuccessfulRead);
        factory.Tags["D"].Disposed.ShouldBeTrue();
    }
}