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);
}
