Beispiel #1
0
 public void Run(RegistrationTaskContext context)
 {
     BootstrapperRegistrationTasksHelper.Tasks.Add($"Executed {this.GetType().Name}");
     context.Container
     .AddTransient <Employee>()
     .AddTransient <ClassWithInjectedDependency>();
 }
Beispiel #2
0
        public void Run(RegistrationTaskContext context)
        {
            var container = context.Container;

            container.AddScoped <MediatorDataContext>();
            container.AddInterceptor <EFQueryTrackingBehaviorInterceptor>();
        }
        public void Run(RegistrationTaskContext context)
        {
            if (MediatorTestHelper.IsSqlServer)
            {
                //context.Container.AddDbContext<SchoolDbContext>(options =>
                //{
                //	options.UseSqlite("Data Source=TestDatabase.db");
                //	options.ConfigureWarnings(x => x.Ignore(RelationalEventId.AmbientTransactionWarning));
                //});


                context.Container.AddDbContext <SchoolDbContext>(options =>
                {
                    options.UseSqlServer("Data Source=127.0.0.1;initial catalog=Testing;persist security info=True;User ID=sa;Password=$Password1;");
                });
            }
            else
            {
                context.Container.AddDbContext <SchoolDbContext>(options =>
                {
                    options.UseInMemoryDatabase("InMemoryDbForTesting");
                    options.ConfigureWarnings(x => x.Ignore(RelationalEventId.AmbientTransactionWarning));
                });
            }
        }
Beispiel #4
0
        public void Run(RegistrationTaskContext context)
        {
            var efAutoDetectChangesInterceptor = new Mock <IBoltOnLogger <EFQueryTrackingBehaviorInterceptor> >();

            efAutoDetectChangesInterceptor.Setup(s => s.Debug(It.IsAny <string>()))
            .Callback <string>(st => MediatorTestHelper.LoggerStatements.Add(st));
            context.Container.AddTransient((s) => efAutoDetectChangesInterceptor.Object);
        }
        public void Run(RegistrationTaskContext context)
        {
            var container = context.Container;

            container.AddTransient <IMediator, Pipeline.Mediator>();
            container.AddSingleton <IUnitOfWorkOptionsBuilder, UnitOfWorkOptionsBuilder>();
            RegisterInterceptors(container);
            RegisterHandlers(context);
            RegisterOneWayRequestHandlers(context);
            RegisterAsyncHandlers(context);
            RegisterOneWayAsyncHandlers(context);
        }
        public void Run(RegistrationTaskContext context)
        {
            var boltOnClock     = new Mock <IBoltOnClock>();
            var currentDateTime = DateTime.Parse("10/27/2018 12:51:59 PM");

            boltOnClock.Setup(s => s.Now).Returns(currentDateTime);
            context.Container.AddTransient((s) => boltOnClock.Object);

            var testInterceptorLogger = new Mock <IBoltOnLogger <TestInterceptor> >();

            testInterceptorLogger.Setup(s => s.Debug(It.IsAny <string>()))
            .Callback <string>(st => MediatorTestHelper.LoggerStatements.Add(st));
            context.Container.AddTransient((s) => testInterceptorLogger.Object);

            var stopWatchInterceptorLogger = new Mock <IBoltOnLogger <StopwatchInterceptor> >();

            stopWatchInterceptorLogger.Setup(s => s.Debug(It.IsAny <string>()))
            .Callback <string>(st => MediatorTestHelper.LoggerStatements.Add(st));
            context.Container.AddTransient((s) => stopWatchInterceptorLogger.Object);

            //var efAutoDetectChangesInterceptor = new Mock<IBoltOnLogger<EFAutoDetectChangesDisablingInterceptor>>();
            //efAutoDetectChangesInterceptor.Setup(s => s.Debug(It.IsAny<string>()))
            //                         .Callback<string>(st => MediatorTestHelper.LoggerStatements.Add(st));
            //context.Container.AddTransient((s) => efAutoDetectChangesInterceptor.Object);

            var customUoWOptionsBuilder = new Mock <IBoltOnLogger <CustomUnitOfWorkOptionsBuilder> >();

            customUoWOptionsBuilder.Setup(s => s.Debug(It.IsAny <string>()))
            .Callback <string>(st => MediatorTestHelper.LoggerStatements.Add(st));
            context.Container.AddTransient((s) => customUoWOptionsBuilder.Object);

            var uowOptionsBuilderLogger = new Mock <IBoltOnLogger <UnitOfWorkOptionsBuilder> >();

            uowOptionsBuilderLogger.Setup(s => s.Debug(It.IsAny <string>()))
            .Callback <string>(st => MediatorTestHelper.LoggerStatements.Add(st));
            context.Container.AddTransient((s) => uowOptionsBuilderLogger.Object);

            if (MediatorTestHelper.IsClearInterceptors)
            {
                context.Container.RemoveAllInterceptors();
            }

            if (MediatorTestHelper.IsCustomizeIsolationLevel)
            {
                context.Container.AddSingleton <IUnitOfWorkOptionsBuilder, CustomUnitOfWorkOptionsBuilder>();
            }

            context.Container.AddInterceptor <TestInterceptor>();
        }
        private void RegisterOneWayAsyncHandlers(RegistrationTaskContext context)
        {
            var requestHandlerInterfaceType = typeof(IRequestAsyncHandler <>);
            var handlers = (from a in context.Assemblies.ToList()
                            from t in a.GetTypes()
                            from i in t.GetInterfaces()
                            where i.IsGenericType &&
                            requestHandlerInterfaceType.IsAssignableFrom(i.GetGenericTypeDefinition())
                            select new { Interface = i, Implementation = t }).ToList();

            foreach (var handler in handlers)
            {
                context.Container.AddTransient(handler.Interface, handler.Implementation);
            }
        }