/// <summary>
/// Resolves a <see cref="ProjectTemplateDbContext"/> service scope and executes a delegate action.
/// The scoped DbContext is disposed after the delegate is executed.
/// </summary>
/// <param name="action">The delegate <see cref="Action"/> to execute with the scoped <see cref="ProjectTemplateDbContext"/></param>
public static void ExecuteWithDbScope(this IServiceProvider provider, Action <ProjectTemplateDbContext> action)
{
using IServiceScope scope = provider.CreateScope();
ProjectTemplateDbContext db = scope.ServiceProvider.GetRequiredService <ProjectTemplateDbContext>();
action.Invoke(db);
}
/// <summary>
/// Asynchronously resolves a <see cref="ProjectTemplateDbContext"/> service scope and executes a delegate function.
/// The scoped DbContext is disposed after the delegate is executed.
/// </summary>
/// <param name="func">The delegate <see cref="Func{T, TResult}"/> to execute with the scoped <see cref="ProjectTemplateDbContext"/></param>
public static async Task <TResult> ExecuteWithDbScope <TResult>(this IServiceProvider provider, Func <ProjectTemplateDbContext, Task <TResult> > func)
{
using IServiceScope scope = provider.CreateScope();
ProjectTemplateDbContext db = scope.ServiceProvider.GetRequiredService <ProjectTemplateDbContext>();
return(await func.Invoke(db).ConfigureAwait(false));
}
// Query handler constructor
public LibraryQueryHandler(
IMediator mediator,
ProjectTemplateDbContext database,
IMapper mapper,
IAuthorizationService authorizationService)
: base(mediator, database, mapper, authorizationService)
{
}
public static Project CreateValidNewProject(ProjectTemplateDbContext database, Group group = null)
{
return(new Project()
{
Name = RandomFactory.GetCodeName(),
Group = group ?? GetRandomGroup(database)
});
}
public static Group CreateValidNewGroup(ProjectTemplateDbContext database, string name = "")
{
return(new Group()
{
Name = name.Length == 0 ? RandomFactory.GetAlphanumericString(8) : name,
IsActive = RandomFactory.GetBoolean()
});
}
public CreateGroupCommandHandler(
IMediator mediator,
ProjectTemplateDbContext database,
IMapper mapper,
IAuthorizationService authorizationService)
: base(mediator, database, mapper, authorizationService)
{
}
protected CommandHandlerBase(
IMediator mediator,
ProjectTemplateDbContext database,
IMapper mapper,
IAuthorizationService authorizationService)
: base(mediator, database, mapper, authorizationService)
{
}
protected QueryHandlerBase(
IMediator mediator,
ProjectTemplateDbContext database,
IMapper mapper,
IAuthorizationService authorizationService)
: base(mediator, database, mapper, authorizationService)
{
// queries do not make changes to the database so we do not need ChangeTracker
database.ChangeTracker.QueryTrackingBehavior = EntityFrameworkCore.QueryTrackingBehavior.NoTracking;
}
protected HandlerBase(
IMediator mediator,
ProjectTemplateDbContext database,
IMapper mapper,
IAuthorizationService authorizationService)
{
Mediator = mediator;
Database = database;
Mapper = mapper;
AuthorizationService = authorizationService;
}
public GroupCreatedEventHandler(
IMediator mediator,
ProjectTemplateDbContext database,
IMapper mapper,
IAuthorizationService authorizationService,
IEmailService emailService,
ILogger <GroupCreatedEventHandler> logger)
: base(mediator, database, mapper, authorizationService)
{
_emailService = emailService;
_logger = logger;
}
/// <summary>
/// Execute a query against an in-memory database seeded with test data and then check assertions using the return value.
/// </summary>
/// <remarks>To test methods which we expect to throw an exception, don't specify <paramref name="assertions"/>.</remarks>
/// <param name="func">Function to execute.</param>
/// <param name="assertions">Assertions to execute after the function has executed.</param>
protected async Task ExecuteWithDb <TResult>(
Func <ProjectTemplateDbContext, Task <TResult> > func,
Action <TResult, ProjectTemplateDbContext> assertions = null)
{
using (var db = new ProjectTemplateDbContext(CreateInMemoryContextOptions()))
{
// seed test data
new TestDataSeeder(db, LoggerFactory.CreateLogger <TestDataSeeder>()).SeedTestData();
// execute our test
var result = await func(db);
// check our test results
assertions?.Invoke(result, db);
}
}
// Create a new library
public static Library CreateValidNewLibrary(ProjectTemplateDbContext database, string name = "")
{
// Create a new random address
var address = new Address()
{
LocationAddressLine1 = RandomFactory.GetStreetAddress(),
LocationAddressLine2 = "",
LocationCity = RandomFactory.GetCity(),
LocationStateProvince = RandomFactory.GetState(),
LocationZipCode = RandomFactory.GetZip(),
LocationCountry = "US"
};
var library = new Library()
{
Name = RandomFactory.GetLibraryName(),
Address = address
};
return(library);
}
public TestDataSeeder(ProjectTemplateDbContext context, ILogger <TestDataSeeder> logger)
{
_dbContext = context;
_logger = logger;
}
// Retrieves a random library from the database
public static Library GetRandomLibrary(ProjectTemplateDbContext database)
{
return(database.Libraries.OrderBy(x => Guid.NewGuid()).First());
}
public static GroupDto CreateValidNewGroupDto(ProjectTemplateDbContext database, IMapper mapper, string name = "")
{
var group = CreateValidNewGroup(database, name);
return(mapper.Map <GroupDto>(group));
}
public static Group GetRandomGroup(ProjectTemplateDbContext database)
{
return(database.Groups.OrderBy(x => Guid.NewGuid()).First());
}
