public void ShouldAutoResolveMissingDependeciesWithMocks() { var arrange = Arrange.Dependencies <IUserService, UserService>(); var userService = arrange.Resolve <IUserService>(); Assert.IsInstanceOf <UserService>(userService); }
public void ShouldAutoResolveLogging() { var arrange = Arrange.Dependencies <IUserService, UserService>(); var userService = arrange.Resolve <IUserService>(); userService.Log(); }
public void ShouldResolveUseImplementation() { var arrange = Arrange.Dependencies(dependencies => { dependencies.UseImplementation <IUserService, UserService>(); }); var userService = arrange.Resolve <IUserService>(); Assert.IsInstanceOf <UserService>(userService); }
public void ShouldUseDbContext() { var arrange = Arrange.Dependencies(dependencies => { dependencies.UseDbContext <TestDbContext>(); }); var testContext = arrange.Resolve <TestDbContext>(); Assert.IsInstanceOf <TestDbContext>(testContext); }
public void ShouldResolveUseImplementationWhenConstructed() { var arrange = Arrange.Dependencies(dependencies => { dependencies.UseImplementation <IUserFactory, AdminUserFactory>(new AdminUserFactory()); }); var userService = arrange.Resolve <IUserFactory>(); Assert.IsInstanceOf <AdminUserFactory>(userService); }
public void ShouldResolveClassWithInMemoryCacheDependency() { var arrange = Arrange.Dependencies <IUserRepository, UserRepository>(dependencies => { dependencies.UseDbContext <TestDbContext>(); }); var userRepository = arrange.Resolve <IUserRepository>(); Assert.IsInstanceOf <UserRepository>(userRepository); }
public void ShouldResolveMultipleImplementationsFromAssembly() { var arrange = Arrange.Dependencies(dependencies => { dependencies.UseImplementations <IUserFactory>(typeof(IUserFactory).Assembly); }); var providers = arrange.Resolve <IUserFactory[]>(); Assert.AreEqual(2, providers.Length); }
public void ShouldNotCreateMultipleEntitesOnMultipleResolves() { var arrange = Arrange.Dependencies <IUserService, UserService>(dependencies => { dependencies.UseEntity <User, TestDbContext>((user) => user.SetName("Test name")); }); var service = arrange.Resolve <IUserService>(); var db = arrange.Resolve <TestDbContext>(); Assert.AreEqual(1, db.User.Count()); }
public void ShouldAddEntity() { var arrange = Arrange.Dependencies(dependencies => { dependencies.UseEntity <Company, TestDbContext>(new Company()); }); var db = arrange.Resolve <TestDbContext>(); var company = db.Company.FirstOrDefault(); Assert.AreEqual(1, company.Id); }
public void ShouldCreateEntity() { var arrange = Arrange.Dependencies(dependencies => { dependencies.UseEntity <User, TestDbContext>((user) => user.SetName("Test name")); }); var db = arrange.Resolve <TestDbContext>(); var user = db.User.FirstOrDefault(); Assert.IsNotNull(user); }
public void ShouldNotRegisterDbContextTwice() { var arrange = Arrange.Dependencies(dependencies => { dependencies.UseDbContext <TestDbContext>(); dependencies.UseDbContext <TestDbContext>(); }); var testContexts = arrange.Resolve <TestDbContext[]>(); Assert.AreEqual(1, testContexts.Length); }
public void ShouldResolveMultipleImplementations() { var arrange = Arrange.Dependencies(dependencies => { dependencies.UseImplementation <IUserFactory, AdminUserFactory>(); dependencies.UseImplementation <IUserFactory, BasicUserFactory>(); }); var providers = arrange.Resolve <IUserFactory[]>(); Assert.AreEqual(2, providers.Length); }
public void ShouldResolveUsingMock() { var arrange = Arrange.Dependencies <IUserService, UserService>(dependencies => { dependencies.UseMock <IUserRepository>(mock => { mock.Setup(x => x.GetByName(It.IsAny <string>())).Returns(new Basis.Entites.User()); }); }); var userService = arrange.Resolve <IUserService>(); Assert.IsInstanceOf <UserService>(userService); }
public void ShouldCreateMultipleInstances() { for (int i = 0; i < 25; i++) { var arrange = Arrange.Dependencies <IUserService, UserService>(dependencies => { dependencies.UseEntity <User, TestDbContext>((user) => user.SetName("Test name")); }); var db = arrange.Resolve <TestDbContext>(); Assert.AreEqual(1, db.User.Count()); } }
public void DependencyOnLoggerFactoryShouldVerifyLogError() { Mock <ILogger <LoggingService> > logger = null; var arrange = Arrange.Dependencies <ILoggingService, LoggingFactoryService>(dependencies => { dependencies.UseLogger(out logger); }); var loggingService = arrange.Resolve <ILoggingService>(); loggingService.LogError(); logger.Verify(LogLevel.Error, Times.Once()); }
public void ShouldReturnValueInCache() { var user = new User(); user.SetName("Test"); var arrange = Arrange.Dependencies <IUserRepository, UserRepository>(dependencies => { dependencies.UseDbContext <TestDbContext>(); dependencies.UseMemoryCache("Test", user); }); var userRepository = arrange.Resolve <IUserRepository>(); var result = userRepository.GetByName("Test"); Assert.AreEqual(user.Name, result?.Name); }
public void ShouldCreateRelatedEntity() { Company company = null; var arrange = Arrange.Dependencies(dependencies => { dependencies.UseEntity <Company, TestDbContext>((company) => company.SetName("Test name"), out company); dependencies.UseEntity <User, TestDbContext>((user) => { user.SetName("Test name"); user.SetCompany(company); }); }); var db = arrange.Resolve <TestDbContext>(); var user = db.User.FirstOrDefault(); Assert.AreEqual(company.Id, user.CompanyId); Assert.AreNotEqual(0, company.Id); }
public void ExecuteRobotCommands() { Mock <IOutputService> outputService = null; var arrange = Arrange.Dependencies <IRobotApp, RobotApp>(dependencies => { dependencies.UseImplementation <ICleanedSpots, CleanedSpots>(); dependencies.UseMock <IInputService>(mock => mock.SetupSequence(x => x.ReadNextInput()) .Returns("2") .Returns("10 22") .Returns("E 2") .Returns("N 1")); dependencies.UseMock(out outputService); }); var robotApp = arrange.Resolve <IRobotApp>(); robotApp.Run(); outputService.Verify(x => x.Output("=> Cleaned: 4"), Times.Once); }