(GH-599) Allowed ninject ioc extension to configure registered logger provider

Author: johelvisguzman

src/DotNetToolkit.Repository.Extensions.Ninject/KernelExtensions.cs

@@ -1,13 +1,14 @@
 namespace DotNetToolkit.Repository.Extensions.Ninject
 {
     using Configuration.Interceptors;
+    using Configuration.Logging;
     using Configuration.Options;
     using Configuration.Options.Internal;
     using global::Ninject;
     using JetBrains.Annotations;
     using Services;
     using System;
-    using System.Collections.Generic;
+    using System.Linq;
     using System.Reflection;
     using Transactions;
     using Utility;
@@ -65,27 +66,23 @@ public static void BindRepositories([NotNull] this IKernel kernel, [NotNull] Act
 
             optionsAction(optionsBuilder);
 
-            var registeredInterceptorTypes = new List<Type>();
+            var scanResults = AssemblyScanner.FindRepositoriesFromAssemblies(assembliesToScan);
 
-            // Scan assemblies for repositories, services, and interceptors
-            AssemblyScanner
-                .FindRepositoriesFromAssemblies(assembliesToScan)
-                .ForEach(scanResult =>
+            scanResults.ForEach(scanResult =>
+            {
+                foreach (var implementationType in scanResult.ImplementationTypes)
                 {
-                    foreach (var implementationType in scanResult.ImplementationTypes)
+                    if (scanResult.InterfaceType == typeof(IRepositoryInterceptor))
+                    {
+                        kernel.Bind(implementationType).ToSelf();
+                        kernel.Bind(scanResult.InterfaceType).To(implementationType);
+                    }
+                    else
                     {
-                        if (scanResult.InterfaceType == typeof(IRepositoryInterceptor))
-                        {
-                            kernel.Bind(implementationType).ToSelf();
-                            kernel.Bind(scanResult.InterfaceType).To(implementationType);
-                            registeredInterceptorTypes.Add(implementationType);
-                        }
-                        else
-                        {
-                            kernel.Bind(scanResult.InterfaceType).To(implementationType);
-                        }
+                        kernel.Bind(scanResult.InterfaceType).To(implementationType);
                     }
-                });
+                }
+            });
 
             // Binds other services
             kernel.Bind<IRepositoryFactory>().ToMethod(c => new RepositoryFactory(c.Kernel.Get<IRepositoryOptions>()));
@@ -96,14 +93,21 @@ public static void BindRepositories([NotNull] this IKernel kernel, [NotNull] Act
             {
                 var options = new RepositoryOptions(optionsBuilder.Options);
 
-                foreach (var interceptorType in registeredInterceptorTypes)
+                foreach (var interceptorType in scanResults.OfType<IRepositoryInterceptor>())
                 {
                     if (!optionsBuilder.Options.Interceptors.ContainsKey(interceptorType))
                     {
                         options = options.With(interceptorType, () => (IRepositoryInterceptor)c.Kernel.Get(interceptorType));
                     }
                 }
 
+                if (optionsBuilder.Options.LoggerProvider == null)
+                {
+                    var loggerProviderType = scanResults.OfType<ILoggerProvider>().FirstOrDefault();
+
+                    options = options.With((ILoggerProvider)c.Kernel.Get(loggerProviderType));
+                }
+
                 return options;
             });
 

test/DotNetToolkit.Repository.Integration.Test/Tests/DependencyInjection/DependencyInjectionTests.Ninject.cs

@@ -8,7 +8,6 @@
     using Ninject;
     using Services;
     using System;
-    using System.Collections.Generic;
     using System.Linq;
     using System.Reflection;
     using Transactions;
@@ -111,11 +110,9 @@ public void DependencyInjectionCanConfigureRepositoriesWithInterceptorsFromOptio
                 options.UseLoggerProvider(TestXUnitLoggerProvider);
             });
 
-            var repo = new Repository<Customer>(kernel.Get<IRepositoryOptions>());
-
-            var configuredInterceptors = GetLazyInterceptorsOptionsFromPrivateField<InternalRepositoryBase<Customer>>(repo);
+            var repoOptions = kernel.Get<IRepositoryOptions>();
 
-            Assert.Equal(3, configuredInterceptors.Count());
+            Assert.Equal(3, repoOptions.Interceptors.Count());
             Assert.Equal(3, kernel.GetAll<IRepositoryInterceptor>().Count());
             Assert.NotNull(kernel.Get<TestRepositoryInterceptorWithDependencyInjectedServices>());
 
@@ -130,12 +127,12 @@ public void DependencyInjectionCanConfigureRepositoriesWithInterceptorsFromOptio
             Assert.Null(registeredInterceptor2.P1);
             Assert.False(registeredInterceptor2.P2);
 
-            var configueredInterceptor1 = (TestRepositoryTimeStampInterceptor)configuredInterceptors[typeof(TestRepositoryTimeStampInterceptor)].Value;
+            var configueredInterceptor1 = (TestRepositoryTimeStampInterceptor)repoOptions.Interceptors[typeof(TestRepositoryTimeStampInterceptor)].Value;
 
             Assert.NotNull(configueredInterceptor1);
             Assert.Equal("RANDOM USER", configueredInterceptor1.User);
 
-            var configueredInterceptor2 = (TestRepositoryInterceptor)configuredInterceptors[typeof(TestRepositoryInterceptor)].Value;
+            var configueredInterceptor2 = (TestRepositoryInterceptor)repoOptions.Interceptors[typeof(TestRepositoryInterceptor)].Value;
 
             Assert.NotNull(configueredInterceptor2);
             Assert.Equal("RANDOM P1", configueredInterceptor2.P1);
@@ -153,22 +150,35 @@ public void DependencyInjectionCanConfigureRepositoriesWithScannedInterceptors()
                 options.UseLoggerProvider(TestXUnitLoggerProvider);
             });
 
-            var repo = new Repository<Customer>(kernel.Get<IRepositoryOptions>());
+            var repoOptions = kernel.Get<IRepositoryOptions>();
 
-            Assert.Equal(3, GetLazyInterceptorsOptionsFromPrivateField<InternalRepositoryBase<Customer>>(repo).Count());
+            Assert.Equal(3, repoOptions.Interceptors.Count());
             Assert.Equal(3, kernel.GetAll<IRepositoryInterceptor>().Count());
             Assert.NotNull(kernel.Get<TestRepositoryInterceptorWithDependencyInjectedServices>());
             Assert.NotNull(kernel.Get<TestRepositoryTimeStampInterceptor>());
             Assert.NotNull(kernel.Get<TestRepositoryInterceptor>());
         }
 
-        private static IReadOnlyDictionary<Type, Lazy<IRepositoryInterceptor>> GetLazyInterceptorsOptionsFromPrivateField<T>(object obj)
+        [Fact]
+        public void DependencyInjectionCanConfigureLogginProviderWithScannedLogger()
         {
-            var options = (IRepositoryOptions)typeof(T)
-                .GetField("_options", BindingFlags.NonPublic | BindingFlags.Instance)
-                .GetValue(obj);
+            var kernel = new StandardKernel();
 
-            return options.Interceptors;
+            kernel.BindRepositories<MicrosoftDependencyInjectionTests>(options =>
+            {
+                options.UseInMemoryDatabase(Guid.NewGuid().ToString(), ignoreTransactionWarning: true);
+                options.UseLoggerProvider(TestXUnitLoggerProvider);
+            });
+
+            var repoOptions = kernel.Get<IRepositoryOptions>();
+
+            Assert.Equal(typeof(TestXUnitLoggerProvider), repoOptions.LoggerProvider.GetType());
+
+            Assert.Equal(3, repoOptions.Interceptors.Count());
+            Assert.Equal(3, kernel.GetAll<IRepositoryInterceptor>().Count());
+            Assert.NotNull(kernel.Get<TestRepositoryInterceptorWithDependencyInjectedServices>());
+            Assert.NotNull(kernel.Get<TestRepositoryTimeStampInterceptor>());
+            Assert.NotNull(kernel.Get<TestRepositoryInterceptor>());
         }
     }
 }