Optimized CachingTestPlugin service replacement (#247)

Author: ivaylokenov

src/MyTested.AspNetCore.Mvc.Caching/Plugins/CachingTestPlugin.cs

@@ -1,68 +1,52 @@
 namespace MyTested.AspNetCore.Mvc.Plugins
 {
     using System;
-    using System.Linq;
     using Internal;
     using Internal.Contracts;
     using Microsoft.Extensions.Caching.Memory;
     using Microsoft.Extensions.DependencyInjection;
     using Internal.Services;
     using Microsoft.Extensions.Caching.Distributed;
-    using Utilities.Validators;
 
     public class CachingTestPlugin : IServiceRegistrationPlugin
     {
-        private readonly Type defaultCachingServiceType = typeof(IMemoryCache);
-        private readonly Type defaultCachingImplementationType = typeof(MemoryCache);
+        private readonly Type defaultMemoryCacheServiceType = typeof(IMemoryCache);
+        private readonly Type defaultMemoryCacheImplementationType = typeof(MemoryCache);
 
-        private readonly Type defaultDistributedCachingServiceType = typeof(IDistributedCache);
-        private readonly Type defaultDistributedCachingImplementationType = typeof(MemoryDistributedCache);
+        private readonly Type defaultDistributedCacheServiceType = typeof(IDistributedCache);
+        private readonly Type defaultDistributedCacheImplementationType = typeof(MemoryDistributedCache);
+
+        private bool replaceMemoryCache = false;
+        private bool replaceDistributedCache = false;
 
         public Func<ServiceDescriptor, bool> ServiceSelectorPredicate
             => serviceDescriptor =>
             {
-                var isSupportedService = 
-                    serviceDescriptor.ServiceType == this.defaultCachingServiceType ||
-                    serviceDescriptor.ServiceType == this.defaultDistributedCachingServiceType;
+                this.replaceMemoryCache = this.replaceMemoryCache ||
+                    (serviceDescriptor.ServiceType == this.defaultMemoryCacheServiceType &&
+                    serviceDescriptor.ImplementationType == this.defaultMemoryCacheImplementationType);
 
-                var isSupportedImplementation =
-                    serviceDescriptor.ImplementationType == this.defaultCachingImplementationType ||
-                    serviceDescriptor.ImplementationType == this.defaultDistributedCachingImplementationType;
+                this.replaceDistributedCache = this.replaceDistributedCache ||
+                    (serviceDescriptor.ServiceType == this.defaultDistributedCacheServiceType &&
+                    serviceDescriptor.ImplementationType == this.defaultDistributedCacheImplementationType);
 
-                return isSupportedService && isSupportedImplementation;
+                return replaceMemoryCache || replaceDistributedCache;
             };
 
         public Action<IServiceCollection> ServiceRegistrationDelegate
-        {
-            get
+            => serviceCollection =>
             {
-                return serviceCollection =>
+                if (this.replaceMemoryCache)
                 {
-                    CommonValidator.CheckForNullReference(serviceCollection);
-
-                    if (this.ShouldReplace(serviceCollection, this.defaultCachingServiceType, this.defaultCachingImplementationType))
-                    {
-                        serviceCollection.ReplaceMemoryCache();
-                        TestHelper.GlobalTestCleanup += () => TestServiceProvider.GetService<IMemoryCache>()?.Dispose();
-                    }
-
-                    if (this.ShouldReplace(serviceCollection, this.defaultDistributedCachingServiceType, this.defaultDistributedCachingImplementationType))
-                    {
-                        serviceCollection.ReplaceDistributedCache();
-                        TestHelper.GlobalTestCleanup += () => TestServiceProvider.GetService<IDistributedCacheMock>()?.Dispose();
-                    }
-                };
-            }
-        }
+                    serviceCollection.ReplaceMemoryCache();
+                    TestHelper.GlobalTestCleanup += () => TestServiceProvider.GetService<IMemoryCache>()?.Dispose();
+                }
 
-        private bool ShouldReplace(IServiceCollection serviceCollection, Type serviceType, Type implementationType)
-        {
-            var existingService = serviceCollection
-                .FirstOrDefault(s => s.ServiceType == serviceType);
-
-            return existingService == null || 
-                   existingService.ImplementationType == implementationType;
-        }
-            
+                if (this.replaceDistributedCache)
+                {
+                    serviceCollection.ReplaceDistributedCache();
+                    TestHelper.GlobalTestCleanup += () => TestServiceProvider.GetService<IDistributedCacheMock>()?.Dispose();
+                }
+            };
     }
 }

test/MyTested.AspNetCore.Mvc.Caching.Test/PluginsTests/CachingTestPluginTest.cs

@@ -1,33 +1,32 @@
 namespace MyTested.AspNetCore.Mvc.Test.PluginsTests
 {
     using System;
+    using Microsoft.Extensions.Caching.Distributed;
     using Microsoft.Extensions.Caching.Memory;
     using Microsoft.Extensions.DependencyInjection;
     using Plugins;
     using Xunit;
 
     public class CachingTestPluginTest
     {
-        [Fact]
-        public void ShouldThrowArgumentNullExceptionWithInvalidServiceCollection()
-        {
-            var testPlugin = new CachingTestPlugin();
-
-            Assert.Throws<NullReferenceException>(() => testPlugin.ServiceRegistrationDelegate(null));
-        }
-
         [Fact]
         public void ShouldInvokeMethodOfTypeVoidWithValidServiceCollection()
         {
             var testPlugin = new CachingTestPlugin();
             var serviceCollection = new ServiceCollection();
 
+            serviceCollection.AddMemoryCache();
+            serviceCollection.AddDistributedMemoryCache();
+
             testPlugin.ServiceRegistrationDelegate(serviceCollection);
 
-            var methodReturnType = testPlugin.ServiceRegistrationDelegate.Method.ReturnType.Name;
+            Assert.Contains(
+                serviceCollection, 
+                s => s.ServiceType == typeof(IMemoryCache) && s.ImplementationType == typeof(MemoryCache));
 
-            Assert.True(methodReturnType == "Void");
-            Assert.Contains(serviceCollection, s => s.ServiceType == typeof(IMemoryCache));
+            Assert.Contains(
+                serviceCollection, 
+                s => s.ServiceType == typeof(IDistributedCache) && s.ImplementationType == typeof(MemoryDistributedCache));
         }
     }
 }