public void ShouldRegisterWithConventionAndWithRegistration()
        {
            //Arrange
            var assembly = Assembly.GetAssembly(typeof(TestAutofacRegistration));

            A.CallTo(() => registrationHelper.GetAssemblies())
            .Returns(new List <Assembly> {
                assembly
            });
            A.CallTo(() => registrationHelper.GetTypesImplementing <IAutofacRegistration>(assembly))
            .Returns(new List <Type> {
                typeof(TestAutofacRegistration)
            });
            A.CallTo(() => options.AutoRegistration).Returns(true);
            var containerExtension = new AutofacExtension(registrationHelper, options);

            //Act
            containerExtension.Run();

            //Assert
            A.CallTo(() => registrationHelper.GetAssemblies()).MustHaveHappened();
            A.CallTo(() => registrationHelper.GetTypesImplementing <IAutofacRegistration>(assembly)).MustHaveHappened();
            Assert.IsNotNull(containerExtension.Resolve <IRegistrationHelper>());
            Assert.IsNotNull(containerExtension.Resolve <IRegisteredByConvention>());
        }
        public void ShouldInvokeTheLoadMethodOfAllIModuleTypes()
        {
            //Arrange
            var assembly = Assembly.GetAssembly(typeof(TestAutofacModule));

            A.CallTo(() => registrationHelper.GetAssemblies())
            .Returns(new List <Assembly> {
                assembly
            });
            A.CallTo(() => registrationHelper.GetTypesImplementing <IModule>(assembly))
            .Returns(new List <Type> {
                typeof(TestAutofacModule)
            });
            var containerExtension = new AutofacExtension(registrationHelper, options);

            //Act
            containerExtension.Run();
            var result = containerExtension.Resolve <ITestInterface>();

            //Assert
            A.CallTo(() => registrationHelper.GetAssemblies()).MustHaveHappened();
            A.CallTo(() => registrationHelper.GetTypesImplementing <IModule>(assembly)).MustHaveHappened();
            Assert.IsNotNull(result);
            Assert.IsInstanceOfType(result, typeof(ITestInterface));
        }
        public void ShouldThrowNoContainerExceptionWhenResolvingSimpleTypeBeforeInitializingTheContainer()
        {
            //Arrange
            var containerExtension = new AutofacExtension(registrationHelper, options);

            //Act
            var result = ExceptionAssert.Throws <NoContainerException>(() => containerExtension.Resolve <object>());

            //Assert
            Assert.AreEqual(NoContainerException.DefaultMessage, result.Message);
        }
        public Task Execute(IJobExecutionContext context)
        {
            //_logger.LogInformation($"{result} at {DateTime.Now.ToDateTimeString()}!");
            //var service = AutofacExtension.Resolve<IUserQueryService>();
            //_logger.LogInformation($"施晓勇测试:{service.GetAll().ToJson()}");

            var service = AutofacExtension.Resolve <ITimeSource>();

            //_logger.LogInformation($"施晓勇测试:{service.GetCurrentTime()}");
            NLogHelper.Default.Info($"施晓勇测试:{service.GetCurrentTime()}");
            return(Task.CompletedTask);
        }
        public void ShouldResolveASingleType()
        {
            //Arrange
            var containerExtension = new AutofacExtension(registrationHelper, options);
            var containerBuilder   = new ContainerBuilder();
            var instance           = new object();

            containerBuilder.RegisterInstance(instance);
            containerExtension.InitializeContainer(containerBuilder.Build());

            //Act
            var result = containerExtension.Resolve <object>();

            //Assert
            Assert.IsNotNull(result);
            Assert.AreSame(instance, result);
        }
        public void ShouldInvokeTheRegisterMethodOfAllIBootstrapperRegistrationTypes()
        {
            //Arrange
            var assembly = Assembly.GetAssembly(typeof(AutoMapperRegistration));

            A.CallTo(() => registrationHelper.GetAssemblies())
            .Returns(new List <Assembly> {
                assembly
            });
            A.CallTo(() => registrationHelper.GetTypesImplementing <IBootstrapperRegistration>(assembly))
            .Returns(new List <Type> {
                typeof(AutoMapperRegistration)
            });
            var containerExtension = new AutofacExtension(registrationHelper, options);

            //Act
            containerExtension.Run();

            //Assert
            A.CallTo(() => registrationHelper.GetAssemblies()).MustHaveHappened();
            A.CallTo(() => registrationHelper.GetTypesImplementing <IBootstrapperRegistration>(assembly)).MustHaveHappened();
            Assert.IsNotNull(containerExtension.Resolve <IProfileExpression>());
        }
예제 #7
0
        public void Run_WhenInvokedAndAutoMapperExtensionIsLoaded_ShouldRegisterMapperAsSingelton()
        {
            //Arrange
            var assembly = Assembly.GetAssembly(typeof(AutoMapperRegistration));

            A.CallTo(() => registrationHelper.GetAssemblies())
            .Returns(new List <Assembly> {
                assembly
            });
            A.CallTo(() => registrationHelper.GetTypesImplementing <IBootstrapperRegistration>(assembly))
            .Returns(new List <Type> {
                typeof(AutoMapperRegistration)
            });
            var containerExtension = new AutofacExtension(registrationHelper, options);

            //Act
            containerExtension.Run();

            //Assert
            Assert.AreSame(Mapper.Configuration, containerExtension.Resolve <IProfileExpression>());
            Assert.AreSame(Mapper.Engine, containerExtension.Resolve <IMappingEngine>());
            Assert.AreSame(containerExtension.Resolve <IProfileExpression>(), containerExtension.Resolve <IProfileExpression>());
            Assert.AreSame(containerExtension.Resolve <IMappingEngine>(), containerExtension.Resolve <IMappingEngine>());
        }