Tests: key fixes and cleanup

Also parallelizes most Config test for quicker runs - moved the unfriendly ones to Failover.

StackExchange.Redis.Tests/Booksleeve/Issues/Massive Delete.cs

@@ -9,41 +9,44 @@ namespace StackExchange.Redis.Tests.Booksleeve.Issues
 {
     public class Massive_Delete : BookSleeveTestBase
     {
-        public Massive_Delete(ITestOutputHelper output) : base(output)
+        public Massive_Delete(ITestOutputHelper output) : base(output) { }
+
+        private void Prep(int db, string key)
         {
+            var prefix = Me();
             using (var muxer = GetUnsecuredConnection(allowAdmin: true))
             {
                 GetServer(muxer).FlushDatabase(db);
                 Task last = null;
                 var conn = muxer.GetDatabase(db);
-                for (int i = 0; i < 100000; i++)
+                for (int i = 0; i < 10000; i++)
                 {
-                    string key = "key" + i;
-                    conn.StringSetAsync(key, key);
-                    last = conn.SetAddAsync(todoKey, key);
+                    string iKey = prefix + i;
+                    conn.StringSetAsync(iKey, iKey);
+                    last = conn.SetAddAsync(key, iKey);
                 }
                 conn.Wait(last);
             }
         }
 
-        private const int db = 4;
-        private const string todoKey = "todo";
-
-        [Fact]
+        [FactLongRunning]
         public async Task ExecuteMassiveDelete()
         {
+            const int db = 4;
+            var key = Me();
+            Prep(db, key);
             var watch = Stopwatch.StartNew();
             using (var muxer = GetUnsecuredConnection())
             using (var throttle = new SemaphoreSlim(1))
             {
                 var conn = muxer.GetDatabase(db);
-                var originally = await conn.SetLengthAsync(todoKey);
+                var originally = await conn.SetLengthAsync(key).ForAwait();
                 int keepChecking = 1;
                 Task last = null;
                 while (Volatile.Read(ref keepChecking) == 1)
                 {
                     throttle.Wait(); // acquire
-                    var x = conn.SetPopAsync(todoKey).ContinueWith(task =>
+                    var x = conn.SetPopAsync(key).ContinueWith(task =>
                     {
                         throttle.Release();
                         if (task.IsCompleted)
@@ -65,7 +68,7 @@ public async Task ExecuteMassiveDelete()
                     await last;
                 }
                 watch.Stop();
-                long remaining = await conn.SetLengthAsync(todoKey);
+                long remaining = await conn.SetLengthAsync(key).ForAwait();
                 Output.WriteLine("From {0} to {1}; {2}ms", originally, remaining,
                     watch.ElapsedMilliseconds);
 

StackExchange.Redis.Tests/Booksleeve/PubSub.cs

@@ -90,7 +90,7 @@ public async Task PubSubGetAllAnyOrder()
                 var syncLock = new object();
 
                 var data = new HashSet<int>();
-                await sub.SubscribeAsync(channel, (key, val) =>
+                await sub.SubscribeAsync(channel, (_, val) =>
                 {
                     bool pulse;
                     lock (data)
@@ -139,15 +139,15 @@ public async Task PubSubGetAllCorrectOrder()
                 var syncLock = new object();
 
                 var data = new List<int>(count);
-                var subChannel = await sub.SubscribeAsync(channel);
+                var subChannel = await sub.SubscribeAsync(channel).ForAwait();
 
-                await sub.PingAsync();
+                await sub.PingAsync().ForAwait();
 
                 async Task RunLoop()
                 {
                     while (!subChannel.IsCompleted)
                     {
-                        var work = await subChannel.ReadAsync();
+                        var work = await subChannel.ReadAsync().ForAwait();
                         int i = int.Parse(Encoding.UTF8.GetString(work.Message));
                         lock (data)
                         {
@@ -185,9 +185,8 @@ async Task RunLoop()
                 Assert.True(subChannel.IsCompleted);
                 await Assert.ThrowsAsync<ChannelClosedException>(async delegate
                 {
-                    var final = await subChannel.ReadAsync();
-                });
-
+                    var final = await subChannel.ReadAsync().ForAwait();
+                }).ForAwait();
             }
         }
 
@@ -203,7 +202,7 @@ public async Task PubSubGetAllCorrectOrder_OnMessage_Sync()
                 var syncLock = new object();
 
                 var data = new List<int>(count);
-                var subChannel = await sub.SubscribeAsync(channel);
+                var subChannel = await sub.SubscribeAsync(channel).ForAwait();
                 subChannel.OnMessage(msg =>
                 {
                     int i = int.Parse(Encoding.UTF8.GetString(msg.Message));
@@ -222,7 +221,7 @@ public async Task PubSubGetAllCorrectOrder_OnMessage_Sync()
                         }
                     }
                 });
-                await sub.PingAsync();
+                await sub.PingAsync().ForAwait();
 
                 lock (syncLock)
                 {
@@ -246,9 +245,8 @@ public async Task PubSubGetAllCorrectOrder_OnMessage_Sync()
                 Assert.True(subChannel.IsCompleted);
                 await Assert.ThrowsAsync<ChannelClosedException>(async delegate
                 {
-                    var final = await subChannel.ReadAsync();
-                });
-
+                    var final = await subChannel.ReadAsync().ForAwait();
+                }).ForAwait();
             }
         }
 
@@ -264,7 +262,7 @@ public async Task PubSubGetAllCorrectOrder_OnMessage_Async()
                 var syncLock = new object();
 
                 var data = new List<int>(count);
-                var subChannel = await sub.SubscribeAsync(channel);
+                var subChannel = await sub.SubscribeAsync(channel).ForAwait();
                 subChannel.OnMessage(msg =>
                 {
                     int i = int.Parse(Encoding.UTF8.GetString(msg.Message));
@@ -284,7 +282,7 @@ public async Task PubSubGetAllCorrectOrder_OnMessage_Async()
                     }
                     return i % 2 == 0 ? null : Task.CompletedTask;
                 });
-                await sub.PingAsync();
+                await sub.PingAsync().ForAwait();
 
                 lock (syncLock)
                 {
@@ -308,9 +306,8 @@ public async Task PubSubGetAllCorrectOrder_OnMessage_Async()
                 Assert.True(subChannel.IsCompleted);
                 await Assert.ThrowsAsync<ChannelClosedException>(async delegate
                 {
-                    var final = await subChannel.ReadAsync();
-                });
-
+                    var final = await subChannel.ReadAsync().ForAwait();
+                }).ForAwait();
             }
         }
 

StackExchange.Redis.Tests/Cluster.cs

@@ -46,7 +46,7 @@ public async Task ConnectUsesSingleSocket()
                     {
                         using (var muxer = Create(failMessage: i + ": ", log: sw))
                         {
-                            await Task.Delay(500);
+                            await Task.Delay(500).ForAwait();
                             foreach (var ep in muxer.GetEndPoints())
                             {
                                 var srv = muxer.GetServer(ep);

StackExchange.Redis.Tests/Config.cs

 using System;
-using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Threading;
-using System.Threading.Tasks;
 using Xunit;
 using Xunit.Abstractions;
 
 namespace StackExchange.Redis.Tests
 {
-    [Collection(NonParallelCollection.Name)]
     public class Config : TestBase
     {
         public Config(ITestOutputHelper output) : base (output) { }
@@ -140,30 +137,6 @@ public void ReadConfig()
             }
         }
 
-        [Fact]
-        public async System.Threading.Tasks.Task TestConfigureAsync()
-        {
-            using (var muxer = Create())
-            {
-                Thread.Sleep(1000);
-                Debug.WriteLine("About to reconfigure.....");
-                await muxer.ConfigureAsync().ForAwait();
-                Debug.WriteLine("Reconfigured");
-            }
-        }
-
-        [Fact]
-        public void TestConfigureSync()
-        {
-            using (var muxer = Create())
-            {
-                Thread.Sleep(1000);
-                Debug.WriteLine("About to reconfigure.....");
-                muxer.Configure();
-                Debug.WriteLine("Reconfigured");
-            }
-        }
-
         [Fact]
         public void GetTime()
         {

StackExchange.Redis.Tests/Failover.cs

@@ -45,6 +45,30 @@ private static ConfigurationOptions GetMasterSlaveConfig()
             };
         }
 
+        [Fact]
+        public async Task ConfigureAsync()
+        {
+            using (var muxer = Create())
+            {
+                Thread.Sleep(1000);
+                Output.WriteLine("About to reconfigure.....");
+                await muxer.ConfigureAsync().ForAwait();
+                Output.WriteLine("Reconfigured");
+            }
+        }
+
+        [Fact]
+        public void ConfigureSync()
+        {
+            using (var muxer = Create())
+            {
+                Thread.Sleep(1000);
+                Output.WriteLine("About to reconfigure.....");
+                muxer.Configure();
+                Output.WriteLine("Reconfigured");
+            }
+        }
+
         [Fact]
         public async Task ConfigVerifyReceiveConfigChangeBroadcast()
         {

StackExchange.Redis.Tests/Issues/Issue182.cs

@@ -27,17 +27,17 @@ public async Task SetMembers()
 
                 var key = Me();
                 const int count = (int)5e6;
-                var len = await db.SetLengthAsync(key);
+                var len = await db.SetLengthAsync(key).ForAwait();
 
                 if (len != count)
                 {
-                    await db.KeyDeleteAsync(key);
+                    await db.KeyDeleteAsync(key).ForAwait();
                     foreach (var _ in Enumerable.Range(0, count))
                         db.SetAdd(key, Guid.NewGuid().ToByteArray(), CommandFlags.FireAndForget);
 
-                    Assert.Equal(count, await db.SetLengthAsync(key)); // SCARD for set
+                    Assert.Equal(count, await db.SetLengthAsync(key).ForAwait()); // SCARD for set
                 }
-                var result = await db.SetMembersAsync(key);
+                var result = await db.SetMembersAsync(key).ForAwait();
                 Assert.Equal(count, result.Length); // SMEMBERS result length
             }
         }
@@ -55,25 +55,24 @@ public async Task SetUnion()
 
                 const int count = (int)5e6;
 
-                var len1 = await db.SetLengthAsync(key1);
-                var len2 = await db.SetLengthAsync(key2);
-                await db.KeyDeleteAsync(dstkey);
+                var len1 = await db.SetLengthAsync(key1).ForAwait();
+                var len2 = await db.SetLengthAsync(key2).ForAwait();
+                await db.KeyDeleteAsync(dstkey).ForAwait();
 
                 if (len1 != count || len2 != count)
                 {
-                    await db.KeyDeleteAsync(key1);
-                    await db.KeyDeleteAsync(key2);
-                    
+                    await db.KeyDeleteAsync(key1).ForAwait();
+                    await db.KeyDeleteAsync(key2).ForAwait();
 
                     foreach (var _ in Enumerable.Range(0, count))
                     {
                         db.SetAdd(key1, Guid.NewGuid().ToByteArray(), CommandFlags.FireAndForget);
                         db.SetAdd(key2, Guid.NewGuid().ToByteArray(), CommandFlags.FireAndForget);
                     }
-                    Assert.Equal(count, await db.SetLengthAsync(key1)); // SCARD for set 1
-                    Assert.Equal(count, await db.SetLengthAsync(key2)); // SCARD for set 2
+                    Assert.Equal(count, await db.SetLengthAsync(key1).ForAwait()); // SCARD for set 1
+                    Assert.Equal(count, await db.SetLengthAsync(key2).ForAwait()); // SCARD for set 2
                 }
-                await db.SetCombineAndStoreAsync(SetOperation.Union, dstkey, key1, key2);
+                await db.SetCombineAndStoreAsync(SetOperation.Union, dstkey, key1, key2).ForAwait();
                 var dstLen = db.SetLength(dstkey);
                 Assert.Equal(count * 2, dstLen); // SCARD for destination set
             }

StackExchange.Redis.Tests/Sentinel.cs

@@ -66,7 +66,7 @@ public void SentinelGetMasterAddressByNameNegativeTest()
         [Fact]
         public async Task SentinelGetMasterAddressByNameAsyncNegativeTest()
         {
-            var endpoint = await Server.SentinelGetMasterAddressByNameAsync("FakeServiceName");
+            var endpoint = await Server.SentinelGetMasterAddressByNameAsync("FakeServiceName").ForAwait();
             Assert.Null(endpoint);
         }
 

StackExchange.Redis/StackExchange/Redis/TaskExtensions.cs

@@ -26,5 +26,6 @@ public static Task<T> ObserveErrors<T>(this Task<T> task)
 
         public static ConfiguredTaskAwaitable ForAwait(this Task task) => task.ConfigureAwait(false);
         public static ConfiguredTaskAwaitable<T> ForAwait<T>(this Task<T> task) => task.ConfigureAwait(false);
+        public static ConfiguredValueTaskAwaitable<T> ForAwait<T>(this ValueTask<T> task) => task.ConfigureAwait(false);
     }
 }