refactor(alarms): reuse open scope for coordinator culture read + assert prompt replacement

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

Author: HandyS11

src/RustPlusBot.Features.Alarms/Pairing/AlarmPairingCoordinator.cs

@@ -37,24 +37,30 @@ internal sealed class AlarmPairingCoordinator(
     public async Task HandlePairedAsync(AlarmPairedEvent evt, CancellationToken cancellationToken)
     {
         ArgumentNullException.ThrowIfNull(evt);
-        if (await ExistsAsync(evt.GuildId, evt.ServerId, evt.EntityId, cancellationToken).ConfigureAwait(false))
-        {
-            return;
-        }
 
-        var channelId = await locator.GetChannelIdAsync(evt.GuildId, evt.ServerId, cancellationToken)
-            .ConfigureAwait(false);
-        if (channelId is not { } channel)
+        var scope = scopeFactory.CreateAsyncScope();
+        await using (scope.ConfigureAwait(false))
         {
-            return;
-        }
+            var store = scope.ServiceProvider.GetRequiredService<IAlarmStore>();
+            if (await store.ExistsAsync(evt.GuildId, evt.ServerId, evt.EntityId, cancellationToken).ConfigureAwait(false))
+            {
+                return;
+            }
 
-        var culture = await GetCultureAsync(evt.GuildId, cancellationToken).ConfigureAwait(false);
-        var defaultName = $"Alarm {evt.EntityId}";
-        var (embed, components) = renderer.RenderPrompt(evt.ServerId, evt.EntityId, defaultName, culture);
-        var messageId = await poster.EnsureAsync(channel, null, embed, components, cancellationToken)
-            .ConfigureAwait(false);
-        _pending[(evt.GuildId, evt.ServerId, evt.EntityId)] = new Pending(defaultName, messageId);
+            var channelId = await locator.GetChannelIdAsync(evt.GuildId, evt.ServerId, cancellationToken)
+                .ConfigureAwait(false);
+            if (channelId is not { } channel)
+            {
+                return;
+            }
+
+            var culture = await GetCultureAsync(scope.ServiceProvider, evt.GuildId, cancellationToken).ConfigureAwait(false);
+            var defaultName = $"Alarm {evt.EntityId}";
+            var (embed, components) = renderer.RenderPrompt(evt.ServerId, evt.EntityId, defaultName, culture);
+            var messageId = await poster.EnsureAsync(channel, null, embed, components, cancellationToken)
+                .ConfigureAwait(false);
+            _pending[(evt.GuildId, evt.ServerId, evt.EntityId)] = new Pending(defaultName, messageId);
+        }
     }
 
     /// <summary>Accepts a pending pairing: persist + replace prompt with the alarm embed. Race-guarded.</summary>
@@ -71,26 +77,26 @@ public async Task<bool> TryAcceptAsync(
         ulong acceptingUserId,
         CancellationToken cancellationToken)
     {
-        if (await ExistsAsync(guildId, serverId, entityId, cancellationToken).ConfigureAwait(false))
-        {
-            _pending.TryRemove((guildId, serverId, entityId), out _);
-            return false;
-        }
-
         _pending.TryGetValue((guildId, serverId, entityId), out var pending);
         var name = pending?.DefaultName ?? $"Alarm {entityId}";
 
         var scope = scopeFactory.CreateAsyncScope();
         await using (scope.ConfigureAwait(false))
         {
             var store = scope.ServiceProvider.GetRequiredService<IAlarmStore>();
+            if (await store.ExistsAsync(guildId, serverId, entityId, cancellationToken).ConfigureAwait(false))
+            {
+                _pending.TryRemove((guildId, serverId, entityId), out _);
+                return false;
+            }
+
             var added = await store.AddAsync(guildId, serverId, entityId, name, acceptingUserId, cancellationToken)
                 .ConfigureAwait(false);
 
             var channelId = await locator.GetChannelIdAsync(guildId, serverId, cancellationToken).ConfigureAwait(false);
             if (channelId is { } channel)
             {
-                var culture = await GetCultureAsync(guildId, cancellationToken).ConfigureAwait(false);
+                var culture = await GetCultureAsync(scope.ServiceProvider, guildId, cancellationToken).ConfigureAwait(false);
 
                 // The alarm is freshly accepted; unreachable is false (it just paired).
                 // The supervisor's prime path will re-render real state shortly.
@@ -118,24 +124,10 @@ await store.SetMessageIdAsync(guildId, serverId, entityId, mid, cancellationToke
     public bool TryDismiss(ulong guildId, Guid serverId, ulong entityId) =>
         _pending.TryRemove((guildId, serverId, entityId), out _);
 
-    private async Task<bool> ExistsAsync(ulong guildId, Guid serverId, ulong entityId, CancellationToken ct)
-    {
-        var scope = scopeFactory.CreateAsyncScope();
-        await using (scope.ConfigureAwait(false))
-        {
-            var store = scope.ServiceProvider.GetRequiredService<IAlarmStore>();
-            return await store.ExistsAsync(guildId, serverId, entityId, ct).ConfigureAwait(false);
-        }
-    }
-
-    private async Task<string> GetCultureAsync(ulong guildId, CancellationToken ct)
+    private static async Task<string> GetCultureAsync(IServiceProvider provider, ulong guildId, CancellationToken ct)
     {
-        var scope = scopeFactory.CreateAsyncScope();
-        await using (scope.ConfigureAwait(false))
-        {
-            var store = scope.ServiceProvider.GetRequiredService<IWorkspaceStore>();
-            return await store.GetCultureAsync(guildId, ct).ConfigureAwait(false);
-        }
+        var store = provider.GetRequiredService<IWorkspaceStore>();
+        return await store.GetCultureAsync(guildId, ct).ConfigureAwait(false);
     }
 
     private sealed record Pending(string DefaultName, ulong? MessageId);

tests/RustPlusBot.Features.Alarms.Tests/AlarmPairingCoordinatorTests.cs

@@ -91,6 +91,12 @@ public async Task Accept_persists_alarm_and_replaces_prompt()
         Assert.True(ok);
         await h.Store.Received(1).AddAsync(10UL, serverId, 42UL, "Alarm 42", 5UL, Arg.Any<CancellationToken>());
         Assert.Null(h.Coordinator.PendingName(10UL, serverId, 42UL)); // pending cleared
+        // The prompt (posted by HandlePairedAsync) must be replaced by the alarm embed (posted by TryAcceptAsync).
+        // EnsureAsync is called twice: once for the prompt (messageId=null), once for the embed (messageId=900 from prompt).
+        await h.Poster.Received(2).EnsureAsync(777UL, Arg.Any<ulong?>(), Arg.Any<global::Discord.Embed>(),
+            Arg.Any<global::Discord.MessageComponent>(), Arg.Any<CancellationToken>());
+        await h.Poster.Received(1).EnsureAsync(777UL, 900UL, Arg.Any<global::Discord.Embed>(),
+            Arg.Any<global::Discord.MessageComponent>(), Arg.Any<CancellationToken>());
     }
 
     [Fact]