Merge pull request #55 from marcwittke/feature/forelab

avoid usage of Activator.CreateInstance, using ICompositionRoot instead

src/implementations/Backend.Fx.EfCorePersistence/DatabaseManager.cs

@@ -1,28 +1,27 @@
 namespace Backend.Fx.EfCorePersistence
 {
-    using System;
-    using System.Linq;
-    using System.Reflection;
+    using System.Data;
     using Environment.Persistence;
     using Logging;
     using Microsoft.EntityFrameworkCore;
+    using Backend.Fx.Patterns.DependencyInjection;
 
     public abstract class DatabaseManager<TDbContext> : IDatabaseManager where TDbContext : DbContext
     {
-        private readonly Func<TDbContext> _dbContextFactory;
+        private readonly ICompositionRoot _compositionRoot;
         private static readonly ILogger Logger = LogManager.Create<DatabaseManager<TDbContext>>();
-        
-        protected DatabaseManager(Func<TDbContext> dbContextFactory)
+
+        protected DatabaseManager(ICompositionRoot compositionRoot)
         {
-            _dbContextFactory = dbContextFactory;
+            _compositionRoot = compositionRoot;
         }
-        
+
         public bool DatabaseExists { get; protected set; }
 
         public void EnsureDatabaseExistence()
         {
             Logger.Info("Ensuring database existence");
-            using (var dbContext = _dbContextFactory())
+            using (var dbContext = _compositionRoot.GetInstance<TDbContext>())
             {
                 ExecuteCreationStrategy(dbContext);
             }
@@ -36,49 +35,30 @@ public void EnsureDatabaseExistence()
         private void EnsureSearchIndexExistence()
         {
             Logger.Info("Ensuring existence of full text search indizes");
-            var fullTextSearchIndexTypes = typeof(TDbContext)
-                    .GetTypeInfo()
-                    .Assembly
-                    .ExportedTypes
-                    .Select(t => t.GetTypeInfo())
-                    .Where(t => t.IsClass && !t.IsAbstract && !t.IsGenericType && typeof(IFullTextSearchIndex).GetTypeInfo().IsAssignableFrom(t));
 
-            using (var dbContext = _dbContextFactory())
+            using (var dbContext = _compositionRoot.GetInstance<TDbContext>())
             {
-                foreach (var fullTextSearchIndexType in fullTextSearchIndexTypes)
+                foreach (var fullTextSearchIndexType in _compositionRoot.GetInstances<IFullTextSearchIndex>())
                 {
-                    IFullTextSearchIndex fullTextSearchIndex = (IFullTextSearchIndex)Activator.CreateInstance(fullTextSearchIndexType.AsType());
-                    fullTextSearchIndex.EnsureIndex(dbContext);
+                    fullTextSearchIndexType.EnsureIndex(dbContext);
                 }
             }
         }
 
         private void EnsureSequenceExistence()
         {
             Logger.Info("Ensuring existence of sequences");
-            var sequenceTypes = typeof(TDbContext)
-                    .GetTypeInfo()
-                    .Assembly
-                    .ExportedTypes
-                    .Select(t => t.GetTypeInfo())
-                    .Where(t => t.IsClass && !t.IsAbstract && !t.IsGenericType && typeof(ISequence).GetTypeInfo().IsAssignableFrom(t));
-
-            using (var dbContext = _dbContextFactory())
+            foreach (var sequence in _compositionRoot.GetInstances<ISequence>())
             {
-                foreach (var sequenceType in sequenceTypes)
-                {
-                    ISequence sequence = (ISequence)Activator.CreateInstance(sequenceType.AsType());
-                    sequence.EnsureSequence(dbContext.Database.GetDbConnection());
-                }
+                sequence.EnsureSequence(_compositionRoot.GetInstance<IDbConnection>());
             }
-
         }
 
         protected abstract void ExecuteCreationStrategy(DbContext dbContext);
 
         public virtual void DeleteDatabase()
         {
-            using (var dbContext = _dbContextFactory())
+            using (var dbContext = _compositionRoot.GetInstance<TDbContext>())
             {
                 Logger.Warn("Database is being deleted!");
                 dbContext.Database.EnsureDeleted();

src/implementations/Backend.Fx.EfCorePersistence/DatabaseManagerWithMigration.cs

@@ -1,3 +1,5 @@
+using Backend.Fx.Patterns.DependencyInjection;
+
 namespace Backend.Fx.EfCorePersistence
 {
     using System;
@@ -8,7 +10,7 @@ public class DatabaseManagerWithMigration<TDbContext> : DatabaseManager<TDbConte
     {
         private static readonly ILogger Logger = LogManager.Create<DatabaseManagerWithMigration<TDbContext>>();
 
-        public DatabaseManagerWithMigration(Func<TDbContext> dbContextFactory) : base(dbContextFactory)
+        public DatabaseManagerWithMigration(ICompositionRoot compositionRoot) : base(compositionRoot)
         { }
 
         protected override void ExecuteCreationStrategy(DbContext dbContext)

src/implementations/Backend.Fx.EfCorePersistence/DatabaseManagerWithoutMigration.cs

@@ -1,14 +1,14 @@
 namespace Backend.Fx.EfCorePersistence
 {
-    using System;
     using Logging;
     using Microsoft.EntityFrameworkCore;
+    using Backend.Fx.Patterns.DependencyInjection;
 
     public class DatabaseManagerWithoutMigration<TDbContext> : DatabaseManager<TDbContext> where TDbContext : DbContext
     {
         private static readonly ILogger Logger = LogManager.Create<DatabaseManagerWithoutMigration<TDbContext>>();
 
-        public DatabaseManagerWithoutMigration(Func<TDbContext> dbContextFactory) : base(dbContextFactory)
+        public DatabaseManagerWithoutMigration(ICompositionRoot compositionRoot) : base(compositionRoot)
         { }
 
         protected override void ExecuteCreationStrategy(DbContext dbContext)

tests/Backend.Fx.EfCorePersistence.Tests/TestCompositionRoot.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Backend.Fx.Patterns.DependencyInjection;
+using Backend.Fx.Patterns.EventAggregation.Domain;
+
+namespace Backend.Fx.EfCorePersistence.Tests
+{
+    public class TestCompositionRoot : ICompositionRoot
+    {
+        private readonly Dictionary<Type, object[]> _registry;
+
+        public TestCompositionRoot(params object[] instances)
+        {
+            _registry = instances
+                .GroupBy(i => i.GetType())
+                .ToDictionary(grp => grp.Key, grp => grp.ToArray());
+        }
+
+        public void Dispose()
+        { }
+
+        public IEnumerable<IDomainEventHandler<TDomainEvent>> GetAllEventHandlers<TDomainEvent>()
+            where TDomainEvent : IDomainEvent
+        {
+            return new IDomainEventHandler<TDomainEvent>[0];
+        }
+
+        public object GetInstance(Type serviceType)
+        {
+            if (_registry.TryGetValue(serviceType, out var instances))
+            {
+                return instances.FirstOrDefault();
+            }
+
+            return null;
+        }
+
+        public T GetInstance<T>() where T : class
+        {
+            return (T)GetInstance(typeof(T));
+        }
+
+        public IEnumerable<T> GetInstances<T>() where T : class
+        {
+            if (_registry.TryGetValue(typeof(T), out var instances))
+            {
+                return instances.Cast<T>();
+            }
+
+            return new T[0];
+        }
+
+        public void Verify()
+        { }
+
+        public void RegisterModules(params IModule[] modules)
+        { }
+    }
+}

tests/Backend.Fx.EfCorePersistence.Tests/TheDatabaseManager.cs

@@ -1,4 +1,5 @@
 using Backend.Fx.EfCorePersistence.Tests.DummyImpl.Persistence;
+using FakeItEasy;
 using Xunit;
 
 namespace Backend.Fx.EfCorePersistence.Tests
@@ -19,7 +20,9 @@ public TheDatabaseManager()
         {
             _dbFilePath = Path.GetTempFileName();
             _dbContextOptions = new DbContextOptionsBuilder<TestDbContext>().UseSqlite("Data Source=" + _dbFilePath).Options;
-            _sut = new DatabaseManagerWithoutMigration<TestDbContext>(() => new TestDbContext(_dbContextOptions));
+
+            var testCompRoot = new TestCompositionRoot(new TestDbContext(_dbContextOptions));
+            _sut = new DatabaseManagerWithoutMigration<TestDbContext>(testCompRoot);
         }
 
         [Fact]