public void And_Epao_Course_Not_Valid_Then_Throws_NotFoundException(
GetCourseEpaoQuery query,
GetEpaoResponse epaoApiResponse,
List <GetCourseEpaoListItem> courseEpaosApiResponse,
List <GetDeliveryAreaListItem> areasFromCache,
[Frozen] Mock <IAssessorsApiClient <AssessorsApiConfiguration> > mockAssessorsApiClient,
[Frozen] Mock <ICachedDeliveryAreasService> mockCacheService,
[Frozen] Mock <ICourseEpaoIsValidFilterService> mockCourseEpaoFilter,
GetCourseEpaoQueryHandler handler)
{
courseEpaosApiResponse[0].EpaoId = query.EpaoId.ToLower();
mockAssessorsApiClient
.Setup(client => client.Get <GetEpaoResponse>(
It.Is <GetEpaoRequest>(request => request.EpaoId == query.EpaoId)))
.ReturnsAsync(epaoApiResponse);
mockAssessorsApiClient
.Setup(client => client.GetAll <GetCourseEpaoListItem>(
It.Is <GetCourseEpaosRequest>(request => request.CourseId == query.CourseId)))
.ReturnsAsync(courseEpaosApiResponse);
mockCacheService
.Setup(service => service.GetDeliveryAreas())
.ReturnsAsync(areasFromCache);
mockCourseEpaoFilter
.Setup(service => service.IsValidCourseEpao(It.IsAny <GetCourseEpaoListItem>()))
.Returns(false);
Func <Task> act = async() => await handler.Handle(query, CancellationToken.None);
act.Should().Throw <NotFoundException <GetCourseEpaoResult> >();
}
public async Task <IActionResult> CourseEpao(GetCourseEpaoDetailsRequest request)
{
try
{
var query = new GetCourseEpaoQuery
{
CourseId = request.Id,
EpaoId = request.EpaoId
};
var result = await _mediator.Send(query);
var model = new CourseEpaoViewModel
{
Course = result.Course,
Epao = new EpaoDetailsViewModel(
result.Epao,
result.EpaoDeliveryAreas,
result.DeliveryAreas,
_locationStringBuilder.BuildLocationString),
CourseEpaosCount = result.CourseEpaosCount,
EffectiveFrom = result.EffectiveFrom,
AllCourses = result.AllCourses
.Select(item => (CourseListItemViewModel)item)
.ToList()
};
return(View(model));
}
catch (Exception ex) when(
ex is ValidationException ||
ex is NotFoundException <CourseEpao>)
{
return(RedirectToRoute(RouteNames.ErrorEpaoUnavailable));
}
}
public async Task Then_Gets_CourseEpao_From_Service(
GetCourseEpaoQuery query,
CourseEpao courseEpao,
List <CourseListItem> allCourses,
[Frozen] Mock <ICourseService> mockCourseService,
GetCourseEpaoQueryHandler handler)
{
allCourses.Add(new CourseListItem("3", "aaaaa", 3, false, new string[] { "1.0" }));
courseEpao.AllCourses = allCourses;
mockCourseService
.Setup(service => service.GetCourseEpao(query.CourseId, query.EpaoId))
.ReturnsAsync(courseEpao);
var result = await handler.Handle(query, CancellationToken.None);
result.Course.Should().BeEquivalentTo(courseEpao.Course);
result.Epao.Should().BeEquivalentTo(courseEpao.Epao);
result.CourseEpaosCount.Should().Be(courseEpao.CourseEpaosCount);
result.EffectiveFrom.Should().Be(courseEpao.EffectiveFrom);
result.EpaoDeliveryAreas.Should().BeEquivalentTo(courseEpao.EpaoDeliveryAreas);
result.DeliveryAreas.Should().BeEquivalentTo(courseEpao.DeliveryAreas);
result.StandardVersions.Should().BeEquivalentTo(courseEpao.StandardVersions);
result.AllCourses.Should().BeEquivalentTo(courseEpao.AllCourses)
.And.BeInAscendingOrder(item => item.Description);
}
public async Task Then_Gets_Epao_From_Assessors_Api_And_Course_From_Courses_Api_And_DeliveryAreas_From_Cache_And_Other_Courses_From_Cache_Filtered(
GetCourseEpaoQuery query,
GetEpaoResponse epaoApiResponse,
List <GetCourseEpaoListItem> courseEpaosApiResponse,
List <GetEpaoCourseListItem> epaoCoursesApiResponse,
List <GetDeliveryAreaListItem> areasFromCache,
GetStandardsListResponse coursesFromCache,
[Frozen] Mock <IAssessorsApiClient <AssessorsApiConfiguration> > mockAssessorsApiClient,
[Frozen] Mock <ICachedDeliveryAreasService> mockCachedAreasService,
[Frozen] Mock <ICachedCoursesService> mockCachedCoursesService,
[Frozen] Mock <ICourseEpaoIsValidFilterService> mockCourseEpaoFilter,
GetCourseEpaoQueryHandler handler)
{
courseEpaosApiResponse[0].EpaoId = query.EpaoId.ToLower();
coursesFromCache.Standards.First().LarsCode = epaoCoursesApiResponse.First().StandardCode;
coursesFromCache.Standards.ElementAt(1).LarsCode = query.CourseId;
mockAssessorsApiClient
.Setup(client => client.Get <GetEpaoResponse>(
It.Is <GetEpaoRequest>(request => request.EpaoId == query.EpaoId)))
.ReturnsAsync(epaoApiResponse);
mockAssessorsApiClient
.Setup(client => client.GetAll <GetCourseEpaoListItem>(
It.Is <GetCourseEpaosRequest>(request => request.CourseId == query.CourseId)))
.ReturnsAsync(courseEpaosApiResponse);
mockAssessorsApiClient
.Setup(client => client.GetAll <GetEpaoCourseListItem>(
It.Is <GetEpaoCoursesRequest>(request => request.EpaoId == query.EpaoId)))
.ReturnsAsync(epaoCoursesApiResponse);
mockCachedAreasService
.Setup(service => service.GetDeliveryAreas())
.ReturnsAsync(areasFromCache);
mockCachedCoursesService
.Setup(client => client.GetCourses())
.ReturnsAsync(coursesFromCache);
mockCourseEpaoFilter
.Setup(service => service.IsValidCourseEpao(It.IsAny <GetCourseEpaoListItem>()))
.Returns <GetCourseEpaoListItem>(item => item.EpaoId == query.EpaoId.ToLower());
mockCourseEpaoFilter
.Setup(service => service.ValidateEpaoStandardDates(It.IsAny <DateTime?>(), It.IsAny <DateTime?>(), It.IsAny <DateTime?>()))
.Returns(true);
var result = await handler.Handle(query, CancellationToken.None);
result.Epao.Should().BeEquivalentTo(epaoApiResponse);
result.EpaoDeliveryAreas.Should().BeEquivalentTo(courseEpaosApiResponse.Single(item => string.Equals(item.EpaoId, query.EpaoId, StringComparison.CurrentCultureIgnoreCase)).DeliveryAreas);
result.CourseEpaosCount.Should().Be(courseEpaosApiResponse.Count(item => item.EpaoId == query.EpaoId.ToLower()));//filter returns true
result.Course.Should().BeEquivalentTo(coursesFromCache.Standards.Single(item => item.LarsCode == query.CourseId));
result.DeliveryAreas.Should().BeEquivalentTo(areasFromCache);
result.AllCourses.Should().BeEquivalentTo(
coursesFromCache.Standards.Where(item =>
epaoCoursesApiResponse.Any(listItem => listItem.StandardCode == item.LarsCode)));
foreach (var courseListItem in epaoCoursesApiResponse)
{
mockCourseEpaoFilter.Verify(x => x.ValidateEpaoStandardDates(courseListItem.DateStandardApprovedOnRegister, courseListItem.EffectiveTo, courseListItem.EffectiveFrom),
Times.Once);
}
result.EffectiveFrom.Should().Be(courseEpaosApiResponse
.Single(item => item.EpaoId == query.EpaoId.ToLower())
.CourseEpaoDetails.EffectiveFrom !.Value);//nulls removed in filter
}
public async Task And_Not_Match_Regex_Then_Not_Valid(
GetCourseEpaoQuery query,
GetCourseEpaoQueryValidator validator)
{
var validationResult = await validator.ValidateAsync(query);
validationResult.IsValid().Should().BeFalse();
validationResult.ValidationDictionary.Should().ContainKey("epaoId");
}
public async Task Match_Regex_Cases(
string epaoId,
bool isValid,
GetCourseEpaoQuery query,
GetCourseEpaoQueryValidator validator)
{
query.EpaoId = epaoId;
var validationResult = await validator.ValidateAsync(query);
validationResult.IsValid().Should().Be(isValid);
}
public async Task If_No_Valid_Standards_Found_Returns_Zero_AllCourses(
GetCourseEpaoQuery query,
GetEpaoResponse epaoApiResponse,
List <GetCourseEpaoListItem> courseEpaosApiResponse,
List <GetEpaoCourseListItem> epaoCoursesApiResponse,
List <GetDeliveryAreaListItem> areasFromCache,
GetStandardsListResponse coursesFromCache,
[Frozen] Mock <IAssessorsApiClient <AssessorsApiConfiguration> > mockAssessorsApiClient,
[Frozen] Mock <ICachedDeliveryAreasService> mockCachedAreasService,
[Frozen] Mock <ICachedCoursesService> mockCachedCoursesService,
[Frozen] Mock <ICourseEpaoIsValidFilterService> mockCourseEpaoFilter,
GetCourseEpaoQueryHandler handler)
{
courseEpaosApiResponse[0].EpaoId = query.EpaoId.ToLower();
coursesFromCache.Standards.First().LarsCode = epaoCoursesApiResponse.First().StandardCode;
coursesFromCache.Standards.ElementAt(1).LarsCode = query.CourseId;
mockAssessorsApiClient
.Setup(client => client.Get <GetEpaoResponse>(
It.Is <GetEpaoRequest>(request => request.EpaoId == query.EpaoId)))
.ReturnsAsync(epaoApiResponse);
mockAssessorsApiClient
.Setup(client => client.GetAll <GetCourseEpaoListItem>(
It.Is <GetCourseEpaosRequest>(request => request.CourseId == query.CourseId)))
.ReturnsAsync(courseEpaosApiResponse);
mockAssessorsApiClient
.Setup(client => client.GetAll <GetEpaoCourseListItem>(
It.Is <GetEpaoCoursesRequest>(request => request.EpaoId == query.EpaoId)))
.ReturnsAsync(epaoCoursesApiResponse);
mockCachedAreasService
.Setup(service => service.GetDeliveryAreas())
.ReturnsAsync(areasFromCache);
mockCachedCoursesService
.Setup(client => client.GetCourses())
.ReturnsAsync(coursesFromCache);
mockCourseEpaoFilter
.Setup(service => service.IsValidCourseEpao(It.IsAny <GetCourseEpaoListItem>()))
.Returns <GetCourseEpaoListItem>(item => item.EpaoId == query.EpaoId.ToLower());
mockCourseEpaoFilter
.Setup(service => service.ValidateEpaoStandardDates(It.IsAny <DateTime?>(), It.IsAny <DateTime?>(), It.IsAny <DateTime?>()))
.Returns(true);
mockCourseEpaoFilter
.Setup(service => service.ValidateVersionDates(It.IsAny <DateTime>(), It.IsAny <DateTime?>(), It.IsAny <DateTime?>()))
.Returns(false);
var result = await handler.Handle(query, CancellationToken.None);
result.Epao.Should().BeEquivalentTo(epaoApiResponse);
result.StandardVersions.Should().BeEmpty();
result.AllCourses.Should().BeEmpty();
}
public void And_No_Epao_Courses_Then_Throws_NotFoundException(
GetCourseEpaoQuery query,
[Frozen] Mock <IAssessorsApiClient <AssessorsApiConfiguration> > mockAssessorsApiClient,
GetCourseEpaoQueryHandler handler)
{
mockAssessorsApiClient
.Setup(client => client.Get <GetEpaoResponse>(
It.Is <GetEpaoRequest>(request => request.EpaoId == query.EpaoId)))
.ReturnsAsync(default(GetEpaoResponse));
Func <Task> act = async() => await handler.Handle(query, CancellationToken.None);
act.Should().Throw <NotFoundException <GetCourseEpaoResult> >();
}
public async Task And_Query_InValid_Then_Throws_ValidationException(
GetCourseEpaoQuery query,
string propertyName,
ValidationResult validationResult,
[Frozen] Mock <IValidator <GetCourseEpaoQuery> > mockValidator,
GetCourseEpaoQueryHandler handler)
{
validationResult.AddError(propertyName);
mockValidator
.Setup(validator => validator.ValidateAsync(query))
.ReturnsAsync(validationResult);
var act = new Func <Task>(async() => await handler.Handle(query, CancellationToken.None));
act.Should().Throw <ValidationException>()
.WithMessage($"*{propertyName}*");
}
