using ZB.MOM.WW.MxGateway.Contracts.Proto.Galaxy; using Shouldly; using Xunit; using ZB.MOM.WW.OtOpcUa.Core.Abstractions; using ZB.MOM.WW.OtOpcUa.Driver.Galaxy.Browse; using ZB.MOM.WW.OtOpcUa.Driver.Galaxy.Config; using ZB.MOM.WW.OtOpcUa.Driver.Galaxy.Runtime; namespace ZB.MOM.WW.OtOpcUa.Driver.Galaxy.Tests.Runtime; /// /// v3 RawPath identity: the server addresses Galaxy nodes by RawPath, while MXAccess dials the /// Galaxy attributeRef (tag_name.AttributeName). These tests pin the driver-side boundary /// translation built from — RawPath → attributeRef on /// read / write / subscribe / ack (forward dial), and attributeRef → RawPath on the value fan-out /// and alarm ConditionId (reverse), so the alarm resolves back to the same RawPath the value path /// surfaces. Each entry's TagConfig carries the dialled address under the camelCase key /// attributeRef. /// public sealed class GalaxyDriverRawPathKeyingTests { private const string RawPath = "area/line/tank1/level"; private const string AttributeRef = "Tank1.Level"; private static GalaxyDriverOptions OptsWithRawTags(bool writeIdempotent = false) => new( new GalaxyGatewayOptions("https://mxgw.test:5001", "key"), new GalaxyMxAccessOptions("OtOpcUa-A"), new GalaxyRepositoryOptions(), new GalaxyReconnectOptions()) { RawTags = [new RawTagEntry(RawPath, $"{{\"attributeRef\":\"{AttributeRef}\"}}", writeIdempotent)], }; // ===== Read: RawPath in → attributeRef dialled ===== /// ReadAsync translates the incoming RawPath to the Galaxy attributeRef before dialling. [Fact] public async Task ReadAsync_TranslatesRawPath_ToAttributeRef() { var reader = new RecordingReader(); using var driver = new GalaxyDriver("g", OptsWithRawTags(), hierarchySource: null, dataReader: reader); await driver.ReadAsync([RawPath], CancellationToken.None); reader.LastRequest.ShouldBe([AttributeRef]); } /// An unmapped RawPath dials as-is (identity) — the gateway then rejects an unknown address. [Fact] public async Task ReadAsync_UnmappedRawPath_DialsIdentity() { var reader = new RecordingReader(); using var driver = new GalaxyDriver("g", OptsWithRawTags(), hierarchySource: null, dataReader: reader); await driver.ReadAsync(["not/authored"], CancellationToken.None); reader.LastRequest.ShouldBe(["not/authored"]); } // ===== Write: RawPath in → attributeRef dialled, security resolved by RawPath ===== /// /// WriteAsync dials the attributeRef, and the security the writer resolves is the one captured at /// discovery under the tag's RawPath (the discoverer emitted FullName = RawPath) — proving the /// reverse mapping the resolver applies (attributeRef → RawPath) lands on the right classification. /// [Fact] public async Task WriteAsync_DialsAttributeRef_AndResolvesSecurityByRawPath() { var writer = new RecordingWriter(); // Hierarchy: Tank1.Level classified Operate (sec 1). Discovery keys security by the RawPath. var src = new FakeHierarchySource([Obj("Tank1", Attr("Level", sec: 1))]); using var driver = new GalaxyDriver( "g", OptsWithRawTags(), hierarchySource: src, dataReader: null, dataWriter: writer); await driver.DiscoverAsync(new CapturingBuilder(), CancellationToken.None); await driver.WriteAsync([new WriteRequest(RawPath, 42.0)], CancellationToken.None); writer.Calls.ShouldHaveSingleItem(); writer.Calls[0].FullRef.ShouldBe(AttributeRef); // dialled address writer.Calls[0].Resolved.ShouldBe(SecurityClassification.Operate); // resolved by RawPath } // ===== Subscribe + value fan-out: RawPath in → attributeRef dialled → RawPath out ===== /// /// SubscribeAsync dials the attributeRef; the resulting value fan-out surfaces on the public /// OnDataChange keyed by the tag's RawPath — the same identity the alarm ConditionId uses. /// [Fact] public async Task Subscribe_DialsAttributeRef_AndValueFanOutSurfacesRawPath() { var subscriber = new GalaxyDriverSubscribeTests.FakeSubscriber(); using var driver = new GalaxyDriver( "g", OptsWithRawTags(), hierarchySource: null, dataReader: null, dataWriter: null, subscriber: subscriber); var captured = new List(); driver.OnDataChange += (_, args) => { lock (captured) captured.Add(args); }; await driver.SubscribeAsync([RawPath], TimeSpan.FromSeconds(1), CancellationToken.None); // The gateway saw the dialled attributeRef, not the RawPath. subscriber.Map.ShouldContainKey(AttributeRef); subscriber.Map.ShouldNotContainKey(RawPath); await subscriber.EmitOnDataChangeAsync(subscriber.Map[AttributeRef], 42.0); await GalaxyDriverSubscribeTests.WaitForCapturedAsync(captured, 1, "the value change must be dispatched"); captured.ShouldHaveSingleItem(); captured[0].FullReference.ShouldBe(RawPath); // surfaced under the RawPath identity ((double)captured[0].Snapshot.Value!).ShouldBe(42.0); } // ===== Alarm: ConditionId is the RawPath; ack round-trips back to the attributeRef ===== /// /// The alarm feed reports the Galaxy attributeRef; the driver surfaces the transition with /// ConditionId = the tag's RawPath (matching the value path), and a subsequent ack keyed by that /// RawPath dials back down to the attributeRef the gateway acknowledges. /// [Fact] public async Task Alarm_ConditionIdIsRawPath_AndAckRoundTripsToAttributeRef() { var feed = new FakeAlarmFeed(); var ack = new RecordingAcknowledger(); using var driver = new GalaxyDriver( "g", OptsWithRawTags(), hierarchySource: null, alarmAcknowledger: ack, alarmFeed: feed, ackCredentialResolver: FixedAckCredentialResolver.Fallback()); var handle = await driver.SubscribeAlarmsAsync(["Tank1"], CancellationToken.None); var observed = new List(); driver.OnAlarmEvent += (_, args) => observed.Add(args); // Feed reports the dialled attributeRef. feed.Emit(NewTransition(AttributeRef, "Tank1")); observed.ShouldHaveSingleItem(); observed[0].ConditionId.ShouldBe(RawPath); // reverse-mapped to the RawPath identity observed[0].SubscriptionHandle.ShouldBe(handle); // Ack keyed by the RawPath the driver reported → dials back to the attributeRef. await driver.AcknowledgeAsync( [new AlarmAcknowledgeRequest("Tank1", RawPath, "ack it")], CancellationToken.None); ack.Calls.ShouldHaveSingleItem(); ack.Calls[0].AlarmRef.ShouldBe(AttributeRef); } /// /// lmxopcua#895 (G6 live gate, windev 2026-11-12): the real gateway feed names an alarm /// Galaxy!Area.tag.Attr with SourceObjectReference = tag.Attr, while the AdminUI Galaxy /// picker authors attributeRef = tag.Attr. The transition must resolve to the tag's RawPath (before /// the fix it surfaced under the full reference, which matched no condition, so the alarm never went /// active), and the ack must dial the provider-qualified reference the gateway accepts. /// [Fact] public async Task Alarm_PickerAuthoredAttributeRef_ResolvesViaSourceObjectReference_AndAcksFullReference() { const string fullRef = "Galaxy!Area1.Tank1.Level"; var feed = new FakeAlarmFeed(); var ack = new RecordingAcknowledger(); using var driver = new GalaxyDriver( "g", OptsWithRawTags(), hierarchySource: null, alarmAcknowledger: ack, alarmFeed: feed, ackCredentialResolver: FixedAckCredentialResolver.Fallback()); await driver.SubscribeAlarmsAsync(["Tank1"], CancellationToken.None); var observed = new List(); driver.OnAlarmEvent += (_, args) => observed.Add(args); feed.Emit(NewTransition(fullRef, AttributeRef)); observed.ShouldHaveSingleItem(); observed[0].ConditionId.ShouldBe(RawPath); await driver.AcknowledgeAsync( [new AlarmAcknowledgeRequest("Tank1", RawPath, "ack it")], CancellationToken.None); ack.Calls.ShouldHaveSingleItem(); ack.Calls[0].AlarmRef.ShouldBe(fullRef); } /// lmxopcua#895: with no usable SourceObjectReference the Provider!Area. prefix is stripped /// to find the picker-authored tag. [Fact] public void ResolveAlarmRawPath_StripsProviderAndArea_WhenSourceReferenceDoesNotMatch() { using var driver = new GalaxyDriver("g", OptsWithRawTags(), hierarchySource: null); driver.ResolveAlarmRawPath("Galaxy!Area1.Tank1.Level", sourceObjectReference: "").ShouldBe(RawPath); driver.ToAlarmAckReference(RawPath).ShouldBe("Galaxy!Area1.Tank1.Level"); } /// lmxopcua#895: a tag authored with the full provider-qualified reference still resolves directly, /// and an alarm no authored tag matches keeps the identity fallback (nothing learned). [Fact] public void ResolveAlarmRawPath_DirectMatchAndUnmatchedIdentity_AreUnchanged() { var opts = OptsWithRawTags() with { RawTags = [new RawTagEntry(RawPath, "{\"attributeRef\":\"Galaxy!Area1.Tank1.Level\"}", false)], }; using var driver = new GalaxyDriver("g", opts, hierarchySource: null); driver.ResolveAlarmRawPath("Galaxy!Area1.Tank1.Level", "Tank1.Level").ShouldBe(RawPath); driver.ToAlarmAckReference(RawPath).ShouldBe("Galaxy!Area1.Tank1.Level"); driver.ResolveAlarmRawPath("Galaxy!Area1.Other.Attr", "Other.Attr").ShouldBe("Galaxy!Area1.Other.Attr"); driver.ToAlarmAckReference("Galaxy!Area1.Other.Attr").ShouldBe("Galaxy!Area1.Other.Attr"); } // ===== lmxopcua#895 review: area changes, subtag-provider shape, collisions, ack confirmation ===== private const string OtherRawPath = "area/line/tank1/level-hand"; private static GalaxyDriverOptions Opts(params (string RawPath, string AttributeRef)[] tags) => OptsWithRawTags() with { RawTags = [.. tags.Select(t => new RawTagEntry(t.RawPath, $"{{\"attributeRef\":\"{t.AttributeRef}\"}}", false))], }; /// Galaxy moves a picker-authored tag's object to another area: the transition still resolves (via the /// unchanged source reference) and the ack follows the latest area the feed named. [Fact] public void PickerForm_AfterReArea_ResolvesAndAckFollowsTheNewArea() { using var driver = new GalaxyDriver("g", OptsWithRawTags(), hierarchySource: null); driver.ResolveAlarmRawPath("Galaxy!Area1.Tank1.Level", AttributeRef).ShouldBe(RawPath); driver.ResolveAlarmRawPath("Galaxy!Area2.Tank1.Level", AttributeRef).ShouldBe(RawPath); driver.ToAlarmAckReference(RawPath).ShouldBe("Galaxy!Area2.Tank1.Level"); } /// A tag hand-authored as Galaxy!Area1.tag.Attr keeps resolving after Galaxy re-areas the object /// (before the review fix the feed's Galaxy!Area2… matched nothing and every transition was dropped), and /// its ack dials the reference the feed now uses. [Fact] public void HandAuthoredProviderForm_AfterReArea_ResolvesAndAcksTheNewArea() { using var driver = new GalaxyDriver("g", Opts((RawPath, "Galaxy!Area1.Tank1.Level")), hierarchySource: null); driver.ToAlarmAckReference(RawPath).ShouldBe("Galaxy!Area1.Tank1.Level"); driver.ResolveAlarmRawPath("Galaxy!Area2.Tank1.Level", "Tank1.Level").ShouldBe(RawPath); driver.ToAlarmAckReference(RawPath).ShouldBe("Galaxy!Area2.Tank1.Level"); } /// The gateway's subtag (degraded) provider sends only the object as the source reference. The /// area-stripped full reference resolves it, and a reference composed with an empty area /// (Galaxy!tag.Attr) resolves through what follows the !. [Theory] [InlineData("Galaxy!Area1.Tank1.Level", "Tank1")] [InlineData("Galaxy!Tank1.Level", "Tank1")] [InlineData("Galaxy!Tank1.Level", "")] [InlineData("Galaxy!Area1.Tank1.Level", null)] public void SubtagProviderShapes_Resolve(string fullRef, string? source) { using var driver = new GalaxyDriver("g", OptsWithRawTags(), hierarchySource: null); driver.ResolveAlarmRawPath(fullRef, source).ShouldBe(RawPath); driver.ToAlarmAckReference(RawPath).ShouldBe(fullRef); } /// H6-style contained/dotted references: the object's tag_name (not its contained hierarchy) is what /// the feed and the picker share, and an alarm attribute nested under another attribute keeps its dots. [Theory] [InlineData("TableAlarms_008.RuntimeAlert", "Galaxy!CVDAisle_1.TableAlarms_008.RuntimeAlert", "TableAlarms_008.RuntimeAlert")] [InlineData("TableAlarms_008.RuntimeAlert", "Galaxy!CVDAisle_1.TableAlarms_008.RuntimeAlert", "TableAlarms_008")] [InlineData("Tank1.Level.HiHi", "Galaxy!Area1.Tank1.Level.HiHi", "Tank1")] public void DottedAndContainedReferences_Resolve(string attributeRef, string fullRef, string source) { using var driver = new GalaxyDriver("g", Opts((RawPath, attributeRef)), hierarchySource: null); driver.ResolveAlarmRawPath(fullRef, source).ShouldBe(RawPath); driver.ToAlarmAckReference(RawPath).ShouldBe(fullRef); } /// Feed references that match nothing — or are malformed — keep the identity fallback, never throw, and /// teach nothing (no authored RawPath's ack reference changes). [Theory] [InlineData("Galaxy!Area1.Other.Attr", "Other.Attr")] [InlineData("Galaxy!Area1.Other.Attr", "Other")] [InlineData("Galaxy!", "")] [InlineData("Galaxy!Area1.", null)] [InlineData("NoBang.Tank1", "")] [InlineData("", "")] public void UnmatchedOrMalformed_KeepsIdentity_AndLearnsNothing(string fullRef, string? source) { using var driver = new GalaxyDriver("g", OptsWithRawTags(), hierarchySource: null); driver.ResolveAlarmRawPath(fullRef, source).ShouldBe(fullRef); driver.ToAlarmAckReference(RawPath).ShouldBe(AttributeRef); } /// The same Galaxy alarm authored twice — picker form and hand-authored provider form. Deterministic: the /// exact provider-form match wins while the area matches; any other area surfaces under the picker tag. [Fact] public void PickerAndHandAuthoredOfTheSameAlarm_ResolveDeterministically() { using var driver = new GalaxyDriver( "g", Opts((RawPath, AttributeRef), (OtherRawPath, "Galaxy!Area1.Tank1.Level")), hierarchySource: null); driver.ResolveAlarmRawPath("Galaxy!Area1.Tank1.Level", AttributeRef).ShouldBe(OtherRawPath); driver.ResolveAlarmRawPath("Galaxy!Area2.Tank1.Level", AttributeRef).ShouldBe(RawPath); driver.ToAlarmAckReference(RawPath).ShouldBe("Galaxy!Area2.Tank1.Level"); driver.ToAlarmAckReference(OtherRawPath).ShouldBe("Galaxy!Area1.Tank1.Level"); } /// A transition that arrives while no alarm subscription is registered is not fanned out, but it still /// teaches the ack reference (the feed starts before SubscribeAlarmsAsync registers its handle). [Fact] public async Task TransitionWithoutSubscription_StillTeachesTheAckReference() { var feed = new FakeAlarmFeed(); var ack = new RecordingAcknowledger(); using var driver = new GalaxyDriver( "g", OptsWithRawTags(), hierarchySource: null, alarmAcknowledger: ack, alarmFeed: feed, ackCredentialResolver: FixedAckCredentialResolver.Fallback()); var handle = await driver.SubscribeAlarmsAsync(["Tank1"], CancellationToken.None); await driver.UnsubscribeAlarmsAsync(handle, CancellationToken.None); var observed = new List(); driver.OnAlarmEvent += (_, args) => observed.Add(args); feed.Emit(NewTransition("Galaxy!Area1.Tank1.Level", AttributeRef)); await driver.AcknowledgeAsync( [new AlarmAcknowledgeRequest("Tank1", RawPath, "ack it")], CancellationToken.None); observed.ShouldBeEmpty(); ack.Calls.ShouldHaveSingleItem().AlarmRef.ShouldBe("Galaxy!Area1.Tank1.Level"); } /// lmxopcua#869 with the picker form: an ack the gateway only SENT is confirmed by Galaxy's acknowledged /// transition, which names the provider-qualified reference — the one the ack now dials. [Fact] public async Task PickerForm_UnconfirmedAck_IsConfirmedByTheFeedsAcknowledgedTransition() { const string fullRef = "Galaxy!Area1.Tank1.Level"; var feed = new FakeAlarmFeed(); var opts = OptsWithRawTags() with { AlarmAck = new GalaxyAlarmAckOptions { ConfirmTimeoutMs = 120_000 } }; using var driver = new GalaxyDriver( "g", opts, hierarchySource: null, alarmAcknowledger: new UnconfirmedAcknowledger(), alarmFeed: feed, ackCredentialResolver: FixedAckCredentialResolver.Fallback()); await driver.SubscribeAlarmsAsync(["Tank1"], CancellationToken.None); feed.Emit(NewTransition(fullRef, AttributeRef)); AlarmAcknowledgeRequest[] request = [new AlarmAcknowledgeRequest("Tank1", RawPath, "ack it")]; await driver.AcknowledgeAsync(request, CancellationToken.None); var confirm = driver.ConfirmAcknowledgedAsync(request, CancellationToken.None); confirm.IsCompleted.ShouldBeFalse(); feed.Emit(NewTransition(fullRef, AttributeRef) with { TransitionKind = GalaxyAlarmTransitionKind.Acknowledge }); await TestWait.ForAsync(confirm, "the feed's acknowledged transition must confirm the picker-form ack"); } // ===== lmxopcua#904: a picker-form ack before the feed has named the alarm ===== private static GalaxyDriver NewAckDriver(IGalaxyAlarmFeed feed, IGalaxyAlarmAcknowledger ack, GalaxyDriverOptions? opts = null) => new("g", opts ?? OptsWithRawTags(), hierarchySource: null, alarmAcknowledger: ack, alarmFeed: feed, ackCredentialResolver: FixedAckCredentialResolver.Fallback()); /// /// lmxopcua#904: after a host restart the condition is restored from LocalDb before the feed's first snapshot /// reaches the new driver instance. An ack in that window must wait for the snapshot and dial the /// provider-qualified reference it names — in the object's CURRENT area — not the bare tag.Attr the /// gateway refuses. /// [Fact] public async Task PickerForm_AckBeforeFeedSnapshot_WaitsForTheSnapshot_AndDialsItsFullReference() { const string fullRef = "Galaxy!Area2.Tank1.Level"; var feed = new SnapshotAlarmFeed(); var ack = new RecordingAcknowledger(); using var driver = NewAckDriver(feed, ack); driver.AckSnapshotWait = TimeSpan.FromMinutes(2); await driver.SubscribeAlarmsAsync(["Tank1"], CancellationToken.None); var pending = driver.AcknowledgeAsync( [new AlarmAcknowledgeRequest("Tank1", RawPath, "ack it")], CancellationToken.None); ack.Calls.ShouldBeEmpty(); // nothing dialled while the feed has not named the alarm feed.Emit(NewTransition(fullRef, AttributeRef) with { TransitionKind = GalaxyAlarmTransitionKind.Retrigger, IsRestatement = true, }); feed.CompleteSnapshot(); await TestWait.ForAsync(pending, "the ack must proceed once the feed snapshot arrives"); ack.Calls.ShouldHaveSingleItem().AlarmRef.ShouldBe(fullRef); } /// lmxopcua#904: a snapshot that does not name the alarm (not active in Galaxy) releases the ack at once; /// nothing is guessed, the authored reference is dialled as before and the gateway decides. [Fact] public async Task PickerForm_SnapshotWithoutTheAlarm_DialsTheAuthoredReference() { var feed = new SnapshotAlarmFeed(); var ack = new RecordingAcknowledger(); using var driver = NewAckDriver(feed, ack); driver.AckSnapshotWait = TimeSpan.FromMinutes(2); await driver.SubscribeAlarmsAsync(["Tank1"], CancellationToken.None); var pending = driver.AcknowledgeAsync( [new AlarmAcknowledgeRequest("Tank1", RawPath, "ack it")], CancellationToken.None); feed.Emit(NewTransition("Galaxy!Area1.Other.Attr", "Other.Attr")); feed.CompleteSnapshot(); await TestWait.ForAsync(pending, "a completed snapshot must release the ack"); ack.Calls.ShouldHaveSingleItem().AlarmRef.ShouldBe(AttributeRef); } /// lmxopcua#904: the wait is bounded — a feed whose snapshot never comes (gateway unreachable) lets the ack /// through after with the authored reference. [Fact] public async Task PickerForm_SnapshotNeverArrives_AckProceedsAfterTheBoundedWait() { var feed = new SnapshotAlarmFeed(); var ack = new RecordingAcknowledger(); using var driver = NewAckDriver(feed, ack); driver.AckSnapshotWait = TimeSpan.FromMilliseconds(100); await driver.SubscribeAlarmsAsync(["Tank1"], CancellationToken.None); await driver.AcknowledgeAsync( [new AlarmAcknowledgeRequest("Tank1", RawPath, "ack it")], CancellationToken.None); ack.Calls.ShouldHaveSingleItem().AlarmRef.ShouldBe(AttributeRef); } /// lmxopcua#904: the caller's token cuts the wait, and nothing is dialled. [Fact] public async Task PickerForm_AckCancelledWhileWaitingForTheSnapshot_DialsNothing() { var feed = new SnapshotAlarmFeed(); var ack = new RecordingAcknowledger(); using var driver = NewAckDriver(feed, ack); driver.AckSnapshotWait = TimeSpan.FromMinutes(2); await driver.SubscribeAlarmsAsync(["Tank1"], CancellationToken.None); using var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(100)); await Should.ThrowAsync(() => driver.AcknowledgeAsync( [new AlarmAcknowledgeRequest("Tank1", RawPath, "ack it")], cts.Token)); ack.Calls.ShouldBeEmpty(); } /// lmxopcua#904: no wait where the feed has nothing to add — a provider-form tag already carries the /// reference, and a feed that is not running sends no snapshot. [Fact] public async Task NoSnapshotWait_ForProviderFormTags_OrWhenTheFeedIsNotRunning() { var feed = new SnapshotAlarmFeed(); var ack = new RecordingAcknowledger(); var providerOpts = OptsWithRawTags() with { RawTags = [new RawTagEntry(RawPath, "{\"attributeRef\":\"Galaxy!Area1.Tank1.Level\"}", false)], }; using (var driver = NewAckDriver(feed, ack, providerOpts)) { driver.AckSnapshotWait = TimeSpan.FromMinutes(2); await driver.SubscribeAlarmsAsync(["Tank1"], CancellationToken.None); var pending = driver.AcknowledgeAsync( [new AlarmAcknowledgeRequest("Tank1", RawPath, "ack it")], CancellationToken.None); await TestWait.ForAsync(pending, "a provider-form ack must not wait for the snapshot"); } using (var driver = NewAckDriver(new SnapshotAlarmFeed(), ack)) { driver.AckSnapshotWait = TimeSpan.FromMinutes(2); var pending = driver.AcknowledgeAsync( // feed never started: no SubscribeAlarmsAsync [new AlarmAcknowledgeRequest("Tank1", RawPath, "ack it")], CancellationToken.None); await TestWait.ForAsync(pending, "an ack must not wait on a feed that is not running"); } ack.Calls.Select(c => c.AlarmRef).ShouldBe(["Galaxy!Area1.Tank1.Level", AttributeRef]); } /// A feed with a snapshot phase the test completes by hand, like . private sealed class SnapshotAlarmFeed : IGalaxyAlarmFeed { private readonly TaskCompletionSource _snapshot = new(TaskCreationOptions.RunContinuationsAsynchronously); public event EventHandler? OnAlarmTransition; public Task InitialSnapshotCompleted => _snapshot.Task; public void Start() { } public void Emit(GalaxyAlarmTransition transition) => OnAlarmTransition?.Invoke(this, transition); public void CompleteSnapshot() => _snapshot.TrySetResult(); public ValueTask DisposeAsync() => ValueTask.CompletedTask; } private sealed class UnconfirmedAcknowledger : IGalaxyAlarmAcknowledger { public Task AcknowledgeAsync( string alarmFullReference, string comment, GalaxyAckCredential credential, CancellationToken cancellationToken) => Task.FromResult(GalaxyAckOutcome.Unconfirmed("sent; OnWriteComplete not observed")); } // ===== helpers / fakes ===== private static GalaxyAttribute Attr(string name, int sec) => new() { AttributeName = name, MxDataType = 2 /*Float32*/, SecurityClassification = sec }; private static GalaxyObject Obj(string tag, params GalaxyAttribute[] attrs) { var o = new GalaxyObject { TagName = tag, ContainedName = tag }; o.Attributes.AddRange(attrs); return o; } private static GalaxyAlarmTransition NewTransition(string alarmFullReference, string source) => new( AlarmFullReference: alarmFullReference, SourceObjectReference: source, AlarmTypeName: "AnalogLimitAlarm.HiHi", TransitionKind: GalaxyAlarmTransitionKind.Raise, SeverityBucket: AlarmSeverity.High, OpcUaSeverity: 800, RawMxAccessSeverity: 750, OriginalRaiseTimestampUtc: null, TransitionTimestampUtc: DateTime.UtcNow, OperatorUser: string.Empty, OperatorComment: string.Empty, Category: "Process", Description: "high level"); private sealed class FakeHierarchySource(IReadOnlyList objects) : IGalaxyHierarchySource { public Task> GetHierarchyAsync(CancellationToken cancellationToken) => Task.FromResult(objects); } /// Minimal builder — discovery only needs the SecurityCapturingBuilder wrapper to run. private sealed class CapturingBuilder : IAddressSpaceBuilder { public IAddressSpaceBuilder Folder(string browseName, string displayName) => this; public IVariableHandle Variable(string browseName, string displayName, DriverAttributeInfo attributeInfo) => new Handle(attributeInfo.FullName); public void AddProperty(string browseName, DriverDataType dataType, object? value) { } private sealed class Handle(string fullRef) : IVariableHandle { public string FullReference { get; } = fullRef; public IAlarmConditionSink MarkAsAlarmCondition(AlarmConditionInfo info) => new Sink(); private sealed class Sink : IAlarmConditionSink { public void OnTransition(AlarmEventArgs args) { } } } } private sealed class RecordingReader : IGalaxyDataReader { public IReadOnlyList? LastRequest { get; private set; } public Task> ReadAsync( IReadOnlyList fullReferences, CancellationToken cancellationToken) { LastRequest = fullReferences; return Task.FromResult>( fullReferences.Select(_ => new DataValueSnapshot(0.0, StatusCodeMap.Good, null, DateTime.UtcNow)).ToArray()); } } private sealed class RecordingWriter : IGalaxyDataWriter { public List<(string FullRef, object? Value, SecurityClassification Resolved)> Calls { get; } = []; public Task> WriteAsync( IReadOnlyList writes, Func securityResolver, CancellationToken cancellationToken) { var results = new WriteResult[writes.Count]; for (var i = 0; i < writes.Count; i++) { Calls.Add((writes[i].FullReference, writes[i].Value, securityResolver(writes[i].FullReference))); results[i] = new WriteResult(StatusCodeMap.Good); } return Task.FromResult>(results); } public void InvalidateHandleCaches() { } } private sealed class FakeAlarmFeed : IGalaxyAlarmFeed { public event EventHandler? OnAlarmTransition; public void Start() { } public void Emit(GalaxyAlarmTransition transition) => OnAlarmTransition?.Invoke(this, transition); public ValueTask DisposeAsync() => ValueTask.CompletedTask; } private sealed class RecordingAcknowledger : IGalaxyAlarmAcknowledger { public List<(string AlarmRef, string Comment, string Operator)> Calls { get; } = []; public Task AcknowledgeAsync(string alarmFullReference, string comment, GalaxyAckCredential credential, CancellationToken cancellationToken) { Calls.Add((alarmFullReference, comment, credential.User)); return Task.FromResult(GalaxyAckOutcome.Applied); } } /// Two RawPaths sharing one attributeRef: first wins the reverse map, the loser is recorded in the skipped ledger (06/S-13). [Fact] public void DuplicateAttributeRef_RecordsLosingRawPath_InSkippedLedger() { var opts = OptsWithRawTags() with { RawTags = [ new RawTagEntry(RawPath, $"{{\"attributeRef\":\"{AttributeRef}\"}}", false), new RawTagEntry("area/line/tank1/level-copy", $"{{\"attributeRef\":\"{AttributeRef}\"}}", false), ], }; using var driver = new GalaxyDriver("g", opts, hierarchySource: null); var report = driver.GetSkippedTags(); report.ShouldNotBeNull(); report.AuthoredCount.ShouldBe(2); report.SkippedCount.ShouldBe(1); report.Sample[0].RawPath.ShouldBe("area/line/tank1/level-copy"); report.Sample[0].Reason.ShouldContain(RawPath); } }