fix(mqtt): initial push of cached snapshots on (re)subscribe — the push-model forceRaise (05/STAB-18 shape b)
This commit is contained in:
Joseph Doherty
+139
@@ -0,0 +1,139 @@
|
||||
using Shouldly;
|
||||
using Xunit;
|
||||
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
|
||||
|
||||
namespace ZB.MOM.WW.OtOpcUa.Driver.Mqtt.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// The push-model edge behaviours <see cref="MqttSubscriptionManager"/> lacked (archreview
|
||||
/// 05/STAB-18): an <b>initial push</b> of the cached snapshot on every (re)subscribe, and a
|
||||
/// <b>connection-loss stale</b> to <c>BadNoCommunication</c> with the value retained.
|
||||
///
|
||||
/// <para><b>Why both, and why the identical payload is load-bearing.</b> The manager's steady-state
|
||||
/// dedup suppresses a message whose value AND status equal the cached one, and that cache is
|
||||
/// driver-owned — it survives a reconnect and a redeploy. So a broker that replays its retained
|
||||
/// message unchanged after an outage raised nothing, and every node the host had latched Bad stayed
|
||||
/// Bad until the plant value happened to change. A recovery test that replays a <em>different</em>
|
||||
/// payload passes against the pre-fix code and proves nothing; every recovery assertion here
|
||||
/// therefore replays the <b>identical</b> payload.</para>
|
||||
///
|
||||
/// <para>The steady-state suppression itself must survive — it is what keeps a 10 Hz topic from
|
||||
/// re-triggering the whole downstream fan-out per message — so each recovery case is paired with a
|
||||
/// control that asserts an unchanged republish is still suppressed.</para>
|
||||
/// </summary>
|
||||
public sealed class MqttSubscriptionManagerRecoveryTests
|
||||
{
|
||||
// OPC UA status codes, verified against Opc.Ua.StatusCodes rather than recalled.
|
||||
private const uint Good = 0x00000000u;
|
||||
private const uint BadNoCommunication = 0x80310000u;
|
||||
private const uint BadWaitingForInitialData = 0x80320000u;
|
||||
|
||||
private const string TempPath = "Plant/Mqtt/broker1/OvenTemp";
|
||||
private const string PressPath = "Plant/Mqtt/broker1/OvenPressure";
|
||||
private const string TempTopic = "f/oven/temp";
|
||||
private const string PressTopic = "f/oven/press";
|
||||
|
||||
private static RawTagEntry Tag(string rawPath, string topic) =>
|
||||
new(rawPath, $$"""{"topic":"{{topic}}","payloadFormat":"Json","jsonPath":"$.value","dataType":"Float64"}""",
|
||||
WriteIdempotent: false);
|
||||
|
||||
private static MqttSubscriptionManager NewManager()
|
||||
{
|
||||
var mgr = new MqttSubscriptionManager(new MqttDriverOptions { Mode = MqttMode.Plain }, "mqtt-1");
|
||||
mgr.Register([Tag(TempPath, TempTopic), Tag(PressPath, PressTopic)]);
|
||||
return mgr;
|
||||
}
|
||||
|
||||
private sealed record Raised(string Reference, object? Value, uint StatusCode, ISubscriptionHandle Handle);
|
||||
|
||||
private static List<Raised> Record(MqttSubscriptionManager mgr)
|
||||
{
|
||||
var raised = new List<Raised>();
|
||||
mgr.OnDataChange += (_, e) =>
|
||||
raised.Add(new Raised(e.FullReference, e.Snapshot.Value, e.Snapshot.StatusCode, e.SubscriptionHandle));
|
||||
return raised;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------------
|
||||
// (A) Initial push on (re)subscribe — 05/STAB-18 shape (b)
|
||||
// ---------------------------------------------------------------------------------
|
||||
|
||||
/// <summary>
|
||||
/// A ref observed before the subscription existed is pushed once, with its cached snapshot,
|
||||
/// attributed to the new handle. This is the push-model equivalent of the poll engine's
|
||||
/// <c>forceRaise: true</c> on the first poll of a new subscription, and it is what refills a
|
||||
/// node the address-space rebuild reseeded <c>BadWaitingForInitialData</c> on a quiet topic.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task SubscribeAsync_pushes_the_cached_snapshot_for_an_observed_ref()
|
||||
{
|
||||
var mgr = NewManager();
|
||||
mgr.HandleMessage(TempTopic, """{"value":21.5}"""u8.ToArray(), retained: false); // cached; no handle yet
|
||||
|
||||
var raised = Record(mgr);
|
||||
var handle = await mgr.SubscribeAsync([TempPath], TimeSpan.FromSeconds(1), TestContext.Current.CancellationToken);
|
||||
|
||||
raised.Count.ShouldBe(1);
|
||||
raised[0].Reference.ShouldBe(TempPath);
|
||||
raised[0].Value.ShouldBe(21.5);
|
||||
raised[0].StatusCode.ShouldBe(Good);
|
||||
raised[0].Handle.ShouldBe(handle);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// A ref that has never been observed carries only the materialiser's
|
||||
/// <c>BadWaitingForInitialData</c> placeholder — pushing that would claim an observation the
|
||||
/// driver has not made, so the initial push skips it.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task SubscribeAsync_does_not_push_a_never_observed_ref()
|
||||
{
|
||||
var mgr = NewManager();
|
||||
mgr.HandleMessage(TempTopic, """{"value":21.5}"""u8.ToArray(), retained: false);
|
||||
|
||||
var raised = Record(mgr);
|
||||
await mgr.SubscribeAsync([TempPath, PressPath], TimeSpan.FromSeconds(1), TestContext.Current.CancellationToken);
|
||||
|
||||
raised.Select(r => r.Reference).ShouldBe([TempPath]);
|
||||
mgr.Values.Read(PressPath).StatusCode.ShouldBe(BadWaitingForInitialData);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// <b>Control.</b> The initial push must not weaken steady-state suppression: an identical
|
||||
/// message arriving after the subscribe is still swallowed. Without this, "recovery works"
|
||||
/// could simply mean "nothing is ever deduped any more".
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task An_identical_message_after_the_initial_push_is_still_suppressed()
|
||||
{
|
||||
var mgr = NewManager();
|
||||
mgr.HandleMessage(TempTopic, """{"value":21.5}"""u8.ToArray(), retained: false);
|
||||
|
||||
var raised = Record(mgr);
|
||||
await mgr.SubscribeAsync([TempPath], TimeSpan.FromSeconds(1), TestContext.Current.CancellationToken);
|
||||
mgr.HandleMessage(TempTopic, """{"value":21.5}"""u8.ToArray(), retained: false);
|
||||
|
||||
raised.Count.ShouldBe(1); // the initial push only
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The rebuild shape: unsubscribe and subscribe again — as every deploy does through
|
||||
/// <c>DriverInstanceActor</c>'s unsubscribe-then-subscribe — and the cached value is pushed
|
||||
/// again onto the new handle rather than leaving the rebuilt node waiting for the plant.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task A_resubscribe_pushes_again()
|
||||
{
|
||||
var mgr = NewManager();
|
||||
mgr.HandleMessage(TempTopic, """{"value":21.5}"""u8.ToArray(), retained: false);
|
||||
var first = await mgr.SubscribeAsync([TempPath], TimeSpan.FromSeconds(1), TestContext.Current.CancellationToken);
|
||||
await mgr.UnsubscribeAsync(first, TestContext.Current.CancellationToken);
|
||||
|
||||
var raised = Record(mgr);
|
||||
var second = await mgr.SubscribeAsync([TempPath], TimeSpan.FromSeconds(1), TestContext.Current.CancellationToken);
|
||||
|
||||
raised.Count.ShouldBe(1);
|
||||
raised[0].Value.ShouldBe(21.5);
|
||||
raised[0].Handle.ShouldBe(second);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user