Merge latest in

Author: NickCraver

tests/StackExchange.Redis.Tests/CancellationTests.cs

@@ -3,79 +3,30 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Xunit;
-using Xunit.Abstractions;
 
 namespace StackExchange.Redis.Tests;
 
-#if !NET6_0_OR_GREATER
-internal static class TaskExtensions
-{
-    // suboptimal polyfill version of the .NET 6+ API; I'm not recommending this for production use,
-    // but it's good enough for tests
-    public static Task<T> WaitAsync<T>(this Task<T> task, CancellationToken cancellationToken)
-    {
-        if (task.IsCompleted || !cancellationToken.CanBeCanceled) return task;
-        return Wrap(task, cancellationToken);
-
-        static async Task<T> Wrap(Task<T> task, CancellationToken cancellationToken)
-        {
-            var tcs = new TaskCompletionSource<T>();
-            using var reg = cancellationToken.Register(() => tcs.TrySetCanceled(cancellationToken));
-            _ = task.ContinueWith(t =>
-            {
-                if (t.IsCanceled) tcs.TrySetCanceled();
-                else if (t.IsFaulted) tcs.TrySetException(t.Exception!);
-                else tcs.TrySetResult(t.Result);
-            });
-            return await tcs.Task;
-        }
-    }
-
-    public static Task<T> WaitAsync<T>(this Task<T> task, TimeSpan timeout)
-    {
-        if (task.IsCompleted) return task;
-        return Wrap(task, timeout);
-
-        static async Task<T> Wrap(Task<T> task, TimeSpan timeout)
-        {
-            Task other = Task.Delay(timeout);
-            var first = await Task.WhenAny(task, other);
-            if (ReferenceEquals(first, other))
-            {
-                throw new TimeoutException();
-            }
-            return await task;
-        }
-    }
-}
-#endif
-
 [Collection(SharedConnectionFixture.Key)]
-public class CancellationTests : TestBase
+public class CancellationTests(ITestOutputHelper output, SharedConnectionFixture fixture) : TestBase(output, fixture)
 {
-    public CancellationTests(ITestOutputHelper output, SharedConnectionFixture fixture) : base(output, fixture) { }
-
     [Fact]
     public async Task WithCancellation_CancelledToken_ThrowsOperationCanceledException()
     {
-        using var conn = Create();
+        await using var conn = Create();
         var db = conn.GetDatabase();
 
         using var cts = new CancellationTokenSource();
         cts.Cancel(); // Cancel immediately
 
-        await Assert.ThrowsAnyAsync<OperationCanceledException>(async () =>
-        {
-            await db.StringSetAsync(Me(), "value").WaitAsync(cts.Token);
-        });
+        await Assert.ThrowsAnyAsync<OperationCanceledException>(async () => await db.StringSetAsync(Me(), "value").WaitAsync(cts.Token));
     }
 
     private IInternalConnectionMultiplexer Create() => Create(syncTimeout: 10_000);
 
     [Fact]
     public async Task WithCancellation_ValidToken_OperationSucceeds()
     {
-        using var conn = Create();
+        await using var conn = Create();
         var db = conn.GetDatabase();
 
         using var cts = new CancellationTokenSource();
@@ -89,13 +40,13 @@ public async Task WithCancellation_ValidToken_OperationSucceeds()
 
     private void Pause(IDatabase db)
     {
-        db.Execute("client", new object[] { "pause", ConnectionPauseMilliseconds }, CommandFlags.FireAndForget);
+        db.Execute("client", ["pause", ConnectionPauseMilliseconds], CommandFlags.FireAndForget);
     }
 
     [Fact]
     public async Task WithTimeout_ShortTimeout_Async_ThrowsOperationCanceledException()
     {
-        using var conn = Create();
+        await using var conn = Create();
         var db = conn.GetDatabase();
 
         var watch = Stopwatch.StartNew();
@@ -122,7 +73,7 @@ public async Task WithTimeout_ShortTimeout_Async_ThrowsOperationCanceledExceptio
     [Fact]
     public async Task WithoutCancellation_OperationsWorkNormally()
     {
-        using var conn = Create();
+        await using var conn = Create();
         var db = conn.GetDatabase();
 
         // No cancellation - should work normally
@@ -171,7 +122,7 @@ private static CancellationTokenSource CreateCts(CancelStrategy strategy)
     [InlineData(CancelStrategy.Manual)]
     public async Task CancellationDuringOperation_Async_CancelsGracefully(CancelStrategy strategy)
     {
-        using var conn = Create();
+        await using var conn = Create();
         var db = conn.GetDatabase();
 
         var watch = Stopwatch.StartNew();

tests/StackExchange.Redis.Tests/TaskExtensions.cs

@@ -0,0 +1,49 @@
+#if !NET
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace StackExchange.Redis.Tests;
+
+internal static class TaskExtensions
+{
+    // suboptimal polyfill version of the .NET 6+ API; I'm not recommending this for production use,
+    // but it's good enough for tests
+    public static Task<T> WaitAsync<T>(this Task<T> task, CancellationToken cancellationToken)
+    {
+        if (task.IsCompleted || !cancellationToken.CanBeCanceled) return task;
+        return Wrap(task, cancellationToken);
+
+        static async Task<T> Wrap(Task<T> task, CancellationToken cancellationToken)
+        {
+            var tcs = new TaskCompletionSource<T>();
+            using var reg = cancellationToken.Register(() => tcs.TrySetCanceled(cancellationToken));
+            _ = task.ContinueWith(t =>
+            {
+                if (t.IsCanceled) tcs.TrySetCanceled();
+                else if (t.IsFaulted) tcs.TrySetException(t.Exception!);
+                else tcs.TrySetResult(t.Result);
+            });
+            return await tcs.Task;
+        }
+    }
+
+    public static Task<T> WaitAsync<T>(this Task<T> task, TimeSpan timeout)
+    {
+        if (task.IsCompleted) return task;
+        return Wrap(task, timeout);
+
+        static async Task<T> Wrap(Task<T> task, TimeSpan timeout)
+        {
+            Task other = Task.Delay(timeout);
+            var first = await Task.WhenAny(task, other);
+            if (ReferenceEquals(first, other))
+            {
+                throw new TimeoutException();
+            }
+            return await task;
+        }
+    }
+}
+
+#endif