lmxopcua/tests/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests/AddressSpacePlannerDualNamespaceTests.cs

using Shouldly;
using Xunit;
using ZB.MOM.WW.OtOpcUa.Configuration.Entities;
using ZB.MOM.WW.OtOpcUa.Configuration.Enums;

namespace ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests;

/// <summary>
///     v3 Batch 4 (B4-WP1) — the planner diffs per realm. Raw containers + raw tags diff by RawPath
///     (NodeId), so a rename is remove(old)+add(new); UNS reference variables diff by the stable
///     <c>UnsTagReferenceId</c>, so a backing-tag rename is a re-point (BackingRawPath moves, NodeId stable)
///     and a display-name-override edit is a UNS-only change with no raw delta.
///     <para><b>The pinned invariant:</b> a raw-tag rename = remove+add in Raw AND re-point in UNS.</para>
/// </summary>
public sealed class AddressSpacePlannerDualNamespaceTests
{
    private const string RawFolderName = "Plant";
    private const string DriverName = "Modbus1";
    private const string DeviceName = "PLC-A";

    // Compose a fixture with one raw tag (given name) under Plant/Modbus1/PLC-A and one UNS reference to it
    // (with an optional display-name override so the effective name can be held stable across a raw rename).
    private static AddressSpaceComposition Compose(string tagName, string? displayOverride)
    {
        var folder = new RawFolder { RawFolderId = "raw-plant", ClusterId = "c1", Name = RawFolderName };
        var driver = new DriverInstance
        {
            DriverInstanceId = "drv-modbus", ClusterId = "c1", RawFolderId = "raw-plant",
            Name = DriverName, DriverType = "Modbus", DriverConfig = "{}",
        };
        var device = new Device { DeviceId = "dev-1", DriverInstanceId = "drv-modbus", Name = DeviceName, DeviceConfig = "{}" };
        var tag = new Tag
        {
            TagId = "t-speed", DeviceId = "dev-1", Name = tagName,
            DataType = "Float", AccessLevel = TagAccessLevel.ReadWrite, TagConfig = "{}",
        };
        var area = new UnsArea { UnsAreaId = "area-1", ClusterId = "c1", Name = "filling" };
        var line = new UnsLine { UnsLineId = "line-1", UnsAreaId = "area-1", Name = "line-1" };
        var equip = new Equipment { EquipmentId = "eq-1", UnsLineId = "line-1", Name = "station-1", MachineCode = "STATION_001" };
        var reference = new UnsTagReference
        {
            UnsTagReferenceId = "ref-1", EquipmentId = "eq-1", TagId = "t-speed",
            DisplayNameOverride = displayOverride,
        };

        return AddressSpaceComposer.Compose(
            new[] { area }, new[] { line }, new[] { equip },
            new[] { driver }, Array.Empty<ScriptedAlarm>(),
            unsTagReferences: new[] { reference },
            tags: new[] { tag },
            rawFolders: new[] { folder },
            devices: new[] { device });
    }

    /// <summary>A newly-added raw tag surfaces in AddedRawTags (keyed by RawPath); the plan is non-empty.</summary>
    [Fact]
    public void Added_raw_tag_goes_to_AddedRawTags()
    {
        var prev = Compose("Speed", displayOverride: null);
        var next = Compose("Speed", displayOverride: null);
        // prev without the tag: strip RawTags/UNS by composing an empty raw side.
        var empty = AddressSpaceComposer.Compose(
            Array.Empty<UnsArea>(), Array.Empty<UnsLine>(), Array.Empty<Equipment>(),
            Array.Empty<DriverInstance>(), Array.Empty<ScriptedAlarm>());

        var plan = AddressSpacePlanner.Compute(empty, next);

        plan.IsEmpty.ShouldBeFalse();
        plan.AddedRawTags.Select(t => t.NodeId).ShouldContain("Plant/Modbus1/PLC-A/Speed");
        plan.RemovedRawTags.ShouldBeEmpty();
        _ = prev;
    }

    /// <summary>A disappeared raw tag surfaces in RemovedRawTags.</summary>
    [Fact]
    public void Removed_raw_tag_goes_to_RemovedRawTags()
    {
        var prev = Compose("Speed", displayOverride: null);
        var empty = AddressSpaceComposer.Compose(
            Array.Empty<UnsArea>(), Array.Empty<UnsLine>(), Array.Empty<Equipment>(),
            Array.Empty<DriverInstance>(), Array.Empty<ScriptedAlarm>());

        var plan = AddressSpacePlanner.Compute(prev, empty);

        plan.RemovedRawTags.Select(t => t.NodeId).ShouldContain("Plant/Modbus1/PLC-A/Speed");
        plan.AddedRawTags.ShouldBeEmpty();
    }

    /// <summary>A newly-added UNS reference surfaces in AddedUnsReferenceVariables.</summary>
    [Fact]
    public void Added_uns_reference_goes_to_AddedUnsReferenceVariables()
    {
        var empty = AddressSpaceComposer.Compose(
            Array.Empty<UnsArea>(), Array.Empty<UnsLine>(), Array.Empty<Equipment>(),
            Array.Empty<DriverInstance>(), Array.Empty<ScriptedAlarm>());
        var next = Compose("Speed", displayOverride: null);

        var plan = AddressSpacePlanner.Compute(empty, next);

        plan.AddedUnsReferenceVariables.Single().UnsTagReferenceId.ShouldBe("ref-1");
        plan.RemovedUnsReferenceVariables.ShouldBeEmpty();
    }

    /// <summary>A disappeared UNS reference surfaces in RemovedUnsReferenceVariables.</summary>
    [Fact]
    public void Removed_uns_reference_goes_to_RemovedUnsReferenceVariables()
    {
        var prev = Compose("Speed", displayOverride: null);
        var empty = AddressSpaceComposer.Compose(
            Array.Empty<UnsArea>(), Array.Empty<UnsLine>(), Array.Empty<Equipment>(),
            Array.Empty<DriverInstance>(), Array.Empty<ScriptedAlarm>());

        var plan = AddressSpacePlanner.Compute(prev, empty);

        plan.RemovedUnsReferenceVariables.Single().UnsTagReferenceId.ShouldBe("ref-1");
        plan.AddedUnsReferenceVariables.ShouldBeEmpty();
    }

    /// <summary><b>THE PIN:</b> a raw-tag rename = remove+add in Raw AND re-point in UNS. With a display-name
    /// override holding the effective name stable, the reference row is unchanged (same UnsTagReferenceId,
    /// same UNS NodeId) but its backing NodeId moved ⇒ the UNS variable's Organizes target (BackingRawPath)
    /// re-points via a ChangedUnsReferenceVariables delta.</summary>
    [Fact]
    public void Raw_rename_is_remove_add_in_raw_and_repoint_in_uns()
    {
        var prev = Compose("Speed", displayOverride: "Spd");
        var next = Compose("Velocity", displayOverride: "Spd"); // raw tag renamed; effective name held stable

        var plan = AddressSpacePlanner.Compute(prev, next);

        // Raw realm: remove the old RawPath, add the new one (immutable NodeId ⇒ not a Changed delta).
        plan.RemovedRawTags.Select(t => t.NodeId).ShouldBe(new[] { "Plant/Modbus1/PLC-A/Speed" });
        plan.AddedRawTags.Select(t => t.NodeId).ShouldBe(new[] { "Plant/Modbus1/PLC-A/Velocity" });
        plan.ChangedRawTags.ShouldBeEmpty();

        // UNS realm: the reference row is unchanged in identity + NodeId, but re-points to the new RawPath.
        plan.AddedUnsReferenceVariables.ShouldBeEmpty();
        plan.RemovedUnsReferenceVariables.ShouldBeEmpty();
        var repoint = plan.ChangedUnsReferenceVariables.ShouldHaveSingleItem();
        repoint.Previous.UnsTagReferenceId.ShouldBe("ref-1");
        repoint.Current.UnsTagReferenceId.ShouldBe("ref-1");
        repoint.Previous.NodeId.ShouldBe(repoint.Current.NodeId); // effective name stable ⇒ NodeId stable
        repoint.Previous.BackingRawPath.ShouldBe("Plant/Modbus1/PLC-A/Speed");
        repoint.Current.BackingRawPath.ShouldBe("Plant/Modbus1/PLC-A/Velocity");

        // The raw container topology (Folder/Driver/Device) is untouched by a tag rename.
        plan.AddedRawContainers.ShouldBeEmpty();
        plan.RemovedRawContainers.ShouldBeEmpty();
        plan.ChangedRawContainers.ShouldBeEmpty();
    }

    /// <summary>A display-name-override change is a UNS-only change (no raw delta): same reference row id,
    /// the effective name + UNS NodeId move, the backing RawPath is unchanged.</summary>
    [Fact]
    public void Display_name_override_change_is_uns_only_no_raw_change()
    {
        var prev = Compose("Speed", displayOverride: "Spd");
        var next = Compose("Speed", displayOverride: "Speedy"); // only the override changed

        var plan = AddressSpacePlanner.Compute(prev, next);

        // No raw-side change whatsoever.
        plan.AddedRawTags.ShouldBeEmpty();
        plan.RemovedRawTags.ShouldBeEmpty();
        plan.ChangedRawTags.ShouldBeEmpty();
        plan.AddedRawContainers.ShouldBeEmpty();
        plan.RemovedRawContainers.ShouldBeEmpty();
        plan.ChangedRawContainers.ShouldBeEmpty();

        // UNS: same reference row id, effective name + NodeId changed, backing RawPath unchanged.
        var delta = plan.ChangedUnsReferenceVariables.ShouldHaveSingleItem();
        delta.Previous.UnsTagReferenceId.ShouldBe("ref-1");
        delta.Previous.EffectiveName.ShouldBe("Spd");
        delta.Current.EffectiveName.ShouldBe("Speedy");
        delta.Previous.NodeId.ShouldNotBe(delta.Current.NodeId);
        delta.Previous.BackingRawPath.ShouldBe(delta.Current.BackingRawPath);
        plan.AddedUnsReferenceVariables.ShouldBeEmpty();
        plan.RemovedUnsReferenceVariables.ShouldBeEmpty();
    }

    /// <summary>An attribute-only raw-tag edit (historize toggle) keeps the same RawPath ⇒ a
    /// ChangedRawTags delta (not remove+add).</summary>
    [Fact]
    public void Raw_tag_attribute_edit_keeps_nodeid_and_routes_to_ChangedRawTags()
    {
        var prev = Compose("Speed", displayOverride: null);
        // next: same identity + name, but toggle historize on the raw tag.
        var folder = new RawFolder { RawFolderId = "raw-plant", ClusterId = "c1", Name = RawFolderName };
        var driver = new DriverInstance
        {
            DriverInstanceId = "drv-modbus", ClusterId = "c1", RawFolderId = "raw-plant",
            Name = DriverName, DriverType = "Modbus", DriverConfig = "{}",
        };
        var device = new Device { DeviceId = "dev-1", DriverInstanceId = "drv-modbus", Name = DeviceName, DeviceConfig = "{}" };
        var tag = new Tag
        {
            TagId = "t-speed", DeviceId = "dev-1", Name = "Speed",
            DataType = "Float", AccessLevel = TagAccessLevel.ReadWrite, TagConfig = "{\"isHistorized\":true}",
        };
        var next = AddressSpaceComposer.Compose(
            Array.Empty<UnsArea>(), Array.Empty<UnsLine>(), Array.Empty<Equipment>(),
            new[] { driver }, Array.Empty<ScriptedAlarm>(),
            tags: new[] { tag }, rawFolders: new[] { folder }, devices: new[] { device });

        var prevRawOnly = AddressSpaceComposer.Compose(
            Array.Empty<UnsArea>(), Array.Empty<UnsLine>(), Array.Empty<Equipment>(),
            new[] { driver }, Array.Empty<ScriptedAlarm>(),
            tags: new[] { new Tag { TagId = "t-speed", DeviceId = "dev-1", Name = "Speed", DataType = "Float", AccessLevel = TagAccessLevel.ReadWrite, TagConfig = "{}" } },
            rawFolders: new[] { folder }, devices: new[] { device });

        var plan = AddressSpacePlanner.Compute(prevRawOnly, next);

        plan.AddedRawTags.ShouldBeEmpty();
        plan.RemovedRawTags.ShouldBeEmpty();
        var changed = plan.ChangedRawTags.ShouldHaveSingleItem();
        changed.Previous.NodeId.ShouldBe(changed.Current.NodeId);
        changed.Previous.IsHistorized.ShouldBeFalse();
        changed.Current.IsHistorized.ShouldBeTrue();
        _ = prev;
    }

    /// <summary>Identical compositions diff to an empty plan across both realms (fresh list instances must
    /// not spuriously flag RawTags/UnsReferenceVariables as changed).</summary>
    [Fact]
    public void Identical_dual_namespace_compositions_diff_to_empty()
    {
        var prev = Compose("Speed", displayOverride: "Spd");
        var next = Compose("Speed", displayOverride: "Spd");

        var plan = AddressSpacePlanner.Compute(prev, next);

        plan.IsEmpty.ShouldBeTrue();
    }
}