I have created a NuGet package to simplify the arrange step when writing tests, that's useful when you use dependency injection.
Basic use
nuget install ArrangeDependencies.Autofac
var arrange = Arrange.Dependencies(dependencies =>
{
dependencies.UseImplementation<IUserService, UserService>();
});
var userService = arrange.Resolve<IUserService>();
// Act
// Assert
This will produce a UserService
to start testing on. All the injected dependencies in UserService
will be injected as Mock.Of<T>()
, resulting in methods calls on any dependency will return the default value of the return type.
When adding more dependencies to the UserService you do not need to change all the tests setups that you have already created. You may, however, still need to change some tests if the behavior has changed.
This arrange block can be simplified by a one liner
var arrange = Arrange.Dependencies<IUserService, UserService>();
This setup will call on UseImplementation<IUserService, UserService>()
under the hood.
Use Mock
nuget install ArrangeDependencies.Autofac
var arrange = Arrange.Dependencies<IUserService, UserService>(dependencies =>
{
dependencies.UseMock<IUserRepository>(mock => {
mock.Setup(x => x.GetByName(It.IsAny<string>())).Returns(new Basis.Entites.User());
});
});
Now UserService
will use your mocked IUserRepository
, instead of the default Mock.Of<T>()
, and return a new User
when GetByName(name)
is called. The mock action is like any other Mock setup that you probably already is used to.
Use DbContext
nuget install ArrangeDependencies.Autofac.EntityFrameworkCore
var arrange = Arrange.Dependencies(dependencies =>
{
dependencies.UseDbContext<TestDbContext>();
});
This will setup an in memory database for TestDbContext in your test.
Use Entity
nuget install ArrangeDependencies.Autofac.EntityFrameworkCore
var arrange = Arrange.Dependencies(dependencies =>
{
dependencies.UseEntity<User, TestDbContext>((user) => user.SetName("Test name"));
});
This will add a new user into TestDbContext
that can be used in testing. NOTE: UseDbContext
is called under the hood here, so you don't need to define it.
var arrange = Arrange.Dependencies(dependencies =>
{
dependencies.UseEntity<Company, TestDbContext>((company) => company.SetName("Test name"), out var company);
dependencies.UseEntity<User, TestDbContext>((user) => {
user.SetName("Test name");
user.SetCompany(company);
});
});
You can also couple the entites by using the out parameter.
Use MemoryCache
nuget install ArrangeDependencies.Autofac.MemoryCache
var user = "Cache test user"
var arrange = Arrange.Dependencies<IUserService, UserService>(dependencies =>
{
dependencies.UseMemoryCache("Cache test", user);
});
With this you can test your cache, where the first parameter is the key and the second is the cached object.
Use Logger
nuget install ArrangeDependencies.Autofac.Logger
Mock<ILogger<LoggingService>> logger = null;
var arrange = Arrange.Dependencies<ILoggingService, LoggingService>(dependencies =>
{
dependencies.UseLogger(out logger);
});
var loggingService = arrange.Resolve<ILoggingService>();
loggingService.LogError();
logger.Verify(LogLevel.Error, Times.Once());
With this you can verfy that you log errors (or any other Log Level).
Create your own extensions
This library is extensible by nature, so if you find yourself writing the same mock setup over and over again, I suggest you to create your own extension method for that mock.
public static class UseMyCustomExtensionExtension
{
public static IArrangeBuilder<ContainerBuilder> UseMyCustomExtension(this IArrangeBuilder<ContainerBuilder> arrangeBuilder, /* parameters... */)
{
if(arrangeBuilder is ArrangeBuilder builder)
builder.UseMock<IMyCustomExtension>(mock => /* setup mock here */);
return arrangeBuilder;
}
}
Top comments (0)