fix(test): deflake InfoMapHostedService tests (publish-before-subscribe race)

Ready_key_publishes_InfoMapReadyEvent_once_per_requester failed on the Linux
CI runner with 0 events received. Root cause: the test collected events by
subscribing to the real InMemoryEventBus from a Task.Run — that bus drops
events published before a subscriber is active, and the service's first tick
(10 ms poll) can announce the key before the background subscription starts
on a loaded runner. The key is announced at most once, so the events are
gone for good and the test times out at 0.

Replace the racy live-bus collector with a small CapturingEventBus fake that
records every published InfoMapReadyEvent synchronously — deterministic, and
the tests now finish in ~170 ms instead of riding the 5 s deadline. The
Connect_registers test keeps the real bus (it re-publishes in a loop, so the
subscribe race self-heals there).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: HandyS11

tests/RustPlusBot.Features.Map.Tests/Hosting/InfoMapHostedServiceTests.cs

@@ -1,3 +1,4 @@
+using System.Collections.Concurrent;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging.Abstractions;
 using Microsoft.Extensions.Options;
@@ -36,6 +37,17 @@ private static IOptions<MapOptions> ShortPollOptions() => Options.Create(new Map
         }
     });
 
+    /// <summary>
+    /// A fake bus that records every published <see cref="InfoMapReadyEvent"/>. Deterministic, unlike
+    /// subscribing to the real <see cref="InMemoryEventBus"/> from a background task: that bus drops
+    /// events published before the subscriber is active, which races the service's first tick.
+    /// </summary>
+    private static (IEventBus Bus, ConcurrentQueue<InfoMapReadyEvent> Received) CapturingBus()
+    {
+        var bus = new CapturingEventBus();
+        return (bus, bus.Received);
+    }
+
     [Fact]
     public async Task Ready_key_publishes_InfoMapReadyEvent_once_per_requester()
     {
@@ -55,16 +67,10 @@ public async Task Ready_key_publishes_InfoMapReadyEvent_once_per_requester()
         var driver = new RustMapsGenerationDriver(client, coordinator, NullLogger<RustMapsGenerationDriver>.Instance);
 
         var query = Substitute.For<IRustServerQuery>();
-        var bus = new InMemoryEventBus();
-        var received = new List<InfoMapReadyEvent>();
-        using var collectCts = new CancellationTokenSource();
-        _ = Task.Run(async () =>
-        {
-            await foreach (var evt in bus.SubscribeAsync<InfoMapReadyEvent>(collectCts.Token))
-            {
-                received.Add(evt);
-            }
-        });
+        // Capture publishes off a substituted bus: the real InMemoryEventBus drops events published
+        // before a subscriber is active, so collecting via a background subscription races the
+        // service's first tick and flakes on slow CI runners.
+        var (bus, received) = CapturingBus();
 
         var service = new InfoMapHostedService(
             bus, coordinator, driver, query, ShortPollOptions(),
@@ -82,7 +88,6 @@ public async Task Ready_key_publishes_InfoMapReadyEvent_once_per_requester()
         finally
         {
             await service.StopAsync(CancellationToken.None);
-            await collectCts.CancelAsync();
         }
 
         Assert.Equal(2, received.Count);
@@ -120,16 +125,7 @@ public async Task Tick_registers_and_generates_connected_servers_without_any_con
         IReadOnlyList<(ulong GuildId, Guid ServerId)> connectable = [(GuildA, serverId)];
         store.ListConnectableServersAsync(Arg.Any<CancellationToken>()).Returns(connectable);
 
-        var bus = new InMemoryEventBus();
-        var received = new List<InfoMapReadyEvent>();
-        using var collectCts = new CancellationTokenSource();
-        _ = Task.Run(async () =>
-        {
-            await foreach (var evt in bus.SubscribeAsync<InfoMapReadyEvent>(collectCts.Token))
-            {
-                received.Add(evt);
-            }
-        });
+        var (bus, received) = CapturingBus();
 
         var service = new InfoMapHostedService(
             bus, coordinator, driver, query, ShortPollOptions(),
@@ -139,15 +135,14 @@ public async Task Tick_registers_and_generates_connected_servers_without_any_con
         try
         {
             var deadline = DateTimeOffset.UtcNow.AddSeconds(5);
-            while (DateTimeOffset.UtcNow < deadline && received.Count < 1)
+            while (DateTimeOffset.UtcNow < deadline && received.IsEmpty)
             {
                 await Task.Delay(20);
             }
         }
         finally
         {
             await service.StopAsync(CancellationToken.None);
-            await collectCts.CancelAsync();
         }
 
         // No ConnectionStatusChangedEvent was ever published — registration came from the store tick.
@@ -206,4 +201,24 @@ public async Task Connect_registers_the_servers_world_key_with_the_coordinator()
         Assert.Contains(Key, coordinator.PendingKeys());
         Assert.Contains((GuildA, serverId), coordinator.Requesters(Key));
     }
+
+    private sealed class CapturingEventBus : IEventBus
+    {
+        public ConcurrentQueue<InfoMapReadyEvent> Received { get; } = new();
+
+        public ValueTask PublishAsync<TEvent>(TEvent @event, CancellationToken cancellationToken = default)
+            where TEvent : notnull
+        {
+            if (@event is InfoMapReadyEvent ready)
+            {
+                Received.Enqueue(ready);
+            }
+
+            return ValueTask.CompletedTask;
+        }
+
+        public IAsyncEnumerable<TEvent> SubscribeAsync<TEvent>(CancellationToken cancellationToken = default)
+            where TEvent : notnull =>
+            AsyncEnumerable.Empty<TEvent>(); // No live subscriptions needed: assertions read Received.
+    }
 }