Joseph Doherty
850 lines
48 KiB
C#
850 lines
48 KiB
C#
using System.Text.Json;
|
|
using Akka.Actor;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Shouldly;
|
|
using Xunit;
|
|
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.Core.Abstractions;
|
|
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 discovered-node injection wired into <see cref="DriverHostActor"/> (Task 7): when a
|
|
/// driver child reports a captured FixedTree via <see cref="DriverInstanceActor.DiscoveredNodesReady"/>,
|
|
/// the host resolves the bound equipment from the authored composition, maps the nodes under it via
|
|
/// <see cref="DiscoveredNodeMapper"/>, materialises them on the OPC UA publish side
|
|
/// (<see cref="OpcUaPublishActor.MaterialiseDiscoveredNodes"/>), extends the live-value routing map
|
|
/// (<c>_nodeIdByDriverRef</c>), and merges the FixedTree refs into the driver's desired subscription set
|
|
/// (<see cref="DriverInstanceActor.SetDesiredSubscriptions"/>).
|
|
///
|
|
/// <para>
|
|
/// Drives a real apply through the existing harness (same artifact shape as
|
|
/// <c>DriverHostActorLiveValueTests</c> / <c>DriverHostActorWriteRoutingTests</c>) so
|
|
/// <c>_lastComposition</c> is set and a real (non-stubbed) <see cref="DriverInstanceActor"/> child
|
|
/// is spawned for <c>d1</c>. The child is backed by the shared <see cref="SubscribableStubDriver"/>
|
|
/// (records <c>LastSubscribedRefs</c>/<c>SubscribeCount</c>, exactly as
|
|
/// <c>DriverInstanceActorTests</c> asserts) so the merged subscription is observable; the OPC UA
|
|
/// publish actor is a <see cref="Akka.TestKit.TestProbe"/> (as in
|
|
/// <c>DriverHostActorLiveValueTests</c>) so the materialise + the post-injection value route are
|
|
/// observable. There is no test seam to inject a probe AS a driver child, so this is the faithful
|
|
/// end-to-end approach the harness allows.
|
|
/// </para>
|
|
/// </summary>
|
|
[Trait("Category", "Unit")]
|
|
public sealed class DriverHostActorDiscoveryTests : RuntimeActorTestBase
|
|
{
|
|
private static readonly NodeId TestNode = NodeId.Parse("driver-disc-test");
|
|
private static readonly RevisionHash RevA = RevisionHash.Parse(new string('a', 64));
|
|
private static readonly RevisionHash RevB = RevisionHash.Parse(new string('b', 64));
|
|
private static readonly RevisionHash RevC = RevisionHash.Parse(new string('c', 64));
|
|
private static readonly TimeSpan Timeout = TimeSpan.FromSeconds(5);
|
|
private static readonly DateTime Ts = new(2026, 6, 26, 10, 0, 0, DateTimeKind.Utc);
|
|
|
|
/// <summary>A driver's discovered FixedTree (refs differing from the authored tag) is grafted under the
|
|
/// bound equipment: (a) the publish side receives <see cref="OpcUaPublishActor.MaterialiseDiscoveredNodes"/>
|
|
/// rooted at the equipment NodeId; (b) the driver re-subscribes the UNION of the authored ref + the
|
|
/// FixedTree refs; (c) a value published for a FixedTree ref now routes to its mapped NodeId (proving the
|
|
/// live-value routing map was extended).</summary>
|
|
[Fact]
|
|
public void DiscoveredNodes_materialise_extend_routing_and_merge_subscription()
|
|
{
|
|
var db = NewInMemoryDbFactory();
|
|
var factory = new SubscribingDriverFactory("Modbus");
|
|
// One authored value tag: equipment EQ-1, driver d1, FullName "40001" — this both sets
|
|
// _lastComposition AND binds d1 → EQ-1 (the only way the equipment is resolved, since EquipmentNode
|
|
// carries no DriverInstanceId).
|
|
var deploymentId = SeedDeploymentWithEquipmentTags(db, RevA,
|
|
(Equip: "EQ-1", Driver: "d1", FullName: "40001", Folder: (string?)null, Name: "speed"));
|
|
|
|
var (actor, publish, _) = SpawnHostAndApply(db, deploymentId, factory);
|
|
|
|
// A FixedTree discovered node whose FullReference DIFFERS from the authored tag's FullName, so the
|
|
// mapper keeps it (it does not shadow an authored ref).
|
|
var discovered = new[]
|
|
{
|
|
new DiscoveredNode(
|
|
FolderPathSegments: new[] { "FOCAS", "10.0.0.5:8193", "Identity" },
|
|
BrowseName: "Model",
|
|
DisplayName: "Model",
|
|
FullReference: "ft-ref-1",
|
|
DataType: DriverDataType.Float64,
|
|
IsArray: false,
|
|
ArrayDim: null,
|
|
Writable: false,
|
|
IsHistorized: false),
|
|
};
|
|
|
|
actor.Tell(new DriverInstanceActor.DiscoveredNodesReady("d1", discovered));
|
|
|
|
// (a) The publish side materialises the discovered folders + variables UNDER the equipment root "EQ-1".
|
|
var materialise = publish.ExpectMsg<OpcUaPublishActor.MaterialiseDiscoveredNodes>(Timeout);
|
|
materialise.EquipmentRootNodeId.ShouldBe("EQ-1");
|
|
materialise.Variables.Count.ShouldBe(1);
|
|
materialise.Folders.Count.ShouldBeGreaterThan(0);
|
|
var fixedTreeNodeId = materialise.Variables[0].NodeId;
|
|
|
|
// (b) The driver re-subscribed the UNION of the authored value ref AND the FixedTree ref. The union
|
|
// push is the LAST SetDesiredSubscriptions, so the most recent subscribe carries both.
|
|
AwaitAssert(() =>
|
|
{
|
|
var refs = factory.LastSubscribedRefs;
|
|
refs.ShouldNotBeNull();
|
|
refs!.ShouldContain("40001");
|
|
refs.ShouldContain("ft-ref-1");
|
|
}, duration: Timeout);
|
|
|
|
// (c) A value published for the FixedTree ref now routes to the mapped FixedTree NodeId — proving the
|
|
// _nodeIdByDriverRef live-value map was extended by the injection.
|
|
actor.Tell(new DriverInstanceActor.AttributeValuePublished(
|
|
"d1", "ft-ref-1", 42.0, OpcUaQuality.Good, Ts));
|
|
|
|
var update = publish.ExpectMsg<OpcUaPublishActor.AttributeValueUpdate>(Timeout);
|
|
update.NodeId.ShouldBe(fixedTreeNodeId);
|
|
update.Value.ShouldBe(42.0);
|
|
update.Quality.ShouldBe(OpcUaQuality.Good);
|
|
update.TimestampUtc.ShouldBe(Ts);
|
|
}
|
|
|
|
/// <summary>NEW capability (follow-up E): a driver bound to an equipment via
|
|
/// <see cref="EquipmentNode.DriverInstanceId"/> with ZERO authored equipment tags can still graft its
|
|
/// discovered FixedTree. The equipment is resolved from the composition's <c>EquipmentNodes</c> (not just
|
|
/// the authored <c>EquipmentTags</c>), so a tag-less equipment receives
|
|
/// <see cref="OpcUaPublishActor.MaterialiseDiscoveredNodes"/> rooted at its NodeId and the driver
|
|
/// subscribes the discovered refs (no authored ref exists to union). Previously this was skipped with
|
|
/// "no equipment/authored tags".</summary>
|
|
[Fact]
|
|
public void Tag_less_equipment_resolved_via_EquipmentNode_grafts_discovered_nodes()
|
|
{
|
|
var db = NewInMemoryDbFactory();
|
|
var factory = new SubscribingDriverFactory("Modbus");
|
|
// EQ-1 bound to driver d1 via EquipmentNode.DriverInstanceId, with NO authored equipment tags for d1.
|
|
var deploymentId = SeedDeploymentWithTagLessEquipment(db, RevA, equipmentId: "EQ-1", driverId: "d1");
|
|
|
|
var (actor, publish, _) = SpawnHostAndApply(db, deploymentId, factory);
|
|
|
|
actor.Tell(new DriverInstanceActor.DiscoveredNodesReady("d1", new[]
|
|
{
|
|
new DiscoveredNode(
|
|
FolderPathSegments: new[] { "FOCAS", "10.0.0.5:8193", "Identity" },
|
|
BrowseName: "Model", DisplayName: "Model", FullReference: "ft-ref-1",
|
|
DataType: DriverDataType.Float64, IsArray: false, ArrayDim: null,
|
|
Writable: false, IsHistorized: false),
|
|
}));
|
|
|
|
// (a) The discovered nodes materialise UNDER EQ-1 even though no authored tag binds d1 → EQ-1.
|
|
var materialise = publish.ExpectMsg<OpcUaPublishActor.MaterialiseDiscoveredNodes>(Timeout);
|
|
materialise.EquipmentRootNodeId.ShouldBe("EQ-1");
|
|
materialise.Variables.Count.ShouldBe(1);
|
|
var fixedTreeNodeId = materialise.Variables[0].NodeId;
|
|
|
|
// (b) The driver subscribes the discovered ref (the union is just the FixedTree ref — no authored ref).
|
|
AwaitAssert(() =>
|
|
{
|
|
var refs = factory.LastSubscribedRefs;
|
|
refs.ShouldNotBeNull();
|
|
refs!.ShouldContain("ft-ref-1");
|
|
}, duration: Timeout);
|
|
|
|
// (c) A value published for the FixedTree ref routes to its mapped NodeId (routing map was extended).
|
|
actor.Tell(new DriverInstanceActor.AttributeValuePublished("d1", "ft-ref-1", 42.0, OpcUaQuality.Good, Ts));
|
|
var update = publish.ExpectMsg<OpcUaPublishActor.AttributeValueUpdate>(Timeout);
|
|
update.NodeId.ShouldBe(fixedTreeNodeId);
|
|
update.Value.ShouldBe(42.0);
|
|
}
|
|
|
|
/// <summary>Multi-equipment-per-driver still warn+skips (the multi-device partition is the NEXT follow-up
|
|
/// task). A driver that resolves to MORE THAN ONE equipment injects nothing yet: no
|
|
/// <see cref="OpcUaPublishActor.MaterialiseDiscoveredNodes"/> is told.</summary>
|
|
[Fact]
|
|
public void Driver_mapping_to_more_than_one_equipment_still_warn_skips()
|
|
{
|
|
var db = NewInMemoryDbFactory();
|
|
var factory = new SubscribingDriverFactory("Modbus");
|
|
// d1 is bound to TWO equipments via two authored tags ⇒ equipmentIds.Count == 2 ⇒ warn+skip.
|
|
var deploymentId = SeedDeploymentWithEquipmentTags(db, RevA,
|
|
(Equip: "EQ-1", Driver: "d1", FullName: "40001", Folder: (string?)null, Name: "speed"),
|
|
(Equip: "EQ-2", Driver: "d1", FullName: "40002", Folder: (string?)null, Name: "speed2"));
|
|
|
|
var (actor, publish, _) = SpawnHostAndApply(db, deploymentId, factory);
|
|
|
|
actor.Tell(new DriverInstanceActor.DiscoveredNodesReady("d1", new[]
|
|
{
|
|
new DiscoveredNode(
|
|
FolderPathSegments: new[] { "FOCAS", "10.0.0.5:8193", "Identity" },
|
|
BrowseName: "Model", DisplayName: "Model", FullReference: "ft-ref-1",
|
|
DataType: DriverDataType.Float64, IsArray: false, ArrayDim: null,
|
|
Writable: false, IsHistorized: false),
|
|
}));
|
|
|
|
// Nothing is grafted — the >1-equipment branch warn+skips (replaced by the multi-device task).
|
|
publish.ExpectNoMsg(TimeSpan.FromMilliseconds(500));
|
|
}
|
|
|
|
/// <summary>Guard: a <see cref="DriverInstanceActor.DiscoveredNodesReady"/> arriving BEFORE any deployment
|
|
/// is applied (<c>_lastComposition</c> still null) is ignored — nothing is materialised on the publish
|
|
/// side (the equipment can't be resolved without a composition).</summary>
|
|
[Fact]
|
|
public void DiscoveredNodes_before_any_apply_are_ignored()
|
|
{
|
|
var db = NewInMemoryDbFactory();
|
|
var coordinator = CreateTestProbe();
|
|
var publish = CreateTestProbe();
|
|
var vtHost = CreateTestProbe();
|
|
|
|
// No deployment dispatched ⇒ Bootstrap enters Steady with no composition ⇒ _lastComposition is null.
|
|
var actor = Sys.ActorOf(DriverHostActor.Props(
|
|
db, TestNode, coordinator.Ref,
|
|
driverFactory: new SubscribingDriverFactory("Modbus"),
|
|
localRoles: new HashSet<string> { "driver" },
|
|
opcUaPublishActor: publish.Ref,
|
|
virtualTagHostOverride: vtHost.Ref));
|
|
|
|
actor.Tell(new DriverInstanceActor.DiscoveredNodesReady("d1", new[]
|
|
{
|
|
new DiscoveredNode(
|
|
FolderPathSegments: new[] { "FOCAS", "10.0.0.5:8193", "Identity" },
|
|
BrowseName: "Model", DisplayName: "Model", FullReference: "ft-ref-1",
|
|
DataType: DriverDataType.Float64, IsArray: false, ArrayDim: null,
|
|
Writable: false, IsHistorized: false),
|
|
}));
|
|
|
|
// No composition ⇒ no materialise (and no RebuildAddressSpace either, since nothing was applied).
|
|
publish.ExpectNoMsg(TimeSpan.FromMilliseconds(500));
|
|
}
|
|
|
|
/// <summary>Dedup: a discovered node whose <c>FullReference</c> equals an authored equipment tag's
|
|
/// FullName is NOT injected (it would shadow the authored node) — only the genuinely-new FixedTree refs
|
|
/// are materialised.</summary>
|
|
[Fact]
|
|
public void Discovered_node_shadowing_an_authored_ref_is_not_injected()
|
|
{
|
|
var db = NewInMemoryDbFactory();
|
|
var factory = new SubscribingDriverFactory("Modbus");
|
|
var deploymentId = SeedDeploymentWithEquipmentTags(db, RevA,
|
|
(Equip: "EQ-1", Driver: "d1", FullName: "40001", Folder: (string?)null, Name: "speed"));
|
|
|
|
var (actor, publish, _) = SpawnHostAndApply(db, deploymentId, factory);
|
|
|
|
// Two captured nodes: one SHADOWS the authored ref "40001" (must be dropped), one is genuinely new.
|
|
actor.Tell(new DriverInstanceActor.DiscoveredNodesReady("d1", new[]
|
|
{
|
|
new DiscoveredNode(
|
|
FolderPathSegments: new[] { "FOCAS", "10.0.0.5:8193", "Registers" },
|
|
BrowseName: "speed", DisplayName: "Speed", FullReference: "40001",
|
|
DataType: DriverDataType.Float64, IsArray: false, ArrayDim: null,
|
|
Writable: false, IsHistorized: false),
|
|
new DiscoveredNode(
|
|
FolderPathSegments: new[] { "FOCAS", "10.0.0.5:8193", "Identity" },
|
|
BrowseName: "Model", DisplayName: "Model", FullReference: "ft-ref-1",
|
|
DataType: DriverDataType.Float64, IsArray: false, ArrayDim: null,
|
|
Writable: false, IsHistorized: false),
|
|
}));
|
|
|
|
// Exactly ONE variable materialised — the new "Model", not the authored-shadow "Speed".
|
|
var materialise = publish.ExpectMsg<OpcUaPublishActor.MaterialiseDiscoveredNodes>(Timeout);
|
|
materialise.Variables.Count.ShouldBe(1);
|
|
materialise.Variables[0].DisplayName.ShouldBe("Model");
|
|
}
|
|
|
|
/// <summary>Idempotency / the unchanged-plan short-circuit: re-sending the SAME discovered set (the driver
|
|
/// re-discovers each ~2s pass) is a no-op — it materialises ONCE and does not force the child to
|
|
/// re-subscribe. A GROWN set, however, DOES re-apply (materialise again + re-subscribe), so a stabilising
|
|
/// FixedTree still converges.</summary>
|
|
[Fact]
|
|
public void Repeated_identical_discovery_does_not_reapply_but_a_grown_set_does()
|
|
{
|
|
var db = NewInMemoryDbFactory();
|
|
var factory = new SubscribingDriverFactory("Modbus");
|
|
var deploymentId = SeedDeploymentWithEquipmentTags(db, RevA,
|
|
(Equip: "EQ-1", Driver: "d1", FullName: "40001", Folder: (string?)null, Name: "speed"));
|
|
|
|
var (actor, publish, _) = SpawnHostAndApply(db, deploymentId, factory);
|
|
|
|
var node1 = new DiscoveredNode(
|
|
FolderPathSegments: new[] { "FOCAS", "10.0.0.5:8193", "Identity" },
|
|
BrowseName: "Model", DisplayName: "Model", FullReference: "ft-ref-1",
|
|
DataType: DriverDataType.Float64, IsArray: false, ArrayDim: null,
|
|
Writable: false, IsHistorized: false);
|
|
var node2 = new DiscoveredNode(
|
|
FolderPathSegments: new[] { "FOCAS", "10.0.0.5:8193", "Status" },
|
|
BrowseName: "Run", DisplayName: "Run", FullReference: "ft-ref-2",
|
|
DataType: DriverDataType.Float64, IsArray: false, ArrayDim: null,
|
|
Writable: false, IsHistorized: false);
|
|
|
|
// Pass 1: a new set ⇒ one materialise + a union re-subscribe.
|
|
actor.Tell(new DriverInstanceActor.DiscoveredNodesReady("d1", new[] { node1 }));
|
|
publish.ExpectMsg<OpcUaPublishActor.MaterialiseDiscoveredNodes>(Timeout);
|
|
AwaitAssert(() =>
|
|
{
|
|
var refs = factory.LastSubscribedRefs;
|
|
refs.ShouldNotBeNull();
|
|
refs!.ShouldContain("ft-ref-1");
|
|
}, duration: Timeout);
|
|
var subscribeCountAfterFirst = factory.SubscribeCount;
|
|
|
|
// Pass 2: the IDENTICAL set ⇒ short-circuited (no materialise, no re-subscribe).
|
|
actor.Tell(new DriverInstanceActor.DiscoveredNodesReady("d1", new[] { node1 }));
|
|
publish.ExpectNoMsg(TimeSpan.FromMilliseconds(500));
|
|
factory.SubscribeCount.ShouldBe(subscribeCountAfterFirst);
|
|
|
|
// Pass 3: a GROWN set (superset) ⇒ re-applies (materialise again + re-subscribe with both refs).
|
|
actor.Tell(new DriverInstanceActor.DiscoveredNodesReady("d1", new[] { node1, node2 }));
|
|
publish.ExpectMsg<OpcUaPublishActor.MaterialiseDiscoveredNodes>(Timeout).Variables.Count.ShouldBe(2);
|
|
AwaitAssert(() =>
|
|
{
|
|
factory.SubscribeCount.ShouldBeGreaterThan(subscribeCountAfterFirst);
|
|
var refs = factory.LastSubscribedRefs;
|
|
refs.ShouldNotBeNull();
|
|
refs!.ShouldContain("ft-ref-1");
|
|
refs.ShouldContain("ft-ref-2");
|
|
}, duration: Timeout);
|
|
}
|
|
|
|
/// <summary>Task 8 survival: discovered (FixedTree) nodes injected after the first apply must SURVIVE a
|
|
/// redeploy. A second deployment re-runs <c>PushDesiredSubscriptions</c>, which clears the live-value
|
|
/// routing maps and re-pushes an authored-only subscription set; without the tail re-apply the injected
|
|
/// FixedTree routes + materialised nodes would be lost until the driver reconnects. Asserts the cached
|
|
/// plan is (a) re-materialised under EQ-1 after the rebuild, (b) still present in the child's
|
|
/// post-redeploy subscription, and (c) still routes a published value to its mapped NodeId.</summary>
|
|
[Fact]
|
|
public void Discovered_nodes_survive_a_redeploy_rebuild()
|
|
{
|
|
var db = NewInMemoryDbFactory();
|
|
var factory = new SubscribingDriverFactory("Modbus");
|
|
var deploymentId = SeedDeploymentWithEquipmentTags(db, RevA,
|
|
(Equip: "EQ-1", Driver: "d1", FullName: "40001", Folder: (string?)null, Name: "speed"));
|
|
|
|
var (actor, publish, coordinator) = SpawnHostAndApply(db, deploymentId, factory);
|
|
|
|
var discovered = new[]
|
|
{
|
|
new DiscoveredNode(
|
|
FolderPathSegments: new[] { "FOCAS", "10.0.0.5:8193", "Identity" },
|
|
BrowseName: "Model", DisplayName: "Model", FullReference: "ft-ref-1",
|
|
DataType: DriverDataType.Float64, IsArray: false, ArrayDim: null,
|
|
Writable: false, IsHistorized: false),
|
|
};
|
|
actor.Tell(new DriverInstanceActor.DiscoveredNodesReady("d1", discovered));
|
|
|
|
// First injection: materialise #1 under EQ-1 — capture the mapped NodeId for the survival asserts.
|
|
var materialise1 = publish.ExpectMsg<OpcUaPublishActor.MaterialiseDiscoveredNodes>(Timeout);
|
|
materialise1.EquipmentRootNodeId.ShouldBe("EQ-1");
|
|
materialise1.Variables.Count.ShouldBe(1);
|
|
var fixedTreeNodeId = materialise1.Variables[0].NodeId;
|
|
|
|
// Apply a SECOND deployment (new revision, SAME d1 → EQ-1 binding so HandleDispatchFromSteady doesn't
|
|
// short-circuit on an identical rev). This re-runs PushDesiredSubscriptions, which clears + rebuilds
|
|
// the routing maps and re-pushes the authored-only subscription set — the exact path Task 8 self-heals.
|
|
var deploymentId2 = SeedDeploymentWithEquipmentTags(db, RevB,
|
|
(Equip: "EQ-1", Driver: "d1", FullName: "40001", Folder: (string?)null, Name: "speed"));
|
|
actor.Tell(new DispatchDeployment(deploymentId2, RevB, CorrelationId.NewId()));
|
|
coordinator.ExpectMsg<ApplyAck>(Timeout).Outcome.ShouldBe(ApplyAckOutcome.Applied);
|
|
|
|
// The redeploy fires a fresh RebuildAddressSpace first (drain it) ...
|
|
publish.ExpectMsg<OpcUaPublishActor.RebuildAddressSpace>(Timeout);
|
|
|
|
// (a) ... then the cached discovered plan is RE-MATERIALISED under EQ-1 (the Task-8 tail re-apply),
|
|
// at the SAME NodeId the first injection placed it.
|
|
var materialise2 = publish.ExpectMsg<OpcUaPublishActor.MaterialiseDiscoveredNodes>(Timeout);
|
|
materialise2.EquipmentRootNodeId.ShouldBe("EQ-1");
|
|
materialise2.Variables.Count.ShouldBe(1);
|
|
materialise2.Variables[0].NodeId.ShouldBe(fixedTreeNodeId);
|
|
|
|
// (b) The child's post-redeploy subscription STILL carries the FixedTree ref — it was re-merged onto
|
|
// the freshly-cleared authored-only set, not dropped by the _nodeIdByDriverRef.Clear().
|
|
AwaitAssert(() =>
|
|
{
|
|
var refs = factory.LastSubscribedRefs;
|
|
refs.ShouldNotBeNull();
|
|
refs!.ShouldContain("40001");
|
|
refs.ShouldContain("ft-ref-1");
|
|
}, duration: Timeout);
|
|
|
|
// (c) A value published for the FixedTree ref STILL routes to its mapped NodeId — proving the
|
|
// live-value routing map was rebuilt by the re-apply (not left empty after the Clear()).
|
|
actor.Tell(new DriverInstanceActor.AttributeValuePublished("d1", "ft-ref-1", 42.0, OpcUaQuality.Good, Ts));
|
|
var update = publish.ExpectMsg<OpcUaPublishActor.AttributeValueUpdate>(Timeout);
|
|
update.NodeId.ShouldBe(fixedTreeNodeId);
|
|
update.Value.ShouldBe(42.0);
|
|
update.Quality.ShouldBe(OpcUaQuality.Good);
|
|
}
|
|
|
|
/// <summary>Task 8 cache-drop: a redeploy whose composition no longer binds the driver to any equipment
|
|
/// (its authored tags were removed) must DROP the cached discovered plan rather than re-graft it onto a
|
|
/// stale equipment. After such a redeploy the host re-applies the authored rebuild but does NOT re-tell
|
|
/// <see cref="OpcUaPublishActor.MaterialiseDiscoveredNodes"/> for the now-unresolved driver.</summary>
|
|
[Fact]
|
|
public void Discovered_nodes_dropped_when_equipment_no_longer_resolves()
|
|
{
|
|
var db = NewInMemoryDbFactory();
|
|
var factory = new SubscribingDriverFactory("Modbus");
|
|
var deploymentId = SeedDeploymentWithEquipmentTags(db, RevA,
|
|
(Equip: "EQ-1", Driver: "d1", FullName: "40001", Folder: (string?)null, Name: "speed"));
|
|
|
|
var (actor, publish, coordinator) = SpawnHostAndApply(db, deploymentId, factory);
|
|
|
|
actor.Tell(new DriverInstanceActor.DiscoveredNodesReady("d1", new[]
|
|
{
|
|
new DiscoveredNode(
|
|
FolderPathSegments: new[] { "FOCAS", "10.0.0.5:8193", "Identity" },
|
|
BrowseName: "Model", DisplayName: "Model", FullReference: "ft-ref-1",
|
|
DataType: DriverDataType.Float64, IsArray: false, ArrayDim: null,
|
|
Writable: false, IsHistorized: false),
|
|
}));
|
|
|
|
// First injection materialises under EQ-1.
|
|
publish.ExpectMsg<OpcUaPublishActor.MaterialiseDiscoveredNodes>(Timeout);
|
|
|
|
// Apply a SECOND deployment that binds a DIFFERENT driver (d2 → EQ-2) and carries NO authored tags for
|
|
// d1, so d1's equipment can no longer be resolved (equipmentIds.Count == 0) — the cache entry is dropped.
|
|
var deploymentId2 = SeedDeploymentWithEquipmentTags(db, RevB,
|
|
(Equip: "EQ-2", Driver: "d2", FullName: "40002", Folder: (string?)null, Name: "speed2"));
|
|
actor.Tell(new DispatchDeployment(deploymentId2, RevB, CorrelationId.NewId()));
|
|
coordinator.ExpectMsg<ApplyAck>(Timeout).Outcome.ShouldBe(ApplyAckOutcome.Applied);
|
|
|
|
// The redeploy fires a fresh RebuildAddressSpace; after draining it, NO MaterialiseDiscoveredNodes is
|
|
// re-told (the cached d1 plan was dropped because its equipment no longer resolves).
|
|
publish.ExpectMsg<OpcUaPublishActor.RebuildAddressSpace>(Timeout);
|
|
publish.ExpectNoMsg(TimeSpan.FromMilliseconds(500));
|
|
}
|
|
|
|
/// <summary>Task 8 rebind-guard: a redeploy that REBINDS the driver to a DIFFERENT equipment must DROP the
|
|
/// cached discovered plan rather than re-graft EQ-1-scoped nodes under EQ-2. d1 still resolves to exactly
|
|
/// one equipment (so the Count==0 drop does NOT fire), but the cached plan's NodeIds are scoped to the OLD
|
|
/// equipment (EQ-1), so the <c>StartsWith(equipmentId + "/")</c> guard sees they no longer match EQ-2 and
|
|
/// drops the entry. After the redeploy NO <see cref="OpcUaPublishActor.MaterialiseDiscoveredNodes"/> is
|
|
/// re-told. (Complements <see cref="Discovered_nodes_dropped_when_equipment_no_longer_resolves"/>, which
|
|
/// covers the Count==0 branch; this covers the rebind/StartsWith branch.)</summary>
|
|
[Fact]
|
|
public void Discovered_nodes_dropped_when_driver_rebound_to_a_different_equipment()
|
|
{
|
|
var db = NewInMemoryDbFactory();
|
|
var factory = new SubscribingDriverFactory("Modbus");
|
|
var deploymentId = SeedDeploymentWithEquipmentTags(db, RevA,
|
|
(Equip: "EQ-1", Driver: "d1", FullName: "40001", Folder: (string?)null, Name: "speed"));
|
|
|
|
var (actor, publish, coordinator) = SpawnHostAndApply(db, deploymentId, factory);
|
|
|
|
actor.Tell(new DriverInstanceActor.DiscoveredNodesReady("d1", new[]
|
|
{
|
|
new DiscoveredNode(
|
|
FolderPathSegments: new[] { "FOCAS", "10.0.0.5:8193", "Identity" },
|
|
BrowseName: "Model", DisplayName: "Model", FullReference: "ft-ref-1",
|
|
DataType: DriverDataType.Float64, IsArray: false, ArrayDim: null,
|
|
Writable: false, IsHistorized: false),
|
|
}));
|
|
|
|
// First injection materialises under EQ-1 (the cached plan's NodeIds are scoped to EQ-1).
|
|
publish.ExpectMsg<OpcUaPublishActor.MaterialiseDiscoveredNodes>(Timeout);
|
|
|
|
// Apply a SECOND deployment where d1 is REBOUND to a DIFFERENT equipment EQ-2 (d1 still present + still
|
|
// resolves to exactly one equipment, but the cached plan is scoped to EQ-1). The DriverConfig is
|
|
// unchanged ("{}") so ReconcileDrivers does NOT restart d1 — exactly the config-unchanged rebind the
|
|
// guard's known-limitation comment describes.
|
|
var deploymentId2 = SeedDeploymentWithEquipmentTags(db, RevB,
|
|
(Equip: "EQ-2", Driver: "d1", FullName: "40001", Folder: (string?)null, Name: "speed"));
|
|
actor.Tell(new DispatchDeployment(deploymentId2, RevB, CorrelationId.NewId()));
|
|
coordinator.ExpectMsg<ApplyAck>(Timeout).Outcome.ShouldBe(ApplyAckOutcome.Applied);
|
|
|
|
// After draining the fresh RebuildAddressSpace, NO MaterialiseDiscoveredNodes is re-told — the cached
|
|
// EQ-1-scoped plan was dropped by the rebind guard (its NodeId no longer starts with "EQ-2/").
|
|
publish.ExpectMsg<OpcUaPublishActor.RebuildAddressSpace>(Timeout);
|
|
publish.ExpectNoMsg(TimeSpan.FromMilliseconds(500));
|
|
}
|
|
|
|
/// <summary>Follow-up C, part 2: a CONFIG-UNCHANGED rebind must RE-TRIGGER discovery on the driver's child
|
|
/// so the dropped FixedTree re-grafts under the NEW equipment on the next pass (rather than staying absent
|
|
/// until the driver's next natural reconnect). Wires a REAL <see cref="ITagDiscovery"/> child (policy
|
|
/// <see cref="DiscoveryRediscoverPolicy.Once"/>, ever-growing set) so the connect-time pass populates the
|
|
/// per-equipment cache under EQ-1, then redeploys to rebind d1 → EQ-2 with the SAME (unchanged) DriverConfig
|
|
/// (so <c>ReconcileDrivers</c> does NOT restart the child — exactly the config-unchanged rebind). The
|
|
/// re-inject tail drops the stale EQ-1 entry and must send <see cref="DriverInstanceActor.TriggerRediscovery"/>
|
|
/// to d1's child. The trigger reaching the child is observed at the host level (the only faithful seam — there
|
|
/// is no probe-as-driver-child seam): the child re-runs discovery (its <c>DiscoverCount</c> advances past the
|
|
/// single Once pass — impossible without the trigger, since the child stays Connected so nothing else re-kicks
|
|
/// discovery) AND a fresh <see cref="OpcUaPublishActor.MaterialiseDiscoveredNodes"/> re-grafts the FixedTree
|
|
/// under the new equipment EQ-2.</summary>
|
|
[Fact]
|
|
public void Config_unchanged_rebind_re_triggers_discovery_on_the_child()
|
|
{
|
|
var db = NewInMemoryDbFactory();
|
|
// A REAL ITagDiscovery child (Once policy) — so the connect-time pass populates the cache and a
|
|
// TriggerRediscovery re-runs discovery, making the trigger observable at the host level.
|
|
var factory = new DiscoverableSubscribingDriverFactory("Modbus");
|
|
var deploymentId = SeedDeploymentWithEquipmentTags(db, RevA,
|
|
(Equip: "EQ-1", Driver: "d1", FullName: "40001", Folder: (string?)null, Name: "speed"));
|
|
|
|
var coordinator = CreateTestProbe();
|
|
var publish = CreateTestProbe();
|
|
var vtHost = CreateTestProbe();
|
|
|
|
var actor = Sys.ActorOf(DriverHostActor.Props(
|
|
db, TestNode, coordinator.Ref,
|
|
driverFactory: factory,
|
|
localRoles: new HashSet<string> { "driver" },
|
|
opcUaPublishActor: publish.Ref,
|
|
virtualTagHostOverride: vtHost.Ref));
|
|
|
|
actor.Tell(new DispatchDeployment(deploymentId, RevA, CorrelationId.NewId()));
|
|
coordinator.ExpectMsg<ApplyAck>(Timeout).Outcome.ShouldBe(ApplyAckOutcome.Applied);
|
|
publish.ExpectMsg<OpcUaPublishActor.RebuildAddressSpace>(Timeout);
|
|
|
|
// The child connects and runs its single (Once) post-connect discovery pass, which the host grafts
|
|
// under EQ-1 — this POPULATES the per-equipment cache (_discoveredByDriver[d1] = { EQ-1: plan }).
|
|
publish.FishForMessage<OpcUaPublishActor.MaterialiseDiscoveredNodes>(
|
|
m => m.EquipmentRootNodeId == "EQ-1", Timeout);
|
|
AwaitAssert(() => factory.DiscoverCount.ShouldBe(1), duration: Timeout);
|
|
|
|
// Redeploy: REBIND d1 from EQ-1 → EQ-2 (same FullName; DriverConfig "{}" unchanged so ReconcileDrivers
|
|
// does NOT restart the child). The re-inject tail drops the stale EQ-1-scoped cache entry.
|
|
var deploymentId2 = SeedDeploymentWithEquipmentTags(db, RevB,
|
|
(Equip: "EQ-2", Driver: "d1", FullName: "40001", Folder: (string?)null, Name: "speed"));
|
|
actor.Tell(new DispatchDeployment(deploymentId2, RevB, CorrelationId.NewId()));
|
|
coordinator.ExpectMsg<ApplyAck>(Timeout).Outcome.ShouldBe(ApplyAckOutcome.Applied);
|
|
|
|
// The drop must SEND DriverInstanceActor.TriggerRediscovery to d1's (still-Connected) child, which
|
|
// re-runs discovery: DiscoverCount advances past the single connect pass — the observable proof the
|
|
// trigger reached the child. (Pre-task: no trigger ⇒ Once already settled, child never reconnects ⇒
|
|
// DiscoverCount stays 1 ⇒ this fails.)
|
|
AwaitAssert(() => factory.DiscoverCount.ShouldBeGreaterThan(1), duration: TimeSpan.FromSeconds(10));
|
|
|
|
// ... and the re-triggered pass re-grafts the FixedTree under the NEW equipment EQ-2 (the host resolves
|
|
// d1 → EQ-2 against the new _lastComposition). The re-discovery re-populates the cache as
|
|
// { EQ-2: plan-scoped-to-EQ-2 }.
|
|
publish.FishForMessage<OpcUaPublishActor.MaterialiseDiscoveredNodes>(
|
|
m => m.EquipmentRootNodeId == "EQ-2", Timeout);
|
|
var discoverCountAfterRebind = factory.DiscoverCount; // 2 (connect pass + the rebind re-trigger pass)
|
|
|
|
// Convergence: a FURTHER unchanged redeploy (SAME EQ-2 composition) must NOT drop again, NOT re-trigger,
|
|
// and NOT advance discovery — proving the re-trigger CONVERGES and doesn't loop. The cached EQ-2 plan now
|
|
// SURVIVES the re-inject tail (candidate + NodeIds still scoped to EQ-2), so EQ-2 simply re-materialises
|
|
// (the Task-8 survivor re-apply) — but droppedAny stays false, so no TriggerRediscovery is sent and no
|
|
// fresh discovery pass runs.
|
|
var deploymentId3 = SeedDeploymentWithEquipmentTags(db, RevC,
|
|
(Equip: "EQ-2", Driver: "d1", FullName: "40001", Folder: (string?)null, Name: "speed"));
|
|
actor.Tell(new DispatchDeployment(deploymentId3, RevC, CorrelationId.NewId()));
|
|
coordinator.ExpectMsg<ApplyAck>(Timeout).Outcome.ShouldBe(ApplyAckOutcome.Applied);
|
|
publish.ExpectMsg<OpcUaPublishActor.RebuildAddressSpace>(Timeout);
|
|
// The survivor re-apply re-materialises EQ-2 (NOT a drop+re-trigger).
|
|
publish.ExpectMsg<OpcUaPublishActor.MaterialiseDiscoveredNodes>(Timeout)
|
|
.EquipmentRootNodeId.ShouldBe("EQ-2");
|
|
// No further publish traffic and NO further discovery pass — the re-trigger converged.
|
|
publish.ExpectNoMsg(TimeSpan.FromMilliseconds(500));
|
|
factory.DiscoverCount.ShouldBe(discoverCountAfterRebind);
|
|
}
|
|
|
|
/// <summary>Negative / regression guard: a routine redeploy of a discovery-capable driver that does NOT
|
|
/// rebind (SAME composition, new revision) must NOT spuriously re-trigger discovery. The cached EQ-1 plan
|
|
/// SURVIVES the re-inject tail (its equipment still resolves and its NodeIds are still EQ-1-scoped), so it is
|
|
/// re-applied (EQ-1 re-materialises — the Task-8 survival path) — but NOTHING is dropped, so <c>droppedAny</c>
|
|
/// stays false and no <see cref="DriverInstanceActor.TriggerRediscovery"/> is sent. Uses the REAL
|
|
/// <see cref="ITagDiscovery"/> child (the existing <c>ExpectNoMsg</c> drop tests use a NON-discovery driver,
|
|
/// whose child would no-op a <c>TriggerRediscovery</c> in <c>StartDiscovery</c>'s <c>is not ITagDiscovery</c>
|
|
/// guard — so they would NOT catch a future regression that sets <c>droppedAny</c> on a non-drop path). The
|
|
/// regression is observable here: a spurious trigger would advance <c>DiscoverCount</c> past the single Once
|
|
/// pass.</summary>
|
|
[Fact]
|
|
public void No_drop_redeploy_does_not_re_trigger_discovery()
|
|
{
|
|
var db = NewInMemoryDbFactory();
|
|
var factory = new DiscoverableSubscribingDriverFactory("Modbus");
|
|
var deploymentId = SeedDeploymentWithEquipmentTags(db, RevA,
|
|
(Equip: "EQ-1", Driver: "d1", FullName: "40001", Folder: (string?)null, Name: "speed"));
|
|
|
|
var coordinator = CreateTestProbe();
|
|
var publish = CreateTestProbe();
|
|
var vtHost = CreateTestProbe();
|
|
|
|
var actor = Sys.ActorOf(DriverHostActor.Props(
|
|
db, TestNode, coordinator.Ref,
|
|
driverFactory: factory,
|
|
localRoles: new HashSet<string> { "driver" },
|
|
opcUaPublishActor: publish.Ref,
|
|
virtualTagHostOverride: vtHost.Ref));
|
|
|
|
actor.Tell(new DispatchDeployment(deploymentId, RevA, CorrelationId.NewId()));
|
|
coordinator.ExpectMsg<ApplyAck>(Timeout).Outcome.ShouldBe(ApplyAckOutcome.Applied);
|
|
publish.ExpectMsg<OpcUaPublishActor.RebuildAddressSpace>(Timeout);
|
|
|
|
// Connect-time discovery grafts under EQ-1 and populates the cache (DiscoverCount == 1).
|
|
publish.FishForMessage<OpcUaPublishActor.MaterialiseDiscoveredNodes>(
|
|
m => m.EquipmentRootNodeId == "EQ-1", Timeout);
|
|
AwaitAssert(() => factory.DiscoverCount.ShouldBe(1), duration: Timeout);
|
|
|
|
// Redeploy with the SAME composition (new revision so it applies; NO rebind ⇒ NO drop).
|
|
var deploymentId2 = SeedDeploymentWithEquipmentTags(db, RevB,
|
|
(Equip: "EQ-1", Driver: "d1", FullName: "40001", Folder: (string?)null, Name: "speed"));
|
|
actor.Tell(new DispatchDeployment(deploymentId2, RevB, CorrelationId.NewId()));
|
|
coordinator.ExpectMsg<ApplyAck>(Timeout).Outcome.ShouldBe(ApplyAckOutcome.Applied);
|
|
publish.ExpectMsg<OpcUaPublishActor.RebuildAddressSpace>(Timeout);
|
|
// The cached EQ-1 plan SURVIVES the re-inject tail and is re-applied — EQ-1 re-materialises.
|
|
publish.ExpectMsg<OpcUaPublishActor.MaterialiseDiscoveredNodes>(Timeout)
|
|
.EquipmentRootNodeId.ShouldBe("EQ-1");
|
|
// But NOTHING was dropped, so NO TriggerRediscovery was sent: no fresh discovery pass runs and no
|
|
// further publish traffic arrives. DiscoverCount stays 1.
|
|
publish.ExpectNoMsg(TimeSpan.FromMilliseconds(500));
|
|
factory.DiscoverCount.ShouldBe(1);
|
|
}
|
|
|
|
/// <summary>Spawns the host with the subscribing driver factory + a publish probe, dispatches the
|
|
/// deployment, and waits for the Applied ACK so the apply (and thus <c>_lastComposition</c> + the live
|
|
/// child + the initial SubscribeBulk pass) has completed before the test injects discovered nodes. A
|
|
/// VirtualTag-host probe is injected so the real host isn't spawned. The <see cref="OpcUaPublishActor.RebuildAddressSpace"/>
|
|
/// that lands on the publish probe during apply is drained so the test's materialise / value-update
|
|
/// assertions see only post-apply traffic.</summary>
|
|
private (IActorRef Actor, Akka.TestKit.TestProbe Publish, Akka.TestKit.TestProbe Coordinator) SpawnHostAndApply(
|
|
IDbContextFactory<OtOpcUaConfigDbContext> db, DeploymentId deploymentId, IDriverFactory factory)
|
|
{
|
|
var coordinator = CreateTestProbe();
|
|
var publish = CreateTestProbe();
|
|
var vtHost = CreateTestProbe();
|
|
|
|
var actor = Sys.ActorOf(DriverHostActor.Props(
|
|
db, TestNode, coordinator.Ref,
|
|
driverFactory: factory,
|
|
localRoles: new HashSet<string> { "driver" },
|
|
opcUaPublishActor: publish.Ref,
|
|
virtualTagHostOverride: vtHost.Ref));
|
|
|
|
actor.Tell(new DispatchDeployment(deploymentId, RevA, CorrelationId.NewId()));
|
|
coordinator.ExpectMsg<ApplyAck>(Timeout).Outcome.ShouldBe(ApplyAckOutcome.Applied);
|
|
|
|
publish.ExpectMsg<OpcUaPublishActor.RebuildAddressSpace>(Timeout);
|
|
|
|
return (actor, publish, coordinator);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Seeds a Sealed deployment whose artifact carries the minimal arrays
|
|
/// <c>DeploymentArtifact.BuildEquipmentTagPlans</c> needs to project equipment tags, plus a
|
|
/// <c>DriverInstances</c> row with a non-Windows-only <c>DriverType</c> ("Modbus") + Enabled flag so
|
|
/// a REAL (non-stubbed) <see cref="DriverInstanceActor"/> child is spawned (mirrors
|
|
/// <c>DriverHostActorWriteRoutingTests.SeedDeploymentWithEquipmentTags</c>).
|
|
/// </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
|
|
{
|
|
DriverInstanceRowId = Guid.NewGuid(),
|
|
DriverInstanceId = d,
|
|
Name = d,
|
|
DriverType = "Modbus", // not Windows-only ⇒ a real child is spawned (not stubbed)
|
|
Enabled = true,
|
|
DriverConfig = "{}",
|
|
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;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Seeds a Sealed deployment whose artifact binds an equipment to a driver via the
|
|
/// <c>Equipment</c> row's <c>DriverInstanceId</c> (the <see cref="EquipmentNode.DriverInstanceId"/>
|
|
/// projection) but carries NO authored equipment tags — so the equipment can only be resolved from
|
|
/// <c>EquipmentNodes</c>, not <c>EquipmentTags</c>. A <c>DriverInstances</c> row (non-Windows-only
|
|
/// "Modbus", Enabled) is included so a REAL (non-stubbed) <see cref="DriverInstanceActor"/> child is
|
|
/// spawned for the driver even though it has zero tags.
|
|
/// </summary>
|
|
private static DeploymentId SeedDeploymentWithTagLessEquipment(
|
|
IDbContextFactory<OtOpcUaConfigDbContext> db, RevisionHash rev, string equipmentId, string driverId)
|
|
{
|
|
var artifact = JsonSerializer.SerializeToUtf8Bytes(new
|
|
{
|
|
Namespaces = new[]
|
|
{
|
|
new { NamespaceId = "ns-eq", Kind = 0 }, // NamespaceKind.Equipment = 0
|
|
},
|
|
DriverInstances = new[]
|
|
{
|
|
new
|
|
{
|
|
DriverInstanceRowId = Guid.NewGuid(),
|
|
DriverInstanceId = driverId,
|
|
Name = driverId,
|
|
DriverType = "Modbus", // not Windows-only ⇒ a real child is spawned (not stubbed)
|
|
Enabled = true,
|
|
DriverConfig = "{}",
|
|
NamespaceId = "ns-eq",
|
|
},
|
|
},
|
|
// The equipment binds to the driver via DriverInstanceId — the NEW resolution path — with no tags.
|
|
Equipment = new[]
|
|
{
|
|
new
|
|
{
|
|
EquipmentId = equipmentId,
|
|
Name = equipmentId,
|
|
UnsLineId = (string?)null,
|
|
DriverInstanceId = driverId,
|
|
DeviceId = (string?)null,
|
|
},
|
|
},
|
|
Tags = Array.Empty<object>(),
|
|
});
|
|
|
|
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;
|
|
}
|
|
|
|
/// <summary>Factory producing a single shared <see cref="SubscribableStubDriver"/> for the supported
|
|
/// type, exposing its most-recent subscribed reference set for assertions (mirrors
|
|
/// <c>DriverHostActorWriteRoutingTests.RecordingDriverFactory</c>, but the driver is
|
|
/// <see cref="ISubscribable"/> so the merged subscription is observable).</summary>
|
|
private sealed class SubscribingDriverFactory : IDriverFactory
|
|
{
|
|
private readonly string _supportedType;
|
|
private readonly SubscribableStubDriver _driver = new();
|
|
public SubscribingDriverFactory(string supportedType) { _supportedType = supportedType; }
|
|
|
|
/// <summary>The reference set passed to the driver's most recent <c>SubscribeAsync</c> call.</summary>
|
|
public IReadOnlyList<string>? LastSubscribedRefs => _driver.LastSubscribedRefs;
|
|
|
|
/// <summary>Number of <c>SubscribeAsync</c> calls so far — lets a test prove a redundant re-apply did
|
|
/// NOT force a (drop-then-)re-subscribe of the whole handle.</summary>
|
|
public int SubscribeCount => _driver.SubscribeCount;
|
|
|
|
/// <inheritdoc />
|
|
public IDriver? TryCreate(string driverType, string driverInstanceId, string driverConfigJson) =>
|
|
string.Equals(driverType, _supportedType, StringComparison.Ordinal) ? _driver : null;
|
|
|
|
/// <inheritdoc />
|
|
public IReadOnlyCollection<string> SupportedTypes => new[] { _supportedType };
|
|
}
|
|
|
|
/// <summary>Factory producing a single shared <see cref="DiscoverableSubscribingDriver"/> for the supported
|
|
/// type — a real (non-stubbed) <see cref="DriverInstanceActor"/> child that exposes <see cref="ITagDiscovery"/>,
|
|
/// so the host's post-connect discovery loop populates the discovered-node cache AND a
|
|
/// <see cref="DriverInstanceActor.TriggerRediscovery"/> re-runs discovery (the seam the rebind re-trigger
|
|
/// test asserts through). Exposes the driver's pass count so a test can observe the trigger landing.</summary>
|
|
private sealed class DiscoverableSubscribingDriverFactory : IDriverFactory
|
|
{
|
|
private readonly string _supportedType;
|
|
private DiscoverableSubscribingDriver? _driver;
|
|
public DiscoverableSubscribingDriverFactory(string supportedType) { _supportedType = supportedType; }
|
|
|
|
/// <summary>Number of <c>DiscoverAsync</c> passes the child has driven (advances on every
|
|
/// connect-time pass and every <see cref="DriverInstanceActor.TriggerRediscovery"/>-driven pass).</summary>
|
|
public int DiscoverCount => _driver?.DiscoverCount ?? 0;
|
|
|
|
/// <inheritdoc />
|
|
public IDriver? TryCreate(string driverType, string driverInstanceId, string driverConfigJson) =>
|
|
string.Equals(driverType, _supportedType, StringComparison.Ordinal)
|
|
? _driver ??= new DiscoverableSubscribingDriver(driverInstanceId)
|
|
: null;
|
|
|
|
/// <inheritdoc />
|
|
public IReadOnlyCollection<string> SupportedTypes => new[] { _supportedType };
|
|
}
|
|
|
|
/// <summary>A <see cref="StubDriver"/> that is BOTH <see cref="ISubscribable"/> (so the host's subscribe
|
|
/// path is exercised) and <see cref="ITagDiscovery"/> with policy <see cref="DiscoveryRediscoverPolicy.Once"/>
|
|
/// — exactly one post-connect pass, re-runnable by <see cref="DriverInstanceActor.TriggerRediscovery"/>. Each
|
|
/// pass streams an ever-growing FixedTree (pass N → N nodes, refs "ft-ref-1".."ft-ref-N", none shadowing the
|
|
/// authored "40001"), so a re-triggered pass yields a grown set the host re-applies — and the public
|
|
/// <see cref="DiscoverCount"/> makes the trigger observable at the host level. Re-implements
|
|
/// <see cref="IDriver.DriverInstanceId"/> (the base <see cref="StubDriver"/> hardcodes "stub-driver-1") so the
|
|
/// spawned child reports the SPEC's id — otherwise its auto-sent <see cref="DriverInstanceActor.DiscoveredNodesReady"/>
|
|
/// would carry the wrong driver id and resolve no equipment.</summary>
|
|
private sealed class DiscoverableSubscribingDriver : StubDriver, IDriver, ISubscribable, ITagDiscovery
|
|
{
|
|
private int _passCount;
|
|
private readonly string _driverInstanceId;
|
|
private readonly StubHandle _handle = new();
|
|
|
|
public DiscoverableSubscribingDriver(string driverInstanceId) => _driverInstanceId = driverInstanceId;
|
|
|
|
/// <summary>The spec's driver instance id (re-mapped from the base "stub-driver-1").</summary>
|
|
public new string DriverInstanceId => _driverInstanceId;
|
|
|
|
/// <summary>Single post-connect pass per (re)kick — re-runnable by TriggerRediscovery.</summary>
|
|
public DiscoveryRediscoverPolicy RediscoverPolicy => DiscoveryRediscoverPolicy.Once;
|
|
|
|
/// <summary>Number of <c>DiscoverAsync</c> passes driven so far.</summary>
|
|
public int DiscoverCount => Volatile.Read(ref _passCount);
|
|
|
|
/// <summary>Never raised (the test asserts on discovery + materialise, not data changes); explicit
|
|
/// empty accessors satisfy the interface without a never-used backing field (no CS0067).</summary>
|
|
public event EventHandler<DataChangeEventArgs>? OnDataChange { add { } remove { } }
|
|
|
|
/// <inheritdoc />
|
|
public Task<ISubscriptionHandle> SubscribeAsync(
|
|
IReadOnlyList<string> fullReferences, TimeSpan publishingInterval, CancellationToken cancellationToken)
|
|
=> Task.FromResult<ISubscriptionHandle>(_handle);
|
|
|
|
/// <inheritdoc />
|
|
public Task UnsubscribeAsync(ISubscriptionHandle handle, CancellationToken cancellationToken)
|
|
=> Task.CompletedTask;
|
|
|
|
/// <summary>Streams an ever-growing FixedTree (pass N → N nodes).</summary>
|
|
public Task DiscoverAsync(IAddressSpaceBuilder builder, CancellationToken cancellationToken)
|
|
{
|
|
var pass = Interlocked.Increment(ref _passCount);
|
|
var fixedTree = builder.Folder("FixedTree", "FixedTree");
|
|
for (var i = 0; i < pass; i++)
|
|
{
|
|
fixedTree.Variable($"v{i}", $"v{i}", new DriverAttributeInfo(
|
|
FullName: $"ft-ref-{i + 1}",
|
|
DriverDataType: DriverDataType.Float64,
|
|
IsArray: false,
|
|
ArrayDim: null,
|
|
SecurityClass: SecurityClassification.ViewOnly,
|
|
IsHistorized: false));
|
|
}
|
|
return Task.CompletedTask;
|
|
}
|
|
}
|
|
}
|