test: shared actor test bases poll AwaitCondition every 20 ms, not max/10 (lmxopcua#775)

Akka TestKit's AwaitCondition without an interval polls every max/10 of the
DILATED budget. Measured here: a condition that turned true at 2 s under a
15 s budget returned after 3003 ms at timefactor 1 (3 polls) and 4502 ms at
timefactor 3 (2 polls). AwaitAssert / AwaitAssertAsync are unaffected (a
fixed 100 ms: 21 polls in ~2 s at both factors).

RuntimeActorTestBase and ControlPlaneActorTestBase now declare
AwaitCondition overloads that hide TestKit's and default the interval to
PollInterval (20 ms), so every subclass call without an interval binds to
them (measured after: returns 5-22 ms after the condition holds, at both
factors). PresenceBudget's doc no longer claims the helpers return "the
instant the condition holds" - it states the per-helper poll behaviour.

Bare-TestKit classes with AwaitCondition calls get an explicit interval:
TelemetryDialDeadlineTests / TelemetryDialSupervisorTests (next to their own
undilated 5 s / 8 s WaitForCount deadlines and a 1 s dial deadline) and
OpcUaEndpointStepDownActorTests (RuntimeActorTestBase.PollInterval, now
public like PresenceBudget). ContinuousHistorizationRecorderTypedValueTests'
AwaitConditionAsync was left alone (historian code is being changed in
parallel).

Suite results (Release, 0 warnings):
- Runtime.Tests 946/3 skipped/0 failed at timefactor 3 (1 m 45 s, was
  2 m 57 s) and 1 (1 m 18 s, was 2 m 57 s);
- ControlPlane.Tests 319/0 failed at 3 (1 m 51 s) and 1 (1 m 11 s);
- AdminUI.Tests Telemetry 15/0 failed at 3 and 1.

Claude-Session: https://claude.ai/code/session_01GT67AEHd2Acv1YPwGfXEoV

tests/Server/ZB.MOM.WW.OtOpcUa.AdminUI.Tests/Telemetry/TelemetryDialDeadlineTests.cs

@@ -23,6 +23,10 @@ namespace ZB.MOM.WW.OtOpcUa.AdminUI.Tests.Telemetry;
 /// </summary>
 public sealed class TelemetryDialDeadlineTests : TestKit
 {
+    /// <summary>Explicit AwaitCondition poll interval: Akka's default is max / 10 of the dilated budget, i.e.
+    /// seconds under CI's timefactor (lmxopcua#775).</summary>
+    private static readonly TimeSpan PollInterval = TimeSpan.FromMilliseconds(20);
+
     private static readonly TimeSpan Timeout = TimeSpan.FromSeconds(8);
 
     [Fact]
@@ -35,7 +39,7 @@ public sealed class TelemetryDialDeadlineTests : TestKit
         first.Ct.IsCancellationRequested.ShouldBeFalse("the deadline has not elapsed yet");
 
         // The stalled dial is cut at the deadline...
-        AwaitCondition(() => first.Ct.IsCancellationRequested, Timeout);
+        AwaitCondition(() => first.Ct.IsCancellationRequested, Timeout, PollInterval);
         // ...and the supervisor re-dials (a stalled dial is a transport failure, never a silent end).
         var invocations = dial.WaitForCount(2, Timeout);
         invocations[1].CorrelationId.ShouldBe("central-node-1-2");
@@ -49,7 +53,7 @@ public sealed class TelemetryDialDeadlineTests : TestKit
         Spawn(dial, callTimeoutSeconds: 1, sinks);
 
         var first = dial.WaitForCount(1, Timeout).Single();
-        AwaitCondition(() => sinks.HealthStore.Upserts.Count == 1, Timeout);
+        AwaitCondition(() => sinks.HealthStore.Upserts.Count == 1, Timeout, PollInterval);
 
         // Positive control: well past the deadline, the established stream is untouched.
         await Task.Delay(TimeSpan.FromSeconds(2.5));

tests/Server/ZB.MOM.WW.OtOpcUa.AdminUI.Tests/Telemetry/TelemetryDialSupervisorTests.cs

@@ -23,6 +23,10 @@ namespace ZB.MOM.WW.OtOpcUa.AdminUI.Tests.Telemetry;
 /// </summary>
 public sealed class TelemetryDialSupervisorTests : TestKit
 {
+    /// <summary>Explicit AwaitCondition poll interval: Akka's default is max / 10 of the dilated budget, i.e.
+    /// seconds under CI's timefactor (lmxopcua#775).</summary>
+    private static readonly TimeSpan PollInterval = TimeSpan.FromMilliseconds(20);
+
     private static readonly TimeSpan Timeout = TimeSpan.FromSeconds(5);
 
     [Fact]
@@ -66,7 +70,7 @@ public sealed class TelemetryDialSupervisorTests : TestKit
         actor.Tell(new TelemetryDialSupervisor.RefreshNodes());
 
         // node-1's dialer is cancelled and dropped.
-        AwaitCondition(() => node1.Ct.IsCancellationRequested, Timeout);
+        AwaitCondition(() => node1.Ct.IsCancellationRequested, Timeout, PollInterval);
         // node-3 gets a fresh dialer.
         var invocations = dial.WaitForCount(3, Timeout);
         invocations.ShouldContain(i => i.Target.NodeId == "node-3" && i.CorrelationId == "central-node-3-1");
@@ -98,7 +102,7 @@ public sealed class TelemetryDialSupervisorTests : TestKit
         actor.Tell(new TelemetryDialSupervisor.RefreshNodes());
 
         // The old node-1 stream is torn down and a fresh dialer opens at the NEW endpoint (gen 2).
-        AwaitCondition(() => node1Original.Ct.IsCancellationRequested, Timeout);
+        AwaitCondition(() => node1Original.Ct.IsCancellationRequested, Timeout, PollInterval);
         var invocations = dial.WaitForCount(3, Timeout);
         invocations.ShouldContain(i =>
             i.Target.NodeId == "node-1"
@@ -246,7 +250,7 @@ public sealed class TelemetryDialSupervisorTests : TestKit
 
         Sys.Stop(actor);
 
-        AwaitCondition(() => inv.All(i => i.Ct.IsCancellationRequested), Timeout);
+        AwaitCondition(() => inv.All(i => i.Ct.IsCancellationRequested), Timeout, PollInterval);
     }
 
     [Fact]

tests/Server/ZB.MOM.WW.OtOpcUa.ControlPlane.Tests/Harness/ControlPlaneTestHarness.cs

@@ -1,4 +1,5 @@
 using Akka.Cluster;
+using Akka.TestKit;
 using Akka.TestKit.Xunit2;
 using Microsoft.EntityFrameworkCore;
 using ZB.MOM.WW.OtOpcUa.Configuration;
@@ -21,7 +22,9 @@ public abstract class ControlPlaneActorTestBase : TestKit
     ///     <c>AwaitAssert</c>) — the same doctrine as <c>RuntimeActorTestBase.PresenceBudget</c>.
     /// </summary>
     /// <remarks>
-    ///     A budget, not a delay: the helpers return the instant the condition holds, so raising it costs
+    ///     A budget, not a delay: the helpers return within one poll interval of the condition holding
+    ///     (<c>AwaitCondition</c> polls every <see cref="PollInterval"/> through this class's overloads, not Akka's
+    ///     <c>max / 10</c> of the dilated budget — lmxopcua#775), so raising it costs
     ///     nothing on the happy path and cannot make a genuinely failing assertion pass. Several actors here
     ///     do their first EF Core (InMemory) work inside the waited-for step — model build is a multi-second
     ///     cold cost on a loaded CI runner — and 3–5 s budgets sized on an idle machine failed there (#606).
@@ -29,6 +32,40 @@ public abstract class ControlPlaneActorTestBase : TestKit
     /// </remarks>
     protected static readonly TimeSpan PresenceBudget = TimeSpan.FromSeconds(15);
 
+    /// <summary>
+    ///     Poll interval for every <c>AwaitCondition</c> in this class's subclasses that does not pass its own
+    ///     (lmxopcua#775). Akka's own default is <c>max / 10</c> of the DILATED budget — 1.5 s for a 15 s budget
+    ///     locally, 4.5 s under CI's <c>AKKA_TEST_TIMEFACTOR=3</c> — so a wait could overshoot the moment its
+    ///     condition held by seconds. That wasted CI time everywhere, and failed tests where an undilated
+    ///     deadline in the code under test elapsed during the overshoot (lmxopcua 342a825d). <c>AwaitAssert</c>
+    ///     is unaffected: its default interval is a fixed 100 ms.
+    /// </summary>
+    protected static readonly TimeSpan PollInterval = TimeSpan.FromMilliseconds(20);
+
+    /// <summary>
+    ///     <see cref="TestKitBase.AwaitCondition(Func{bool}, TimeSpan?, TimeSpan?, string, CancellationToken)"/> with
+    ///     <paramref name="interval"/> defaulting to <see cref="PollInterval"/> instead of Akka's <c>max / 10</c>.
+    ///     Hides the TestKit overloads, so every subclass call without an interval binds here.
+    /// </summary>
+    /// <param name="conditionIsFulfilled">The condition to poll.</param>
+    /// <param name="max">The budget (dilated by Akka); null takes the enclosing <c>Within</c> or the default.</param>
+    /// <param name="interval">The poll interval; null means <see cref="PollInterval"/>.</param>
+    /// <param name="message">The failure message.</param>
+    /// <param name="cancellationToken">Cancels the wait.</param>
+    protected new void AwaitCondition(Func<bool> conditionIsFulfilled, TimeSpan? max = null, TimeSpan? interval = null,
+        string? message = null, CancellationToken cancellationToken = default) =>
+        base.AwaitCondition(conditionIsFulfilled, max, interval ?? PollInterval, message!, cancellationToken);
+
+    /// <summary>The message-carrying overload of <see cref="AwaitCondition(Func{bool}, TimeSpan?, TimeSpan?, string?, CancellationToken)"/>,
+    /// polled every <see cref="PollInterval"/>.</summary>
+    /// <param name="conditionIsFulfilled">The condition to poll.</param>
+    /// <param name="max">The budget (dilated by Akka).</param>
+    /// <param name="message">The failure message.</param>
+    /// <param name="cancellationToken">Cancels the wait.</param>
+    protected new void AwaitCondition(Func<bool> conditionIsFulfilled, TimeSpan? max, string message,
+        CancellationToken cancellationToken = default) =>
+        base.AwaitCondition(conditionIsFulfilled, max, PollInterval, message, cancellationToken);
+
     /// <summary>Gets the Akka configuration for test actors, including cluster and pub-sub extensions.</summary>
     /// <remarks>
     ///     <c>akka.test.single-expect-default</c> is raised from Akka's 3 s to <see cref="PresenceBudget"/>:

tests/Server/ZB.MOM.WW.OtOpcUa.Runtime.Tests/Harness/RuntimeActorTestBase.cs

@@ -1,4 +1,5 @@
 using Akka.Cluster;
+using Akka.TestKit;
 using Akka.TestKit.Xunit2;
 using Microsoft.EntityFrameworkCore;
 using ZB.MOM.WW.OtOpcUa.Configuration;
@@ -15,8 +16,11 @@ public abstract class RuntimeActorTestBase : TestKit
     ///     Shared upper bound for a <b>presence</b> wait (<c>AwaitAssert</c> / <c>AwaitCondition</c>).
     /// </summary>
     /// <remarks>
-    ///     <para><b>A budget, not a delay.</b> These helpers poll and return the instant the condition holds,
-    ///     so the value is how long to wait before giving up. Raising it costs nothing on the happy path and
+    ///     <para><b>A budget, not a delay.</b> These helpers poll and return within one poll interval of the
+    ///     condition holding (<c>ExpectMsg</c> the instant the message arrives; <c>AwaitAssert</c> every 100 ms,
+    ///     Akka's default; <c>AwaitCondition</c> every <see cref="PollInterval"/> through this class's overloads —
+    ///     Akka's own default there is <c>max / 10</c> of the dilated budget, 4.5 s in CI, lmxopcua#775), so the
+    ///     value is how long to wait before giving up. Raising it costs nothing on the happy path and
     ///     <em>cannot</em> make a genuinely failing assertion pass — it only changes how quickly a real
     ///     breakage is reported. That is the opposite of an <b>absence</b> window (<c>ExpectNoMsg</c>,
     ///     settle-then-assert), where the elapsed time IS the assertion and every millisecond is spent on
@@ -33,6 +37,41 @@ public abstract class RuntimeActorTestBase : TestKit
     /// </remarks>
     public static readonly TimeSpan PresenceBudget = TimeSpan.FromSeconds(15);
 
+    /// <summary>
+    ///     Poll interval for every <c>AwaitCondition</c> in this class's subclasses that does not pass its own
+    ///     (lmxopcua#775). Akka's own default is <c>max / 10</c> of the DILATED budget — 1.5 s for a 15 s budget
+    ///     locally, 4.5 s under CI's <c>AKKA_TEST_TIMEFACTOR=3</c> — so a wait could overshoot the moment its
+    ///     condition held by seconds. That wasted CI time everywhere, and failed tests where an undilated
+    ///     deadline in the code under test elapsed during the overshoot (lmxopcua 342a825d). <c>AwaitAssert</c>
+    ///     is unaffected: its default interval is a fixed 100 ms. Public, like <see cref="PresenceBudget"/>, for
+    ///     test classes that are not subclasses (a bare <see cref="TestKit"/>) to pass explicitly.
+    /// </summary>
+    public static readonly TimeSpan PollInterval = TimeSpan.FromMilliseconds(20);
+
+    /// <summary>
+    ///     <see cref="TestKitBase.AwaitCondition(Func{bool}, TimeSpan?, TimeSpan?, string, CancellationToken)"/> with
+    ///     <paramref name="interval"/> defaulting to <see cref="PollInterval"/> instead of Akka's <c>max / 10</c>.
+    ///     Hides the TestKit overloads, so every subclass call without an interval binds here.
+    /// </summary>
+    /// <param name="conditionIsFulfilled">The condition to poll.</param>
+    /// <param name="max">The budget (dilated by Akka); null takes the enclosing <c>Within</c> or the default.</param>
+    /// <param name="interval">The poll interval; null means <see cref="PollInterval"/>.</param>
+    /// <param name="message">The failure message.</param>
+    /// <param name="cancellationToken">Cancels the wait.</param>
+    protected new void AwaitCondition(Func<bool> conditionIsFulfilled, TimeSpan? max = null, TimeSpan? interval = null,
+        string? message = null, CancellationToken cancellationToken = default) =>
+        base.AwaitCondition(conditionIsFulfilled, max, interval ?? PollInterval, message!, cancellationToken);
+
+    /// <summary>The message-carrying overload of <see cref="AwaitCondition(Func{bool}, TimeSpan?, TimeSpan?, string?, CancellationToken)"/>,
+    /// polled every <see cref="PollInterval"/>.</summary>
+    /// <param name="conditionIsFulfilled">The condition to poll.</param>
+    /// <param name="max">The budget (dilated by Akka).</param>
+    /// <param name="message">The failure message.</param>
+    /// <param name="cancellationToken">Cancels the wait.</param>
+    protected new void AwaitCondition(Func<bool> conditionIsFulfilled, TimeSpan? max, string message,
+        CancellationToken cancellationToken = default) =>
+        base.AwaitCondition(conditionIsFulfilled, max, PollInterval, message, cancellationToken);
+
     /// <summary>Gets the Akka test HOCON configuration string for single-node cluster setup.</summary>
     /// <remarks>
     ///     <c>akka.test.single-expect-default</c> is raised from Akka's 3 s to <see cref="PresenceBudget"/>

tests/Server/ZB.MOM.WW.OtOpcUa.Runtime.Tests/Redundancy/OpcUaEndpointStepDownActorTests.cs

@@ -56,11 +56,13 @@ akka {
         _nodeA = new TestKit(Hocon + TestTimeFactor.Hocon);
         var clusterA = Akka.Cluster.Cluster.Get(_nodeA.Sys);
         clusterA.Join(clusterA.SelfAddress);
-        AwaitCondition(() => UpCount(clusterA) == 1, RuntimeActorTestBase.PresenceBudget);
+        AwaitCondition(() => UpCount(clusterA) == 1, RuntimeActorTestBase.PresenceBudget,
+            RuntimeActorTestBase.PollInterval);
 
         var clusterB = Akka.Cluster.Cluster.Get(Sys);
         clusterB.Join(clusterA.SelfAddress);
-        AwaitCondition(() => UpCount(clusterA) == 2 && UpCount(clusterB) == 2, RuntimeActorTestBase.PresenceBudget);
+        AwaitCondition(() => UpCount(clusterA) == 2 && UpCount(clusterB) == 2, RuntimeActorTestBase.PresenceBudget,
+            RuntimeActorTestBase.PollInterval);
 
         // Fixture sanity: A must be the Primary going in, or every assertion below is about the wrong node.
         ClusterActiveNode.SelfIsActive(clusterA, RoleParser.Driver).ShouldBeTrue("node A formed the cluster, so it is the oldest Up driver member");
@@ -100,7 +102,7 @@ akka {
         var clusterB = Akka.Cluster.Cluster.Get(Sys);
         AwaitCondition(() => ClusterActiveNode.SelfIsActive(clusterB, RoleParser.Driver)
                              && clusterB.State.Members.Count(m => m.Status == MemberStatus.Up) == 1,
-            RuntimeActorTestBase.PresenceBudget);
+            RuntimeActorTestBase.PresenceBudget, RuntimeActorTestBase.PollInterval);
     }
 
     /// <summary>A failed endpoint on the SECONDARY changes nothing: there is no role to hand over.</summary>