public async Task And_The_AccountIdentifier_Is_External_Then_HashedIds_Are_Not_Set(
Guid externalId,
GetVacanciesQuery query,
GetVacanciesResponse apiResponse,
GetProviderAccountLegalEntitiesResponse providerAccountLegalEntitiesResponse,
GetStandardsListResponse courses,
[Frozen] Mock <ICourseService> courseService,
[Frozen] Mock <IAccountLegalEntityPermissionService> accountLegalEntityPermissionService,
[Frozen] Mock <IFindApprenticeshipApiClient <FindApprenticeshipApiConfiguration> > apiClient,
GetVacanciesQueryHandler handler)
{
query.Routes = new List <string>();
query.AccountPublicHashedId = "";
query.AccountIdentifier = new AccountIdentifier($"External-{externalId}-Product");
var expectedGetRequest = new GetVacanciesRequest(query.PageNumber, query.PageSize,
"", query.Ukprn, query.AccountPublicHashedId, query.StandardLarsCode,
query.NationWideOnly, query.Lat, query.Lon, query.DistanceInMiles, new List <string>(), query.PostedInLastNumberOfDays, query.Sort);
courseService.Setup(x => x.MapRoutesToCategories(query.Routes)).Returns(new List <string>());
apiClient.Setup(x =>
x.Get <GetVacanciesResponse>(It.Is <GetVacanciesRequest>(c =>
c.GetUrl.Equals(expectedGetRequest.GetUrl)))).ReturnsAsync(apiResponse);
courseService.Setup(x => x.GetActiveStandards <GetStandardsListResponse>(nameof(GetStandardsListResponse))).ReturnsAsync(courses);
var actual = await handler.Handle(query, CancellationToken.None);
actual.Vacancies.Should().BeEquivalentTo(apiResponse.ApprenticeshipVacancies);
accountLegalEntityPermissionService
.Verify(x => x.GetAccountLegalEntity(It.IsAny <AccountIdentifier>(),
query.AccountLegalEntityPublicHashedId), Times.Never);
}
public async Task And_The_AccountLegalEntityPublicHashedId_And_Ukprn_Is_Not_Null_And_AccountPublicHashedId_Is_Null_Then_Permission_Checked(
GetVacanciesQuery query,
GetVacanciesResponse apiResponse,
AccountLegalEntityItem accountLegalEntityItem,
GetStandardsListResponse courses,
[Frozen] Mock <ICourseService> courseService,
[Frozen] Mock <IAccountLegalEntityPermissionService> accountLegalEntityPermissionService,
[Frozen] Mock <IFindApprenticeshipApiClient <FindApprenticeshipApiConfiguration> > apiClient,
GetVacanciesQueryHandler handler)
{
query.Routes = null;
query.AccountIdentifier = new AccountIdentifier("Employer-ABC123-Product");
var expectedGetRequest = new GetVacanciesRequest(query.PageNumber, query.PageSize,
query.AccountLegalEntityPublicHashedId, query.Ukprn, query.AccountPublicHashedId, query.StandardLarsCode,
query.NationWideOnly, query.Lat, query.Lon, query.DistanceInMiles, new List <string>(), query.PostedInLastNumberOfDays, query.Sort);
courseService.Setup(x => x.MapRoutesToCategories(query.Routes)).Returns(new List <string>());
apiClient.Setup(x =>
x.Get <GetVacanciesResponse>(It.Is <GetVacanciesRequest>(c =>
c.GetUrl.Equals(expectedGetRequest.GetUrl)))).ReturnsAsync(apiResponse);
accountLegalEntityPermissionService
.Setup(x => x.GetAccountLegalEntity(It.Is <AccountIdentifier>(c => c.Equals(query.AccountIdentifier)),
query.AccountLegalEntityPublicHashedId)).ReturnsAsync(accountLegalEntityItem);
courseService.Setup(x => x.GetActiveStandards <GetStandardsListResponse>(nameof(GetStandardsListResponse))).ReturnsAsync(courses);
var actual = await handler.Handle(query, CancellationToken.None);
actual.Vacancies.Should().BeEquivalentTo(apiResponse.ApprenticeshipVacancies);
}
public async Task And_Invalid_Id_Specified_Then_No_Opportunity_Returned(
int opportunityId,
string standardId,
GetStandardsListResponse response,
[Frozen] Mock <ILevyTransferMatchingService> mockLevyTransferMatchingService,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > client,
GetApplicationDetailsQueryHandler getApplicationDetailsQueryHandler)
{
var getApplicationDetailsQuery = new GetApplicationDetailsQuery()
{
StandardId = standardId,
OpportunityId = opportunityId
};
mockLevyTransferMatchingService
.Setup(x => x.GetPledge(It.Is <int>(y => y == opportunityId)))
.ReturnsAsync((Pledge)null);
client
.Setup(x => x.Get <GetStandardsListResponse>(It.IsAny <GetAvailableToStartStandardsListRequest>()))
.ReturnsAsync(response);
var result = await getApplicationDetailsQueryHandler.Handle(getApplicationDetailsQuery, CancellationToken.None);
Assert.IsNull(result.Opportunity);
}
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 Then_Caches_The_Courses_If_There_Are_No_Filters(
GetStandardsListResponse apiResponse,
GetRoutesListResponse routesApiResponse,
GetLevelsListResponse levelsApiResponse,
[Frozen] Mock <ICacheStorageService> cacheStorageService,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > mockApiClient,
GetTrainingCoursesListQueryHandler handler)
{
var query = new GetTrainingCoursesListQuery
{
Levels = new List <int>(),
RouteIds = new List <string>()
};
mockApiClient
.Setup(client => client.Get <GetStandardsListResponse>(
It.IsAny <GetAvailableToStartStandardsListRequest>()))
.ReturnsAsync(apiResponse);
mockApiClient
.Setup(client => client.Get <GetRoutesListResponse>(It.IsAny <GetRoutesListRequest>()))
.ReturnsAsync(routesApiResponse);
mockApiClient
.Setup(client => client.Get <GetLevelsListResponse>(It.IsAny <GetLevelsListRequest>()))
.ReturnsAsync(levelsApiResponse);
var result = await handler.Handle(query, CancellationToken.None);
cacheStorageService.Verify(x => x.SaveToCache(nameof(GetStandardsListResponse), apiResponse, TimeSpan.FromHours(2)));
result.Courses.Should().BeEquivalentTo(apiResponse.Standards);
result.Sectors.Should().BeEquivalentTo(routesApiResponse.Routes);
result.Levels.Should().BeEquivalentTo(levelsApiResponse.Levels);
result.Total.Should().Be(apiResponse.Total);
result.TotalFiltered.Should().Be(apiResponse.TotalFiltered);
result.OrderBy.Should().Be(query.OrderBy);
}
public async Task Then_Returns_Totals_For_Standard(
GetTrainingCourseProviderQuery query,
GetProviderStandardItem apiResponse,
GetStandardsListItem apiCourseResponse,
GetOverallAchievementRateResponse apiAchievementRateResponse,
GetProviderAdditionalStandardsItem apiAdditionalStandardsResponse,
GetStandardsListResponse allCoursesApiResponse,
GetApprenticeFeedbackResponse appfeedbackResponse,
List <int> ukprnsByStandard,
List <int> ukprnsByStandardAndLocation,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > mockCoursesApiClient,
[Frozen] Mock <ICourseDeliveryApiClient <CourseDeliveryApiConfiguration> > mockApiClient,
[Frozen] Mock <IApprenticeFeedbackApiClient <ApprenticeFeedbackApiConfiguration> > mockApprenticeFeedbackApiClient,
GetTrainingCourseProviderQueryHandler handler)
{
ukprnsByStandard.Add(query.ProviderId);
ukprnsByStandardAndLocation.Add(query.ProviderId);
var ukprnsCountResponse = new GetUkprnsForStandardAndLocationResponse
{
UkprnsByStandard = ukprnsByStandard,
UkprnsByStandardAndLocation = ukprnsByStandardAndLocation
};
ArrangeClients(query, apiResponse, apiCourseResponse, apiAchievementRateResponse, allCoursesApiResponse, ukprnsCountResponse, appfeedbackResponse, mockCoursesApiClient, mockApiClient, mockApprenticeFeedbackApiClient);
var result = await handler.Handle(query, CancellationToken.None);
result.TotalProviders.Should().Be(ukprnsCountResponse.UkprnsByStandard.ToList().Count);
result.TotalProvidersAtLocation.Should().Be(ukprnsCountResponse.UkprnsByStandardAndLocation.ToList().Count);
}
public async Task Then_The_Api_Is_Called_And_Sector_Looked_Up_And_Returns_Standards(
int routeId,
GetStandardsQuery query,
GetStandardsListResponse apiResponse,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > apiClient,
[Frozen] Mock <ICourseService> courseService,
GetStandardsQueryHandler handler
)
{
//Arrange
courseService
.Setup(x => x.GetRoutes())
.ReturnsAsync(new GetRoutesListResponse
{
Routes = new List <GetRoutesListItem>
{
new GetRoutesListItem
{
Id = routeId,
Name = query.Sector
}
}
});
apiClient.Setup(x => x.Get <GetStandardsListResponse>(It.Is <GetAvailableToStartStandardsListRequest>(c => c.RouteIds.Contains(routeId)))).ReturnsAsync(apiResponse);
//Act
var actual = await handler.Handle(query, CancellationToken.None);
//Assert
actual.Standards.Should().BeEquivalentTo(apiResponse.Standards);
}
public async Task And_The_AccountLegalEntityPublicHashedId_Is_Null_Then_No_LegalEntity_Check_Is_Performed(
GetVacanciesQuery query,
GetVacanciesResponse apiResponse,
GetStandardsListResponse courses,
[Frozen] Mock <ICourseService> courseService,
[Frozen] Mock <IAccountsApiClient <AccountsConfiguration> > accountsApi,
[Frozen] Mock <IProviderRelationshipsApiClient <ProviderRelationshipsApiConfiguration> > providerRelationshipsApiClient,
[Frozen] Mock <IFindApprenticeshipApiClient <FindApprenticeshipApiConfiguration> > apiClient,
GetVacanciesQueryHandler handler)
{
query.Routes = null;
query.AccountLegalEntityPublicHashedId = "";
var expectedGetRequest = new GetVacanciesRequest(query.PageNumber, query.PageSize,
query.AccountLegalEntityPublicHashedId, query.Ukprn, query.AccountPublicHashedId, query.StandardLarsCode,
query.NationWideOnly, query.Lat, query.Lon, query.DistanceInMiles, new List <string>(), query.PostedInLastNumberOfDays, query.Sort);
courseService.Setup(x => x.MapRoutesToCategories(query.Routes)).Returns(new List <string>());
apiClient.Setup(x =>
x.Get <GetVacanciesResponse>(It.Is <GetVacanciesRequest>(c =>
c.GetUrl.Equals(expectedGetRequest.GetUrl)))).ReturnsAsync(apiResponse);
courseService.Setup(x => x.GetActiveStandards <GetStandardsListResponse>(nameof(GetStandardsListResponse))).ReturnsAsync(courses);
await handler.Handle(query, CancellationToken.None);
accountsApi.Verify(x => x.Get <AccountDetail>(It.IsAny <GetAllEmployerAccountLegalEntitiesRequest>()), Times.Never);
providerRelationshipsApiClient.Verify(x => x.Get <GetProviderAccountLegalEntitiesResponse>(It.IsAny <GetProviderAccountLegalEntitiesRequest>()), Times.Never);
}
public async Task Then_Returns_Additional_Courses_for_Provider_That_Are_Available(
GetTrainingCourseProviderQuery query,
GetProviderStandardItem apiResponse,
GetStandardsListItem apiCourseResponse,
GetOverallAchievementRateResponse apiAchievementRateResponse,
GetProviderAdditionalStandardsItem apiAdditionalStandardsResponse,
GetStandardsListResponse allCoursesApiResponse,
GetUkprnsForStandardAndLocationResponse ukprnsCountResponse,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > mockCoursesApiClient,
[Frozen] Mock <ICourseDeliveryApiClient <CourseDeliveryApiConfiguration> > mockApiClient,
GetTrainingCourseProviderQueryHandler handler)
{
mockApiClient
.Setup(client => client.Get <GetProviderStandardItem>(It.Is <GetProviderByCourseAndUkPrnRequest>(c =>
c.GetUrl.Contains(query.CourseId.ToString()) &&
c.GetUrl.Contains(query.ProviderId.ToString()
))))
.ReturnsAsync(apiResponse);
mockCoursesApiClient
.Setup(client => client.Get <GetStandardsListResponse>(It.IsAny <GetAvailableToStartStandardsListRequest>()))
.ReturnsAsync(allCoursesApiResponse);
var additionalCourses = allCoursesApiResponse.Standards.Select(c => c.LarsCode).ToList();
additionalCourses.Add(-10);
mockApiClient
.Setup(client => client.Get <GetProviderAdditionalStandardsItem>(It.Is <GetProviderAdditionalStandardsRequest>(
c =>
c.GetUrl.Contains(query.ProviderId.ToString()
))))
.ReturnsAsync(new GetProviderAdditionalStandardsItem
{
StandardIds = additionalCourses
});
mockApiClient
.Setup(x => x.Get <GetUkprnsForStandardAndLocationResponse>(
It.Is <GetUkprnsForStandardAndLocationRequest>(c => c.GetUrl.Contains(query.CourseId.ToString()))))
.ReturnsAsync(ukprnsCountResponse);
mockCoursesApiClient
.Setup(client =>
client.Get <GetStandardsListItem>(
It.Is <GetStandardRequest>(c => c.GetUrl.Contains(query.CourseId.ToString()))))
.ReturnsAsync(apiCourseResponse);
mockApiClient.Setup(client => client.Get <GetOverallAchievementRateResponse>(It.Is <GetOverallAchievementRateRequest>(
c =>
c.GetUrl.Contains(apiCourseResponse.SectorSubjectAreaTier2Description)
)))
.ReturnsAsync(apiAchievementRateResponse);
var result = await handler.Handle(query, CancellationToken.None);
result.AdditionalCourses.Should().BeInAscendingOrder(c => c.Title);
result.AdditionalCourses.Should()
.BeEquivalentTo(allCoursesApiResponse.Standards, options => options.ExcludingMissingMembers());
}
public async Task <IActionResult> GetList(
[FromQuery] string keyword,
[FromQuery] IList <int> routeIds,
[FromQuery] IList <int> levels,
[FromQuery] OrderBy orderBy = OrderBy.Score,
[FromQuery] StandardFilter filter = StandardFilter.ActiveAvailable)
{
var queryResult = await _mediator.Send(new GetStandardsListQuery
{
Keyword = keyword,
RouteIds = routeIds,
Levels = levels,
OrderBy = orderBy,
Filter = filter
});
var response = new GetStandardsListResponse
{
Standards = queryResult.Standards.Select(standard => (GetStandardResponse)standard),
Total = queryResult.Total,
TotalFiltered = queryResult.TotalFiltered
};
return(Ok(response));
}
public async Task Then_Gets_The_Standard_And_The_Provider_For_That_Course_And_Shortlist_Count_From_Course_Delivery_Api_Client(
GetTrainingCourseProviderQuery query,
GetProviderStandardItem apiResponse,
GetStandardsListItem apiCourseResponse,
GetOverallAchievementRateResponse apiAchievementRateResponse,
GetStandardsListResponse allCoursesApiResponse,
GetUkprnsForStandardAndLocationResponse ukprnsCountResponse,
GetApprenticeFeedbackResponse apprenticeFeedbackResponse,
int shortlistItemCount,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > mockCoursesApiClient,
[Frozen] Mock <ICourseDeliveryApiClient <CourseDeliveryApiConfiguration> > mockApiClient,
[Frozen] Mock <IApprenticeFeedbackApiClient <ApprenticeFeedbackApiConfiguration> > mockApprenticeFeedbackApiClient,
[Frozen] Mock <IShortlistService> shortlistService,
GetTrainingCourseProviderQueryHandler handler)
{
shortlistService.Setup(x => x.GetShortlistItemCount(query.ShortlistUserId))
.ReturnsAsync(shortlistItemCount);
ArrangeClients(query, apiResponse, apiCourseResponse, apiAchievementRateResponse, allCoursesApiResponse, ukprnsCountResponse, apprenticeFeedbackResponse, mockCoursesApiClient, mockApiClient, mockApprenticeFeedbackApiClient);
var result = await handler.Handle(query, CancellationToken.None);
result.ProviderStandard.Should().BeEquivalentTo(apiResponse, options => options.Excluding(s => s.ApprenticeFeedback));
result.ProviderStandard.ApprenticeFeedback.Should().BeEquivalentTo(apprenticeFeedbackResponse);
result.Course.Should().BeEquivalentTo(apiCourseResponse);
result.ShortlistItemCount.Should().Be(shortlistItemCount);
mockApiClient.Verify(x => x.Get <GetProviderStandardItem>(It.IsAny <GetProviderByCourseAndUkPrnRequest>()), Times.Once);
}
public async Task And_Courses_Not_Cached_Then_Gets_From_Api_And_Stores_In_Cache(
GetStandardsListResponse coursesFromApi,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > mockCoursesApiClient,
[Frozen] Mock <ICacheStorageService> mockCacheService,
CachedCoursesService service)
{
var expectedExpirationInHours = 1;
mockCoursesApiClient
.Setup(client => client.Get <GetStandardsListResponse>(
It.IsAny <GetActiveStandardsListRequest>()))
.ReturnsAsync(coursesFromApi);
mockCacheService
.Setup(service => service.RetrieveFromCache <GetStandardsListResponse>(nameof(GetStandardsListResponse)))
.ReturnsAsync((GetStandardsListResponse)null);
var result = await service.GetCourses();
result.Should().BeEquivalentTo(coursesFromApi);
mockCacheService.Verify(service =>
service.SaveToCache <GetStandardsListResponse>(
nameof(GetStandardsListResponse),
coursesFromApi,
expectedExpirationInHours));
}
public async Task Then_Additional_Courses_for_Provider_Should_Contain_Course_Passed_To_Handler(
GetTrainingCourseProviderQuery query,
GetProviderStandardItem apiResponse,
GetStandardsListItem apiCourseResponse,
GetOverallAchievementRateResponse apiAchievementRateResponse,
GetStandardsListResponse allCoursesApiResponse,
List <GetStandardsListItem> allStandards,
GetUkprnsForStandardAndLocationResponse ukprnsCountResponse,
GetApprenticeFeedbackResponse appfeedbackResponse,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > mockCoursesApiClient,
[Frozen] Mock <ICourseDeliveryApiClient <CourseDeliveryApiConfiguration> > mockApiClient,
[Frozen] Mock <IApprenticeFeedbackApiClient <ApprenticeFeedbackApiConfiguration> > mockApprenticeFeedbackApiClient,
GetTrainingCourseProviderQueryHandler handler)
{
apiCourseResponse.LarsCode = query.CourseId;
allStandards.Add(new GetStandardsListItem
{
LarsCode = apiCourseResponse.LarsCode,
Title = apiCourseResponse.Title,
Level = apiCourseResponse.Level
});
allCoursesApiResponse.Standards = allStandards;
ArrangeClients(query, apiResponse, apiCourseResponse, apiAchievementRateResponse, allCoursesApiResponse, ukprnsCountResponse, appfeedbackResponse, mockCoursesApiClient, mockApiClient, mockApprenticeFeedbackApiClient);
var result = await handler.Handle(query, CancellationToken.None);
result.AdditionalCourses.Should().BeEquivalentTo(allCoursesApiResponse.Standards.Select(c => new { Id = c.LarsCode, c.Title, c.Level }).ToList());
}
public async Task Then_Gets_The_Shortlist_From_CourseDeliveryApi_And_Course_From_CoursesApi(
GetShortlistForUserQuery query,
GetShortlistForUserResponse apiResponse,
GetStandardsListResponse cachedCourses,
List <GetStandardsListItem> standards,
[Frozen] Mock <ICourseDeliveryApiClient <CourseDeliveryApiConfiguration> > mockCourseDeliveryApiClient,
[Frozen] Mock <ICachedCoursesService> mockCachedCoursesService,
GetShortlistForUserQueryHandler handler)
{
var shortlistFromApi = apiResponse.Shortlist.ToList();
for (var i = 0; i < shortlistFromApi.Count; i++)
{
standards[i].LarsCode = shortlistFromApi[i].CourseId;
}
cachedCourses.Standards = standards;
mockCourseDeliveryApiClient
.Setup(client => client.Get <GetShortlistForUserResponse>(
It.Is <GetShortlistForUserRequest>(request =>
request.ShortlistUserId == query.ShortlistUserId)))
.ReturnsAsync(apiResponse);
mockCachedCoursesService
.Setup(service => service.GetCourses())
.ReturnsAsync(cachedCourses);
var result = await handler.Handle(query, CancellationToken.None);
result.Shortlist.Should().BeEquivalentTo(apiResponse.Shortlist,
options => options.Excluding(item => item.Course));
foreach (var item in result.Shortlist)
{
item.Course.Should().NotBeNull();
item.Course.Should().BeEquivalentTo(cachedCourses.Standards.Single(listItem => listItem.LarsCode == item.CourseId));
}
}
public async Task And_Courses_Not_Cached_Then_Gets_From_Api_And_Stores_In_Cache(
GetTrainingCoursesQuery query,
GetStandardsListResponse coursesFromApi,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > mockCoursesApiClient,
[Frozen] Mock <ICacheStorageService> mockCacheService,
GetTrainingCoursesQueryHandler handler)
{
var expectedExpirationInHours = 3;
mockCoursesApiClient
.Setup(client => client.Get <GetStandardsListResponse>(
It.IsAny <GetActiveStandardsListRequest>()))
.ReturnsAsync(coursesFromApi);
mockCacheService
.Setup(service => service.RetrieveFromCache <GetStandardsListResponse>(nameof(GetStandardsListResponse)))
.ReturnsAsync((GetStandardsListResponse)null);
var result = await handler.Handle(query, CancellationToken.None);
result.TrainingCourses.Should().BeEquivalentTo(coursesFromApi.Standards);
mockCacheService.Verify(service =>
service.SaveToCache(
nameof(GetStandardsListResponse),
coursesFromApi,
expectedExpirationInHours));
}
public async Task Then_The_Levels_Are_Returned_From_The_Cache_If_Available(GetTrainingCoursesListQuery query,
GetStandardsListResponse apiResponse,
GetRoutesListResponse routesApiResponse,
GetLevelsListResponse levelsApiResponse,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > mockApiClient,
[Frozen] Mock <ICacheStorageService> cacheStorageService,
GetTrainingCoursesListQueryHandler handler)
{
//Arrange
mockApiClient
.Setup(client => client.Get <GetStandardsListResponse>(
It.Is <GetAvailableToStartStandardsListRequest>(c => c.Keyword.Equals(query.Keyword))))
.ReturnsAsync(apiResponse);
mockApiClient
.Setup(client => client.Get <GetRoutesListResponse>(It.IsAny <GetRoutesListRequest>()))
.ReturnsAsync(routesApiResponse);
cacheStorageService
.Setup(x =>
x.RetrieveFromCache <GetLevelsListResponse>(nameof(GetLevelsListResponse)))
.ReturnsAsync(levelsApiResponse);
//Act
var result = await handler.Handle(query, CancellationToken.None);
//Assert
result.Courses.Should().BeEquivalentTo(apiResponse.Standards);
result.Sectors.Should().BeEquivalentTo(routesApiResponse.Routes);
result.Levels.Should().BeEquivalentTo(levelsApiResponse.Levels);
result.Total.Should().Be(apiResponse.Total);
result.TotalFiltered.Should().Be(apiResponse.TotalFiltered);
mockApiClient.Verify(x => x.Get <GetLevelsListResponse>(It.IsAny <GetLevelsListRequest>()), Times.Never);
}
public async Task Then_Gets_The_CourseDemand_Ids_From_The_Api(
GetStandardsListResponse closedStandardsApiResponse,
GetUnmetCourseDemandsResponse unmetDemandResponse,
GetUnmetDemandsWithStoppedCourseQuery query,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > mockCoursesApiClient,
[Frozen] Mock <IEmployerDemandApiClient <EmployerDemandApiConfiguration> > mockEmployerDemandApiClient,
GetUnmetDemandsWithStoppedCourseQueryHandler handler)
{
//Arrange
mockCoursesApiClient
.Setup(client => client.Get <GetStandardsListResponse>(
It.IsAny <GetStandardsClosedToNewStartsRequest>()))
.ReturnsAsync(closedStandardsApiResponse);
var expectedApiRequest = new GetUnmetEmployerDemandsRequest(0);
mockEmployerDemandApiClient
.Setup(client => client.Get <GetUnmetCourseDemandsResponse>(
It.Is <GetUnmetEmployerDemandsRequest>(c => c.GetUrl == expectedApiRequest.GetUrl)))
.ReturnsAsync(unmetDemandResponse);
unmetDemandResponse.UnmetCourseDemands[0].CourseId = closedStandardsApiResponse.Standards[0].LarsCode;
var expectedDemandIds = new List <Guid> {
unmetDemandResponse.UnmetCourseDemands[0].Id
};
//Act
var actual = await handler.Handle(query, CancellationToken.None);
//Assert
actual.EmployerDemandIds.Should().BeEquivalentTo(expectedDemandIds);
}
public async Task Then_Gets_Standards_And_Sectors_And_Levels_From_Courses_Api_With_Request_Params(
GetTrainingCoursesListQuery query,
GetStandardsListResponse apiResponse,
GetSectorsListResponse sectorsApiResponse,
GetLevelsListResponse levelsApiResponse,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > mockApiClient,
GetTrainingCoursesListQueryHandler handler)
{
mockApiClient
.Setup(client => client.Get <GetStandardsListResponse>(
It.Is <GetStandardsListRequest>(c => c.Keyword.Equals(query.Keyword) &&
c.RouteIds.Equals(query.RouteIds) &&
c.Levels.Equals(query.Levels)
)))
.ReturnsAsync(apiResponse);
mockApiClient
.Setup(client => client.Get <GetSectorsListResponse>(It.IsAny <GetSectorsListRequest>()))
.ReturnsAsync(sectorsApiResponse);
mockApiClient
.Setup(client => client.Get <GetLevelsListResponse>(It.IsAny <GetLevelsListRequest>()))
.ReturnsAsync(levelsApiResponse);
var result = await handler.Handle(query, CancellationToken.None);
result.Courses.Should().BeEquivalentTo(apiResponse.Standards);
result.Sectors.Should().BeEquivalentTo(sectorsApiResponse.Sectors);
result.Levels.Should().BeEquivalentTo(levelsApiResponse.Levels);
result.Total.Should().Be(apiResponse.Total);
result.TotalFiltered.Should().Be(apiResponse.TotalFiltered);
result.OrderBy.Should().Be(query.OrderBy);
}
public async Task Then_If_There_Is_Lat_Lon_Data_The_Location_Is_Used(
string locationName,
string authorityName,
GetTrainingCourseProviderQuery query,
GetOverallAchievementRateResponse apiResponse,
GetProviderStandardItem apiProviderStandardResponse,
GetStandardsListItem apiCourseResponse,
GetStandardsListResponse allCoursesApiResponse,
LocationItem locationLookupResponse,
GetOverallAchievementRateResponse apiAchievementRateResponse,
GetUkprnsForStandardAndLocationResponse ukprnsCountResponse,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > mockCoursesApiClient,
[Frozen] Mock <ICourseDeliveryApiClient <CourseDeliveryApiConfiguration> > mockApiClient,
[Frozen] Mock <ILocationLookupService> mockLocationLookupService,
GetTrainingCourseProviderQueryHandler handler)
{
mockLocationLookupService
.Setup(service => service.GetLocationInformation(query.Location, query.Lat, query.Lon))
.ReturnsAsync(locationLookupResponse);
mockApiClient
.Setup(client => client.Get <GetProviderStandardItem>(It.Is <GetProviderByCourseAndUkPrnRequest>(c =>
c.GetUrl.Contains(query.CourseId.ToString()) &&
c.GetUrl.Contains(query.ProviderId.ToString()) &&
c.GetUrl.Contains(locationLookupResponse.GeoPoint.First().ToString()) &&
c.GetUrl.Contains(locationLookupResponse.GeoPoint.Last().ToString())
)))
.ReturnsAsync(apiProviderStandardResponse);
mockApiClient
.Setup(client => client.Get <GetProviderAdditionalStandardsItem>(It.Is <GetProviderAdditionalStandardsRequest>(
c =>
c.GetUrl.Contains(query.ProviderId.ToString()
))))
.ReturnsAsync(new GetProviderAdditionalStandardsItem
{
StandardIds = allCoursesApiResponse.Standards.Select(c => c.LarsCode).ToList()
});
mockCoursesApiClient
.Setup(client =>
client.Get <GetStandardsListItem>(
It.Is <GetStandardRequest>(c => c.GetUrl.Contains(query.CourseId.ToString()))))
.ReturnsAsync(apiCourseResponse);
mockApiClient
.Setup(x => x.Get <GetUkprnsForStandardAndLocationResponse>(
It.Is <GetUkprnsForStandardAndLocationRequest>(c => c.GetUrl.Contains(query.CourseId.ToString()))))
.ReturnsAsync(ukprnsCountResponse);
mockCoursesApiClient
.Setup(client => client.Get <GetStandardsListResponse>(It.IsAny <GetAvailableToStartStandardsListRequest>()))
.ReturnsAsync(allCoursesApiResponse);
mockApiClient.Setup(client => client.Get <GetOverallAchievementRateResponse>(It.Is <GetOverallAchievementRateRequest>(
c =>
c.GetUrl.Contains(apiCourseResponse.SectorSubjectAreaTier2Description)
)))
.ReturnsAsync(apiAchievementRateResponse);
var result = await handler.Handle(query, CancellationToken.None);
result.ProviderStandard.Should().BeEquivalentTo(apiProviderStandardResponse);
result.Location.Should().BeEquivalentTo(locationLookupResponse);
}
private static void ArrangeClients(
GetTrainingCourseProviderQuery query,
GetProviderStandardItem apiProviderStandardResponse,
GetStandardsListItem apiCourseResponse,
GetOverallAchievementRateResponse apiAchievementRateResponse,
GetStandardsListResponse allCoursesApiResponse,
GetUkprnsForStandardAndLocationResponse ukprnsCountResponse,
GetApprenticeFeedbackResponse apprenticeFeedbackResponse,
Mock <ICoursesApiClient <CoursesApiConfiguration> > mockCoursesApiClient,
Mock <ICourseDeliveryApiClient <CourseDeliveryApiConfiguration> > mockApiClient,
Mock <IApprenticeFeedbackApiClient <ApprenticeFeedbackApiConfiguration> > mockApprenticeFeedbackClient)
{
mockApiClient
.Setup(client => client.Get <GetProviderStandardItem>(It.Is <GetProviderByCourseAndUkPrnRequest>(c =>
c.GetUrl.Contains(query.CourseId.ToString()) &&
c.GetUrl.Contains(query.ProviderId.ToString()) &&
c.GetUrl.Contains(apiCourseResponse.SectorSubjectAreaTier2Description) &&
c.GetUrl.Contains($"shortlistUserId={query.ShortlistUserId}")
)))
.ReturnsAsync(apiProviderStandardResponse);
mockApiClient
.Setup(client => client.Get <GetProviderAdditionalStandardsItem>(It.Is <GetProviderAdditionalStandardsRequest>(
c =>
c.GetUrl.Contains(query.ProviderId.ToString()
))))
.ReturnsAsync(new GetProviderAdditionalStandardsItem
{
StandardIds = allCoursesApiResponse.Standards.Select(c => c.LarsCode).ToList()
});
mockApiClient
.Setup(x => x.Get <GetUkprnsForStandardAndLocationResponse>(
It.Is <GetUkprnsForStandardAndLocationRequest>(c => c.GetUrl.Contains(query.CourseId.ToString()))))
.ReturnsAsync(ukprnsCountResponse);
mockCoursesApiClient
.Setup(client =>
client.Get <GetStandardsListItem>(
It.Is <GetStandardRequest>(c => c.GetUrl.Contains(query.CourseId.ToString()))))
.ReturnsAsync(apiCourseResponse);
mockCoursesApiClient
.Setup(client => client.Get <GetStandardsListResponse>(It.IsAny <GetAvailableToStartStandardsListRequest>()))
.ReturnsAsync(allCoursesApiResponse);
mockApiClient.Setup(client => client.Get <GetOverallAchievementRateResponse>(It.Is <GetOverallAchievementRateRequest>(
c =>
c.GetUrl.Contains(apiCourseResponse.SectorSubjectAreaTier2Description)
)))
.ReturnsAsync(apiAchievementRateResponse);
apprenticeFeedbackResponse.Ukprn = query.ProviderId;
mockApprenticeFeedbackClient
.Setup(s => s.PostWithResponseCode <IEnumerable <GetApprenticeFeedbackResponse> >
(It.Is <PostApprenticeFeedbackRequest>(t => ((PostApprenticeFeedbackRequestData)t.Data).Ukprns.Contains(query.ProviderId))))
.ReturnsAsync(new ApiResponse <IEnumerable <GetApprenticeFeedbackResponse> >(new List <GetApprenticeFeedbackResponse> {
apprenticeFeedbackResponse
}, HttpStatusCode.OK, string.Empty));
}
public async Task Then_Does_Not_Return_Additional_Courses_If_No_Additional_Courses(
GetTrainingCourseProviderQuery query,
GetProviderStandardItem apiResponse,
GetStandardsListItem apiCourseResponse,
GetProviderAdditionalStandardsItem apiAdditionalStandardsResponse,
GetStandardsListResponse allCoursesApiResponse,
GetOverallAchievementRateResponse apiAchievementRateResponse,
GetUkprnsForStandardAndLocationResponse ukprnsCountResponse,
GetApprenticeFeedbackResponse apprenticeFeedbackResponse,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > mockCoursesApiClient,
[Frozen] Mock <ICourseDeliveryApiClient <CourseDeliveryApiConfiguration> > mockApiClient,
[Frozen] Mock <IApprenticeFeedbackApiClient <ApprenticeFeedbackApiConfiguration> > mockApprenticeFeedbackApiClient,
GetTrainingCourseProviderQueryHandler handler)
{
mockApiClient
.Setup(client => client.Get <GetProviderStandardItem>(It.Is <GetProviderByCourseAndUkPrnRequest>(c =>
c.GetUrl.Contains(query.CourseId.ToString()) &&
c.GetUrl.Contains(query.ProviderId.ToString()
))))
.ReturnsAsync(apiResponse);
mockApiClient
.Setup(client => client.Get <GetProviderAdditionalStandardsItem>(It.Is <GetProviderAdditionalStandardsRequest>(c =>
c.GetUrl.Contains(query.ProviderId.ToString()
))))
.ReturnsAsync(new GetProviderAdditionalStandardsItem
{
StandardIds = new List <int>()
});
mockCoursesApiClient
.Setup(client => client.Get <GetStandardsListItem>(It.Is <GetStandardRequest>(c => c.GetUrl.Contains(query.CourseId.ToString()))))
.ReturnsAsync(apiCourseResponse);
mockCoursesApiClient
.Setup(client => client.Get <GetStandardsListResponse>(It.IsAny <GetAvailableToStartStandardsListRequest>()))
.ReturnsAsync(allCoursesApiResponse);
mockApiClient.Setup(client => client.Get <GetOverallAchievementRateResponse>(It.Is <GetOverallAchievementRateRequest>(c =>
c.GetUrl.Contains(apiCourseResponse.SectorSubjectAreaTier2Description)
)))
.ReturnsAsync(apiAchievementRateResponse);
mockApiClient
.Setup(x => x.Get <GetUkprnsForStandardAndLocationResponse>(
It.Is <GetUkprnsForStandardAndLocationRequest>(c => c.GetUrl.Contains(query.CourseId.ToString()))))
.ReturnsAsync(ukprnsCountResponse);
apprenticeFeedbackResponse.Ukprn = query.ProviderId;
mockApprenticeFeedbackApiClient
.Setup(s => s.PostWithResponseCode <IEnumerable <GetApprenticeFeedbackResponse> >
(It.Is <PostApprenticeFeedbackRequest>(t => ((PostApprenticeFeedbackRequestData)t.Data).Ukprns.Contains(query.ProviderId))))
.ReturnsAsync(new ApiResponse <IEnumerable <GetApprenticeFeedbackResponse> >(new List <GetApprenticeFeedbackResponse> {
apprenticeFeedbackResponse
}, HttpStatusCode.OK, string.Empty));
var result = await handler.Handle(query, CancellationToken.None);
result.AdditionalCourses.Should().BeEquivalentTo(new List <GetAdditionalCourseListItem>());
}
public async Task And_Courses_Cached_Then_Gets_Courses_From_Cache(
GetStandardsListResponse coursesFromCache,
[Frozen] Mock <ICacheStorageService> mockCacheService,
CachedCoursesService service)
{
mockCacheService
.Setup(service => service.RetrieveFromCache <GetStandardsListResponse>(nameof(GetStandardsListResponse)))
.ReturnsAsync(coursesFromCache);
var result = await service.GetCourses();
result.Should().BeEquivalentTo(coursesFromCache);
}
public async Task And_Courses_Cached_Then_Gets_Courses_From_Cache(
GetTrainingCoursesQuery query,
GetStandardsListResponse coursesFromCache,
[Frozen] Mock <ICacheStorageService> mockCacheService,
GetTrainingCoursesQueryHandler handler)
{
mockCacheService
.Setup(service => service.RetrieveFromCache <GetStandardsListResponse>(nameof(GetStandardsListResponse)))
.ReturnsAsync(coursesFromCache);
var result = await handler.Handle(query, CancellationToken.None);
result.TrainingCourses.Should().BeEquivalentTo(coursesFromCache.Standards);
}
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 async Task Then_Gets_Standards_From_Courses_Api(
GetStandardsQuery query,
GetStandardsListResponse apiResponse,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > mockApiClient,
GetStandardsQueryHandler handler)
{
mockApiClient
.Setup(client => client.Get <GetStandardsListResponse>(It.IsAny <GetActiveStandardsListRequest>()))
.ReturnsAsync(apiResponse);
var result = await handler.Handle(query, CancellationToken.None);
result.Standards.Should().BeEquivalentTo(apiResponse.Standards);
}
public async Task And_Courses_Are_Taken_From_Service_And_Returned(
GetTrainingCoursesQuery query,
GetStandardsListResponse coursesFromCache,
[Frozen] Mock <ICourseService> standardsService,
GetTrainingCoursesQueryHandler handler)
{
standardsService
.Setup(service => service.GetActiveStandards <GetStandardsListResponse>(nameof(GetStandardsListResponse)))
.ReturnsAsync(coursesFromCache);
var result = await handler.Handle(query, CancellationToken.None);
result.TrainingCourses.Should().BeEquivalentTo(coursesFromCache.Standards);
}
public async Task Then_Gets_The_Shortlist_From_CourseDeliveryApi_And_Course_From_CoursesApi(
GetShortlistForUserQuery query,
GetShortlistForUserResponse apiResponse,
List <GetApprenticeFeedbackResponse> apprenticeFeedbackResponse,
GetStandardsListResponse cachedCourses,
List <GetStandardsListItem> standards,
[Frozen] Mock <ICourseDeliveryApiClient <CourseDeliveryApiConfiguration> > mockCourseDeliveryApiClient,
[Frozen] Mock <IApprenticeFeedbackApiClient <ApprenticeFeedbackApiConfiguration> > mockApprenticeFeedbackClient,
[Frozen] Mock <ICachedCoursesService> mockCachedCoursesService,
GetShortlistForUserQueryHandler handler)
{
var shortlistFromApi = apiResponse.Shortlist.ToList();
for (var i = 0; i < shortlistFromApi.Count; i++)
{
standards[i].LarsCode = shortlistFromApi[i].CourseId;
apprenticeFeedbackResponse[i].Ukprn = shortlistFromApi[i].ProviderDetails.Ukprn;
}
cachedCourses.Standards = standards;
mockCourseDeliveryApiClient
.Setup(client => client.Get <GetShortlistForUserResponse>(
It.Is <GetShortlistForUserRequest>(request =>
request.ShortlistUserId == query.ShortlistUserId)))
.ReturnsAsync(apiResponse);
mockCachedCoursesService
.Setup(service => service.GetCourses())
.ReturnsAsync(cachedCourses);
mockApprenticeFeedbackClient
.Setup(s => s.PostWithResponseCode <IEnumerable <GetApprenticeFeedbackResponse> >(It.Is <PostApprenticeFeedbackRequest>
(t =>
((PostApprenticeFeedbackRequestData)t.Data).Ukprns.Except(apiResponse.Shortlist.Select(s => s.ProviderDetails.Ukprn)).Count() == 0 &&
apiResponse.Shortlist.Select(s => s.ProviderDetails.Ukprn).Except(((PostApprenticeFeedbackRequestData)t.Data).Ukprns).Count() == 0
))).ReturnsAsync(new ApiResponse <IEnumerable <GetApprenticeFeedbackResponse> >(apprenticeFeedbackResponse, HttpStatusCode.OK, string.Empty));
var result = await handler.Handle(query, CancellationToken.None);
result.Shortlist.Should().BeEquivalentTo(apiResponse.Shortlist,
options => options.Excluding(item => item.Course).Excluding(item => item.ProviderDetails.ApprenticeFeedback));
foreach (var item in result.Shortlist)
{
item.Course.Should().NotBeNull();
item.Course.Should().BeEquivalentTo(cachedCourses.Standards.Single(listItem => listItem.LarsCode == item.CourseId));
item.ProviderDetails.ApprenticeFeedback.Should().NotBeNull();
item.ProviderDetails.ApprenticeFeedback.Should().BeEquivalentTo(apprenticeFeedbackResponse.First(s => s.Ukprn == item.ProviderDetails.Ukprn));
}
}
public async Task Then_Gets_Standards_And_Sectors_And_Levels_From_Courses_Api_And_Shortlist_Item_Count_With_Request_Params(
int sectorId,
GetTrainingCoursesListQuery query,
GetStandardsListResponse apiResponse,
GetLevelsListResponse levelsApiResponse,
int shortlistItemCount,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > mockApiClient,
[Frozen] Mock <IShortlistService> shortlistService,
GetTrainingCoursesListQueryHandler handler)
{
var sectorsApiResponse = new GetRoutesListResponse
{
Routes = new List <GetRoutesListItem>
{
new GetRoutesListItem
{
Id = sectorId,
Name = query.RouteIds.First()
}
}
};
mockApiClient
.Setup(client => client.Get <GetStandardsListResponse>(
It.Is <GetAvailableToStartStandardsListRequest>(c => c.Keyword.Equals(query.Keyword) &&
c.RouteIds.Contains(sectorId) &&
c.Levels.Equals(query.Levels)
)))
.ReturnsAsync(apiResponse);
mockApiClient
.Setup(client => client.Get <GetRoutesListResponse>(It.IsAny <GetRoutesListRequest>()))
.ReturnsAsync(sectorsApiResponse);
mockApiClient
.Setup(client => client.Get <GetLevelsListResponse>(It.IsAny <GetLevelsListRequest>()))
.ReturnsAsync(levelsApiResponse);
shortlistService.Setup(x => x.GetShortlistItemCount(query.ShortlistUserId))
.ReturnsAsync(shortlistItemCount);
var result = await handler.Handle(query, CancellationToken.None);
result.Courses.Should().BeEquivalentTo(apiResponse.Standards);
result.Sectors.Should().BeEquivalentTo(sectorsApiResponse.Routes);
result.Levels.Should().BeEquivalentTo(levelsApiResponse.Levels);
result.Total.Should().Be(apiResponse.Total);
result.TotalFiltered.Should().Be(apiResponse.TotalFiltered);
result.OrderBy.Should().Be(query.OrderBy);
result.ShortlistItemCount.Should().Be(shortlistItemCount);
}
private static void ArrangeClients(
GetTrainingCourseProviderQuery query,
GetProviderStandardItem apiProviderStandardResponse,
GetStandardsListItem apiCourseResponse,
GetOverallAchievementRateResponse apiAchievementRateResponse,
GetStandardsListResponse allCoursesApiResponse,
GetUkprnsForStandardAndLocationResponse ukprnsCountResponse,
Mock <ICoursesApiClient <CoursesApiConfiguration> > mockCoursesApiClient,
Mock <ICourseDeliveryApiClient <CourseDeliveryApiConfiguration> > mockApiClient)
{
mockApiClient
.Setup(client => client.Get <GetProviderStandardItem>(It.Is <GetProviderByCourseAndUkPrnRequest>(c =>
c.GetUrl.Contains(query.CourseId.ToString()) &&
c.GetUrl.Contains(query.ProviderId.ToString()) &&
c.GetUrl.Contains(apiCourseResponse.SectorSubjectAreaTier2Description) &&
c.GetUrl.Contains($"shortlistUserId={query.ShortlistUserId}")
)))
.ReturnsAsync(apiProviderStandardResponse);
mockApiClient
.Setup(client => client.Get <GetProviderAdditionalStandardsItem>(It.Is <GetProviderAdditionalStandardsRequest>(
c =>
c.GetUrl.Contains(query.ProviderId.ToString()
))))
.ReturnsAsync(new GetProviderAdditionalStandardsItem
{
StandardIds = allCoursesApiResponse.Standards.Select(c => c.LarsCode).ToList()
});
mockApiClient
.Setup(x => x.Get <GetUkprnsForStandardAndLocationResponse>(
It.Is <GetUkprnsForStandardAndLocationRequest>(c => c.GetUrl.Contains(query.CourseId.ToString()))))
.ReturnsAsync(ukprnsCountResponse);
mockCoursesApiClient
.Setup(client =>
client.Get <GetStandardsListItem>(
It.Is <GetStandardRequest>(c => c.GetUrl.Contains(query.CourseId.ToString()))))
.ReturnsAsync(apiCourseResponse);
mockCoursesApiClient
.Setup(client => client.Get <GetStandardsListResponse>(It.IsAny <GetAvailableToStartStandardsListRequest>()))
.ReturnsAsync(allCoursesApiResponse);
mockApiClient.Setup(client => client.Get <GetOverallAchievementRateResponse>(It.Is <GetOverallAchievementRateRequest>(
c =>
c.GetUrl.Contains(apiCourseResponse.SectorSubjectAreaTier2Description)
)))
.ReturnsAsync(apiAchievementRateResponse);
}
public async Task Then_Gets_Demands_And_Courses_From_Apis_And_Adds_Courses_To_Cache(
GetAggregatedCourseDemandListQuery query,
GetStandardsListResponse coursesApiResponse,
GetAggregatedCourseDemandListResponse demandApiResponse,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > mockCoursesApi,
[Frozen] Mock <IEmployerDemandApiClient <EmployerDemandApiConfiguration> > mockDemandApi,
[Frozen] Mock <ILocationLookupService> mockLocationLookup,
[Frozen] Mock <ICacheStorageService> cacheStorageService,
GetAggregatedCourseDemandListQueryHandler handler)
{
query.LocationName = null;
query.LocationRadius = null;
cacheStorageService
.Setup(client => client.RetrieveFromCache <GetStandardsListResponse>(nameof(GetStandardsListResponse)))
.ReturnsAsync((GetStandardsListResponse)null);
mockLocationLookup
.Setup(service => service.GetLocationInformation(null, default, default))
