Enabled perf tests as they are fast, added tests for remove all

Author: niemyjski

src/Foundatio.TestHarness/Caching/CacheClientTestsBase.cs

@@ -357,6 +357,64 @@ public virtual async Task CanUseScopedCachesAsync()
         }
     }
 
+    public virtual async Task CanRemoveAllAsync()
+    {
+        const int COUNT = 10000;
+
+        var cache = GetCacheClient();
+        if (cache == null)
+            return;
+
+        using (cache)
+        {
+            await cache.RemoveAllAsync();
+
+            var dictionary = Enumerable.Range(0, COUNT).ToDictionary(i => $"remove-all:{i}");
+
+            var sw = Stopwatch.StartNew();
+            await cache.SetAllAsync(dictionary);
+            sw.Stop();
+            _logger.LogInformation("Set All Time: {Elapsed:g}", sw.Elapsed);
+
+            sw = Stopwatch.StartNew();
+            Assert.Equal(COUNT, await cache.RemoveAllAsync());
+            sw.Stop();
+            _logger.LogInformation("Remove All Time: {Elapsed:g}", sw.Elapsed);
+
+            Assert.False(await cache.ExistsAsync("remove-all:0"));
+            Assert.False(await cache.ExistsAsync($"remove-all:{COUNT - 1}"));
+        }
+    }
+
+    public virtual async Task CanRemoveAllKeysAsync()
+    {
+        const int COUNT = 10000;
+
+        var cache = GetCacheClient();
+        if (cache == null)
+            return;
+
+        using (cache)
+        {
+            await cache.RemoveAllAsync();
+
+            var dictionary = Enumerable.Range(0, COUNT).ToDictionary(i => $"remove-all-keys:{i}");
+
+            var sw = Stopwatch.StartNew();
+            await cache.SetAllAsync(dictionary);
+            sw.Stop();
+            _logger.LogInformation("Set All Time: {Elapsed:g}", sw.Elapsed);
+
+            sw = Stopwatch.StartNew();
+            Assert.Equal(COUNT, await cache.RemoveAllAsync(dictionary.Keys));
+            sw.Stop();
+            _logger.LogInformation("Remove All Time: {Elapsed:g}", sw.Elapsed);
+
+            Assert.False(await cache.ExistsAsync("remove-all-keys:0"));
+            Assert.False(await cache.ExistsAsync($"remove-all-keys:{COUNT - 1}"));
+        }
+    }
+
     public virtual async Task CanRemoveByPrefixAsync()
     {
         var cache = GetCacheClient();
@@ -1036,7 +1094,7 @@ public virtual async Task MeasureThroughputAsync()
                 await cache.SetAsync("test", 13422);
                 await cache.SetAsync("flag", true);
                 Assert.Equal(13422, (await cache.GetAsync<int>("test")).Value);
-                Assert.Null(await cache.GetAsync<int>("test2"));
+                Assert.False((await cache.GetAsync<int>("test2")).HasValue);
                 Assert.True((await cache.GetAsync<bool>("flag")).Value);
             }
             sw.Stop();

src/Foundatio.TestHarness/Caching/HybridCacheClientTests.cs

@@ -81,6 +81,18 @@ public override Task CanSetAndGetObjectAsync()
         return base.CanSetAndGetObjectAsync();
     }
 
+    [Fact]
+    public override Task CanRemoveAllAsync()
+    {
+        return base.CanRemoveAllAsync();
+    }
+
+    [Fact]
+    public override Task CanRemoveAllKeysAsync()
+    {
+        return base.CanRemoveAllKeysAsync();
+    }
+
     [Fact]
     public override Task CanRemoveByPrefixAsync()
     {

tests/Foundatio.Tests/Caching/InMemoryCacheClientTests.cs

@@ -77,6 +77,18 @@ public override Task CanSetAndGetObjectAsync()
         return base.CanSetAndGetObjectAsync();
     }
 
+    [Fact]
+    public override Task CanRemoveAllAsync()
+    {
+        return base.CanRemoveAllAsync();
+    }
+
+    [Fact]
+    public override Task CanRemoveAllKeysAsync()
+    {
+        return base.CanRemoveAllKeysAsync();
+    }
+
     [Fact]
     public override Task CanRemoveByPrefixAsync()
     {
@@ -187,10 +199,28 @@ public override Task CanManageListRemoveExpirationAsync()
         return base.CanManageListRemoveExpirationAsync();
     }
 
+    [Fact]
+    public override Task MeasureThroughputAsync()
+    {
+        return base.MeasureThroughputAsync();
+    }
+
+    [Fact]
+    public override Task MeasureSerializerSimpleThroughputAsync()
+    {
+        return base.MeasureSerializerSimpleThroughputAsync();
+    }
+
+    [Fact]
+    public override Task MeasureSerializerComplexThroughputAsync()
+    {
+        return base.MeasureSerializerComplexThroughputAsync();
+    }
+
     [Fact]
     public async Task CanSetMaxItems()
     {
-        // run in tight loop so that the code is warmed up and we can catch timing issues
+        // run in a tight loop so that the code is warmed up and we can catch timing issues
         for (int x = 0; x < 5; x++)
         {
             var cache = new InMemoryCacheClient(o => o.MaxItems(10).CloneValues(true));

tests/Foundatio.Tests/Caching/InMemoryHybridCacheClientTests.cs

@@ -1,4 +1,4 @@
-using System.Threading.Tasks;
+using System.Threading.Tasks;
 using Foundatio.Caching;
 using Foundatio.Messaging;
 using Microsoft.Extensions.Logging;
@@ -34,6 +34,18 @@ public override Task CanTryGetAsync()
         return base.CanTryGetAsync();
     }
 
+    [Fact]
+    public override Task CanRemoveAllAsync()
+    {
+        return base.CanRemoveAllAsync();
+    }
+
+    [Fact]
+    public override Task CanRemoveAllKeysAsync()
+    {
+        return base.CanRemoveAllKeysAsync();
+    }
+
     [Fact]
     public override Task CanRemoveByPrefixAsync()
     {
@@ -90,19 +102,19 @@ public override Task WillWorkWithSets()
         return base.WillWorkWithSets();
     }
 
-    [Fact(Skip = "Performance Test")]
+    [Fact]
     public override Task MeasureThroughputAsync()
     {
         return base.MeasureThroughputAsync();
     }
 
-    [Fact(Skip = "Performance Test")]
+    [Fact]
     public override Task MeasureSerializerSimpleThroughputAsync()
     {
         return base.MeasureSerializerSimpleThroughputAsync();
     }
 
-    [Fact(Skip = "Performance Test")]
+    [Fact]
     public override Task MeasureSerializerComplexThroughputAsync()
     {
         return base.MeasureSerializerComplexThroughputAsync();