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

Author: johelvisguzman

src/DotNetToolkit.Repository.Extensions.Unity/UnityContainerExtensions.cs

@@ -1,14 +1,15 @@
 namespace DotNetToolkit.Repository.Extensions.Unity
 {
     using Configuration.Interceptors;
+    using Configuration.Logging;
     using Configuration.Options;
     using Configuration.Options.Internal;
     using global::Unity;
     using global::Unity.Lifetime;
     using JetBrains.Annotations;
     using Services;
     using System;
-    using System.Collections.Generic;
+    using System.Linq;
     using System.Reflection;
     using Transactions;
     using Utility;
@@ -72,27 +73,23 @@ public static void RegisterRepositories([NotNull] this IUnityContainer container
 
             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))
+                    {
+                        container.RegisterType(implementationType, implementationType);
+                        container.RegisterType(scanResult.InterfaceType, implementationType, implementationType.FullName);
+                    }
+                    else
                     {
-                        if (scanResult.InterfaceType == typeof(IRepositoryInterceptor))
-                        {
-                            container.RegisterType(implementationType, implementationType);
-                            container.RegisterType(scanResult.InterfaceType, implementationType, implementationType.FullName);
-                            registeredInterceptorTypes.Add(implementationType);
-                        }
-                        else
-                        {
-                            container.RegisterType(scanResult.InterfaceType, implementationType);
-                        }
+                        container.RegisterType(scanResult.InterfaceType, implementationType);
                     }
-                });
+                }
+            });
 
             // Register other services
             container.RegisterFactory<IRepositoryFactory>(c => new RepositoryFactory(c.Resolve<IRepositoryOptions>()), factorylifetimeManager);
@@ -103,14 +100,21 @@ public static void RegisterRepositories([NotNull] this IUnityContainer container
             {
                 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.Resolve(interceptorType));
                     }
                 }
 
+                if (optionsBuilder.Options.LoggerProvider == null)
+                {
+                    var loggerProviderType = scanResults.OfType<ILoggerProvider>().FirstOrDefault();
+
+                    options = options.With((ILoggerProvider)c.Resolve(loggerProviderType));
+                }
+
                 return options;
             }, factorylifetimeManager);
 

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

@@ -8,9 +8,7 @@
     using InMemory;
     using Services;
     using System;
-    using System.Collections.Generic;
     using System.Linq;
-    using System.Reflection;
     using Transactions;
     using Unity;
     using Xunit;
@@ -28,10 +26,10 @@ public void DependencyInjectionCanConfigureRepositoriesServices()
             container.RegisterRepositories<MicrosoftDependencyInjectionTests>(options =>
             {
                 options.UseInMemoryDatabase(Guid.NewGuid().ToString(), ignoreTransactionWarning: true);
-                options.UseLoggerProvider(TestXUnitLoggerProvider);
             });
 
             Assert.NotNull(container.Resolve<TestRepositoryInterceptorWithDependencyInjectedServices>());
+            Assert.NotNull(container.Resolve<TestLoggerProvider>());
             Assert.NotNull(container.Resolve<TestRepositoryTimeStampInterceptor>());
             Assert.NotNull(container.Resolve<TestRepositoryInterceptor>());
             Assert.Equal(3, container.ResolveAll<IRepositoryInterceptor>().Count());
@@ -111,11 +109,9 @@ public void DependencyInjectionCanConfigureRepositoriesWithInterceptorsFromOptio
                 options.UseLoggerProvider(TestXUnitLoggerProvider);
             });
 
-            var repo = new Repository<Customer>(container.Resolve<RepositoryOptions>());
-
-            var configuredInterceptors = GetLazyInterceptorsOptionsFromPrivateField<InternalRepositoryBase<Customer>>(repo);
+            var repoOptions = container.Resolve<IRepositoryOptions>();
 
-            Assert.Equal(3, configuredInterceptors.Count());
+            Assert.Equal(3, repoOptions.Interceptors.Count());
             Assert.Equal(3, container.ResolveAll<IRepositoryInterceptor>().Count());
             Assert.NotNull(container.Resolve<TestRepositoryInterceptorWithDependencyInjectedServices>());
 
@@ -130,12 +126,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 +149,35 @@ public void DependencyInjectionCanConfigureRepositoriesWithScannedInterceptors()
                 options.UseLoggerProvider(TestXUnitLoggerProvider);
             });
 
-            var repo = new Repository<Customer>(container.Resolve<RepositoryOptions>());
+            var repoOptions = container.Resolve<IRepositoryOptions>();
 
-            Assert.Equal(3, GetLazyInterceptorsOptionsFromPrivateField<InternalRepositoryBase<Customer>>(repo).Count());
+            Assert.Equal(3, repoOptions.Interceptors.Count());
             Assert.Equal(3, container.ResolveAll<IRepositoryInterceptor>().Count());
             Assert.NotNull(container.Resolve<TestRepositoryInterceptorWithDependencyInjectedServices>());
             Assert.NotNull(container.Resolve<TestRepositoryTimeStampInterceptor>());
             Assert.NotNull(container.Resolve<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 container = new UnityContainer();
+
+            container.RegisterRepositories<MicrosoftDependencyInjectionTests>(options =>
+            {
+                options.UseInMemoryDatabase(Guid.NewGuid().ToString(), ignoreTransactionWarning: true);
+                options.UseLoggerProvider(TestXUnitLoggerProvider);
+            });
+
+            var repoOptions = container.Resolve<IRepositoryOptions>();
+
+            Assert.Equal(typeof(TestXUnitLoggerProvider), repoOptions.LoggerProvider.GetType());
 
-            return options.Interceptors;
+            Assert.Equal(3, repoOptions.Interceptors.Count());
+            Assert.Equal(3, container.ResolveAll<IRepositoryInterceptor>().Count());
+            Assert.NotNull(container.Resolve<TestRepositoryInterceptorWithDependencyInjectedServices>());
+            Assert.NotNull(container.Resolve<TestRepositoryTimeStampInterceptor>());
+            Assert.NotNull(container.Resolve<TestRepositoryInterceptor>());
         }
     }
 }