using Opc.Ua; using Opc.Ua.Server; using Shouldly; using Xunit; namespace ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests; /// /// Gitea #870: must be observably identical to the SDK's /// . Every test drives the SDK queue and the ring with the same operations and /// compares every result — directly at the queue, and through the SDK's own (which owns /// DiscardOldest, the overflow-event positions and the discarded/overflow counters) built over each factory. /// public sealed class RingEventMonitoredItemQueueParityTests { private static readonly ITelemetryContext Telemetry = DefaultTelemetry.Create(_ => { }); private sealed class Target : IFilterTarget { public bool IsTypeOf(IFilterContext context, NodeId typeDefinitionId) => false; public Variant GetAttributeValue(IFilterContext context, NodeId typeDefinitionId, ArrayOf relativePath, uint attributeId, NumericRange indexRange) => Variant.Null; } private static readonly Target[] Targets = Enumerable.Range(0, 6).Select(_ => new Target()).ToArray(); private static EventFieldList NewEvent(Random random) => new() { Handle = Targets[random.Next(Targets.Length)] }; /// Runs on both, asserting the same outcome (value or exception type + status). private static T Both(Func action, IEventMonitoredItemQueue sdk, IEventMonitoredItemQueue ring, string step) { Exception? sdkError = null, ringError = null; T sdkResult = default!, ringResult = default!; try { sdkResult = action(sdk); } catch (Exception e) { sdkError = e; } try { ringResult = action(ring); } catch (Exception e) { ringError = e; } (ringError?.GetType()).ShouldBe(sdkError?.GetType(), step); if (sdkError is ServiceResultException s) ((ServiceResultException)ringError!).StatusCode.ShouldBe(s.StatusCode, step); if (sdkError is null) ringResult.ShouldBe(sdkResult, step); ring.ItemsInQueue.ShouldBe(sdk.ItemsInQueue, step); ring.QueueSize.ShouldBe(sdk.QueueSize, step); return sdkResult; } [Fact] public void Initial_state_matches() { using var sdk = new EventMonitoredItemQueue(false, 7, Telemetry); using var ring = new RingEventMonitoredItemQueue(7); ring.MonitoredItemId.ShouldBe(sdk.MonitoredItemId); ring.IsDurable.ShouldBe(sdk.IsDurable); ring.QueueSize.ShouldBe(sdk.QueueSize); ring.ItemsInQueue.ShouldBe(sdk.ItemsInQueue); ring.Dequeue(out var value).ShouldBeFalse(); value.ShouldBeNull(); } [Fact] public void Enqueue_at_queue_size_zero_throws_the_same_BadInternalError() { var sdk = new EventMonitoredItemQueue(false, 1, Telemetry); var ring = new RingEventMonitoredItemQueue(1); Both(q => { q.Enqueue(new EventFieldList()); return 0; }, sdk, ring, "enqueue at 0"); Should.Throw(() => ring.Enqueue(new EventFieldList())).StatusCode .ShouldBe(StatusCodes.BadInternalError); } [Theory] [InlineData(true)] [InlineData(false)] public void Shrink_keeps_newest_or_oldest_and_dequeue_order_is_fifo(bool discardOldest) { var sdk = new EventMonitoredItemQueue(false, 1, Telemetry); var ring = new RingEventMonitoredItemQueue(1); var events = Enumerable.Range(0, 10).Select(_ => new EventFieldList()).ToArray(); sdk.SetQueueSize(10, true); ring.SetQueueSize(10, true); // Wrap the ring first so the shrink crosses the buffer end. for (var i = 0; i < 6; i++) { sdk.Enqueue(new EventFieldList()); ring.Enqueue(new EventFieldList()); } for (var i = 0; i < 6; i++) { sdk.Dequeue(out _); ring.Dequeue(out _); } foreach (var e in events) { sdk.Enqueue(e); ring.Enqueue(e); } sdk.SetQueueSize(4, discardOldest); ring.SetQueueSize(4, discardOldest); var expected = discardOldest ? events[6..] : events[..4]; foreach (var e in expected) { sdk.Dequeue(out var a).ShouldBeTrue(); ring.Dequeue(out var b).ShouldBeTrue(); a.ShouldBeSameAs(e); b.ShouldBeSameAs(e); } ring.Dequeue(out _).ShouldBeFalse(); sdk.Dequeue(out _).ShouldBeFalse(); } [Fact] public void Enqueue_at_a_full_queue_drops_the_oldest() { var ring = new RingEventMonitoredItemQueue(1); var sdk = new EventMonitoredItemQueue(false, 1, Telemetry); ring.SetQueueSize(3, false); sdk.SetQueueSize(3, false); var events = Enumerable.Range(0, 5).Select(_ => new EventFieldList()).ToArray(); foreach (var e in events) { ring.Enqueue(e); sdk.Enqueue(e); } foreach (var e in events[2..]) { ring.Dequeue(out var b).ShouldBeTrue(); sdk.Dequeue(out var a).ShouldBeTrue(); b.ShouldBeSameAs(e); a.ShouldBeSameAs(e); } } [Fact] public void Duplicate_check_covers_exactly_the_newest_1000_entries() { var sdk = new EventMonitoredItemQueue(false, 1, Telemetry); var ring = new RingEventMonitoredItemQueue(1); sdk.SetQueueSize(3000, true); ring.SetQueueSize(3000, true); var old = new Target(); var edge = new Target(); void Add(EventFieldList e) { sdk.Enqueue(e); ring.Enqueue(e); } Add(new EventFieldList { Handle = old }); Add(new EventFieldList { Handle = edge }); for (var i = 0; i < 999; i++) Add(new EventFieldList { Handle = Targets[0] }); Add(null!); // a null entry is skipped, as the SDK skips it // 1002 entries: `old` is the 1002nd newest, `edge` the 1001st — both outside the 1000-entry window. Both(q => q.IsEventContainedInQueue(old), sdk, ring, "old").ShouldBeFalse(); Both(q => q.IsEventContainedInQueue(edge), sdk, ring, "edge").ShouldBeFalse(); sdk.Dequeue(out _); ring.Dequeue(out _); sdk.Dequeue(out _); ring.Dequeue(out _); Add(new EventFieldList { Handle = edge }); Both(q => q.IsEventContainedInQueue(edge), sdk, ring, "newest").ShouldBeTrue(); Both(q => q.IsEventContainedInQueue(Targets[0]), sdk, ring, "middle").ShouldBeTrue(); Both(q => q.IsEventContainedInQueue(Targets[1]), sdk, ring, "absent").ShouldBeFalse(); } /// Upper boundary of the window: the entry exactly 1000th from newest is still found; 1001st is not. [Fact] public void Duplicate_check_includes_the_1000th_newest_entry() { var sdk = new EventMonitoredItemQueue(false, 1, Telemetry); var ring = new RingEventMonitoredItemQueue(1); sdk.SetQueueSize(3000, true); ring.SetQueueSize(3000, true); var outside = new Target(); var boundary = new Target(); void Add(EventFieldList e) { sdk.Enqueue(e); ring.Enqueue(e); } Add(new EventFieldList { Handle = outside }); Add(new EventFieldList { Handle = boundary }); for (var i = 0; i < 999; i++) Add(new EventFieldList { Handle = Targets[0] }); // 1001 entries: `boundary` is the 1000th newest (inside), `outside` the 1001st. Both(q => q.IsEventContainedInQueue(boundary), sdk, ring, "boundary").ShouldBeTrue(); Both(q => q.IsEventContainedInQueue(outside), sdk, ring, "outside").ShouldBeFalse(); } /// Random interleavings of every queue operation, at small sizes (wrap-around, grow, shrink, size 0). [Theory] [MemberData(nameof(Seeds))] public void Random_operation_sequences_match_the_sdk_queue(int seed) { var random = new Random(seed); var sdk = new EventMonitoredItemQueue(false, 3, Telemetry); var ring = new RingEventMonitoredItemQueue(3); for (var step = 0; step < 2000; step++) { var label = $"seed {seed} step {step}"; switch (random.Next(10)) { case < 5: var e = random.Next(50) == 0 ? null! : NewEvent(random); Both(q => { q.Enqueue(e); return 0; }, sdk, ring, label); break; case < 8: var (sdkHad, sdkValue) = (sdk.Dequeue(out var a), a); var (ringHad, ringValue) = (ring.Dequeue(out var b), b); ringHad.ShouldBe(sdkHad, label); ringValue.ShouldBeSameAs(sdkValue, label); break; case 8: var size = (uint)(random.Next(8) == 0 ? 0 : random.Next(1, 40)); var discardOldest = random.Next(2) == 0; Both(q => { q.SetQueueSize(size, discardOldest); return 0; }, sdk, ring, label); break; default: var t = Targets[random.Next(Targets.Length)]; Both(q => q.IsEventContainedInQueue(t), sdk, ring, label); break; } } // Drain: the same remaining contents in the same order. while (sdk.Dequeue(out var a)) { ring.Dequeue(out var b).ShouldBeTrue(); b.ShouldBeSameAs(a); } ring.Dequeue(out _).ShouldBeFalse(); } public static TheoryData Seeds() => new(Enumerable.Range(1, 40)); /// /// The SDK's over the SDK factory vs over : /// QueueEvent (incl. the DiscardOldest=false refusal), SetQueueOverflowIfFull, SetQueueSize with DiscardOldest /// flips, Publish with small batches (dequeue mid-stream) — the published events, the overflow-event-due flags, /// the Overflow property and the discarded/overflow callbacks must all agree. /// [Theory] [MemberData(nameof(Seeds))] public void The_sdk_event_queue_handler_behaves_identically_over_either_queue(int seed) { var random = new Random(seed); var counts = new int[4]; // sdk discarded, sdk overflow, ring discarded, ring overflow using var sdkFactory = new MonitoredItemQueueFactory(Telemetry); using var ringFactory = new RingEventQueueFactory(new MonitoredItemQueueFactory(Telemetry)); using var sdk = new EventQueueHandler(false, sdkFactory, 9, Telemetry, () => counts[0]++, () => counts[1]++); using var ring = new EventQueueHandler(false, ringFactory, 9, Telemetry, () => counts[2]++, () => counts[3]++); var context = new OperationContext(new RequestHeader(), null, RequestType.Publish, RequestLifetime.None); var initialOldest = random.Next(2) == 0; sdk.SetQueueSize(10, initialOldest); ring.SetQueueSize(10, initialOldest); for (var step = 0; step < 1500; step++) { var label = $"seed {seed} step {step}"; switch (random.Next(12)) { case < 6: var e = NewEvent(random); Exception? a = null, b = null; try { sdk.QueueEvent(e); } catch (Exception x) { a = x; } try { ring.QueueEvent(e); } catch (Exception x) { b = x; } (b?.GetType()).ShouldBe(a?.GetType(), label); break; case 6: ring.SetQueueOverflowIfFull().ShouldBe(sdk.SetQueueOverflowIfFull(), label); break; case 7: var size = (uint)random.Next(1, 25); var discardOldest = random.Next(2) == 0; sdk.SetQueueSize(size, discardOldest); ring.SetQueueSize(size, discardOldest); break; case < 10: var max = (uint)random.Next(1, 6); var sdkOut = new Queue(); var ringOut = new Queue(); var sdkN = sdk.Publish(context, sdkOut, max); var ringN = ring.Publish(context, ringOut, max); ringN.ShouldBe(sdkN, label); ringOut.Count.ShouldBe(sdkOut.Count, label); while (sdkOut.Count > 0) ringOut.Dequeue().ShouldBeSameAs(sdkOut.Dequeue(), label); break; default: var t = Targets[random.Next(Targets.Length)]; ring.IsEventContainedInQueue(t).ShouldBe(sdk.IsEventContainedInQueue(t), label); break; } ring.ItemsInQueue.ShouldBe(sdk.ItemsInQueue, label); ring.Overflow.ShouldBe(sdk.Overflow, label); counts[2].ShouldBe(counts[0], label); counts[3].ShouldBe(counts[1], label); } // Positive control: the sequence really overflowed (discards and overflow events happened). counts[0].ShouldBeGreaterThan(0); counts[1].ShouldBeGreaterThan(0); } [Fact] public void Factory_supplies_ring_event_queues_and_delegates_everything_else() { using var factory = new RingEventQueueFactory(new MonitoredItemQueueFactory(Telemetry)); factory.SupportsDurableQueues.ShouldBeFalse(); factory.CreateEventQueue(false, 4).ShouldBeOfType().MonitoredItemId.ShouldBe(4u); factory.CreateDataChangeQueue(false, 5).ShouldBeOfType(); // A durable request reaches the SDK factory, which refuses it as before. Should.Throw(() => factory.CreateEventQueue(true, 6)); Should.Throw(() => new MonitoredItemQueueFactory(Telemetry).CreateEventQueue(true, 6)); } [Fact] public void Buffer_grows_lazily_and_is_released_on_shrink() { var ring = new RingEventMonitoredItemQueue(1); ring.SetQueueSize(10000, true); ring.Capacity.ShouldBe(0); for (var i = 0; i < 20000; i++) ring.Enqueue(new EventFieldList()); ring.Capacity.ShouldBe(10000); ring.ItemsInQueue.ShouldBe(10000); ring.SetQueueSize(10, true); ring.ItemsInQueue.ShouldBe(10); ring.Capacity.ShouldBeLessThanOrEqualTo(20); } }