Fixing ms memory cache ctor to work with ms configuration things in CacheManager. Added more tests for MS Configuraiton

Author: MichaConrad

src/CacheManager.Microsoft.Extensions.Caching.Memory/MemoryCacheHandle`1.cs

@@ -20,6 +20,18 @@ public class MemoryCacheHandle<TCacheValue> : BaseCacheHandle<TCacheValue>
 
         private volatile MemoryCache _cache = null;
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MemoryCacheHandle{TCacheValue}"/> class.
+        /// </summary>
+        /// <param name="managerConfiguration">The manager configuration.</param>
+        /// <param name="configuration">The cache handle configuration.</param>
+        /// <param name="loggerFactory">The logger factory.</param>
+        [CLSCompliant(false)]
+        public MemoryCacheHandle(ICacheManagerConfiguration managerConfiguration, CacheHandleConfiguration configuration, ILoggerFactory loggerFactory)
+            : this(managerConfiguration, configuration, loggerFactory, null)
+        {
+        }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="MemoryCacheHandle{TCacheValue}"/> class.
         /// </summary>
@@ -28,7 +40,7 @@ public class MemoryCacheHandle<TCacheValue> : BaseCacheHandle<TCacheValue>
         /// <param name="loggerFactory">The logger factory.</param>
         /// <param name="memoryCacheOptions">The vendor specific options.</param>
         [CLSCompliant(false)]
-        public MemoryCacheHandle(ICacheManagerConfiguration managerConfiguration, CacheHandleConfiguration configuration, ILoggerFactory loggerFactory, MemoryCacheOptions memoryCacheOptions = null)
+        public MemoryCacheHandle(ICacheManagerConfiguration managerConfiguration, CacheHandleConfiguration configuration, ILoggerFactory loggerFactory, MemoryCacheOptions memoryCacheOptions)
             : base(managerConfiguration, configuration)
         {
             NotNull(configuration, nameof(configuration));

src/CacheManager.StackExchange.Redis/RedisCacheHandle.cs

@@ -10,14 +10,6 @@
 
 namespace CacheManager.Redis
 {
-    internal enum ScriptType
-    {
-        Put,
-        Add,
-        Update,
-        Get
-    }
-
     /// <summary>
     /// Cache handle implementation for Redis.
     /// </summary>
@@ -660,17 +652,17 @@ protected override bool RemoveInternal(string key, string region)
         private void SubscribeKeyspaceNotifications()
         {
             _connection.Subscriber.Subscribe(
-                $"__keyevent@{_redisConfiguration.Database}__:expired",
-                (channel, key) =>
-                {
-                    var tupple = ParseKey(key);
-                    if (Logger.IsEnabled(LogLevel.Debug))
-                    {
-                        Logger.LogDebug("Got expired event for key '{0}:{1}'", tupple.Item2, tupple.Item1);
-                    }
-
-                    TriggerCacheSpecificRemove(tupple.Item1, tupple.Item2, CacheItemRemovedReason.Expired);
-                });
+                 $"__keyevent@{_redisConfiguration.Database}__:expired",
+                 (channel, key) =>
+                 {
+                     var tupple = ParseKey(key);
+                     if (Logger.IsEnabled(LogLevel.Debug))
+                     {
+                         Logger.LogDebug("Got expired event for key '{0}:{1}'", tupple.Item2, tupple.Item1);
+                     }
+
+                     TriggerCacheSpecificRemove(tupple.Item1, tupple.Item2, CacheItemRemovedReason.Expired);
+                 });
 
             _connection.Subscriber.Subscribe(
                 $"__keyevent@{_redisConfiguration.Database}__:evicted",

src/CacheManager.StackExchange.Redis/ScriptType.cs

@@ -0,0 +1,10 @@
+namespace CacheManager.Redis
+{
+    internal enum ScriptType
+    {
+        Put,
+        Add,
+        Update,
+        Get
+    }
+}

test/CacheManager.Tests/MicrosoftConfigurationTests.cs

@@ -51,6 +51,9 @@ public void Configuration_CacheManager_ComplexSingleManager()
             config.CacheHandleConfigurations[1].Key.Should().Be(key + "2");
             config.CacheHandleConfigurations[0].Name.Should().Be("handleName");
             config.CacheHandleConfigurations[1].Name.Should().Be("handleName2");
+
+            var cache = new BaseCacheManager<string>(config);
+            cache.Add("key", "value").Should().BeTrue();
         }
 
         [Fact]
@@ -80,13 +83,16 @@ public void Configuration_CacheManager_ComplexManyManager()
             };
 
             var configs = GetConfiguration(data).GetCacheConfigurations().ToArray();
-            for(var i = 1; i <= configs.Count(); i++)
+            for (var i = 1; i <= configs.Count(); i++)
             {
                 var config = configs[i - 1];
-                config.Name.Should().Be("myCacheName" +i);
+                config.Name.Should().Be("myCacheName" + i);
                 config.MaxRetries.Should().Be(i * 100);
                 config.RetryTimeout.Should().Be(i * 100);
                 config.CacheHandleConfigurations.Count.Should().Be(i);
+
+                var cache = new BaseCacheManager<string>(config);
+                cache.Add("key", "value").Should().BeTrue();
             }
         }
 
@@ -121,6 +127,9 @@ public void Configuration_CacheManager_ByNameFromMany()
             config.MaxRetries.Should().Be(200);
             config.RetryTimeout.Should().Be(200);
             config.CacheHandleConfigurations.Count.Should().Be(2);
+
+            var cache = new BaseCacheManager<string>(config);
+            cache.Add("key", "value").Should().BeTrue();
         }
 
         [Fact]
@@ -191,6 +200,8 @@ public void Configuration_CacheManager_AllProperties()
             config.MaxRetries.Should().Be(42);
             config.RetryTimeout.Should().Be(21);
             config.UpdateMode.Should().Be(CacheUpdateMode.Up);
+            var cache = new BaseCacheManager<string>(config);
+            cache.Add("key", "value").Should().BeTrue();
         }
 
         [Fact]
@@ -296,6 +307,7 @@ public void Configuration_CacheHandle_MinimalValid()
         }
 
 #if !NETCOREAPP
+
         [Fact]
         public void Configuration_CacheHandle_KnownType_SystemRuntime()
         {
@@ -309,7 +321,10 @@ public void Configuration_CacheHandle_KnownType_SystemRuntime()
             config.Name.Should().Be("name");
             config.CacheHandleConfigurations.Count.Should().Be(1);
             config.CacheHandleConfigurations[0].HandleType.Should().Be(typeof(SystemRuntimeCaching.MemoryCacheHandle<>));
+            var cache = new BaseCacheManager<string>(config);
+            cache.Add("key", "value").Should().BeTrue();
         }
+
 #endif
 
         [Fact]
@@ -364,6 +379,7 @@ public void Configuration_CacheHandle_KnownType_RedisB()
         }
 
 #if !NETCOREAPP
+
         [Fact]
         public void Configuration_CacheHandle_KnownType_CouchbaseNoKey()
         {
@@ -429,10 +445,13 @@ public void Configuration_CacheHandle_KnownType_MemcachedNoKey()
             action.ShouldThrow<InvalidOperationException>().WithMessage("*'key' or 'name'*");
         }
 
+#if MEMCACHEDENABLED
+
         [Fact]
+        [Trait("category", "memcached")]
         public void Configuration_CacheHandle_KnownType_Memcached()
         {
-            var key = Guid.NewGuid().ToString();
+            var key = "default";
             var data = new Dictionary<string, string>
             {
                 {"cacheManagers:0:name", "name"},
@@ -446,8 +465,13 @@ public void Configuration_CacheHandle_KnownType_Memcached()
             config.CacheHandleConfigurations[0].HandleType.Should().Be(typeof(Memcached.MemcachedCacheHandle<>));
             config.CacheHandleConfigurations[0].Key.Should().Be(key);
             config.CacheHandleConfigurations[0].Name.Should().NotBeNullOrWhiteSpace();  // name is random in this case
+
+            var cache = new BaseCacheManager<string>(config);
+            cache.Add(Guid.NewGuid().ToString(), "value").Should().BeTrue();
         }
 
+#endif
+
         [Fact]
         public void Configuration_CacheHandle_KnownType_MemcachedB()
         {
@@ -465,7 +489,7 @@ public void Configuration_CacheHandle_KnownType_MemcachedB()
             config.CacheHandleConfigurations[0].Name.Should().Be("name");
             config.CacheHandleConfigurations[0].Key.Should().Be("name");    // now key gets set to name
         }
-        
+
         [Fact]
         public void Configuration_CacheHandle_Type_MemcachedB()
         {
@@ -498,6 +522,7 @@ public void Configuration_CacheHandle_KnownType_Web()
             config.CacheHandleConfigurations.Count.Should().Be(1);
             config.CacheHandleConfigurations[0].HandleType.Should().Be(typeof(Web.SystemWebCacheHandle<>));
         }
+
 #endif
 
         [Fact]
@@ -513,8 +538,10 @@ public void Configuration_CacheHandle_KnownType_Dictionary()
             config.Name.Should().Be("name");
             config.CacheHandleConfigurations.Count.Should().Be(1);
             config.CacheHandleConfigurations[0].HandleType.Should().Be(typeof(Core.Internal.DictionaryCacheHandle<>));
-        }
 
+            var cache = new BaseCacheManager<string>(config);
+            cache.Add("key", "value").Should().BeTrue();
+        }
 
         [Fact]
         public void Configuration_CacheHandle_KnownType_MsMemory()
@@ -529,6 +556,9 @@ public void Configuration_CacheHandle_KnownType_MsMemory()
             config.Name.Should().Be("name");
             config.CacheHandleConfigurations.Count.Should().Be(1);
             config.CacheHandleConfigurations[0].HandleType.Should().Be(typeof(CacheManager.MicrosoftCachingMemory.MemoryCacheHandle<>));
+
+            var cache = new BaseCacheManager<string>(config);
+            cache.Add("key", "value").Should().BeTrue();
         }
 
         [Fact]
@@ -557,6 +587,9 @@ public void Configuration_CacheHandle_AllProperties()
             config.CacheHandleConfigurations[0].IsBackplaneSource.Should().BeTrue();
             config.CacheHandleConfigurations[0].Name.Should().Be("handleName");
             config.CacheHandleConfigurations[0].Key.Should().Be(key);
+
+            var cache = new BaseCacheManager<string>(config);
+            cache.Add("key", "value").Should().BeTrue();
         }
 
         [Fact]
@@ -704,7 +737,7 @@ public void Configuration_Backplane_InvalidKnownTypeB()
             Action act = () => GetConfiguration(data).GetCacheConfiguration("name");
             act.ShouldThrow<InvalidOperationException>().WithMessage("*Known backplane type 'Something' is invalid*");
         }
-        
+
         [Fact]
         public void Configuration_Backplane_Redis_MissingKey()
         {
@@ -719,7 +752,11 @@ public void Configuration_Backplane_Redis_MissingKey()
             act.ShouldThrow<InvalidOperationException>().WithMessage("*The key property is required*");
         }
 
+#if REDISENABLED
+
         [Fact]
+        [Trait("category", "Redis")]
+        [Trait("category", "Unreliable")]
         public void Configuration_Backplane_Redis_Valid()
         {
             var key = Guid.NewGuid().ToString();
@@ -742,8 +779,13 @@ public void Configuration_Backplane_Redis_Valid()
             config.BackplaneConfigurationKey.Should().Be(key);
             config.BackplaneType.Should().Be(typeof(Redis.RedisCacheBackplane));
             config.HasBackplane.Should().BeTrue();
+
+            var cache = new BaseCacheManager<string>(config);
+            cache.Add(Guid.NewGuid().ToString(), "value").Should().BeTrue();
         }
 
+#endif
+
         [Fact]
         public void Configuration_Backplane_SomeType_Valid()
         {
@@ -834,6 +876,9 @@ public void Configuration_LoggerFactory_KnownType_Valid()
 
             var config = GetConfiguration(data).GetCacheConfiguration("name");
             config.LoggerFactoryType.Should().Be(typeof(Logging.MicrosoftLoggerFactoryAdapter));
+
+            var cache = new BaseCacheManager<string>(config);
+            cache.Add("key", "value").Should().BeTrue();
         }
 
         [Fact]
@@ -901,6 +946,7 @@ public void Configuration_Serializer_SomeType_Valid()
         }
 
 #if !NETCOREAPP
+
         [Fact]
         public void Configuration_Serializer_KnownType_Binary()
         {
@@ -921,6 +967,7 @@ public void Configuration_Serializer_KnownType_Binary()
             config.SerializerType.Should().Be(typeof(Core.Internal.BinaryCacheSerializer));
             act.ShouldNotThrow();
         }
+
 #endif
 
         [Fact]
@@ -1024,7 +1071,7 @@ public void Configuration_Serializer_KnownType_BondCompact()
                 cache.Add("key", "value");
             };
 
-            config.SerializerType.Should().Be(typeof(Serialization.Bond.BondCompactBinaryCacheSerializer));            
+            config.SerializerType.Should().Be(typeof(Serialization.Bond.BondCompactBinaryCacheSerializer));
             act.ShouldNotThrow();
         }
 
@@ -1049,7 +1096,6 @@ public void Configuration_Serializer_KnownType_BondFast()
             act.ShouldNotThrow();
         }
 
-
         [Fact]
         public void Configuration_Serializer_KnownType_BondJosn()
         {
@@ -1168,7 +1214,7 @@ public void Configuration_Redis_Invalid_IsSsl()
             Action act = () => GetConfiguration(data).LoadRedisConfigurations();
             act.ShouldThrow<InvalidOperationException>().WithMessage("*Failed to convert 'invalid'*");
         }
-        
+
         [Fact]
         public void Configuration_Redis_Properties()
         {

test/CacheManager.Tests/xunit.runner.json

@@ -1,8 +1,8 @@
 {
-  "parallelizeTestCollections": true,
+  "parallelizeTestCollections": false,
   "methodDisplay": "method",
   "preEnumerateTheories": false,
-  "diagnosticMessages": true,
+  "diagnosticMessages": false,
   "longRunningTestSeconds": 5,
   "maxParallelThreads": 2
 }