c9640f5ced
v2-ci / unit-tests (push) Has been cancelled
A picker-form native alarm (attributeRef tag.Attr) only learns the provider-qualified reference Galaxy!<Area>.tag.Attr from the alarm feed. After a host restart the condition can be restored from LocalDb before the feed's first snapshot reached the new driver, and an ack in that window dialled the bare tag.Attr, which the gateway's AcknowledgeAlarm refuses. The feed now exposes InitialSnapshotCompleted (set on snapshot_complete, after every snapshot entry has been raised). AcknowledgeAsync resolves the reference through ResolveAlarmAckReferenceAsync: when a picker-form tag has learned nothing yet and the feed is running, it waits for that snapshot (2 s, and the caller's token) and dials the reference the snapshot names, so the area always comes from the feed and a re-areaed object acks under its current area. No reference is guessed: if the snapshot does not name the alarm, or does not arrive in time, the authored reference is dialled as before and refused visibly. Chosen over the alternatives in the issue: a GR-browse area lookup can be stale against the runtime area and is not loaded for authored tags, and a gateway-side tag.Attr resolution needs a cross-repo deploy and would resolve from the same monitor cache the snapshot already carries. Tests: 5 driver cases + 1 feed case (fail with the call site / sentinel reverted), and a skip-gated live gate GalaxyPickerAckBeforeSnapshotLiveTests, run against windev's TEST Galaxy (TestMachine_015.TestAlarm003): an ack issued before the snapshot dials Galaxy!TestArea.TestMachine_015.TestAlarm003 and is confirmed; with the call site reverted it fails with the gateway's InvalidRequest refusal. Claude-Session: https://claude.ai/code/session_01GT67ACmpMR7b9LGRPLijMi
306 lines
13 KiB
C#
306 lines
13 KiB
C#
using System.Runtime.CompilerServices;
|
||
using Google.Protobuf.WellKnownTypes;
|
||
using ZB.MOM.WW.MxGateway.Contracts.Proto;
|
||
using Shouldly;
|
||
using Xunit;
|
||
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
|
||
using ZB.MOM.WW.OtOpcUa.Driver.Galaxy.Runtime;
|
||
|
||
// Core.Abstractions now also defines an AlarmTransitionKind (the AlarmEventArgs surface
|
||
// kind). This file drives the gateway proto, so pin the bare token to the proto enum to
|
||
// preserve the existing references unchanged.
|
||
using AlarmTransitionKind = ZB.MOM.WW.MxGateway.Contracts.Proto.AlarmTransitionKind;
|
||
|
||
namespace ZB.MOM.WW.OtOpcUa.Driver.Galaxy.Tests.Runtime;
|
||
|
||
/// <summary>
|
||
/// Pins <see cref="GatewayGalaxyAlarmFeed"/> — the session-less consumer of the
|
||
/// gateway's <c>StreamAlarms</c> feed. Synthetic <see cref="AlarmFeedMessage"/>s go
|
||
/// in through the stream-factory seam; the feed fires <c>OnAlarmTransition</c> with
|
||
/// decoded payloads and mapped severity buckets, drops malformed messages, and
|
||
/// re-opens the stream after a transport fault.
|
||
/// </summary>
|
||
public sealed class GatewayGalaxyAlarmFeedTests
|
||
{
|
||
/// <summary>Verifies that the feed decodes active alarm snapshots and live transitions.</summary>
|
||
[Fact]
|
||
public async Task Decodes_active_alarm_snapshot_then_live_transition()
|
||
{
|
||
var raise = new DateTime(2026, 5, 1, 12, 0, 0, DateTimeKind.Utc);
|
||
var messages = new[]
|
||
{
|
||
SnapshotMessage("Tank01.Level.HiHi", AlarmConditionState.Active, severity: 750,
|
||
lastTransition: raise),
|
||
SnapshotMessage("Tank02.Level.HiHi", AlarmConditionState.ActiveAcked, severity: 500,
|
||
lastTransition: raise, operatorUser: "alice", operatorComment: "investigating"),
|
||
new AlarmFeedMessage { SnapshotComplete = true },
|
||
TransitionMessage("Tank01.Level.HiHi", AlarmTransitionKind.Clear, severity: 750,
|
||
transitionTime: raise.AddMinutes(5), originalRaise: raise),
|
||
};
|
||
|
||
var observed = new List<GalaxyAlarmTransition>();
|
||
var got3 = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
|
||
|
||
await using var feed = new GatewayGalaxyAlarmFeed(
|
||
(_, ct) => OpenStream(messages, ct), clientName: "FeedTest");
|
||
feed.OnAlarmTransition += (_, t) =>
|
||
{
|
||
lock (observed)
|
||
{
|
||
observed.Add(t);
|
||
if (observed.Count == 3) got3.TrySetResult(true);
|
||
}
|
||
};
|
||
feed.Start();
|
||
|
||
await TestWait.ForAsync(got3.Task, "snapshot + transition should dispatch",
|
||
() => { lock (observed) return $"dispatched={observed.Count}/3"; });
|
||
|
||
observed.Count.ShouldBe(3);
|
||
|
||
// Active (unacked) snapshot entry → Retrigger (#647 review: forces the upstream's unack on the host).
|
||
observed[0].AlarmFullReference.ShouldBe("Tank01.Level.HiHi");
|
||
observed[0].TransitionKind.ShouldBe(GalaxyAlarmTransitionKind.Retrigger);
|
||
observed[0].SeverityBucket.ShouldBe(AlarmSeverity.Medium); // priority 750: AVEVA Medium 501–750 (#887)
|
||
observed[0].OpcUaSeverity.ShouldBe(500);
|
||
observed[0].RawMxAccessSeverity.ShouldBe(750);
|
||
|
||
// Acknowledged snapshot entry → ActiveAcknowledged (#656 — an Acknowledge kept the host's prior Active, so a
|
||
// cold host projected it INACTIVE), operator fields preserved.
|
||
observed[1].TransitionKind.ShouldBe(GalaxyAlarmTransitionKind.ActiveAcknowledged);
|
||
observed[1].OperatorUser.ShouldBe("alice");
|
||
observed[1].OperatorComment.ShouldBe("investigating");
|
||
|
||
// #656: snapshot entries re-state upstream state; the live transition is unflagged.
|
||
observed[0].IsRestatement.ShouldBeTrue();
|
||
observed[1].IsRestatement.ShouldBeTrue();
|
||
|
||
// Live transition after snapshot_complete.
|
||
observed[2].TransitionKind.ShouldBe(GalaxyAlarmTransitionKind.Clear);
|
||
observed[2].OriginalRaiseTimestampUtc.ShouldBe(raise);
|
||
observed[2].IsRestatement.ShouldBeFalse();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gitea #656 — an Inactive snapshot entry is a re-stated Clear; a LIVE Retrigger (a genuine MXAccess
|
||
/// re-occurrence) is never flagged, so the host keeps its history row.
|
||
/// </summary>
|
||
[Fact]
|
||
public async Task Inactive_snapshot_entry_is_a_restated_clear_and_a_live_retrigger_is_unflagged()
|
||
{
|
||
var at = new DateTime(2026, 5, 1, 12, 0, 0, DateTimeKind.Utc);
|
||
var messages = new[]
|
||
{
|
||
SnapshotMessage("Tank01.Level.HiHi", AlarmConditionState.Inactive, severity: 750, lastTransition: at),
|
||
new AlarmFeedMessage { SnapshotComplete = true },
|
||
TransitionMessage("Tank01.Level.HiHi", AlarmTransitionKind.Retrigger, severity: 750,
|
||
transitionTime: at.AddMinutes(1)),
|
||
};
|
||
|
||
var observed = new List<GalaxyAlarmTransition>();
|
||
var got2 = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
|
||
await using var feed = new GatewayGalaxyAlarmFeed((_, ct) => OpenStream(messages, ct), clientName: "FeedTest656");
|
||
feed.OnAlarmTransition += (_, t) =>
|
||
{
|
||
lock (observed)
|
||
{
|
||
observed.Add(t);
|
||
if (observed.Count == 2) got2.TrySetResult(true);
|
||
}
|
||
};
|
||
feed.Start();
|
||
|
||
await TestWait.ForAsync(got2.Task, "restated snapshot Clear + live Retrigger should dispatch",
|
||
() => { lock (observed) return $"dispatched={observed.Count}/2"; });
|
||
|
||
observed[0].TransitionKind.ShouldBe(GalaxyAlarmTransitionKind.Clear);
|
||
observed[0].IsRestatement.ShouldBeTrue();
|
||
observed[1].TransitionKind.ShouldBe(GalaxyAlarmTransitionKind.Retrigger);
|
||
observed[1].IsRestatement.ShouldBeFalse();
|
||
}
|
||
|
||
/// <summary>Verifies that the feed drops transitions with unspecified kind and empty messages.</summary>
|
||
[Fact]
|
||
public async Task Drops_transition_with_unspecified_kind_and_empty_message()
|
||
{
|
||
var messages = new[]
|
||
{
|
||
TransitionMessage("Tank01.Level.HiHi", AlarmTransitionKind.Unspecified, severity: 100,
|
||
transitionTime: DateTime.UtcNow),
|
||
new AlarmFeedMessage(), // empty oneof — version skew
|
||
TransitionMessage("Tank01.Level.HiHi", AlarmTransitionKind.Raise, severity: 600,
|
||
transitionTime: DateTime.UtcNow),
|
||
};
|
||
|
||
var observed = new List<GalaxyAlarmTransition>();
|
||
var gotOne = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
|
||
|
||
await using var feed = new GatewayGalaxyAlarmFeed(
|
||
(_, ct) => OpenStream(messages, ct), clientName: "FeedTest");
|
||
feed.OnAlarmTransition += (_, t) =>
|
||
{
|
||
lock (observed)
|
||
{
|
||
observed.Add(t);
|
||
gotOne.TrySetResult(true);
|
||
}
|
||
};
|
||
feed.Start();
|
||
|
||
await TestWait.ForAsync(gotOne.Task, "the well-formed Raise should dispatch",
|
||
() => { lock (observed) return $"dispatched={observed.Count}"; });
|
||
|
||
// Only the well-formed Raise survives; the Unspecified + empty messages drop.
|
||
observed.ShouldHaveSingleItem();
|
||
observed[0].TransitionKind.ShouldBe(GalaxyAlarmTransitionKind.Raise);
|
||
observed[0].SeverityBucket.ShouldBe(AlarmSeverity.Medium); // priority 600: AVEVA Medium 501–750 (#887)
|
||
}
|
||
|
||
/// <summary>Verifies that the feed reopens the stream after a transport fault.</summary>
|
||
[Fact]
|
||
public async Task Reopens_stream_after_a_transport_fault()
|
||
{
|
||
var calls = 0;
|
||
var liveTransition = new[]
|
||
{
|
||
TransitionMessage("Tank01.Level.HiHi", AlarmTransitionKind.Raise, severity: 750,
|
||
transitionTime: DateTime.UtcNow),
|
||
};
|
||
|
||
var observed = new List<GalaxyAlarmTransition>();
|
||
var gotOne = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
|
||
|
||
await using var feed = new GatewayGalaxyAlarmFeed(
|
||
(_, ct) =>
|
||
{
|
||
// First open faults; the feed must reconnect and succeed on the retry.
|
||
if (Interlocked.Increment(ref calls) == 1)
|
||
{
|
||
throw new InvalidOperationException("synthetic stream fault");
|
||
}
|
||
return OpenStream(liveTransition, ct);
|
||
},
|
||
clientName: "ReconnectTest",
|
||
reconnectDelay: TimeSpan.FromMilliseconds(20));
|
||
feed.OnAlarmTransition += (_, t) =>
|
||
{
|
||
observed.Add(t);
|
||
gotOne.TrySetResult(true);
|
||
};
|
||
feed.Start();
|
||
|
||
await TestWait.ForAsync(gotOne.Task, "the feed should reopen the stream and deliver after a fault",
|
||
() => $"streamOpens={Volatile.Read(ref calls)}");
|
||
|
||
calls.ShouldBeGreaterThanOrEqualTo(2);
|
||
observed.ShouldHaveSingleItem();
|
||
observed[0].TransitionKind.ShouldBe(GalaxyAlarmTransitionKind.Raise);
|
||
}
|
||
|
||
/// <summary>
|
||
/// lmxopcua#904: <see cref="GatewayGalaxyAlarmFeed.InitialSnapshotCompleted"/> completes on the
|
||
/// <c>snapshot_complete</c> sentinel, after every snapshot entry before it was raised — the driver's ack path
|
||
/// relies on that order to find the provider-qualified reference the snapshot named. It stays incomplete
|
||
/// until the sentinel arrives.
|
||
/// </summary>
|
||
[Fact]
|
||
public async Task InitialSnapshotCompleted_completes_on_the_sentinel_after_the_snapshot_entries()
|
||
{
|
||
var release = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
|
||
var observedAtCompletion = -1;
|
||
var observed = 0;
|
||
|
||
await using var feed = new GatewayGalaxyAlarmFeed(
|
||
(_, ct) => GatedStream(release.Task, ct), clientName: "SnapshotSignalTest");
|
||
feed.OnAlarmTransition += (_, _) => Interlocked.Increment(ref observed);
|
||
var completed = feed.InitialSnapshotCompleted.ContinueWith(
|
||
_ => observedAtCompletion = Volatile.Read(ref observed), TaskScheduler.Default);
|
||
feed.Start();
|
||
|
||
await TestWait.UntilAsync(() => Volatile.Read(ref observed) == 2, "both snapshot entries should dispatch");
|
||
feed.InitialSnapshotCompleted.IsCompleted.ShouldBeFalse(); // entries in, sentinel not yet
|
||
|
||
release.SetResult();
|
||
await TestWait.ForAsync(completed, "the snapshot_complete sentinel should complete the signal");
|
||
observedAtCompletion.ShouldBe(2);
|
||
|
||
static async IAsyncEnumerable<AlarmFeedMessage> GatedStream(
|
||
Task gate, [EnumeratorCancellation] CancellationToken ct = default)
|
||
{
|
||
var now = DateTime.UtcNow;
|
||
yield return SnapshotMessage("Galaxy!Area1.Tank01.Level.HiHi", AlarmConditionState.Active, 750, now);
|
||
yield return SnapshotMessage("Galaxy!Area1.Tank02.Level.HiHi", AlarmConditionState.Active, 750, now);
|
||
await gate.WaitAsync(ct);
|
||
yield return new AlarmFeedMessage { SnapshotComplete = true };
|
||
await Task.Delay(Timeout.Infinite, ct);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Yields each message in order, then holds the stream open until the feed is
|
||
/// disposed — mirrors a live server-streaming RPC that does not complete on its
|
||
/// own.
|
||
/// </summary>
|
||
private static async IAsyncEnumerable<AlarmFeedMessage> OpenStream(
|
||
IEnumerable<AlarmFeedMessage> messages,
|
||
[EnumeratorCancellation] CancellationToken ct = default)
|
||
{
|
||
foreach (var message in messages)
|
||
{
|
||
ct.ThrowIfCancellationRequested();
|
||
yield return message;
|
||
await Task.Yield();
|
||
}
|
||
await Task.Delay(Timeout.Infinite, ct);
|
||
}
|
||
|
||
private static AlarmFeedMessage SnapshotMessage(
|
||
string fullReference,
|
||
AlarmConditionState state,
|
||
int severity,
|
||
DateTime lastTransition,
|
||
string operatorUser = "",
|
||
string operatorComment = "")
|
||
=> new()
|
||
{
|
||
ActiveAlarm = new ActiveAlarmSnapshot
|
||
{
|
||
AlarmFullReference = fullReference,
|
||
SourceObjectReference = fullReference.Split('.')[0],
|
||
AlarmTypeName = "AnalogLimitAlarm.HiHi",
|
||
Severity = severity,
|
||
CurrentState = state,
|
||
Category = "Process",
|
||
Description = "Tank high-high level",
|
||
LastTransitionTimestamp = Timestamp.FromDateTime(lastTransition),
|
||
OperatorUser = operatorUser,
|
||
OperatorComment = operatorComment,
|
||
},
|
||
};
|
||
|
||
private static AlarmFeedMessage TransitionMessage(
|
||
string fullReference,
|
||
AlarmTransitionKind kind,
|
||
int severity,
|
||
DateTime transitionTime,
|
||
DateTime? originalRaise = null)
|
||
{
|
||
var body = new OnAlarmTransitionEvent
|
||
{
|
||
AlarmFullReference = fullReference,
|
||
SourceObjectReference = fullReference.Split('.')[0],
|
||
AlarmTypeName = "AnalogLimitAlarm.HiHi",
|
||
TransitionKind = kind,
|
||
Severity = severity,
|
||
TransitionTimestamp = Timestamp.FromDateTime(transitionTime),
|
||
Category = "Process",
|
||
Description = "Tank high-high level",
|
||
};
|
||
if (originalRaise is { } orts)
|
||
{
|
||
body.OriginalRaiseTimestamp = Timestamp.FromDateTime(orts);
|
||
}
|
||
return new AlarmFeedMessage { Transition = body };
|
||
}
|
||
}
|