extensions package for a named client

Kentico.Kontent.Delivery.Abstractions/IDeliveryClientFactory.cs

@@ -1,7 +1,7 @@
 namespace Kentico.Kontent.Delivery.Abstractions
 {
     /// <summary>
-    /// Defines a methods for getting a <see cref="IDeliveryClient"/>
+    /// Defines a method for getting a named <see cref="IDeliveryClient"/>
     /// </summary>
     public interface IDeliveryClientFactory
     {
@@ -12,10 +12,10 @@ public interface IDeliveryClientFactory
         /// <returns>Returns an <see cref="IDeliveryClient"/> instance with the given name.</returns>
         IDeliveryClient Get(string name);
 
-        /// <summary>
-        /// Returns a default instance of the <see cref="IDeliveryClient"/>.
-        /// </summary>
-        /// <returns>Returns a default instance of the <see cref="IDeliveryClient"/>.</returns>
+        /// <summary>	
+        /// Returns a default instance of the <see cref="IDeliveryClient"/>.	
+        /// </summary>	
+        /// <returns>Returns a default instance of the <see cref="IDeliveryClient"/>.</returns>	
         IDeliveryClient Get();
     }
 }

Kentico.Kontent.Delivery.Caching.Tests/CacheManagerFactoryTests.cs

@@ -0,0 +1,40 @@
+using FakeItEasy;
+using FluentAssertions;
+using Kentico.Kontent.Delivery.Caching.Factories;
+using Microsoft.Extensions.Caching.Distributed;
+using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Options;
+using Xunit;
+
+namespace Kentico.Kontent.Delivery.Caching.Tests
+{
+    public class CacheManagerFactoryTests
+    {
+        private IOptions<DeliveryCacheOptions> _options;
+        private IDistributedCache _distributedCache;
+        private IMemoryCache _memoryCache;
+
+        public CacheManagerFactoryTests()
+        {
+            _options = A.Fake<IOptions<DeliveryCacheOptions>>();
+            _distributedCache = A.Fake<IDistributedCache>();
+            _memoryCache = A.Fake<IMemoryCache>();
+        }
+
+        [Fact]
+        public void Create_DistributedCache()
+        {
+            var deliveryCacheManager = CacheManagerFactory.Create(_distributedCache, _options);
+
+            deliveryCacheManager.Should().NotBeNull();
+        }
+
+        [Fact]
+        public void Create_MemoryCache()
+        {
+            var deliveryCacheManager = CacheManagerFactory.Create(_memoryCache, _options);
+
+            deliveryCacheManager.Should().NotBeNull();
+        }
+    }
+}

Kentico.Kontent.Delivery.Caching.Tests/ServiceCollectionExtensionsTests.cs

@@ -26,112 +26,16 @@ public void AddDeliveryClientCacheWithDeliveryCacheOptions_ThrowsMissingTypeRegi
             Assert.Throws<MissingTypeRegistrationException>(() => _serviceCollection.AddDeliveryClientCache(new DeliveryCacheOptions() { CacheType = cacheType }));
         }
 
-        [Theory]
-        [InlineData(CacheTypeEnum.Memory)]
-        [InlineData(CacheTypeEnum.Distributed)]
-        public void AddDeliveryClient_WithNoCache_GetClient(CacheTypeEnum cacheType)
-        {
-            _serviceCollection.AddDeliveryClient(new DeliveryOptions() { ProjectId = Guid.NewGuid().ToString() });
-            _serviceCollection.AddDeliveryClientCache(new DeliveryCacheOptions()
-            {
-                CacheType = cacheType
-            });
-
-            var sp = _serviceCollection.BuildServiceProvider();
-            var factory = sp.GetRequiredService<IDeliveryClientFactory>();
-
-            var client = factory.Get();
-
-            client.Should().NotBeNull();
-        }
-
-        [Theory]
-        [InlineData(CacheTypeEnum.Memory)]
-        [InlineData(CacheTypeEnum.Distributed)]
-        public void AddDeliveryClient_CacheWithDeliveryCacheOptions_GetNull(CacheTypeEnum cacheType)
-        {
-            _serviceCollection.AddDeliveryClient(new DeliveryOptions() { ProjectId = Guid.NewGuid().ToString() });
-            _serviceCollection.AddDeliveryClientCache(new DeliveryCacheOptions()
-            {
-                CacheType = cacheType
-            });
-
-            var sp = _serviceCollection.BuildServiceProvider();
-            var factory = sp.GetRequiredService<IDeliveryClientFactory>();
-
-            var client = factory.Get("WrongName");
-
-            client.Should().BeNull();
-        }
-
-        [Theory]
-        [InlineData(CacheTypeEnum.Memory)]
-        [InlineData(CacheTypeEnum.Distributed)]
-        public void AddDeliveryNamedClient_CacheWithDeliveryCacheOptions_GetNamedClient(CacheTypeEnum cacheType)
-        {
-            _serviceCollection.AddDeliveryClient("named", new DeliveryOptions() { ProjectId = Guid.NewGuid().ToString() });
-            _serviceCollection.AddDeliveryClientCache("named", new DeliveryCacheOptions()
-            {
-                CacheType = cacheType
-            });
-
-            var sp = _serviceCollection.BuildServiceProvider();
-            var factory = sp.GetRequiredService<IDeliveryClientFactory>();
-
-            var client = factory.Get("named");
-
-            client.Should().NotBeNull();
-        }
-
-        [Theory]
-        [InlineData(CacheTypeEnum.Memory)]
-        [InlineData(CacheTypeEnum.Distributed)]
-        public void AddDeliveryNamedClient_CacheWithDeliveryCacheOptions_GetNull(CacheTypeEnum cacheType)
-        {
-            _serviceCollection.AddDeliveryClient("named", new DeliveryOptions() { ProjectId = Guid.NewGuid().ToString() });
-            _serviceCollection.AddDeliveryClientCache("named", new DeliveryCacheOptions()
-            {
-                CacheType = cacheType
-            });
-
-            var sp = _serviceCollection.BuildServiceProvider();
-            var factory = sp.GetRequiredService<IDeliveryClientFactory>();
-
-            var client = factory.Get("WrongName");
-
-            client.Should().BeNull();
-        }
-
-        [Theory]
-        [InlineData(CacheTypeEnum.Memory)]
-        [InlineData(CacheTypeEnum.Distributed)]
-        public void AddDeliveryClientCacheNamedWithDeliveryCacheOptions_ThrowsInvalidOperationException(CacheTypeEnum cacheType)
-        {
-            Assert.Throws<MissingTypeRegistrationException>(() => _serviceCollection.AddDeliveryClientCache("named", new DeliveryCacheOptions() { CacheType = cacheType }));
-        }
-
         [Fact]
         public void AddDeliveryClientCacheWithNullDeliveryCacheOptions_ThrowsArgumentNullException()
         {
             Assert.Throws<ArgumentNullException>(() => _serviceCollection.AddDeliveryClientCache(null));
         }
 
-        [Fact]
-        public void AddDeliveryClientCacheNamedWithNullDeliveryCacheOptions_ThrowsArgumentNullException()
-        {
-            Assert.Throws<ArgumentNullException>(() => _serviceCollection.AddDeliveryClientCache("named", null));
-        }
-
         [Fact]
         public void AddDeliveryClientCacheWitNoPreviousRegistrationDeliveryClient_ThrowsMissingTypeRegistrationException()
         {
             Assert.Throws<MissingTypeRegistrationException>(() => _serviceCollection.AddDeliveryClientCache(new DeliveryCacheOptions()));
         }
-
-        [Fact]
-        public void AddDeliveryClientNamedCacheWitNoPreviousRegistrationDeliveryClient_ThrowsMissingTypeRegistrationException()
-        {
-            Assert.Throws<MissingTypeRegistrationException>(() => _serviceCollection.AddDeliveryClientCache("named", new DeliveryCacheOptions()));
-        }
     }
 }

Kentico.Kontent.Delivery.Caching/DeliveryCacheOptions.cs

@@ -31,6 +31,6 @@ public class DeliveryCacheOptions
         /// <summary>
         /// Name of an <see cref="IDeliveryCacheManager"/> instance the options are bound to.
         /// </summary>
-        internal string Name { get; set; }
+        public string Name { get; set; }
     }
 }

Kentico.Kontent.Delivery.Caching/Extensions/DeliveryCacheOptionsExtensions.cs

@@ -8,7 +8,7 @@ public static void Configure(this DeliveryCacheOptions o, DeliveryCacheOptions o
             o.DefaultExpiration = options.DefaultExpiration;
             o.DefaultExpirationType = options.DefaultExpirationType;
             o.StaleContentExpiration = options.StaleContentExpiration;
-            o.Name = o.Name;
+            o.Name = options.Name;
         }
     }
 }

Kentico.Kontent.Delivery.Caching/Extensions/ServiceCollectionExtensions.cs

@@ -32,26 +32,13 @@ public static IServiceCollection AddDeliveryClientCache(this IServiceCollection
         }
 
         /// <summary>
-        ///  Registers a delegate that will be used to configure a cached <see cref="IDeliveryClient"/>.
+        /// Registers a <see cref="DeliveryCacheOptions"/>.
         /// </summary>
         /// <param name="services">A <see cref="IServiceCollection"/> instance for registering and resolving dependencies.</param>
-        /// <param name="name">A name of named client which want to use cached <see cref="IDeliveryClient"/></param>
-        /// <param name="options">A <see cref="DeliveryCacheOptions"/> instance. </param> 
-        /// <returns>The <paramref name="services"/> instance with cache services registered in it</returns>
-        public static IServiceCollection AddDeliveryClientCache(this IServiceCollection services, string name, DeliveryCacheOptions options)
-        {
-            if (options == null)
-            {
-                throw new ArgumentNullException(nameof(options), "The Delivery cache  options object is not specified.");
-            }
-
-            return services
-                .RegisterCacheOptions(options, name)
-                .RegisterDependencies(options.CacheType, name)
-                .Decorate<IDeliveryClientFactory, DeliveryClientCacheFactory>();
-        }
-
-        private static IServiceCollection RegisterCacheOptions(this IServiceCollection services, DeliveryCacheOptions options, string name = null)
+        /// <param name="options">A <see cref="DeliveryCacheOptions"/> instance.</param>
+        /// <param name="name">A name of named client which want to use cached.</param>
+        /// <returns></returns>
+        public static IServiceCollection RegisterCacheOptions(this IServiceCollection services, DeliveryCacheOptions options, string name = null)
         {
             if (name == null)
             {
@@ -65,7 +52,14 @@ private static IServiceCollection RegisterCacheOptions(this IServiceCollection s
             return services;
         }
 
-        private static IServiceCollection RegisterDependencies(this IServiceCollection services, CacheTypeEnum cacheType, string name = null)
+        /// <summary>
+        /// Registers <see cref="IDeliveryClient"/> cache dependencies.
+        /// </summary>
+        /// <param name="services">A <see cref="IServiceCollection"/> instance for registering and resolving dependencies.</param>
+        /// <param name="cacheType"> A <see cref="CacheTypeEnum"/></param>
+        /// <param name="name">A name of named client which want to use cached.</param>
+        /// <returns></returns>
+        public static IServiceCollection RegisterDependencies(this IServiceCollection services, CacheTypeEnum cacheType, string name = null)
         {
             switch (cacheType)
             {

Kentico.Kontent.Delivery.Caching/Factories/CacheManagerFactory.cs

@@ -0,0 +1,37 @@
+using Kentico.Kontent.Delivery.Abstractions;
+using Microsoft.Extensions.Caching.Distributed;
+using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Options;
+
+namespace Kentico.Kontent.Delivery.Caching.Factories
+{
+    /// <summary>
+    /// A factory for manually create an <see cref="IDeliveryCacheManager"/> instance.
+    /// </summary>
+    public static class CacheManagerFactory
+    {
+        /// <summary>
+        /// Creates an <see cref="IDeliveryCacheManager"/> instance with a distributed cache.
+        /// </summary>
+        /// <param name="distributedCache">A <see cref="IDistributedCache"/> instance.</param>
+        /// <param name="options">A <see cref="DeliveryCacheOptions"/></param>
+        /// <returns>The <see cref="IDeliveryCacheManager"/> instance with a distribute cache.</returns>
+        public static IDeliveryCacheManager Create(IDistributedCache distributedCache,
+            IOptions<DeliveryCacheOptions> options)
+        {
+            return new DistributedCacheManager(distributedCache, options);
+        }
+
+        /// <summary>
+        /// Creates an <see cref="IDeliveryCacheManager"/> instance with a memory cache.
+        /// </summary>
+        /// <param name="memoryCache">A <see cref="IMemoryCache"/> instance.</param>
+        /// <param name="options">A <see cref="DeliveryCacheOptions"/></param>
+        /// <returns>The <see cref="IDeliveryCacheManager"/> instance with a memory cache.</returns>
+        public static IDeliveryCacheManager Create(IMemoryCache memoryCache,
+           IOptions<DeliveryCacheOptions> options)
+        {
+            return new MemoryCacheManager(memoryCache, options);
+        }
+    }
+}

Kentico.Kontent.Delivery.Caching/Kentico.Kontent.Delivery.Caching.csproj

@@ -37,6 +37,9 @@
     <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
       <_Parameter1>Kentico.Kontent.Delivery.Caching.Tests</_Parameter1>
     </AssemblyAttribute>
+    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
+      <_Parameter1>Kentico.Kontent.Delivery.Extensions.Autofac.DependencyInjection.Tests</_Parameter1>
+    </AssemblyAttribute>
   </ItemGroup>
 
 </Project>