fix(2a): strengthen marker-poll baseline test + deterministic fake script

- FakeRustSocketSource: add source-level EnqueueMarkers that pre-stages
  marker lists and transfers them to FakeConnection at Create time,
  eliminating the setup race between test code and the poll loop.
- FakeConnection: add per-connection ConcurrentQueue<IReadOnlyList<
  MapMarkerSnapshot>> with "hold last" behaviour mirroring NextHeartbeat;
  EnqueueMarkers on the connection available for post-connect injection.
  Existing MarkersResult fallback preserved for Task-2 / no-script callers.
- First_marker_poll_is_a_silent_baseline: rewritten to script poll 1+2 with
  a CargoShip (baseline + no-change) and poll 3 with CargoShip+Heli; waits
  for the definite heli-added event as the race-free signal proving both
  baseline suppression and diff correctness.
- Marker_added_on_a_later_poll_publishes_changed_event: scripted via source
  queue before EnsureConnectionAsync; asserts exact MapDimensions(4000,4000,
  500) from the FakeConnection default.
- Failed_marker_poll_retains_previous_snapshot: polls 1+2 scripted via
  source queue; MarkersThrow used post-event for the throw/recover cycle;
  hold-last means recovery sees the same CargoShip → no spurious event.
- ConnectionOptions.MarkerPollInterval: init → set for IOptions binding.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: HandyS11

src/RustPlusBot.Features.Connections/ConnectionOptions.cs

@@ -19,5 +19,5 @@ public sealed class ConnectionOptions
     public TimeSpan HeartbeatTimeout { get; set; } = TimeSpan.FromSeconds(10);
 
     /// <summary>How often to poll map markers for live-event detection. Default 10s.</summary>
-    public TimeSpan MarkerPollInterval { get; init; } = TimeSpan.FromSeconds(10);
+    public TimeSpan MarkerPollInterval { get; set; } = TimeSpan.FromSeconds(10);
 }

tests/RustPlusBot.Features.Connections.Tests/ConnectionSupervisorTests.cs

@@ -250,9 +250,16 @@ public async Task StartAll_StartsAConnectionPerConnectableServer()
     [Fact]
     public async Task First_marker_poll_is_a_silent_baseline()
     {
-        // Arrange: the connection always returns an empty marker list.
-        // After two full poll cycles the first (silent baseline) plus one repeated poll should
-        // produce no MapMarkersChangedEvent because there is no diff to report.
+        // Contract: the FIRST poll after connect must not publish any event even when markers are
+        // present on that first poll (the baseline records them silently). Only LATER changes alert.
+        //
+        // Script:
+        //   Poll 1 → [CargoShip]     (baseline — must NOT fire an event)
+        //   Poll 2 → [CargoShip]     (no change — still no event)
+        //   Poll 3 → [CargoShip, PatrolHelicopter]  (heli added — ONE event, Added=[heli])
+        //
+        // Waiting for the definite heli-event signal proves both that baseline suppression held AND
+        // that the diff works, without any fixed-sleep assertion.
         var source = new FakeRustSocketSource();
         source.EnqueueConnect(SocketConnectOutcome.Connected);
         source.EnqueueHeartbeat(HeartbeatResult.Ok(1));
@@ -269,16 +276,25 @@ public async Task First_marker_poll_is_a_silent_baseline()
             }
         }, CancellationToken.None);
 
-        await h.Supervisor.EnsureConnectionAsync(10UL, serverId, cts.Token);
+        // Script the three polls before EnsureConnectionAsync so the script is in place before the
+        // poll loop starts — no race between test setup and the supervisor's background poll task.
+        var cargo = new MapMarkerSnapshot(1UL, MarkerKind.CargoShip, 1f, 1f, null);
+        var heli = new MapMarkerSnapshot(2UL, MarkerKind.PatrolHelicopter, 2f, 2f, null);
+        source.EnqueueMarkers([cargo]); // poll 1: baseline (silent)
+        source.EnqueueMarkers([cargo]); // poll 2: no change
+        source.EnqueueMarkers([cargo, heli]); // poll 3: heli added → one event
 
-        // FakeConnection defaults to empty MarkersResult — baseline poll sees nothing.
-        await WaitUntilAsync(() => h.Supervisor.HasLiveSocket(10UL, serverId), cts.Token);
+        await h.Supervisor.EnsureConnectionAsync(10UL, serverId, cts.Token);
 
-        // Wait two full poll cycles so the baseline and one follow-up are definitely consumed.
-        await Task.Delay(TimeSpan.FromMilliseconds(100), cts.Token);
+        // Wait for the heli-added event — its arrival is the definite signal that at least three
+        // poll cycles have completed and proves the baseline CargoShip never triggered an event.
+        await WaitUntilAsync(() => !captured.IsEmpty, cts.Token);
 
-        // The first poll establishes a silent baseline; repeated empty polls produce no event.
-        Assert.Empty(captured);
+        Assert.Single(captured);
+        Assert.True(captured.TryPeek(out var evt));
+        Assert.Single(evt!.Added);
+        Assert.Equal(MarkerKind.PatrolHelicopter, evt.Added[0].Kind);
+        Assert.Empty(evt.Removed);
 
         await h.Supervisor.StopAllAsync();
         await cts.CancelAsync();
@@ -292,7 +308,12 @@ public async Task First_marker_poll_is_a_silent_baseline()
     [Fact]
     public async Task Marker_added_on_a_later_poll_publishes_changed_event()
     {
-        // Arrange: first poll sees nothing (baseline); second poll sees a CargoShip → one event.
+        // Contract: first poll is a silent baseline; a new marker on a subsequent poll fires exactly
+        // one MapMarkersChangedEvent with the correct Added entry and the connect-time dimensions.
+        //
+        // Script:
+        //   Poll 1 → []              (baseline — no event)
+        //   Poll 2 → [CargoShip]     (added → one event)
         var source = new FakeRustSocketSource();
         source.EnqueueConnect(SocketConnectOutcome.Connected);
         source.EnqueueHeartbeat(HeartbeatResult.Ok(1));
@@ -309,33 +330,26 @@ public async Task Marker_added_on_a_later_poll_publishes_changed_event()
             }
         }, CancellationToken.None);
 
-        await h.Supervisor.EnsureConnectionAsync(10UL, serverId, cts.Token);
+        // FakeConnection default DimensionsResult is new(4000u, 4000u, 500); assert those exact values.
+        var expectedDims = new MapDimensions(4000u, 4000u, 500);
 
-        // Wait for the fake connection to exist; start with empty markers (baseline poll sees nothing).
-        await WaitUntilAsync(() => source.LastConnection is not null, cts.Token);
-        source.LastConnection!.MarkersResult = [];
-        await WaitUntilAsync(() => h.Supervisor.HasLiveSocket(10UL, serverId), cts.Token);
+        // Script polls before EnsureConnectionAsync so the marker script is in the connection before
+        // the poll loop can start — eliminates any setup race.
+        source.EnqueueMarkers([]); // poll 1: baseline
+        source.EnqueueMarkers([new MapMarkerSnapshot(2UL, MarkerKind.CargoShip, 1f, 1f, "Cargo A")]); // poll 2
 
-        // Wait one poll cycle for the baseline to be established, then add a CargoShip.
-        await Task.Delay(TimeSpan.FromMilliseconds(60), cts.Token);
-        source.LastConnection!.MarkersResult =
-            [new MapMarkerSnapshot(2UL, MarkerKind.CargoShip, 1f, 1f, "Cargo A")];
+        await h.Supervisor.EnsureConnectionAsync(10UL, serverId, cts.Token);
 
-        // Wait until the event arrives (up to 30s deadline).
-        var deadline = DateTimeOffset.UtcNow.AddSeconds(30);
-        while (captured.IsEmpty && DateTimeOffset.UtcNow < deadline)
-        {
-            await Task.Delay(15, cts.Token);
-        }
+        // Wait for the definite signal: the CargoShip-added event.
+        await WaitUntilAsync(() => !captured.IsEmpty, cts.Token);
 
         Assert.Single(captured);
-        var evt = captured.TryPeek(out var e) ? e : null;
+        Assert.True(captured.TryPeek(out var evt));
         Assert.NotNull(evt);
         Assert.Single(evt!.Added);
         Assert.Equal(MarkerKind.CargoShip, evt.Added[0].Kind);
         Assert.Empty(evt.Removed);
-        // Dimensions should ride along from the connect-time fetch.
-        Assert.NotNull(evt.Dimensions);
+        Assert.Equal(expectedDims, evt.Dimensions);
 
         await h.Supervisor.StopAllAsync();
         await cts.CancelAsync();
@@ -349,8 +363,13 @@ public async Task Marker_added_on_a_later_poll_publishes_changed_event()
     [Fact]
     public async Task Failed_marker_poll_retains_previous_snapshot()
     {
-        // Arrange: baseline is empty. The second poll adds a CargoShip (event published).
-        // The third poll throws (no event). The fourth returns the same CargoShip (no spurious diff).
+        // Contract: a thrown poll does not corrupt the previous snapshot.
+        //
+        // Script:
+        //   Poll 1 → []          (baseline — no event)
+        //   Poll 2 → [CargoShip] (added → exactly one event; queue empties, hold-last = CargoShip)
+        //   Poll 3 → throws      (MarkersThrow = true; no event, snapshot retained)
+        //   Poll 4 → [CargoShip] (same as held-last → no spurious diff, still exactly one event total)
         var source = new FakeRustSocketSource();
         source.EnqueueConnect(SocketConnectOutcome.Connected);
         source.EnqueueHeartbeat(HeartbeatResult.Ok(1));
@@ -367,35 +386,24 @@ public async Task Failed_marker_poll_retains_previous_snapshot()
             }
         }, CancellationToken.None);
 
-        await h.Supervisor.EnsureConnectionAsync(10UL, serverId, cts.Token);
-
-        await WaitUntilAsync(() => source.LastConnection is not null, cts.Token);
-        source.LastConnection!.MarkersResult = [];
-        await WaitUntilAsync(() => h.Supervisor.HasLiveSocket(10UL, serverId), cts.Token);
-
-        // Let baseline settle.
-        await Task.Delay(TimeSpan.FromMilliseconds(60), cts.Token);
-
-        // Poll 2: add CargoShip → expect exactly one event.
         var cargo = new MapMarkerSnapshot(3UL, MarkerKind.CargoShip, 2f, 2f, null);
-        source.LastConnection!.MarkersResult = [cargo];
+        // Script polls before EnsureConnectionAsync to eliminate the setup race.
+        source.EnqueueMarkers([]); // poll 1: baseline
+        source.EnqueueMarkers([cargo]); // poll 2: CargoShip added; queue empties → hold-last = [cargo]
 
-        var deadline = DateTimeOffset.UtcNow.AddSeconds(30);
-        while (captured.IsEmpty && DateTimeOffset.UtcNow < deadline)
-        {
-            await Task.Delay(15, cts.Token);
-        }
+        await h.Supervisor.EnsureConnectionAsync(10UL, serverId, cts.Token);
 
+        // Wait for the one cargo-added event — definite signal that poll 2 completed.
+        await WaitUntilAsync(() => !captured.IsEmpty, cts.Token);
         Assert.Single(captured);
 
-        // Poll 3: make the poll throw.
+        // Poll 3: make the next poll throw; the poll loop catches the exception and retains the snapshot.
         source.LastConnection!.MarkersThrow = true;
-        // Give it time to attempt the failing poll.
+        // Give enough time for at least one failing poll to be attempted.
         await Task.Delay(TimeSpan.FromMilliseconds(60), cts.Token);
 
-        // Poll 4: recover; same CargoShip → snapshot unchanged, no new event.
+        // Poll 4: recover — hold-last still returns [cargo], so snapshot is unchanged, no new event.
         source.LastConnection!.MarkersThrow = false;
-        source.LastConnection!.MarkersResult = [cargo];
         await Task.Delay(TimeSpan.FromMilliseconds(100), cts.Token);
 
         // Still only one event total — the failed poll did not corrupt the snapshot.

tests/RustPlusBot.Features.Connections.Tests/Fakes/FakeRustSocketSource.cs

@@ -19,6 +19,7 @@ internal sealed class FakeRustSocketSource : IRustSocketSource
 {
     private readonly ConcurrentQueue<SocketConnectOutcome> _connectOutcomes = new();
     private readonly ConcurrentQueue<HeartbeatResult> _heartbeats = new();
+    private readonly ConcurrentQueue<IReadOnlyList<MapMarkerSnapshot>> _pendingMarkerScript = new();
     private int _createCount;
 
     private HeartbeatResult _lastHeartbeat = HeartbeatResult.Ok(0);
@@ -42,6 +43,12 @@ public IRustServerConnection Create(string ip, int port, ulong steamId, string p
         LastSteamId = steamId;
         var outcome = _connectOutcomes.TryDequeue(out var next) ? next : SocketConnectOutcome.Connected;
         var connection = new FakeConnection(outcome, this);
+        // Transfer any pre-staged marker script so it is in place before the poll loop starts.
+        while (_pendingMarkerScript.TryDequeue(out var markers))
+        {
+            connection.EnqueueMarkers(markers);
+        }
+
         LastConnection = connection;
         return connection;
     }
@@ -50,6 +57,16 @@ public IRustServerConnection Create(string ip, int port, ulong steamId, string p
 
     public void EnqueueHeartbeat(HeartbeatResult result) => _heartbeats.Enqueue(result);
 
+    /// <summary>
+    /// Pre-stages a scripted marker list for the NEXT connection created by <see cref="Create"/>.
+    /// All items enqueued here are transferred to the new <see cref="FakeConnection"/> at creation
+    /// time, before the supervisor can start the poll loop, eliminating the setup race. Call this
+    /// before <see cref="EnsureConnectionAsync"/> so the script is in place when polls begin.
+    /// </summary>
+    /// <param name="markers">The marker list to deliver on the corresponding poll.</param>
+    public void EnqueueMarkers(IReadOnlyList<MapMarkerSnapshot> markers) =>
+        _pendingMarkerScript.Enqueue(markers);
+
     internal HeartbeatResult NextHeartbeat()
     {
         if (_heartbeats.TryDequeue(out var next))
@@ -63,6 +80,10 @@ internal HeartbeatResult NextHeartbeat()
     internal sealed class FakeConnection(SocketConnectOutcome outcome, FakeRustSocketSource source)
         : IRustServerConnection
     {
+        private readonly ConcurrentQueue<IReadOnlyList<MapMarkerSnapshot>> _markerScript = new();
+        private IReadOnlyList<MapMarkerSnapshot> _lastMarkers = [];
+        private bool _markerScriptStarted;
+
         /// <summary>Gets the messages sent via <see cref="SendTeamMessageAsync"/>.</summary>
         public List<string> SentMessages { get; } = [];
 
@@ -81,10 +102,14 @@ internal sealed class FakeConnection(SocketConnectOutcome outcome, FakeRustSocke
         /// <summary>The Steam ID passed to the most recent <see cref="PromoteToLeaderAsync"/> call.</summary>
         public ulong LastPromotedSteamId { get; private set; }
 
-        /// <summary>The markers returned by <see cref="GetMapMarkersAsync"/>. Defaults to empty (nothing on the map).</summary>
+        /// <summary>
+        /// The fallback markers returned by <see cref="GetMapMarkersAsync"/> when no scripted results remain.
+        /// Defaults to empty (nothing on the map). Callers that do not use <see cref="EnqueueMarkers"/> see
+        /// this value on every poll, matching the original Task-2 behavior.
+        /// </summary>
         public IReadOnlyList<MapMarkerSnapshot> MarkersResult { get; set; } = [];
 
-        /// <summary>When true, <see cref="GetMapMarkersAsync"/> throws (simulates a failed poll).</summary>
+        /// <summary>When true, <see cref="GetMapMarkersAsync"/> throws regardless of any enqueued script.</summary>
         public bool MarkersThrow { get; set; }
 
         /// <summary>The dimensions returned by <see cref="GetMapDimensionsAsync"/>. Defaults to a non-null snapshot.</summary>
@@ -123,17 +148,41 @@ public Task<bool> PromoteToLeaderAsync(ulong steamId, TimeSpan timeout, Cancella
         }
 
         public Task<IReadOnlyList<MapMarkerSnapshot>> GetMapMarkersAsync(TimeSpan timeout,
-            CancellationToken cancellationToken = default) =>
-            MarkersThrow
-                ? Task.FromException<IReadOnlyList<MapMarkerSnapshot>>(new InvalidOperationException("poll failed"))
-                : Task.FromResult(MarkersResult);
+            CancellationToken cancellationToken = default)
+        {
+            if (MarkersThrow)
+            {
+                return Task.FromException<IReadOnlyList<MapMarkerSnapshot>>(
+                    new InvalidOperationException("poll failed"));
+            }
+
+            if (_markerScript.TryDequeue(out var scripted))
+            {
+                _markerScriptStarted = true;
+                _lastMarkers = scripted;
+                return Task.FromResult(_lastMarkers);
+            }
+
+            // Once any scripted result has been dequeued, hold the last one (mirroring NextHeartbeat).
+            // If the script was never started, fall back to MarkersResult so Task-2 callers are unaffected.
+            return Task.FromResult(_markerScriptStarted ? _lastMarkers : MarkersResult);
+        }
 
         public Task<MapDimensions?> GetMapDimensionsAsync(TimeSpan timeout,
             CancellationToken cancellationToken = default) =>
             Task.FromResult(DimensionsResult);
 
         public ValueTask DisposeAsync() => ValueTask.CompletedTask;
 
+        /// <summary>
+        /// Enqueues a scripted marker list to be returned by the next <see cref="GetMapMarkersAsync"/> call.
+        /// Once the queue empties the last dequeued list is held and returned on every subsequent poll,
+        /// mirroring the heartbeat "hold last" pattern. Enqueued results take priority over
+        /// <see cref="MarkersResult"/>; if nothing has been enqueued, <see cref="MarkersResult"/> is used.
+        /// </summary>
+        /// <param name="markers">The marker list to return for the next poll.</param>
+        public void EnqueueMarkers(IReadOnlyList<MapMarkerSnapshot> markers) => _markerScript.Enqueue(markers);
+
         /// <summary>Raises <see cref="TeamMessageReceived"/> to simulate an inbound team chat line.</summary>
         /// <param name="line">The team chat line to raise.</param>
         public void RaiseTeamMessage(TeamChatLine line) => TeamMessageReceived?.Invoke(this, line);