public static IArrangeBuilder <ContainerBuilder> UseDbContext <TContext>(this IArrangeBuilder <ContainerBuilder> arrangeBuilder, out TContext result)
where TContext : DbContext
{
result = AddDbContext <TContext>(arrangeBuilder as ArrangeBuilder);
return(arrangeBuilder);
}
/// <summary>
/// Define a Mock.Of<<typeparamref name="TMock"/>> of a dependency that will be used in testing
/// Produces the <typeparamref name="TMock"/> as out parameter
/// </summary>
/// <typeparam name="TMock"></typeparam>
/// <param name="arrangeBuilder"></param>
/// <param name="mock"></param>
/// <returns></returns>
public static IArrangeBuilder <ContainerBuilder> UseMock <TMock>(this IArrangeBuilder <ContainerBuilder> arrangeBuilder, out Mock <TMock> result)
where TMock : class
{
result = AddMock(arrangeBuilder as ArrangeBuilder, (Mock <TMock> mock) => Mock.Of <TMock>());
return(arrangeBuilder);
}
/// <summary>
/// Define a mock of a dependency that will be used in testing
/// Produces the <typeparamref name="TMock"/> as out parameter
/// </summary>
/// <typeparam name="TMock"></typeparam>
/// <param name="arrangeBuilder"></param>
/// <param name="mock"></param>
/// <returns></returns>
public static IArrangeBuilder <ContainerBuilder> UseMock <TMock>(this IArrangeBuilder <ContainerBuilder> arrangeBuilder, Action <Mock <TMock> > mock, out Mock <TMock> result)
where TMock : class
{
result = AddMock(arrangeBuilder as ArrangeBuilder, mock);
return(arrangeBuilder);
}
public static IArrangeBuilder <ContainerBuilder> UseMemoryCache <T>(this IArrangeBuilder <ContainerBuilder> arrangeBuilder, object key, T value)
{
var memoryCache = AddMemoryCache(arrangeBuilder as ArrangeBuilder);
memoryCache.Set(key, value);
return(arrangeBuilder);
}
private static TEntity AddEntity <TEntity, TContext>(IArrangeBuilder <ContainerBuilder> arrangeBuilder, TEntity entity)
where TEntity : class
where TContext : DbContext
{
arrangeBuilder.UseDbContext <TContext>(out var db);
db.Set <TEntity>().Add(entity);
db.SaveChanges();
return(entity);
}
/// <summary>
/// Creates a Mock<ILogger<<typeparamref name="T"/>>> as an out parameter that you can verify logging on LogLevel
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="arrangeBuilder"></param>
/// <param name="logger"></param>
/// <returns></returns>
public static IArrangeBuilder <ContainerBuilder> UseLogger <T>(this IArrangeBuilder <ContainerBuilder> arrangeBuilder, out Mock <ILogger <T> > logger)
{
if (arrangeBuilder is ArrangeBuilder builder)
{
logger = AddLogger <T>(builder);
}
else
{
logger = new Mock <ILogger <T> >();
}
return(arrangeBuilder);
}
/// <summary>
/// Unsing all implementations of T in provided assemblies
/// </summary>
/// <typeparam name="TInterface"></typeparam>
/// <param name="arrangeBuilder"></param>
/// <returns></returns>
public static IArrangeBuilder <ContainerBuilder> UseImplementationsOf <TInterface>(this IArrangeBuilder <ContainerBuilder> arrangeBuilder, params Assembly[] assemblies)
where TInterface : class
{
if (arrangeBuilder is ArrangeBuilder builder)
{
AddImplementationsOf <TInterface>(builder, assemblies);
}
return(arrangeBuilder);
}
/// <summary>
/// Using all implementations of T in the assembly of T
/// </summary>
/// <typeparam name="TInterface"></typeparam>
/// <param name="arrangeBuilder"></param>
/// <returns></returns>
public static IArrangeBuilder <ContainerBuilder> UseImplementationsOf <TInterface>(this IArrangeBuilder <ContainerBuilder> arrangeBuilder)
where TInterface : class
{
if (arrangeBuilder is ArrangeBuilder builder)
{
AddImplementationsOf <TInterface>(builder, typeof(TInterface).Assembly);
}
return(arrangeBuilder);
}
/// <summary>
/// Difine dependency via the AutoFac Cointainer builder.
/// </summary>
/// <param name="arrangeBuilder"></param>
/// <param name="dependency"></param>
/// <returns></returns>
public static IArrangeBuilder <ContainerBuilder> UseContainerBuilder(this IArrangeBuilder <ContainerBuilder> arrangeBuilder, Action <ContainerBuilder> dependency)
{
AddDependency(arrangeBuilder as ArrangeBuilder, dependency);
return(arrangeBuilder);
}
public static IArrangeBuilder <ContainerBuilder> UseMemoryCache(this IArrangeBuilder <ContainerBuilder> arrangeBuilder)
{
AddMemoryCache(arrangeBuilder as ArrangeBuilder);
return(arrangeBuilder);
}
/// <summary>
/// Adds all implementations of TInterface in assemblies
/// </summary>
/// <param name="arrangeBuilder"></param>
/// <param name="assemblies"></param>
/// <typeparam name="TInterface"></typeparam>
/// <returns></returns>
public static IArrangeBuilder <ContainerBuilder> UseImplementations <TInterface>(this IArrangeBuilder <ContainerBuilder> arrangeBuilder, params Assembly[] assemblies)
where TInterface : class
{
if (arrangeBuilder is ArrangeBuilder builder)
{
var type = typeof(TInterface);
var implementations = assemblies
.SelectMany(s => s.GetTypes())
.Where(t => type.IsAssignableFrom(t) && !t.IsInterface && !t.IsAbstract);
foreach (var implementation in implementations)
{
AddDependency <TInterface>(builder, implementation);
}
}
return(arrangeBuilder);
}
/// <summary>
/// Define an implementation for a interface.
/// </summary>
/// <param name="arrangeBuilder"></param>
/// <param name="implementation">The object that should be used as implementation</param>
/// <typeparam name="TInterface"></typeparam>
/// <typeparam name="TImplementation"></typeparam>
/// <returns></returns>
public static IArrangeBuilder <ContainerBuilder> UseImplementation <TInterface, TImplementation>(this IArrangeBuilder <ContainerBuilder> arrangeBuilder, TImplementation implementation)
where TInterface : class
where TImplementation : class, TInterface
{
if (arrangeBuilder is ArrangeBuilder builder)
{
builder.AddDependency((containerBuilder) =>
{
containerBuilder.Register(context => implementation).As <TInterface>();
});
}
return(arrangeBuilder);
}
/// <summary>
/// Define an implementation for a interface.
/// If the implementation has undefined dependencies they will default to Mock.Of<T>
/// </summary>
/// <typeparam name="TInterface"></typeparam>
/// <typeparam name="TImplementation"></typeparam>
/// <param name="arrangeBuilder"></param>
/// <returns></returns>
public static IArrangeBuilder <ContainerBuilder> UseImplementation <TInterface, TImplementation>(this IArrangeBuilder <ContainerBuilder> arrangeBuilder)
where TInterface : class
where TImplementation : class, TInterface
{
if (arrangeBuilder is ArrangeBuilder builder)
{
AddDependency <TInterface>(builder, typeof(TImplementation));
}
return(arrangeBuilder);
}
public static IArrangeBuilder <ContainerBuilder> UseEntity <TEntity, TContext>(this IArrangeBuilder <ContainerBuilder> arrangeBuilder, TEntity entity, out TEntity result)
where TEntity : class
where TContext : DbContext
{
result = AddEntity <TEntity, TContext>(arrangeBuilder, entity);
return(arrangeBuilder);
}
public static IArrangeBuilder <ContainerBuilder> UseEntity <TEntity, TContext>(this IArrangeBuilder <ContainerBuilder> arrangeBuilder, Func <TEntity> entityBuilder)
where TEntity : class
where TContext : DbContext
{
var entity = entityBuilder();
AddEntity <TEntity, TContext>(arrangeBuilder, entity);
return(arrangeBuilder);
}
/// <summary>
/// Define an <typeparamref name="TEntity"/> to be added to <typeparamref name="TContext"/>.
/// If <typeparamref name="TContext"/> is not yet defined in the scope, it will be added aswell.
/// Produces the <typeparamref name="TEntity"/> as out parameter
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <typeparam name="TContext"></typeparam>
/// <param name="arrangeBuilder"></param>
/// <param name="entityBuilder"></param>
/// <param name="result"></param>
/// <returns></returns>
public static IArrangeBuilder <ContainerBuilder> UseEntity <TEntity, TContext>(this IArrangeBuilder <ContainerBuilder> arrangeBuilder, Action <TEntity> entityBuilder, out TEntity result)
where TEntity : class
where TContext : DbContext
{
var entity = Activator.CreateInstance <TEntity>();
entityBuilder(entity);
result = AddEntity <TEntity, TContext>(arrangeBuilder, entity);
return(arrangeBuilder);
}
