Merge pull request #595 from johelvisguzman/GH-594

GH-594 Allow ability to disable interceptors

Author: johelvisguzman

src/DotNetToolkit.Repository/IRepository.cs

@@ -18,6 +18,16 @@
     /// <seealso cref="IReadOnlyRepository{TEntity, TKey1, TKey2, TKey3}" />
     public interface IRepository<TEntity, in TKey1, in TKey2, in TKey3> : IReadOnlyRepository<TEntity, TKey1, TKey2, TKey3> where TEntity : class
     {
+        /// <summary>
+        /// Gets or sets the value indicating whether all the repository interceptors should be enabled or not.
+        /// </summary>
+        bool InterceptorsEnabled { get; set; }
+
+        /// <summary>
+        /// Gets a dictionary for indicating whether the repository interceptor of the specified type should be disabled.
+        /// </summary>
+        Dictionary<Type, bool> InterceptorTypesDisabled { get; }
+
         /// <summary>
         /// Returns a read-only <see cref="IReadOnlyRepository{TEntity, TKey1, TKey2, TKey3}" /> wrapper for the current repository.
         /// </summary>

src/DotNetToolkit.Repository/RepositoryBase.cs

@@ -1212,6 +1212,16 @@ public abstract class InternalRepositoryBase<TEntity> where TEntity : class
 
         #region Properties
 
+        /// <summary>
+        /// Gets or sets the value indicating whether all the repository interceptors should be enabled or not.
+        /// </summary>
+        public bool InterceptorsEnabled { get; set; }
+
+        /// <summary>
+        /// Gets a dictionary for indicating whether the repository interceptor of the specified type should be disabled.
+        /// </summary>
+        public Dictionary<Type, bool> InterceptorTypesDisabled { get; }
+
         /// <summary>
         /// Gets or sets the value indicating whether caching is enabled or not.
         /// </summary>
@@ -1261,6 +1271,9 @@ internal InternalRepositoryBase([NotNull] IRepositoryOptions options)
 
             if (CacheProvider.GetType() != typeof(NullCacheProvider))
                 CacheEnabled = true;
+
+            InterceptorsEnabled = true;
+            InterceptorTypesDisabled = new Dictionary<Type, bool>();
         }
 
         #endregion
@@ -3046,19 +3059,35 @@ internal void Intercept([NotNull] Action<IRepositoryInterceptor> action)
         {
             Guard.NotNull(action, nameof(action));
 
+            if (!InterceptorsEnabled)
+                return;
+
             foreach (var interceptor in GetInterceptors())
             {
-                action(interceptor);
+                var interceptorType = interceptor.GetType();
+                var isEnabled = InterceptorTypesDisabled.ContainsKey(interceptorType)
+                    ? !InterceptorTypesDisabled[interceptorType]
+                    : true;
+
+                if (isEnabled) action(interceptor);
             }
         }
 
         internal async Task InterceptAsync([NotNull] Func<IRepositoryInterceptor, Task> action)
         {
             Guard.NotNull(action, nameof(action));
 
+            if (!InterceptorsEnabled)
+                return;
+
             foreach (var interceptor in GetInterceptors())
             {
-                await action(interceptor);
+                var interceptorType = interceptor.GetType();
+                var isEnabled = InterceptorTypesDisabled.ContainsKey(interceptorType)
+                    ? !InterceptorTypesDisabled[interceptorType]
+                    : true;
+
+                if (isEnabled) await action(interceptor);
             }
         }
 

test/DotNetToolkit.Repository.Integration.Test/Tests/Interceptor/RepositoryInterceptorTests.cs

@@ -105,6 +105,66 @@ public void CanModifyUserOnInterceptions()
             Assert.Equal(user, entity.ModUser);
         }
 
+        [Fact]
+        public void CantModifyUserOnInterceptionsWhenDisabled()
+        {
+            const string user = "Random User";
+
+            var entity = new CustomerWithTimeStamp();
+            var options = new RepositoryOptionsBuilder()
+                .UseInMemoryDatabase()
+                .UseInterceptor(new TestRepositoryTimeStampInterceptor(user))
+                .Options;
+
+            var repo = new Repository<CustomerWithTimeStamp>(options)
+            {
+                InterceptorsEnabled = false
+            };
+
+            Assert.Null(entity.CreateTime);
+            Assert.Null(entity.ModTime);
+            Assert.Null(entity.CreateUser);
+            Assert.Null(entity.ModUser);
+
+            repo.Add(entity);
+
+            Assert.Null(entity.CreateTime);
+            Assert.Null(entity.ModTime);
+            Assert.Null(entity.CreateUser);
+            Assert.Null(entity.ModUser);
+        }
+
+        [Fact]
+        public void CantModifyUserOnInterceptionsWhenDisabledByType()
+        {
+            const string user = "Random User";
+
+            var entity = new CustomerWithTimeStamp();
+            var options = new RepositoryOptionsBuilder()
+                .UseInMemoryDatabase()
+                .UseInterceptor(new TestRepositoryTimeStampInterceptor(user))
+                .Options;
+
+            var repo = new Repository<CustomerWithTimeStamp>(options)
+            {
+                InterceptorsEnabled = true
+            };
+
+            repo.InterceptorTypesDisabled.Add(typeof(TestRepositoryTimeStampInterceptor), true);
+
+            Assert.Null(entity.CreateTime);
+            Assert.Null(entity.ModTime);
+            Assert.Null(entity.CreateUser);
+            Assert.Null(entity.ModUser);
+
+            repo.Add(entity);
+
+            Assert.Null(entity.CreateTime);
+            Assert.Null(entity.ModTime);
+            Assert.Null(entity.CreateUser);
+            Assert.Null(entity.ModUser);
+        }
+
         [Fact]
         public async Task AddAsync()
         {
@@ -194,5 +254,65 @@ public async Task CanModifyUserOnInterceptionsAsync()
             Assert.Equal(user, entity.CreateUser);
             Assert.Equal(user, entity.ModUser);
         }
+
+        [Fact]
+        public async Task CantModifyUserOnInterceptionsWhenDisabledAsync()
+        {
+            const string user = "Random User";
+
+            var entity = new CustomerWithTimeStamp();
+            var options = new RepositoryOptionsBuilder()
+                .UseInMemoryDatabase()
+                .UseInterceptor(new TestRepositoryTimeStampInterceptor(user))
+                .Options;
+
+            var repo = new Repository<CustomerWithTimeStamp>(options)
+            {
+                InterceptorsEnabled = false
+            };
+
+            Assert.Null(entity.CreateTime);
+            Assert.Null(entity.ModTime);
+            Assert.Null(entity.CreateUser);
+            Assert.Null(entity.ModUser);
+
+            await repo.AddAsync(entity);
+
+            Assert.Null(entity.CreateTime);
+            Assert.Null(entity.ModTime);
+            Assert.Null(entity.CreateUser);
+            Assert.Null(entity.ModUser);
+        }
+
+        [Fact]
+        public async Task CantModifyUserOnInterceptionsWhenDisabledByTypeAsync()
+        {
+            const string user = "Random User";
+
+            var entity = new CustomerWithTimeStamp();
+            var options = new RepositoryOptionsBuilder()
+                .UseInMemoryDatabase()
+                .UseInterceptor(new TestRepositoryTimeStampInterceptor(user))
+                .Options;
+
+            var repo = new Repository<CustomerWithTimeStamp>(options)
+            {
+                InterceptorsEnabled = true
+            };
+
+            repo.InterceptorTypesDisabled.Add(typeof(TestRepositoryTimeStampInterceptor), true);
+
+            Assert.Null(entity.CreateTime);
+            Assert.Null(entity.ModTime);
+            Assert.Null(entity.CreateUser);
+            Assert.Null(entity.ModUser);
+
+            await repo.AddAsync(entity);
+
+            Assert.Null(entity.CreateTime);
+            Assert.Null(entity.ModTime);
+            Assert.Null(entity.CreateUser);
+            Assert.Null(entity.ModUser);
+        }
     }
-}
+}