aswi2021bc304crew-gitlab/tests/Leuze.Tests.Configuration/DatabaseInMemoryFixture.cs @ 678af8f3

using ExtCore.Data.Abstractions;
using ExtCore.Data.EntityFramework;
using ExtCore.Infrastructure;
using FluentValidation;
using Leuze.Core.Application.Behaviors;
using Leuze.Core.Application.Identity;
using Leuze.Core.Infrastructure.Persistence.Interceptors;
using MediatR;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Serilog;
using System;
using System.Linq;

namespace Leuze.Tests.Configuration
{
    /// <summary>
    /// 
    /// </summary>
    public class DatabaseInMemoryFixture : IDisposable
    {
        /// <summary>
        /// Provider for registered services for fixture
        /// </summary>
        public IServiceProvider Services { get; private set; }

        /// <summary>
        /// Instance of database context
        /// </summary>
        public TestingStorageContext Storage { get; private set; }

        /// <summary>
        /// Instance of user manager
        /// </summary>
        public UserManager<ApplicationUser> UserManager { get; private set; }

        /// <summary>
        /// Instance of role manager
        /// </summary>
        public RoleManager<ApplicationRole> RoleManager { get; private set; }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="services"></param>
        public DatabaseInMemoryFixture(ServiceCollection services)
        {
            Log.Logger = new LoggerConfiguration()
                .WriteTo.Console()
                .CreateLogger();

            Utilities.LoadExtensions();
            ConfigureServices(services);
            Services = services.BuildServiceProvider();

            // Assign shortcuts accessors to registered components
            UserManager = Services.GetRequiredService<UserManager<ApplicationUser>>();
            RoleManager = Services.GetRequiredService<RoleManager<ApplicationRole>>();

            // Storage: create using registered db context / storage context
            Storage = (TestingStorageContext)Services.GetRequiredService<IStorageContext>();
        }

        /// <summary>
        /// 
        /// </summary>
        public void Dispose() { }

        private void ConfigureServices(IServiceCollection services)
        {
            //Interceptors
            services.AddScoped<AuditInterceptor>();
            services.AddScoped<DomainEventsInterceptor>();

            // DbContext/IStorageContext
            services.AddDbContext<TestingStorageContext>((serviceProvider, options) =>
            {
                options.UseInMemoryDatabase("TestingInMemoryDatabase");
                var auditInterceptor = serviceProvider.GetService<AuditInterceptor>();
                var domainEventsInterceptor = serviceProvider.GetService<DomainEventsInterceptor>();
                options.AddInterceptors(auditInterceptor, domainEventsInterceptor);
            });

            // Register UserManager & RoleManager
            services.AddIdentity<ApplicationUser, ApplicationRole>()
               .AddEntityFrameworkStores<TestingStorageContext>()
               .AddDefaultTokenProviders();

            // UserManager & RoleManager require logging and HttpContext dependencies
            services.AddLogging();
            services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
            services.AddAutoMapper(ExtensionManager.Assemblies);
            services.AddValidatorsFromAssemblies(ExtensionManager.Assemblies);
            services.AddMediatR(ExtensionManager.Assemblies.ToArray());
            services.AddTransient(typeof(IPipelineBehavior<,>), typeof(ValidationBehavior<,>));

            // Register database-specific storage context implementation.
            services.AddScoped<IStorageContext, TestingStorageContext>();

        }

        /// <summary>
        /// For use by DbContextFactory.
        /// </summary>
        /// <returns></returns>
        public static DbContextOptionsBuilder<TestingStorageContext> GetDbContextOptionsBuilder()
        {
            var optionsBuilder = new DbContextOptionsBuilder<TestingStorageContext>();
            optionsBuilder.UseInMemoryDatabase("TestingInMemoryDatabase");
            return optionsBuilder;
        }

        /// <summary>
        /// Utility class to use the IOptions pattern as required by IStorage implementations constructors.
        /// </summary>
        private class TestStorageContextOptions : IOptions<StorageContextOptions>
        {
            public TestStorageContextOptions(StorageContextOptions value_)
            {
                Value = value_;
            }

            public StorageContextOptions Value { get; }
        }
    }
}