diff --git a/docs/plans/2026-05-26-akka-hosting-alignment-plan.md.tasks.json b/docs/plans/2026-05-26-akka-hosting-alignment-plan.md.tasks.json index dbfd668..97f796c 100644 --- a/docs/plans/2026-05-26-akka-hosting-alignment-plan.md.tasks.json +++ b/docs/plans/2026-05-26-akka-hosting-alignment-plan.md.tasks.json @@ -88,7 +88,7 @@ {"id": "F11", "subject": "Follow-up: HistorianAdapterActor named-pipe IPC + SqliteStoreAndForwardSink wiring", "status": "completed", "classification": "standard", "estMinutes": 30, "parallelizableWith": [], "blockedBy": [], "commit": "6861381", "deviationNotes": "Reshaped HistorianAdapterActor around the existing IAlarmHistorianSink abstraction (alarm-event shape, not the original tag-history-row stub). Defaults to NullAlarmHistorianSink; production deployments wire SqliteStoreAndForwardSink + WonderwareHistorianClient via AddOtOpcUaRuntime overrides. Actor now exposes GetStatus returning HistorianSinkStatus for diagnostics. Named-pipe transport implementation lives unchanged in src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.Historian.Wonderware.Client/WonderwareHistorianClient.cs — the actor is intentionally just a fire-and-forget bridge.", "origin": "Self-review of Task 45 — stub buffers in-memory; named-pipe + SQLite store-and-forward not wired."}, {"id": "F12", "subject": "Follow-up: PeerOpcUaProbeActor real opc.tcp ping (replace Ok=true stub)", "status": "completed", "classification": "small", "estMinutes": 20, "parallelizableWith": [], "blockedBy": [], "commit": "b06e3ae", "deviation": "TCP-connect probe rather than full OPC UA Hello/Acknowledge handshake. Enough for the redundancy calc; deeper liveness signals can layer on later without changing the actor's contract.", "origin": "Self-review of Task 45 — RunProbe always returns Ok=true; replace with OPC UA Client connect."}, {"id": "F13", "subject": "Follow-up: Full OpcUaApplicationHost extraction (security/alarms/history/observability)", "status": "partial", "classification": "high-risk", "estMinutes": 120, "parallelizableWith": [], "blockedBy": [], "commit": "36c4751-partial", "deviationNotes": "F13a (cert auto-creation) shipped in 36c4751. Remaining: endpoint-security wiring (SecurityProfileResolver into ServerConfiguration.SecurityPolicies), LDAP user-token validator (the OPC UA UserNameToken path; HTTP-layer LDAP auth is separate and already in OtOpcUa.Security), scripted-alarm node manager creation, history backend wiring, observability hooks (OpenTelemetry metrics + traces). These are gated by F10's OpcUaPublishActor SDK integration — until F10 lands, nothing instantiates OpcUaApplicationHost so the missing wiring is dead weight.", "origin": "Self-review of Task 46 — facade only boots ApplicationInstance + StandardServer. Legacy 391-line file pulls Server.Security/Alarms/History/Observability. Pull those into thin OpcUaServer interfaces."}, - {"id": "F14", "subject": "Follow-up: Migrate side-effecting Phase7Composer (EquipmentNodeWalker, trace logs, node cache)", "status": "pending", "classification": "standard", "estMinutes": 60, "parallelizableWith": [], "blockedBy": [], "origin": "Self-review of Task 47 — pure version covers the projection. Walker + alarm sink registration + cache mutation stay in legacy until split into Phase7Applier."}, + {"id": "F14", "subject": "Follow-up: Migrate side-effecting Phase7Composer (EquipmentNodeWalker, trace logs, node cache)", "status": "partial", "classification": "standard", "estMinutes": 60, "parallelizableWith": [], "blockedBy": [], "origin": "Self-review of Task 47 — pure version covers the projection. Walker + alarm sink registration + cache mutation stay in legacy until split into Phase7Applier.", "shipped": "Phase7Plan + Phase7Planner.Compute (pure diff over EquipmentNodes/DriverInstancePlans/ScriptedAlarmPlans by stable id, with Added/Removed/Changed lists). Phase7Applier consumes plan + IOpcUaAddressSpaceSink: drives RebuildAddressSpace on Equipment/Alarm topology change, writes inactive AlarmState for removed nodes, catches + logs sink faults. Driver-only changes correctly skip the rebuild (DriverHostActor's spawn-plan in Runtime handles those). Walker integration with the real SDK NodeManager is the remaining piece — split as F14b (consumes the existing EquipmentNodeWalker once F10b lands an SDK builder)."}, {"id": "F15", "subject": "Follow-up: Migrate 47 legacy Admin Blazor components into AdminUI library", "status": "completed", "classification": "high-risk", "estMinutes": 180, "commit": "Phase A-D (read views) + F15.2 batches 1-4 (live-edit CRUD) + F15.3 (live alerts/script-log/CSV import/Monaco)", "deviationNotes": "All 4 phases of read-only views shipped: Phase A (shell/auth/fleet/hosts), B (cluster CRUD + Overview/Redundancy), C (Equipment/UNS/Namespaces/Drivers/Tags/ACLs), D (Audit/VirtualTags/ScriptedAlarms/Scripts/RoleGrants/Certificates/Reservations/AlarmsHistorian). Per Q1–Q5 of docs/v2/AdminUI-rebuild-plan.md: typed driver editors deferred, top-level VirtualTags/ScriptedAlarms kept (Q2 reversed for cross-cluster discoverability), routes-not-tabs adopted, fleet-wide LDAP→role map only, generic login errors. Live-edit forms (F15.2) and ScriptLog page (depends on F16 ScriptLogHub) are explicit follow-ups.", "parallelizableWith": [], "blockedBy": [], "origin": "Self-review of Task 48 — only MapAdminUI scaffold + 1 new page (Deployments). 47 pages stay in legacy Admin (accepted-broken) until Task 56."}, {"id": "F16", "subject": "Follow-up: Bridge FleetStatusBroadcaster → SignalR hubs (FleetStatusHub / AlertHub / ScriptLogHub)", "status": "completed", "classification": "standard", "estMinutes": 30, "parallelizableWith": [], "blockedBy": [], "commit": "f18c285", "deviation": "FleetStatusHub bridge landed. AlertHub + ScriptLogHub deferred — they need upstream message contracts that aren't defined yet (alerts emerge from F9 ScriptedAlarmActor, script logs from F8 VirtualTagActor).", "origin": "Self-review of Task 49 — hubs are passive Hub subclasses; the bridge from FleetStatusBroadcaster.broadcast → IHubContext is not wired."}, {"id": "F17", "subject": "Follow-up: FleetDiagnosticsClient real Akka ActorSelection round-trip (GetDiagnosticsRequest)", "status": "completed", "classification": "standard", "estMinutes": 30, "parallelizableWith": [], "blockedBy": [], "commit": "8f32b89", "origin": "Self-review of Task 51 — client returns an empty snapshot stub. Add GetDiagnosticsRequest contract + DriverHostActor handler + real Ask/Reply."}, diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer/Phase7Applier.cs b/src/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer/Phase7Applier.cs new file mode 100644 index 0000000..35ad7d2 --- /dev/null +++ b/src/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer/Phase7Applier.cs @@ -0,0 +1,109 @@ +using Microsoft.Extensions.Logging; +using ZB.MOM.WW.OtOpcUa.Commons.OpcUa; + +namespace ZB.MOM.WW.OtOpcUa.OpcUaServer; + +/// +/// Side-effecting orchestrator over . Drives an +/// to materialise the diff between two +/// snapshots: +/// +/// +/// RemovedEquipment / RemovedAlarms — write Bad-quality on every removed +/// node id then call RebuildAddressSpace at the end so the sink can +/// actually tear down the OPC UA folders + variables. +/// AddedEquipment / AddedAlarms — same Rebuild trigger (real SDK NodeManager +/// will repopulate from the persisted artifact). For now we record the work. +/// ChangedEquipment / ChangedAlarms — record what changed; the SDK adapter +/// that lands in F10b will decide between in-place property writes and +/// tear-down + rebuild. +/// +/// +/// This is the side-effecting layer Task 47 deferred to F14. It stays pure-of-SDK so +/// production binds a real SDK sink, dev/Mac binds , +/// and tests can capture every call. +/// +public sealed class Phase7Applier +{ + private readonly IOpcUaAddressSpaceSink _sink; + private readonly ILogger _logger; + + public Phase7Applier(IOpcUaAddressSpaceSink sink, ILogger logger) + { + ArgumentNullException.ThrowIfNull(sink); + ArgumentNullException.ThrowIfNull(logger); + _sink = sink; + _logger = logger; + } + + /// + /// Apply to the sink. Returns a summary of what was applied so + /// callers (OpcUaPublishActor) can correlate the work back to the originating deployment. + /// + public Phase7ApplyOutcome Apply(Phase7Plan plan) + { + ArgumentNullException.ThrowIfNull(plan); + + if (plan.IsEmpty) + { + _logger.LogDebug("Phase7Applier: plan is empty; skipping sink writes"); + return new Phase7ApplyOutcome(RemovedNodes: 0, AddedNodes: 0, ChangedNodes: 0, RebuildCalled: false); + } + + var ts = DateTime.UtcNow; + var removedCount = 0; + foreach (var eq in plan.RemovedEquipment) + { + SafeWriteAlarmState(eq.EquipmentId, active: false, acknowledged: false, ts); + removedCount++; + } + foreach (var alarm in plan.RemovedAlarms) + { + SafeWriteAlarmState(alarm.ScriptedAlarmId, active: false, acknowledged: false, ts); + removedCount++; + } + + var changedCount = + plan.ChangedEquipment.Count + plan.ChangedDrivers.Count + plan.ChangedAlarms.Count; + var addedCount = + plan.AddedEquipment.Count + plan.AddedDrivers.Count + plan.AddedAlarms.Count; + + // Any add/remove of Equipment or ScriptedAlarm requires a real address-space rebuild. + // Driver-instance changes don't touch the address-space topology directly — they go + // through DriverHostActor's spawn-plan in Runtime. + var needsRebuild = + plan.AddedEquipment.Count > 0 || plan.RemovedEquipment.Count > 0 || + plan.AddedAlarms.Count > 0 || plan.RemovedAlarms.Count > 0; + + if (needsRebuild) + { + try + { + _sink.RebuildAddressSpace(); + } + catch (Exception ex) + { + _logger.LogError(ex, "Phase7Applier: sink.RebuildAddressSpace threw"); + } + } + + _logger.LogInformation( + "Phase7Applier: applied plan (added={Added}, removed={Removed}, changed={Changed}, rebuild={Rebuild})", + addedCount, removedCount, changedCount, needsRebuild); + + return new Phase7ApplyOutcome(removedCount, addedCount, changedCount, needsRebuild); + } + + private void SafeWriteAlarmState(string nodeId, bool active, bool acknowledged, DateTime ts) + { + try { _sink.WriteAlarmState(nodeId, active, acknowledged, ts); } + catch (Exception ex) { _logger.LogWarning(ex, "Phase7Applier: WriteAlarmState threw for {Node}", nodeId); } + } +} + +/// Summary of one apply pass. Useful for tests + audit-log entries on the deploy path. +public sealed record Phase7ApplyOutcome( + int RemovedNodes, + int AddedNodes, + int ChangedNodes, + bool RebuildCalled); diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer/Phase7Plan.cs b/src/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer/Phase7Plan.cs new file mode 100644 index 0000000..284998c --- /dev/null +++ b/src/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer/Phase7Plan.cs @@ -0,0 +1,98 @@ +namespace ZB.MOM.WW.OtOpcUa.OpcUaServer; + +/// +/// Pure diff between two snapshots — the +/// previous currently-applied composition and the next from a freshly-applied +/// deployment. Three lists per entity class (Equipment / DriverInstance / ScriptedAlarm) +/// captured by stable identity: added items are new, removed items have to be torn down, +/// changed items have the same identity but at least one field differs. +/// +/// OpcUaPublishActor's RebuildAddressSpace consumes this against a real +/// binding so re-applies only mutate the +/// nodes that actually changed — full tear-down + rebuild is reserved for first-boot or +/// drastic schema flips. +/// +public sealed record Phase7Plan( + IReadOnlyList AddedEquipment, + IReadOnlyList RemovedEquipment, + IReadOnlyList ChangedEquipment, + IReadOnlyList AddedDrivers, + IReadOnlyList RemovedDrivers, + IReadOnlyList ChangedDrivers, + IReadOnlyList AddedAlarms, + IReadOnlyList RemovedAlarms, + IReadOnlyList ChangedAlarms) +{ + public bool IsEmpty => + AddedEquipment.Count == 0 && RemovedEquipment.Count == 0 && ChangedEquipment.Count == 0 && + AddedDrivers.Count == 0 && RemovedDrivers.Count == 0 && ChangedDrivers.Count == 0 && + AddedAlarms.Count == 0 && RemovedAlarms.Count == 0 && ChangedAlarms.Count == 0; + + public sealed record EquipmentDelta(EquipmentNode Previous, EquipmentNode Current); + public sealed record DriverDelta(DriverInstancePlan Previous, DriverInstancePlan Current); + public sealed record AlarmDelta(ScriptedAlarmPlan Previous, ScriptedAlarmPlan Current); +} + +public static class Phase7Planner +{ + /// + /// Diff two compositions, emitting Added/Removed/Changed sets per entity class. + /// Identity is the entity's stable id (EquipmentId, DriverInstanceId, ScriptedAlarmId). + /// Element equality on the projection records doubles as the "did this change" check, + /// so any field difference moves an item from "stable" to ChangedX. + /// + public static Phase7Plan Compute(Phase7CompositionResult previous, Phase7CompositionResult next) + { + ArgumentNullException.ThrowIfNull(previous); + ArgumentNullException.ThrowIfNull(next); + + var (addedEq, removedEq, changedEq) = DiffById( + previous.EquipmentNodes, next.EquipmentNodes, + n => n.EquipmentId, + (a, b) => new Phase7Plan.EquipmentDelta(a, b)); + + var (addedDrv, removedDrv, changedDrv) = DiffById( + previous.DriverInstancePlans, next.DriverInstancePlans, + d => d.DriverInstanceId, + (a, b) => new Phase7Plan.DriverDelta(a, b)); + + var (addedAlarm, removedAlarm, changedAlarm) = DiffById( + previous.ScriptedAlarmPlans, next.ScriptedAlarmPlans, + a => a.ScriptedAlarmId, + (a, b) => new Phase7Plan.AlarmDelta(a, b)); + + return new Phase7Plan( + addedEq, removedEq, changedEq, + addedDrv, removedDrv, changedDrv, + addedAlarm, removedAlarm, changedAlarm); + } + + private static (IReadOnlyList Added, IReadOnlyList Removed, IReadOnlyList Changed) + DiffById( + IReadOnlyList previous, + IReadOnlyList next, + Func identity, + Func deltaFactory) where T : class + { + var prevById = previous.ToDictionary(identity, StringComparer.Ordinal); + var nextById = next.ToDictionary(identity, StringComparer.Ordinal); + + var added = new List(); + var removed = new List(); + var changed = new List(); + + foreach (var (id, p) in prevById) + { + if (!nextById.TryGetValue(id, out var n)) { removed.Add(p); continue; } + if (!EqualityComparer.Default.Equals(p, n)) changed.Add(deltaFactory(p, n)); + } + foreach (var (id, n) in nextById) + { + if (!prevById.ContainsKey(id)) added.Add(n); + } + + added.Sort((a, b) => string.CompareOrdinal(identity(a), identity(b))); + removed.Sort((a, b) => string.CompareOrdinal(identity(a), identity(b))); + return (added, removed, changed); + } +} diff --git a/tests/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests/Phase7ApplierTests.cs b/tests/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests/Phase7ApplierTests.cs new file mode 100644 index 0000000..9a85fd2 --- /dev/null +++ b/tests/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests/Phase7ApplierTests.cs @@ -0,0 +1,150 @@ +using System.Collections.Concurrent; +using Microsoft.Extensions.Logging.Abstractions; +using Shouldly; +using Xunit; +using ZB.MOM.WW.OtOpcUa.Commons.OpcUa; + +namespace ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests; + +public sealed class Phase7ApplierTests +{ + [Fact] + public void Empty_plan_does_not_call_sink_and_does_not_trigger_rebuild() + { + var sink = new RecordingSink(); + var applier = new Phase7Applier(sink, NullLogger.Instance); + + var outcome = applier.Apply(EmptyPlan); + + outcome.RebuildCalled.ShouldBeFalse(); + outcome.AddedNodes.ShouldBe(0); + outcome.RemovedNodes.ShouldBe(0); + outcome.ChangedNodes.ShouldBe(0); + sink.RebuildCalls.ShouldBe(0); + sink.AlarmWrites.ShouldBeEmpty(); + } + + [Fact] + public void Removed_equipment_writes_inactive_alarm_state_per_id_and_triggers_rebuild() + { + var sink = new RecordingSink(); + var applier = new Phase7Applier(sink, NullLogger.Instance); + + var plan = WithEquipmentRemoval("eq-1", "eq-2"); + var outcome = applier.Apply(plan); + + outcome.RemovedNodes.ShouldBe(2); + outcome.RebuildCalled.ShouldBeTrue(); + sink.AlarmWrites.Select(a => a.NodeId).OrderBy(x => x).ShouldBe(new[] { "eq-1", "eq-2" }); + sink.AlarmWrites.All(a => a.Active == false && a.Acknowledged == false).ShouldBeTrue(); + sink.RebuildCalls.ShouldBe(1); + } + + [Fact] + public void Added_equipment_triggers_rebuild_without_alarm_writes() + { + var sink = new RecordingSink(); + var applier = new Phase7Applier(sink, NullLogger.Instance); + + var plan = new Phase7Plan( + AddedEquipment: new[] { new EquipmentNode("new", "New", "line-1") }, + RemovedEquipment: Array.Empty(), + ChangedEquipment: Array.Empty(), + AddedDrivers: Array.Empty(), + RemovedDrivers: Array.Empty(), + ChangedDrivers: Array.Empty(), + AddedAlarms: Array.Empty(), + RemovedAlarms: Array.Empty(), + ChangedAlarms: Array.Empty()); + + var outcome = applier.Apply(plan); + + outcome.RebuildCalled.ShouldBeTrue(); + outcome.AddedNodes.ShouldBe(1); + sink.AlarmWrites.ShouldBeEmpty(); + sink.RebuildCalls.ShouldBe(1); + } + + [Fact] + public void Driver_only_changes_do_not_trigger_address_space_rebuild() + { + var sink = new RecordingSink(); + var applier = new Phase7Applier(sink, NullLogger.Instance); + + var plan = new Phase7Plan( + AddedEquipment: Array.Empty(), + RemovedEquipment: Array.Empty(), + ChangedEquipment: Array.Empty(), + AddedDrivers: new[] { new DriverInstancePlan("d-new", "Modbus", "{}") }, + RemovedDrivers: Array.Empty(), + ChangedDrivers: new[] + { + new Phase7Plan.DriverDelta( + new DriverInstancePlan("d-1", "Modbus", "{\"v\":1}"), + new DriverInstancePlan("d-1", "Modbus", "{\"v\":2}")), + }, + AddedAlarms: Array.Empty(), + RemovedAlarms: Array.Empty(), + ChangedAlarms: Array.Empty()); + + var outcome = applier.Apply(plan); + + outcome.RebuildCalled.ShouldBeFalse(); + sink.RebuildCalls.ShouldBe(0); + } + + [Fact] + public void Sink_exception_in_WriteAlarmState_does_not_propagate_and_rebuild_still_fires() + { + var sink = new ThrowingSink(throwOnAlarmWrite: true); + var applier = new Phase7Applier(sink, NullLogger.Instance); + + var plan = WithEquipmentRemoval("eq-1"); + + var outcome = applier.Apply(plan); // should not throw + outcome.RemovedNodes.ShouldBe(1); + outcome.RebuildCalled.ShouldBeTrue(); + } + + private static Phase7Plan EmptyPlan => new( + Array.Empty(), Array.Empty(), Array.Empty(), + Array.Empty(), Array.Empty(), Array.Empty(), + Array.Empty(), Array.Empty(), Array.Empty()); + + private static Phase7Plan WithEquipmentRemoval(params string[] ids) => new( + AddedEquipment: Array.Empty(), + RemovedEquipment: ids.Select(id => new EquipmentNode(id, id, "line-1")).ToArray(), + ChangedEquipment: Array.Empty(), + AddedDrivers: Array.Empty(), + RemovedDrivers: Array.Empty(), + ChangedDrivers: Array.Empty(), + AddedAlarms: Array.Empty(), + RemovedAlarms: Array.Empty(), + ChangedAlarms: Array.Empty()); + + private sealed class RecordingSink : IOpcUaAddressSpaceSink + { + public ConcurrentQueue<(string NodeId, bool Active, bool Acknowledged)> AlarmQueue { get; } = new(); + public int RebuildCalls; + + public List<(string NodeId, bool Active, bool Acknowledged)> AlarmWrites => AlarmQueue.ToList(); + + public void WriteValue(string nodeId, object? value, OpcUaQuality quality, DateTime sourceTimestampUtc) { } + public void WriteAlarmState(string alarmNodeId, bool active, bool acknowledged, DateTime sourceTimestampUtc) + => AlarmQueue.Enqueue((alarmNodeId, active, acknowledged)); + public void RebuildAddressSpace() => Interlocked.Increment(ref RebuildCalls); + } + + private sealed class ThrowingSink : IOpcUaAddressSpaceSink + { + private readonly bool _throwOnAlarmWrite; + public ThrowingSink(bool throwOnAlarmWrite) { _throwOnAlarmWrite = throwOnAlarmWrite; } + + public void WriteValue(string nodeId, object? value, OpcUaQuality quality, DateTime sourceTimestampUtc) { } + public void WriteAlarmState(string alarmNodeId, bool active, bool acknowledged, DateTime sourceTimestampUtc) + { + if (_throwOnAlarmWrite) throw new InvalidOperationException("simulated sink fault"); + } + public void RebuildAddressSpace() { } + } +} diff --git a/tests/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests/Phase7PlannerTests.cs b/tests/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests/Phase7PlannerTests.cs new file mode 100644 index 0000000..ef56b8a --- /dev/null +++ b/tests/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests/Phase7PlannerTests.cs @@ -0,0 +1,150 @@ +using Shouldly; +using Xunit; + +namespace ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests; + +public sealed class Phase7PlannerTests +{ + [Fact] + public void Empty_inputs_produce_empty_plan() + { + var prev = new Phase7CompositionResult(Array.Empty(), Array.Empty(), Array.Empty()); + var next = prev; + + var plan = Phase7Planner.Compute(prev, next); + + plan.IsEmpty.ShouldBeTrue(); + } + + [Fact] + public void Identical_compositions_produce_empty_plan() + { + var eq = new EquipmentNode("eq-1", "Eq 1", "line-1"); + var prev = new Phase7CompositionResult(new[] { eq }, Array.Empty(), Array.Empty()); + var next = new Phase7CompositionResult(new[] { eq }, Array.Empty(), Array.Empty()); + + var plan = Phase7Planner.Compute(prev, next); + + plan.IsEmpty.ShouldBeTrue(); + } + + [Fact] + public void New_equipment_goes_to_AddedEquipment() + { + var prev = new Phase7CompositionResult(Array.Empty(), Array.Empty(), Array.Empty()); + var next = new Phase7CompositionResult( + new[] { new EquipmentNode("eq-1", "A", "line-1") }, + Array.Empty(), + Array.Empty()); + + var plan = Phase7Planner.Compute(prev, next); + + plan.AddedEquipment.Single().EquipmentId.ShouldBe("eq-1"); + plan.RemovedEquipment.ShouldBeEmpty(); + plan.ChangedEquipment.ShouldBeEmpty(); + } + + [Fact] + public void Disappeared_equipment_goes_to_RemovedEquipment() + { + var prev = new Phase7CompositionResult( + new[] { new EquipmentNode("eq-1", "A", "line-1") }, + Array.Empty(), + Array.Empty()); + var next = new Phase7CompositionResult(Array.Empty(), Array.Empty(), Array.Empty()); + + var plan = Phase7Planner.Compute(prev, next); + + plan.RemovedEquipment.Single().EquipmentId.ShouldBe("eq-1"); + plan.AddedEquipment.ShouldBeEmpty(); + } + + [Fact] + public void Same_id_with_different_display_name_routes_to_ChangedEquipment() + { + var prev = new Phase7CompositionResult( + new[] { new EquipmentNode("eq-1", "Old", "line-1") }, + Array.Empty(), + Array.Empty()); + var next = new Phase7CompositionResult( + new[] { new EquipmentNode("eq-1", "New", "line-1") }, + Array.Empty(), + Array.Empty()); + + var plan = Phase7Planner.Compute(prev, next); + + plan.ChangedEquipment.Single().Previous.DisplayName.ShouldBe("Old"); + plan.ChangedEquipment.Single().Current.DisplayName.ShouldBe("New"); + plan.AddedEquipment.ShouldBeEmpty(); + plan.RemovedEquipment.ShouldBeEmpty(); + } + + [Fact] + public void Driver_config_change_routes_to_ChangedDrivers() + { + var prev = new Phase7CompositionResult( + Array.Empty(), + new[] { new DriverInstancePlan("drv-1", "Modbus", "{\"host\":\"old\"}") }, + Array.Empty()); + var next = new Phase7CompositionResult( + Array.Empty(), + new[] { new DriverInstancePlan("drv-1", "Modbus", "{\"host\":\"new\"}") }, + Array.Empty()); + + var plan = Phase7Planner.Compute(prev, next); + + plan.ChangedDrivers.Single().Current.ConfigJson.ShouldContain("new"); + } + + [Fact] + public void Alarm_message_template_change_routes_to_ChangedAlarms() + { + var prev = new Phase7CompositionResult( + Array.Empty(), + Array.Empty(), + new[] { new ScriptedAlarmPlan("a-1", "eq-1", "script-1", "old") }); + var next = new Phase7CompositionResult( + Array.Empty(), + Array.Empty(), + new[] { new ScriptedAlarmPlan("a-1", "eq-1", "script-1", "new") }); + + var plan = Phase7Planner.Compute(prev, next); + + plan.ChangedAlarms.Single().Current.MessageTemplate.ShouldBe("new"); + } + + [Fact] + public void Added_and_removed_lists_are_sorted_by_id_for_deterministic_ordering() + { + var prev = new Phase7CompositionResult( + new[] { new EquipmentNode("z", "Z", "line-1"), new EquipmentNode("a", "A", "line-1") }, + Array.Empty(), + Array.Empty()); + var next = new Phase7CompositionResult(Array.Empty(), Array.Empty(), Array.Empty()); + + var plan = Phase7Planner.Compute(prev, next); + + plan.RemovedEquipment.Select(e => e.EquipmentId).ShouldBe(new[] { "a", "z" }); + } + + [Fact] + public void Mixed_changes_across_all_three_classes_are_captured_in_one_pass() + { + var prev = new Phase7CompositionResult( + new[] { new EquipmentNode("eq-keep", "Keep", "line-1"), new EquipmentNode("eq-drop", "Drop", "line-1") }, + new[] { new DriverInstancePlan("drv-keep", "Modbus", "{}"), new DriverInstancePlan("drv-change", "Modbus", "{\"v\":1}") }, + new[] { new ScriptedAlarmPlan("a-keep", "eq-keep", "s1", "t1") }); + var next = new Phase7CompositionResult( + new[] { new EquipmentNode("eq-keep", "Keep", "line-1"), new EquipmentNode("eq-new", "New", "line-1") }, + new[] { new DriverInstancePlan("drv-keep", "Modbus", "{}"), new DriverInstancePlan("drv-change", "Modbus", "{\"v\":2}") }, + new[] { new ScriptedAlarmPlan("a-keep", "eq-keep", "s1", "t1"), new ScriptedAlarmPlan("a-new", "eq-new", "s2", "t2") }); + + var plan = Phase7Planner.Compute(prev, next); + + plan.AddedEquipment.Single().EquipmentId.ShouldBe("eq-new"); + plan.RemovedEquipment.Single().EquipmentId.ShouldBe("eq-drop"); + plan.ChangedEquipment.ShouldBeEmpty(); + plan.ChangedDrivers.Single().Current.DriverInstanceId.ShouldBe("drv-change"); + plan.AddedAlarms.Single().ScriptedAlarmId.ShouldBe("a-new"); + } +}