feat(runtime): route driver values to folder-scoped equipment NodeIds (live-value delivery)

tests/Server/ZB.MOM.WW.OtOpcUa.Runtime.Tests/Drivers/DriverHostActorLiveValueTests.cs

@@ -0,0 +1,194 @@
+using System.Text.Json;
+using Akka.Actor;
+using Microsoft.EntityFrameworkCore;
+using Shouldly;
+using Xunit;
+using ZB.MOM.WW.OtOpcUa.Commons.Engines;
+using ZB.MOM.WW.OtOpcUa.Commons.Messages.Deploy;
+using ZB.MOM.WW.OtOpcUa.Commons.Messages.Fleet;
+using ZB.MOM.WW.OtOpcUa.Commons.OpcUa;
+using ZB.MOM.WW.OtOpcUa.Commons.Types;
+using ZB.MOM.WW.OtOpcUa.Configuration;
+using ZB.MOM.WW.OtOpcUa.Configuration.Entities;
+using ZB.MOM.WW.OtOpcUa.Configuration.Enums;
+using ZB.MOM.WW.OtOpcUa.Runtime.Drivers;
+using ZB.MOM.WW.OtOpcUa.Runtime.OpcUa;
+using ZB.MOM.WW.OtOpcUa.Runtime.Tests.Harness;
+
+namespace ZB.MOM.WW.OtOpcUa.Runtime.Tests.Drivers;
+
+/// <summary>
+///     Verifies the equipment-tag <b>live-value routing</b> wired into <see cref="DriverHostActor"/>:
+///     a driver publishes a value keyed by its wire-ref <c>FullName</c>, but the equipment variable was
+///     materialised under a FOLDER-SCOPED NodeId (<c>{equipmentId}/{folderPath}/{name}</c>). After an
+///     apply, the host's <c>_nodeIdByDriverRef</c> map resolves <c>(DriverInstanceId, FullName)</c> to
+///     that folder-scoped NodeId, so <c>ForwardToMux</c> lands the value on the right node (and still
+///     forwards the raw value to the dependency mux for VirtualTag inputs).
+///
+///     <para>
+///         Drives a real apply through the existing harness: the seeded artifact carries the
+///         <c>Namespaces</c> / <c>DriverInstances</c> / <c>Tags</c> arrays that
+///         <c>DeploymentArtifact.BuildEquipmentTagPlans</c> needs to project equipment tags, and a
+///         <c>DispatchDeployment</c> triggers the <c>ApplyAndAck → PushDesiredSubscriptions</c> pass
+///         that builds the map. The OPC UA sink and the dependency mux are injected as
+///         <see cref="Akka.TestKit.TestProbe"/>s.
+///     </para>
+/// </summary>
+public sealed class DriverHostActorLiveValueTests : RuntimeActorTestBase
+{
+    private static readonly NodeId TestNode = NodeId.Parse("driver-lv-test");
+    private static readonly RevisionHash RevA = RevisionHash.Parse(new string('a', 64));
+    private static readonly DateTime Ts = new(2026, 6, 13, 10, 0, 0, DateTimeKind.Utc);
+
+    /// <summary>A driver value published by FullName lands on the equipment variable's folder-scoped
+    /// NodeId (here <c>eq-1/speed</c>, no sub-folder), carrying the value/quality/timestamp.</summary>
+    [Fact]
+    public void Driver_value_routes_to_folder_scoped_equipment_NodeId()
+    {
+        var db = NewInMemoryDbFactory();
+        // One equipment tag: eq-1, drv-1, FullName "40001", no folder, Name "speed".
+        var deploymentId = SeedDeploymentWithEquipmentTags(db, RevA,
+            (Equip: "eq-1", Driver: "drv-1", FullName: "40001", Folder: null, Name: "speed"));
+
+        var (actor, publish, mux) = SpawnHostAndApply(db, deploymentId);
+
+        actor.Tell(new DriverInstanceActor.AttributeValuePublished(
+            "drv-1", "40001", 42.0, OpcUaQuality.Good, Ts));
+
+        var update = publish.ExpectMsg<OpcUaPublishActor.AttributeValueUpdate>(TimeSpan.FromSeconds(5));
+        update.NodeId.ShouldBe("eq-1/speed");
+        update.Value.ShouldBe(42.0);
+        update.Quality.ShouldBe(OpcUaQuality.Good);
+        update.TimestampUtc.ShouldBe(Ts);
+
+        // The raw value is still forwarded to the dependency mux (VirtualTag inputs, keyed by FullName).
+        mux.ExpectMsg<DriverInstanceActor.AttributeValuePublished>(TimeSpan.FromSeconds(5))
+            .FullReference.ShouldBe("40001");
+    }
+
+    /// <summary>The same driver ref backing two equipments fans out: a single publish produces one
+    /// <see cref="OpcUaPublishActor.AttributeValueUpdate"/> per equipment variable NodeId.</summary>
+    [Fact]
+    public void Same_ref_on_two_equipments_fans_out_to_both_NodeIds()
+    {
+        var db = NewInMemoryDbFactory();
+        // Same (drv-1, "40001") wire-ref backs eq-1/speed AND eq-2/speed (identical machines).
+        var deploymentId = SeedDeploymentWithEquipmentTags(db, RevA,
+            (Equip: "eq-1", Driver: "drv-1", FullName: "40001", Folder: null, Name: "speed"),
+            (Equip: "eq-2", Driver: "drv-1", FullName: "40001", Folder: null, Name: "speed"));
+
+        var (actor, publish, _) = SpawnHostAndApply(db, deploymentId);
+
+        actor.Tell(new DriverInstanceActor.AttributeValuePublished(
+            "drv-1", "40001", 7.0, OpcUaQuality.Good, Ts));
+
+        // One publish → two updates. Assert the SET of NodeIds (order is not contractual).
+        var first = publish.ExpectMsg<OpcUaPublishActor.AttributeValueUpdate>(TimeSpan.FromSeconds(5));
+        var second = publish.ExpectMsg<OpcUaPublishActor.AttributeValueUpdate>(TimeSpan.FromSeconds(5));
+        new[] { first.NodeId, second.NodeId }.ShouldBe(
+            new[] { "eq-1/speed", "eq-2/speed" }, ignoreOrder: true);
+        first.Value.ShouldBe(7.0);
+        second.Value.ShouldBe(7.0);
+    }
+
+    /// <summary>A value for a ref not in the composition is NOT pushed to the OPC UA sink (no matching
+    /// NodeId), but is still forwarded to the dependency mux.</summary>
+    [Fact]
+    public void Unmatched_ref_is_dropped_from_sink_but_still_forwarded_to_mux()
+    {
+        var db = NewInMemoryDbFactory();
+        var deploymentId = SeedDeploymentWithEquipmentTags(db, RevA,
+            (Equip: "eq-1", Driver: "drv-1", FullName: "40001", Folder: null, Name: "speed"));
+
+        var (actor, publish, mux) = SpawnHostAndApply(db, deploymentId);
+
+        actor.Tell(new DriverInstanceActor.AttributeValuePublished(
+            "drv-1", "59999", 99.0, OpcUaQuality.Good, Ts));
+
+        // No equipment-tag NodeId for ("drv-1","59999") → nothing reaches the sink.
+        publish.ExpectNoMsg(TimeSpan.FromMilliseconds(500));
+        // The raw publish still reaches the dependency mux.
+        mux.ExpectMsg<DriverInstanceActor.AttributeValuePublished>(TimeSpan.FromSeconds(5))
+            .FullReference.ShouldBe("59999");
+    }
+
+    /// <summary>Spawns the host with publish + mux probes, dispatches the deployment, and waits for the
+    /// Applied ACK so the apply (and thus the map build in PushDesiredSubscriptions) has completed
+    /// before the test publishes a value. A VirtualTag-host probe is injected so the real host isn't
+    /// spawned (it would consume the mux-forwarded publishes otherwise — see SpawnVirtualTagHost).</summary>
+    private (IActorRef Actor, Akka.TestKit.TestProbe Publish, Akka.TestKit.TestProbe Mux) SpawnHostAndApply(
+        IDbContextFactory<OtOpcUaConfigDbContext> db, DeploymentId deploymentId)
+    {
+        var coordinator = CreateTestProbe();
+        var publish = CreateTestProbe();
+        var mux = CreateTestProbe();
+        var vtHost = CreateTestProbe();
+
+        var actor = Sys.ActorOf(DriverHostActor.Props(
+            db, TestNode, coordinator.Ref,
+            localRoles: new HashSet<string> { "driver" },
+            dependencyMux: mux.Ref,
+            opcUaPublishActor: publish.Ref,
+            virtualTagEvaluator: NullVirtualTagEvaluator.Instance,
+            virtualTagHostOverride: vtHost.Ref));
+
+        actor.Tell(new DispatchDeployment(deploymentId, RevA, CorrelationId.NewId()));
+        coordinator.ExpectMsg<ApplyAck>(TimeSpan.FromSeconds(5)).Outcome.ShouldBe(ApplyAckOutcome.Applied);
+
+        // RebuildAddressSpace also lands on the publish probe during apply; drain it so the test's
+        // ExpectMsg<AttributeValueUpdate> assertions see only value updates.
+        publish.ExpectMsg<OpcUaPublishActor.RebuildAddressSpace>(TimeSpan.FromSeconds(5));
+
+        return (actor, publish, mux);
+    }
+
+    /// <summary>
+    ///     Seeds a Sealed deployment whose artifact carries the minimal arrays
+    ///     <c>DeploymentArtifact.BuildEquipmentTagPlans</c> needs to project equipment tags:
+    ///     <c>Namespaces</c> (one Equipment-kind ns), <c>DriverInstances</c> (each driver bound to that
+    ///     ns), and <c>Tags</c> (each with a non-null EquipmentId + a TagConfig blob carrying FullName).
+    /// </summary>
+    private static DeploymentId SeedDeploymentWithEquipmentTags(
+        IDbContextFactory<OtOpcUaConfigDbContext> db, RevisionHash rev,
+        params (string Equip, string Driver, string FullName, string? Folder, string Name)[] tags)
+    {
+        var driverIds = tags.Select(t => t.Driver).Distinct(StringComparer.Ordinal).ToArray();
+
+        var artifact = JsonSerializer.SerializeToUtf8Bytes(new
+        {
+            Namespaces = new[]
+            {
+                new { NamespaceId = "ns-eq", Kind = 0 }, // NamespaceKind.Equipment = 0
+            },
+            DriverInstances = driverIds.Select(d => new
+            {
+                DriverInstanceId = d,
+                NamespaceId = "ns-eq",
+            }).ToArray(),
+            Tags = tags.Select((t, i) => new
+            {
+                TagId = $"tag-{i}",
+                EquipmentId = t.Equip,
+                DriverInstanceId = t.Driver,
+                Name = t.Name,
+                FolderPath = t.Folder,
+                DataType = "Double",
+                TagConfig = JsonSerializer.Serialize(new { FullName = t.FullName }),
+            }).ToArray(),
+        });
+
+        var id = DeploymentId.NewId();
+        using var ctx = db.CreateDbContext();
+        ctx.Deployments.Add(new Deployment
+        {
+            DeploymentId = id.Value,
+            RevisionHash = rev.Value,
+            Status = DeploymentStatus.Sealed,
+            CreatedBy = "test",
+            SealedAtUtc = DateTime.UtcNow,
+            ArtifactBlob = artifact,
+        });
+        ctx.SaveChanges();
+        return id;
+    }
+}