Fix flaky test with client initial connection retry.

Signed-off-by: currantw <taylor.curran@improving.com>

Author: currantw

tests/Valkey.Glide.IntegrationTests/GenericCommandTests.cs

@@ -254,13 +254,13 @@ public async Task TestKeyIdleTime(BaseClient client)
 
         // Verify that idle time increases.
         TimeSpan idleTime2 = TimeSpan.Zero;
-        await Polling.AssertTrueAsync(
+        await Polling.WaitForTrueAsync(
             async () =>
             {
                 idleTime2 = Assert.NotNull(await client.ObjectIdleTimeAsync(key));
                 return idleTime2.TotalSeconds > idleTime1.TotalSeconds;
             },
-            $"Idle time expected to increase.");
+            "Idle time expected to increase.");
 
         // Verify that idle time is reset on access.
         _ = await client.GetAsync(key);

tests/Valkey.Glide.IntegrationTests/PubSubQueueTests.cs

@@ -27,7 +27,7 @@ public static async Task Queue_Channel_ReceivesMessage(bool isCluster, PubSubCha
         // Verify that message is received.
         PubSubMessageQueue queue = subscriber.PubSubQueue!;
 
-        await Polling.AssertTrue(
+        await Polling.WaitForTrue(
             () => queue.Count > 0,
             "Expected message was not received.",
             timeout: MaxDuration,
@@ -55,7 +55,7 @@ public static async Task Queue_WithHighVolume_HandlesAllMessages(bool isCluster)
         // Verify that all messages are received.
         PubSubMessageQueue queue = subscriber.PubSubQueue!;
 
-        await Polling.AssertTrue(
+        await Polling.WaitForTrue(
             () => queue!.Count >= messageCount,
             $"Expected {messageCount} messages but only received {queue.Count}.",
             timeout: MaxDuration,

tests/Valkey.Glide.IntegrationTests/PubSubUtils.cs

@@ -695,7 +695,7 @@ public static async Task AssertSubscribedAsync(BaseClient client, IEnumerable<Pu
         }
 
         // For lazy mode, retry until subscribed or timeout occurs.
-        await Polling.AssertTrueAsync(
+        await Polling.WaitForTrueAsync(
             () => IsSubscribedAsync(client, expectedSubscriptions),
             "Expected subscriptions not found.",
             timeout: MaxDuration,
@@ -727,7 +727,7 @@ public static async Task AssertNotSubscribedAsync(BaseClient client, IEnumerable
         }
 
         // For lazy mode, retry until unsubscribed or timeout occurs.
-        await Polling.AssertTrueAsync(
+        await Polling.WaitForTrueAsync(
             () => IsNotSubscribedAsync(client, notExpected),
             "Unexpected subscriptions found.",
             timeout: MaxDuration,

tests/Valkey.Glide.IntegrationTests/StackExchange/PubSubCommandTests.cs

@@ -648,7 +648,7 @@ private static async Task AssertHandlerReceives(ConcurrentBag<MessageInfo> actua
             return;
         }
 
-        await Polling.AssertTrue(
+        await Polling.WaitForTrue(
             () => actual.Count >= expected.Count,
             "Expected messages not received.",
             timeout: AssertTimeout,

tests/Valkey.Glide.TestUtils/Polling.cs

@@ -32,12 +32,12 @@ public static class Polling
     /// <param name="message">The message to report if the condition is not met within the timeout.</param>
     /// <param name="timeout">Maximum time to poll. Defaults to <see cref="DefaultTimeout"/>.</param>
     /// <param name="interval">Delay between attempts. Defaults to <see cref="DefaultInterval"/>.</param>
-    public static Task AssertTrue(
+    public static Task WaitForTrue(
         Func<bool> condition,
         string message,
         TimeSpan? timeout = null,
         TimeSpan? interval = null)
-        => AssertTrueAsync(()
+        => WaitForTrueAsync(()
             => Task.FromResult(condition()), message, timeout, interval);
 
     /// <summary>
@@ -48,22 +48,24 @@ public static Task AssertTrue(
     /// <param name="message">The message to report if the condition is not met within the timeout.</param>
     /// <param name="timeout">Maximum time to poll. Defaults to <see cref="DefaultTimeout"/>.</param>
     /// <param name="interval">Delay between attempts. Defaults to <see cref="DefaultInterval"/>.</param>
-    public static async Task AssertTrueAsync(
+    public static async Task WaitForTrueAsync(
         Func<Task<bool>> condition,
         string message,
         TimeSpan? timeout = null,
         TimeSpan? interval = null)
     {
-        using CancellationTokenSource cts = new(timeout ?? DefaultTimeout);
+        timeout ??= DefaultTimeout;
+        interval ??= DefaultInterval;
 
+        using CancellationTokenSource cts = new(timeout.Value);
         while (!cts.Token.IsCancellationRequested)
         {
             if (await condition())
             {
                 return;
             }
 
-            await Task.Delay(interval ?? DefaultInterval);
+            await Task.Delay(interval.Value);
         }
 
         Assert.Fail(message);

tests/Valkey.Glide.TestUtils/Server.cs

@@ -1,6 +1,7 @@
 // Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0
 
 using static Valkey.Glide.ConnectionConfiguration;
+using static Valkey.Glide.Errors;
 
 namespace Valkey.Glide.TestUtils;
 
@@ -16,6 +17,16 @@ public abstract class Server : IDisposable
     /// </summary>
     protected static readonly GlideString[] KillClientArgs = ["CLIENT", "KILL", "TYPE", "NORMAL"];
 
+    /// <summary>
+    /// Number of attempts to establish the initial client connection.
+    /// </summary>
+    private const int ConnectionAttempts = 5;
+
+    /// <summary>
+    /// Delay between initial connection attempts.
+    /// </summary>
+    private static readonly TimeSpan ConnectionRetryDelay = TimeSpan.FromMilliseconds(500);
+
     #endregion
     #region Fields
 
@@ -122,6 +133,44 @@ public void Dispose()
     /// </summary>
     public abstract Task KillClientsAsync();
 
+    #endregion
+    #region Protected Methods
+
+    /// <summary>
+    /// Creates a client using the given factory.
+    /// </summary>
+    /// <typeparam name="T">The client type produced by the factory.</typeparam>
+    /// <param name="factory">Factory that builds and connects a client.</param>
+    /// <returns>The connected client.</returns>
+    /// <exception cref="ConnectionException">
+    /// Thrown when a connection could not be established after all attempts.
+    /// </exception>
+    protected static async Task<T> CreateClientAsync<T>(Func<Task<T>> factory)
+        where T : BaseClient
+    {
+        ConnectionException? lastException = null;
+
+        /// Retry the initial connection attempt if needed to handle flakiness in CI environment.
+        for (int attempt = 1; attempt <= ConnectionAttempts; attempt++)
+        {
+            try
+            {
+                return await factory();
+            }
+            catch (ConnectionException ex)
+            {
+                lastException = ex;
+
+                if (attempt < ConnectionAttempts)
+                {
+                    await Task.Delay(ConnectionRetryDelay);
+                }
+            }
+        }
+
+        throw lastException!;
+    }
+
     #endregion
 }
 
@@ -150,7 +199,11 @@ public override async Task<BaseClient> CreateClientAsync()
     /// Builds and returns a cluster client for this server.
     /// </summary>
     public async Task<GlideClusterClient> CreateClusterClientAsync()
-        => await GlideClusterClient.CreateClient(CreateConfigBuilder().Build());
+    {
+        var config = CreateConfigBuilder().Build();
+        Task<GlideClusterClient> factory() => GlideClusterClient.CreateClient(config);
+        return await CreateClientAsync(factory);
+    }
 
     public override async Task SetPasswordAsync(string password)
     {
@@ -200,7 +253,11 @@ public override async Task<BaseClient> CreateClientAsync()
     /// Builds and returns a standalone client for this server.
     /// </summary>
     public async Task<GlideClient> CreateStandaloneClientAsync()
-        => await GlideClient.CreateClient(CreateConfigBuilder().Build());
+    {
+        var config = CreateConfigBuilder().Build();
+        Task<GlideClient> factory() => GlideClient.CreateClient(config);
+        return await CreateClientAsync(factory);
+    }
 
     public override async Task SetPasswordAsync(string password)
     {