#283 Adding initial implementation for removing entries from the memory cache.

TODO:
- [] need to add more tests
- [] need to add comments

Author: vaptsarov

src/MyTested.AspNetCore.Mvc.Caching/Builders/Contracts/Data/IAndMemoryCacheBuilder.cs renamed to src/MyTested.AspNetCore.Mvc.Caching/Builders/Contracts/Data/IAndWithMemoryCacheBuilder.cs

@@ -3,12 +3,12 @@
     /// <summary>
     /// Used for adding AndAlso() method to the <see cref="Microsoft.Extensions.Caching.Memory.IMemoryCache"/> builder.
     /// </summary>
-    public interface IAndMemoryCacheBuilder : IMemoryCacheBuilder
+    public interface IAndWithMemoryCacheBuilder : IWithMemoryCacheBuilder
     {
         /// <summary>
         /// AndAlso method for better readability when building <see cref="Microsoft.Extensions.Caching.Memory.IMemoryCache"/>.
         /// </summary>
-        /// <returns>The same <see cref="IMemoryCacheBuilder"/>.</returns>
-        IMemoryCacheBuilder AndAlso();
+        /// <returns>The same <see cref="IWithMemoryCacheBuilder"/>.</returns>
+        IWithMemoryCacheBuilder AndAlso();
     }
 }

src/MyTested.AspNetCore.Mvc.Caching/Builders/Contracts/Data/IAndWithoutMemoryCacheBuilder.cs

@@ -0,0 +1,7 @@
+namespace MyTested.AspNetCore.Mvc.Builders.Contracts.Data
+{
+    public interface IAndWithoutMemoryCacheBuilder : IWithoutMemoryCacheBuilder
+    {
+        IWithoutMemoryCacheBuilder AndAlso();
+    }
+}

src/MyTested.AspNetCore.Mvc.Caching/Builders/Contracts/Data/IMemoryCacheTestBuilder.cs

@@ -13,38 +13,38 @@ public interface IMemoryCacheTestBuilder
         /// Tests whether the <see cref="IMemoryCache"/> contains entry with the provided key.
         /// </summary>
         /// <param name="key">Key of the cache entry.</param>
-        /// <returns>The same <see cref="IAndMemoryCacheBuilder"/>.</returns>
+        /// <returns>The same <see cref="IAndWithMemoryCacheBuilder"/>.</returns>
         IAndMemoryCacheTestBuilder ContainingEntryWithKey(object key);
 
         /// <summary>
         /// Tests whether the <see cref="IMemoryCache"/> contains entry with the provided value.
         /// </summary>
         /// <typeparam name="TValue">Type of the cache entry value.</typeparam>
         /// <param name="value">Value of the cache entry.</param>
-        /// <returns>The same <see cref="IAndMemoryCacheBuilder"/>.</returns>
+        /// <returns>The same <see cref="IAndWithMemoryCacheBuilder"/>.</returns>
         IAndMemoryCacheTestBuilder ContainingEntryWithValue<TValue>(TValue value);
 
         /// <summary>
         /// Tests whether the <see cref="IMemoryCache"/> contains entry with value of the provided type.
         /// </summary>
         /// <typeparam name="TValue">Type of the cache entry value.</typeparam>
-        /// <returns>The same <see cref="IAndMemoryCacheBuilder"/>.</returns>
+        /// <returns>The same <see cref="IAndWithMemoryCacheBuilder"/>.</returns>
         IAndMemoryCacheTestBuilder ContainingEntryOfType<TValue>();
 
         /// <summary>
         /// Tests whether the <see cref="IMemoryCache"/> contains entry with the provided key and corresponding value.
         /// </summary>
         /// <param name="key">Key of the cache entry.</param>
         /// <param name="value">Value of the cache entry.</param>
-        /// <returns>The same <see cref="IAndMemoryCacheBuilder"/>.</returns>
+        /// <returns>The same <see cref="IAndWithMemoryCacheBuilder"/>.</returns>
         IAndMemoryCacheTestBuilder ContainingEntry(object key, object value);
 
         /// <summary>
         /// Tests whether the <see cref="IMemoryCache"/> contains entry with value of the provided type and the given key.
         /// </summary>
         /// <typeparam name="TValue">Type of the cache entry value.</typeparam>
         /// <param name="key">Key of the cache entry.</param>
-        /// <returns>The same <see cref="IAndMemoryCacheBuilder"/>.</returns>
+        /// <returns>The same <see cref="IAndWithMemoryCacheBuilder"/>.</returns>
         IAndMemoryCacheTestBuilder ContainingEntryOfType<TValue>(object key);
 
         /// <summary>
@@ -53,21 +53,21 @@ public interface IMemoryCacheTestBuilder
         /// <param name="key">Key of the cache entry.</param>
         /// <param name="value">Value of the cache entry.</param>
         /// <param name="options"><see cref="MemoryCacheEntryOptions"/> of the cache entry.</param>
-        /// <returns>The same <see cref="IAndMemoryCacheBuilder"/>.</returns>
+        /// <returns>The same <see cref="IAndWithMemoryCacheBuilder"/>.</returns>
         IAndMemoryCacheTestBuilder ContainingEntry(object key, object value, MemoryCacheEntryOptions options);
 
         /// <summary>
         /// Tests whether the <see cref="IMemoryCache"/> contains specific entry by using a builder. 
         /// </summary>
         /// <param name="memoryCacheEntryTestBuilder">Builder for setting specific cache entry tests.</param>
-        /// <returns>The same <see cref="IAndMemoryCacheBuilder"/>.</returns>
+        /// <returns>The same <see cref="IAndWithMemoryCacheBuilder"/>.</returns>
         IAndMemoryCacheTestBuilder ContainingEntry(Action<IMemoryCacheEntryKeyTestBuilder> memoryCacheEntryTestBuilder);
 
         /// <summary>
         /// Tests whether the <see cref="IMemoryCache"/> contains the provided entries. 
         /// </summary>
         /// <param name="entries">Dictionary of cache entries.</param>
-        /// <returns>The same <see cref="IAndMemoryCacheBuilder"/>.</returns>
+        /// <returns>The same <see cref="IAndWithMemoryCacheBuilder"/>.</returns>
         IAndMemoryCacheTestBuilder ContainingEntries(IDictionary<object, object> entries);
     }
 }

src/MyTested.AspNetCore.Mvc.Caching/Builders/Contracts/Data/IMemoryCacheBuilder.cs renamed to src/MyTested.AspNetCore.Mvc.Caching/Builders/Contracts/Data/IWithMemoryCacheBuilder.cs

@@ -7,37 +7,37 @@
     /// <summary>
     /// Used for building mocked <see cref="IMemoryCache"/>.
     /// </summary>
-    public interface IMemoryCacheBuilder
+    public interface IWithMemoryCacheBuilder
     {
         /// <summary>
         /// Adds cache entry to the mocked <see cref="IMemoryCache"/>.
         /// </summary>
         /// <param name="key">Key of the cache entry.</param>
         /// <param name="value">Value of the cache entry.</param>
-        /// <returns>The same <see cref="IAndMemoryCacheBuilder"/>.</returns>
-        IAndMemoryCacheBuilder WithEntry(object key, object value);
+        /// <returns>The same <see cref="IAndWithMemoryCacheBuilder"/>.</returns>
+        IAndWithMemoryCacheBuilder WithEntry(object key, object value);
 
         /// <summary>
         /// Adds cache entry to the mocked <see cref="IMemoryCache"/>.
         /// </summary>
         /// <param name="key">Key of the cache entry.</param>
         /// <param name="value">Value of the cache entry.</param>
         /// <param name="options"><see cref="MemoryCacheEntryOptions"/> of the cache entry.</param>
-        /// <returns>The same <see cref="IAndMemoryCacheBuilder"/>.</returns>
-        IAndMemoryCacheBuilder WithEntry(object key, object value, MemoryCacheEntryOptions options);
+        /// <returns>The same <see cref="IAndWithMemoryCacheBuilder"/>.</returns>
+        IAndWithMemoryCacheBuilder WithEntry(object key, object value, MemoryCacheEntryOptions options);
 
         /// <summary>
         /// Adds cache entry to the mocked <see cref="IMemoryCache"/>.
         /// </summary>
         /// <param name="memoryCacheEntryBuilder">Builder for creating cache entry.</param>
-        /// <returns>The same <see cref="IAndMemoryCacheBuilder"/>.</returns>
-        IAndMemoryCacheBuilder WithEntry(Action<IMemoryCacheEntryKeyBuilder> memoryCacheEntryBuilder);
+        /// <returns>The same <see cref="IAndWithMemoryCacheBuilder"/>.</returns>
+        IAndWithMemoryCacheBuilder WithEntry(Action<IMemoryCacheEntryKeyBuilder> memoryCacheEntryBuilder);
 
         /// <summary>
         /// Adds cache entries to the mocked <see cref="IMemoryCache"/>.
         /// </summary>
         /// <param name="entries">Dictionary of cache entries.</param>
-        /// <returns>The same <see cref="IAndMemoryCacheBuilder"/>.</returns>
-        IAndMemoryCacheBuilder WithEntries(IDictionary<object, object> entries);
+        /// <returns>The same <see cref="IAndWithMemoryCacheBuilder"/>.</returns>
+        IAndWithMemoryCacheBuilder WithEntries(IDictionary<object, object> entries);
     }
 }

src/MyTested.AspNetCore.Mvc.Caching/Builders/Contracts/Data/IWithoutMemoryCacheBuilder.cs

@@ -0,0 +1,13 @@
+namespace MyTested.AspNetCore.Mvc.Builders.Contracts.Data
+{
+    using System.Collections.Generic;
+
+    public interface IWithoutMemoryCacheBuilder
+    {
+        IAndWithoutMemoryCacheBuilder WithoutEntry(object key);
+
+        IAndWithoutMemoryCacheBuilder WithoutEntries(IEnumerable<object> keys);
+
+        IAndWithoutMemoryCacheBuilder ClearCache();
+    }
+}

src/MyTested.AspNetCore.Mvc.Caching/Builders/Data/MemoryCacheBaseBuilder.cs

@@ -0,0 +1,16 @@
+namespace MyTested.AspNetCore.Mvc.Builders.Data
+{
+    using Microsoft.Extensions.Caching.Memory;
+    using Microsoft.Extensions.DependencyInjection;
+    using System;
+
+    public abstract class MemoryCacheBaseBuilder
+    {
+        public MemoryCacheBaseBuilder(IServiceProvider services)
+        {
+            this.MemoryCache = services.GetRequiredService<IMemoryCache>();
+        }
+
+        protected IMemoryCache MemoryCache { get; private set; }
+    }
+}

src/MyTested.AspNetCore.Mvc.Caching/Builders/Data/MemoryCacheBuilder.cs renamed to src/MyTested.AspNetCore.Mvc.Caching/Builders/Data/MemoryCacheWithBuilder.cs

@@ -4,45 +4,35 @@
     using System.Collections.Generic;
     using Contracts.Data;
     using Microsoft.Extensions.Caching.Memory;
-    using Microsoft.Extensions.DependencyInjection;
     using Utilities.Extensions;
 
     /// <summary>
     /// Used for building mocked <see cref="IMemoryCache"/>.
     /// </summary>
-    public class MemoryCacheBuilder : IAndMemoryCacheBuilder
+    public class MemoryCacheWithBuilder : MemoryCacheBaseBuilder, IAndWithMemoryCacheBuilder
     {
         /// <summary>
-        /// Initializes a new instance of the <see cref="MemoryCacheBuilder"/> class.
+        /// Initializes a new instance of the <see cref="MemoryCacheWithBuilder"/> class.
         /// </summary>
         /// <param name="services"><see cref="IServiceProvider"/> providing the current <see cref="IMemoryCache"/>.</param>
-        public MemoryCacheBuilder(IServiceProvider services)
-        {
-            this.MemoryCache = services.GetRequiredService<IMemoryCache>();
-        }
-
-        /// <summary>
-        /// Gets the mocked <see cref="IMemoryCache"/>.
-        /// </summary>
-        /// <value>Built <see cref="IMemoryCache"/>.</value>
-        protected IMemoryCache MemoryCache { get; private set; }
+        public MemoryCacheWithBuilder(IServiceProvider services) : base(services) { }
 
         /// <inheritdoc />
-        public IAndMemoryCacheBuilder WithEntry(object key, object value)
+        public IAndWithMemoryCacheBuilder WithEntry(object key, object value)
         {
             this.MemoryCache.Set(key, value);
             return this;
         }
 
         /// <inheritdoc />
-        public IAndMemoryCacheBuilder WithEntry(object key, object value, MemoryCacheEntryOptions options)
+        public IAndWithMemoryCacheBuilder WithEntry(object key, object value, MemoryCacheEntryOptions options)
         {
             this.MemoryCache.Set(key, value, options);
             return this;
         }
 
         /// <inheritdoc />
-        public IAndMemoryCacheBuilder WithEntry(Action<IMemoryCacheEntryKeyBuilder> memoryCacheEntryBuilder)
+        public IAndWithMemoryCacheBuilder WithEntry(Action<IMemoryCacheEntryKeyBuilder> memoryCacheEntryBuilder)
         {
             var newMemoryCacheEntryBuilder = new MemoryCacheEntryBuilder();
             memoryCacheEntryBuilder(newMemoryCacheEntryBuilder);
@@ -58,13 +48,13 @@ public IAndMemoryCacheBuilder WithEntry(Action<IMemoryCacheEntryKeyBuilder> memo
         }
 
         /// <inheritdoc />
-        public IAndMemoryCacheBuilder WithEntries(IDictionary<object, object> entries)
+        public IAndWithMemoryCacheBuilder WithEntries(IDictionary<object, object> entries)
         {
             entries.ForEach(e => this.WithEntry(e.Key, e.Value));
             return this;
         }
 
         /// <inheritdoc />
-        public IMemoryCacheBuilder AndAlso() => this;
+        public IWithMemoryCacheBuilder AndAlso() => this;
     }
 }

src/MyTested.AspNetCore.Mvc.Caching/Builders/Data/MemoryCacheWithoutBuilder.cs

@@ -0,0 +1,32 @@
+namespace MyTested.AspNetCore.Mvc.Builders.Data
+{
+    using System;
+    using System.Collections.Generic;
+    using Contracts.Data;
+    using Utilities.Extensions;
+
+    public class MemoryCacheWithoutBuilder : MemoryCacheBaseBuilder, IAndWithoutMemoryCacheBuilder
+    {
+        public MemoryCacheWithoutBuilder(IServiceProvider services) : base(services) { }
+
+        public IAndWithoutMemoryCacheBuilder WithoutEntry(object key)
+        {
+            this.MemoryCache.Remove(key);
+            return this;
+        }
+
+        public IAndWithoutMemoryCacheBuilder WithoutEntries(IEnumerable<object> keys)
+        {
+            this.MemoryCache.AsMemoryCacheMock().RemoveKeys(keys);
+            return this;
+        }
+
+        public IAndWithoutMemoryCacheBuilder ClearCache()
+        {
+            this.MemoryCache.AsMemoryCacheMock().ClearCache();
+            return this;
+        }
+
+        public IWithoutMemoryCacheBuilder AndAlso() => this;
+    }
+}

src/MyTested.AspNetCore.Mvc.Caching/ComponentBuilderCachingExtensions.cs

@@ -5,6 +5,7 @@
     using Builders.Contracts.Data;
     using Builders.Data;
     using Builders.Base;
+    using System.Collections.Generic;
 
     /// <summary>
     /// Contains <see cref="Microsoft.Extensions.Caching.Memory.IMemoryCache"/> extension methods for <see cref="IBaseTestBuilderWithComponentBuilder{TBuilder}"/>.
@@ -16,16 +17,45 @@ public static class ComponentBuilderCachingExtensions
         /// </summary>
         /// <typeparam name="TBuilder">Class representing ASP.NET Core MVC test builder.</typeparam>
         /// <param name="builder">Instance of <see cref="IBaseTestBuilderWithComponentBuilder{TBuilder}"/> type.</param>
-        /// <param name="memoryCacheBuilder">Action setting the <see cref="Microsoft.Extensions.Caching.Memory.IMemoryCache"/> values by using <see cref="IMemoryCacheBuilder"/>.</param>
+        /// <param name="memoryCacheBuilder">Action setting the <see cref="Microsoft.Extensions.Caching.Memory.IMemoryCache"/> values by using <see cref="IWithMemoryCacheBuilder"/>.</param>
         /// <returns>The same component builder.</returns>
         public static TBuilder WithMemoryCache<TBuilder>(
             this IBaseTestBuilderWithComponentBuilder<TBuilder> builder,
-            Action<IMemoryCacheBuilder> memoryCacheBuilder)
+            Action<IWithMemoryCacheBuilder> memoryCacheBuilder)
             where TBuilder : IBaseTestBuilder
         {
             var actualBuilder = (BaseTestBuilderWithComponentBuilder<TBuilder>)builder;
 
-            memoryCacheBuilder(new MemoryCacheBuilder(actualBuilder.TestContext.HttpContext.RequestServices));
+            memoryCacheBuilder(new MemoryCacheWithBuilder(actualBuilder.TestContext.HttpContext.RequestServices));
+
+            return actualBuilder.Builder;
+        }
+
+        public static TBuilder WithoutMemoryCache<TBuilder>(
+            this IBaseTestBuilderWithComponentBuilder<TBuilder> builder)
+            where TBuilder : IBaseTestBuilder
+            => builder.WithoutMemoryCache(cache => cache.ClearCache());
+
+        public static TBuilder WithoutMemoryCache<TBuilder>(
+            this IBaseTestBuilderWithComponentBuilder<TBuilder> builder, 
+            object key)
+            where TBuilder : IBaseTestBuilder
+            => builder.WithoutMemoryCache(cache => cache.WithoutEntry(key));
+
+        public static TBuilder WithoutMemoryCache<TBuilder>(
+            this IBaseTestBuilderWithComponentBuilder<TBuilder> builder,
+            IEnumerable<object> keys)
+            where TBuilder : IBaseTestBuilder
+            => builder.WithoutMemoryCache(cache => cache.WithoutEntries(keys));
+
+        public static TBuilder WithoutMemoryCache<TBuilder>(
+            this IBaseTestBuilderWithComponentBuilder<TBuilder> builder,
+            Action<IWithoutMemoryCacheBuilder> memoryCacheBuilder)
+            where TBuilder : IBaseTestBuilder
+        {
+            var actualBuilder = (BaseTestBuilderWithComponentBuilder<TBuilder>)builder;
+
+            memoryCacheBuilder(new MemoryCacheWithoutBuilder(actualBuilder.TestContext.HttpContext.RequestServices));
 
             return actualBuilder.Builder;
         }

src/MyTested.AspNetCore.Mvc.Caching/Internal/Caching/MemoryCacheMock.cs

@@ -12,13 +12,10 @@ private static readonly TestLocal<IDictionary<object, ICacheEntry>> Current
 
         private readonly IDictionary<object, ICacheEntry> cache;
 
-        public MemoryCacheMock() 
+        public MemoryCacheMock()
             => this.cache = this.GetCurrentCache();
 
         public int Count => this.cache.Count;
-        
-        public void Dispose() 
-            => this.cache.Clear();
 
         public void Remove(object key)
         {
@@ -59,9 +56,23 @@ public bool TryGetCacheEntry(object key, out ICacheEntry value)
             return false;
         }
 
-        public IDictionary<object, object> GetCacheAsDictionary() 
+        public IDictionary<object, object> GetCacheAsDictionary()
             => this.cache.ToDictionary(c => c.Key, c => c.Value.Value);
 
+        public void RemoveKeys(IEnumerable<object> keys)
+        {
+            foreach (var key in keys)
+            {
+                this.Remove(key);
+            }
+        }
+
+        public void ClearCache()
+            => this.cache.Clear();
+
+        public void Dispose()
+            => this.ClearCache();
+
         private IDictionary<object, ICacheEntry> GetCurrentCache()
         {
             var result = Current.Value;