public async Task Then_The_Api_Is_Called_With_The_Request_And_Vacancies_Returned(
GetVacanciesQuery query,
GetVacanciesResponse apiResponse,
List <string> categories,
GetStandardsListItem courseResponse,
[Frozen] Mock <ICourseService> courseService,
[Frozen] Mock <IFindApprenticeshipApiClient <FindApprenticeshipApiConfiguration> > apiClient,
GetVacanciesQueryHandler handler)
{
courseService.Setup(x => x.MapRoutesToCategories(query.Routes)).Returns(categories);
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, categories, query.PostedInLastNumberOfDays, query.Sort);
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(new GetStandardsListResponse
{
Standards = new List <GetStandardsListItem> {
courseResponse
}
});
var actual = await handler.Handle(query, CancellationToken.None);
actual.Vacancies.Should().BeEquivalentTo(apiResponse.ApprenticeshipVacancies);
actual.Total.Should().Be(apiResponse.Total);
actual.TotalFiltered.Should().Be(apiResponse.TotalFound);
actual.TotalPages.Should().Be((int)Math.Ceiling((decimal)apiResponse.TotalFound / query.PageSize));
}
public async Task Then_Creates_The_Shortlist_From_The_Request_Calling_CourseDelivery_Api(
PostShortListResponse apiResponse,
CreateShortlistForUserCommand command,
GetStandardsListItem standardApiResponse,
[Frozen] Mock <ICourseDeliveryApiClient <CourseDeliveryApiConfiguration> > courseDeliveryApiClient,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > coursesApiClient,
CreateShortlistForUserCommandHandler handler)
{
//Arrange
coursesApiClient
.Setup(x => x.Get <GetStandardsListItem>(It.Is <GetStandardRequest>(c =>
c.StandardId.Equals(command.StandardId)))).ReturnsAsync(standardApiResponse);
courseDeliveryApiClient.Setup(x =>
x.Post <PostShortListResponse>(It.Is <PostShortlistForUserRequest>(c =>
((PostShortlistData)c.Data).Lat.Equals(command.Lat) &&
((PostShortlistData)c.Data).Lon.Equals(command.Lon) &&
((PostShortlistData)c.Data).Ukprn.Equals(command.Ukprn) &&
((PostShortlistData)c.Data).LocationDescription.Equals(command.LocationDescription) &&
((PostShortlistData)c.Data).StandardId.Equals(command.StandardId) &&
((PostShortlistData)c.Data).SectorSubjectArea.Equals(standardApiResponse.SectorSubjectAreaTier2Description) &&
((PostShortlistData)c.Data).ShortlistUserId.Equals(command.ShortlistUserId)))).ReturnsAsync(apiResponse);
//Act
var actual = await handler.Handle(command, CancellationToken.None);
//Assert
actual.Should().Be(apiResponse.Id);
}
public async Task Then_Gets_Epaos_From_Assessors_Api_And_Course_From_Courses_Api_And_Filters_Epaos(
GetCourseEpaosQuery query,
List <GetCourseEpaoListItem> epaoApiResponse,
GetStandardsListItem coursesApiResponse,
[Frozen] Mock <IAssessorsApiClient <AssessorsApiConfiguration> > mockAssessorsApiClient,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > mockCoursesApiClient,
[Frozen] Mock <ICourseEpaoIsValidFilterService> mockCourseEpaoFilter,
GetCourseEpaosQueryHandler handler)
{
mockAssessorsApiClient
.Setup(client => client.GetAll <GetCourseEpaoListItem>(
It.Is <GetCourseEpaosRequest>(request => request.CourseId == query.CourseId)))
.ReturnsAsync(epaoApiResponse);
mockCoursesApiClient
.Setup(client => client.Get <GetStandardsListItem>(
It.Is <GetStandardRequest>(request => request.StandardId == query.CourseId)))
.ReturnsAsync(coursesApiResponse);
mockCourseEpaoFilter
.Setup(service => service.IsValidCourseEpao(It.Is <GetCourseEpaoListItem>(item => item.EpaoId == epaoApiResponse[0].EpaoId)))
.Returns(true);
var result = await handler.Handle(query, CancellationToken.None);
result.Epaos.Should().BeEquivalentTo(epaoApiResponse.Where(item => item.EpaoId == epaoApiResponse[0].EpaoId).ToList());
result.Epaos.Should().BeInAscendingOrder(item => item.Name);
result.Course.Should().BeEquivalentTo(coursesApiResponse);
}
public async Task And_Application_Exists_Stitches_Up_Standard_To_Result(
GetApplicationQuery getApplicationQuery,
GetApplicationResponse getApplicationResponse,
GetStandardsListItem getStandardsListItem,
GetCohortsResponse getCohortsResponse,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > mockCoursesApiClient,
[Frozen] Mock <ILevyTransferMatchingService> mockLevyTransferMatchingService,
[Frozen] Mock <ICommitmentsV2ApiClient <CommitmentsV2ApiConfiguration> > mockCommitmentsV2ApiClient,
GetApplicationQueryHandler getApplicationQueryHandler)
{
mockLevyTransferMatchingService
.Setup(x => x.GetApplication(It.Is <GetApplicationRequest>(y => y.GetUrl.Contains(getApplicationQuery.ApplicationId.ToString()))))
.ReturnsAsync(getApplicationResponse);
mockCoursesApiClient
.Setup(x => x.Get <GetStandardsListItem>(It.Is <GetStandardDetailsByIdRequest>(y => y.GetUrl.Contains(getApplicationResponse.StandardId))))
.ReturnsAsync(getStandardsListItem);
mockCommitmentsV2ApiClient
.Setup(x => x.Get <GetCohortsResponse>(It.Is <GetCohortsRequest>(y => y.GetUrl.Contains(getApplicationQuery.AccountId.ToString()))))
.ReturnsAsync(getCohortsResponse);
var result = await getApplicationQueryHandler.Handle(getApplicationQuery, CancellationToken.None);
Assert.IsNotNull(result);
Assert.AreEqual(getApplicationResponse.Status, result.Status);
}
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 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 void Then_Maps_Fields_Appropriately(
GetStandardsListItem source)
{
var response = (GetTrainingCoursesListItem)source;
response.Should().BeEquivalentTo(source);
}
public async Task Then_The_Demand_Data_Is_Returned_From_The_Api(
GetRestartEmployerDemandQuery query,
GetEmployerDemandResponse getDemandResponse,
GetStandardsListItem getStandardResponse,
[Frozen] Mock <IEmployerDemandApiClient <EmployerDemandApiConfiguration> > demandApiClient,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > coursesApiClient,
GetRestartEmployerDemandQueryHandler handler)
{
//Arrange
demandApiClient.Setup(x =>
x.Get <GetEmployerDemandResponse>(
It.Is <GetEmployerDemandByExpiredDemandRequest>(c => c.GetUrl.Contains($"demand?expiredCourseDemandId={query.Id}"))))
.ReturnsAsync((GetEmployerDemandResponse)null);
demandApiClient.Setup(x =>
x.Get <GetEmployerDemandResponse>(
It.Is <GetEmployerDemandRequest>(c => c.GetUrl.Contains($"demand/{query.Id}"))))
.ReturnsAsync(getDemandResponse);
coursesApiClient.Setup(x =>
x.Get <GetStandardsListItem>(
It.Is <GetStandardRequest>(c => c.GetUrl.Contains($"api/courses/standards/{getDemandResponse.Course.Id}"))))
.ReturnsAsync(getStandardResponse);
//Act
var actual = await handler.Handle(query, CancellationToken.None);
//Assert
actual.EmployerDemand.Should().BeEquivalentTo(getDemandResponse);
actual.RestartDemandExists.Should().BeFalse();
actual.LastStartDate.Should().Be(getStandardResponse.StandardDates.LastDateStarts);
}
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_With_The_Request_And_Vacancy_And_Course_Not_looked_Up_If_Standard_Is_Null(
GetVacancyQuery query,
GetVacancyApiResponse apiApiResponse,
GetStandardsListItem courseResponse,
string findAnApprenticeshipBaseUrl,
List <string> categories,
[Frozen] Mock <ICourseService> standardsService,
[Frozen] Mock <IFindApprenticeshipApiClient <FindApprenticeshipApiConfiguration> > apiClient,
[Frozen] Mock <IOptions <VacanciesConfiguration> > vacanciesConfiguration,
GetVacancyQueryHandler handler)
{
vacanciesConfiguration.Object.Value.FindAnApprenticeshipBaseUrl = findAnApprenticeshipBaseUrl;
apiApiResponse.StandardLarsCode = null;
standardsService.Setup(x => x.GetActiveStandards <GetStandardsListResponse>(nameof(GetStandardsListResponse))).ReturnsAsync(new GetStandardsListResponse
{
Standards = new List <GetStandardsListItem> {
courseResponse
}
});
var expectedGetRequest = new GetVacancyRequest(query.VacancyReference);
apiClient.Setup(x =>
x.Get <GetVacancyApiResponse>(It.Is <GetVacancyRequest>(c =>
c.GetUrl.Equals(expectedGetRequest.GetUrl)))).ReturnsAsync(apiApiResponse);
var actual = await handler.Handle(query, CancellationToken.None);
actual.Vacancy.Should().BeEquivalentTo(apiApiResponse);
}
public void SetUp()
{
_getAccountResponse = _fixture.Create <GetAccountResponse>();
_command = _fixture.Create <CreateApplicationCommand>();
_response = _fixture.Create <CreateApplicationResponse>();
_getStandardResponse = _fixture.Create <GetStandardsListItem>();
_account = _fixture.Create <Account>();
_accountsService = new Mock <IAccountsService>();
_accountsService.Setup(x => x.GetAccount(_command.EncodedAccountId)).ReturnsAsync(_account);
_coursesApiClient = new Mock <ICoursesApiClient <CoursesApiConfiguration> >();
_coursesApiClient.Setup(x => x.Get <GetStandardsListItem>(It.Is <GetStandardDetailsByIdRequest>(r => r.Id == _command.StandardId)))
.ReturnsAsync(_getStandardResponse);
_levyTransferMatchingService = new Mock <ILevyTransferMatchingService>();
_levyTransferMatchingService.Setup(x => x.GetAccount(It.Is <GetAccountRequest>(r => r.AccountId == _command.EmployerAccountId)))
.ReturnsAsync(_getAccountResponse);
_levyTransferMatchingService.Setup(x => x.CreateApplication(It.IsAny <CreateApplicationRequest>()))
.Callback <CreateApplicationRequest>(r => _createApplicationRequest = r)
.ReturnsAsync(_response);
_handler = new CreateApplicationCommandHandler(_levyTransferMatchingService.Object, _accountsService.Object, Mock.Of <ILogger <CreateApplicationCommandHandler> >(), _coursesApiClient.Object);
}
public void Then_Maps_GetStandardsListItem_Correctly(
GetStandardsListItem source)
{
var response = (ApprenticeshipCourse)source;
response.Should().BeEquivalentTo(source,
o => o
.Excluding(s => s.ApprenticeshipFunding)
.Excluding(s => s.MaxFunding)
.Excluding(s => s.TypicalDuration)
.Excluding(s => s.StandardDates)
.Excluding(s => s.IsActive)
.Excluding(s => s.StandardUId)
.Excluding(s => s.LarsCode)
);
response.Duration.Should().Be(source.TypicalDuration);
response.FundingCap.Should().Be(source.MaxFunding);
response.Id.Should().Be(source.LarsCode.ToString());
for (var i = 0; i < response.FundingPeriods.Count; i++)
{
response.FundingPeriods[i].FundingCap.Should().Be(source.ApprenticeshipFunding[i].MaxEmployerLevyCap);
response.FundingPeriods[i].EffectiveFrom.Should().Be(source.ApprenticeshipFunding[i].EffectiveFrom);
response.FundingPeriods[i].EffectiveTo.Should().Be(source.ApprenticeshipFunding[i].EffectiveTo);
}
}
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 void Then_The_Future_Price_Is_Not_Used(long fundingPrice, long notFundingPrice)
{
//Arrange / Act
var standard = new GetStandardsListItem
{
Title = "Available",
ApprenticeshipFunding = new List <ApprenticeshipFunding>
{
new ApprenticeshipFunding
{
EffectiveFrom = DateTime.UtcNow.AddDays(-10),
EffectiveTo = DateTime.UtcNow.AddDays(9),
MaxEmployerLevyCap = fundingPrice
},
new ApprenticeshipFunding
{
EffectiveFrom = DateTime.UtcNow.AddDays(4),
EffectiveTo = null,
MaxEmployerLevyCap = notFundingPrice
}
},
StandardDates =
new StandardDate
{
EffectiveFrom = DateTime.UtcNow.AddMonths(-1),
LastDateStarts = null
}
};
//Assert
standard.MaxFunding.Should().Be(fundingPrice);
}
public void Then_The_ApprenticeshipFunding_Price_With_No_EffectiveTo_Date_And_Has_A_From_Date_In_The_Past_Is_Used(long fundingPrice)
{
//Arrange / Act
var standard = new GetStandardsListItem
{
Title = "Available",
ApprenticeshipFunding = new List <ApprenticeshipFunding>
{
new ApprenticeshipFunding
{
EffectiveFrom = DateTime.UtcNow.AddDays(-1),
EffectiveTo = null,
MaxEmployerLevyCap = fundingPrice
}
},
StandardDates =
new StandardDate
{
EffectiveFrom = DateTime.UtcNow.AddMonths(-1),
LastDateStarts = null
}
};
//Assert
standard.MaxFunding.Should().Be(fundingPrice);
}
public async Task Then_If_No_Location_Found_Then_Returns_Data(
GetEmployerCourseProviderDemandQuery query,
GetStandardsListItem standardResult,
GetEmployerCourseProviderListResponse demandResponse,
[Frozen] Mock <ILocationLookupService> locationLookupService,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > coursesApiClient,
[Frozen] Mock <IEmployerDemandApiClient <EmployerDemandApiConfiguration> > employerDemandApiClient,
GetEmployerCourseProviderDemandQueryHandler handler)
{
//Arrange
locationLookupService.Setup(x => x.GetLocationInformation(query.LocationName, 0, 0, true))
.ReturnsAsync((LocationItem)null);
coursesApiClient
.Setup(x => x.Get <GetStandardsListItem>(It.Is <GetStandardRequest>(c =>
c.StandardId.Equals(query.CourseId)))).ReturnsAsync(standardResult);
employerDemandApiClient
.Setup(x => x.Get <GetEmployerCourseProviderListResponse>(
It.Is <GetCourseProviderDemandsRequest>(c => c.GetUrl.Contains($"providers/{query.Ukprn}/courses/{query.CourseId}?lat=&lon=&radius="))))
.ReturnsAsync(demandResponse);
//Act
var actual = await handler.Handle(query, CancellationToken.None);
//Assert
actual.Course.Should().BeEquivalentTo(standardResult);
actual.Location.Should().BeNull();
actual.EmployerCourseDemands.Should().BeEquivalentTo(demandResponse.EmployerCourseDemands);
actual.Total.Should().Be(demandResponse.Total);
actual.TotalFiltered.Should().Be(demandResponse.TotalFiltered);
}
public void Then_Maps_Fields_Appropriately(
GetStandardsListItem source)
{
var response = (GetCourseListItem)source;
response.Should().BeEquivalentTo(source, options => options.ExcludingMissingMembers());
}
public async Task Then_If_There_Is_A_Location_Supplied_It_Is_Searched_And_Passed_To_The_Provider_Search(
string locationName,
string authorityName,
GetTrainingCourseProvidersQuery query,
GetProvidersListResponse apiResponse,
IEnumerable <GetApprenticeFeedbackResponse> apprenticeFeedbackResponse,
GetStandardsListItem apiCourseResponse,
LocationItem locationServiceResponse,
[Frozen] Mock <ILocationLookupService> mockLocationLookupService,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > mockCoursesApiClient,
[Frozen] Mock <ICourseDeliveryApiClient <CourseDeliveryApiConfiguration> > mockApiClient,
[Frozen] Mock <IApprenticeFeedbackApiClient <ApprenticeFeedbackApiConfiguration> > mockApprenticeFeedbackApiClient,
GetTrainingCourseProvidersQueryHandler handler)
{
query.Location = $"{locationName}, {authorityName} ";
query.Lat = 0;
query.Lon = 0;
var providerUkprns = apiResponse.Providers.Select(s => s.Ukprn);
for (var i = 0; i < apprenticeFeedbackResponse.Count(); i++)
{
apprenticeFeedbackResponse.ToArray()[i].Ukprn = providerUkprns.ToArray()[i];
}
mockLocationLookupService
.Setup(service => service.GetLocationInformation(query.Location, query.Lat, query.Lon, false))
.ReturnsAsync(locationServiceResponse);
mockApiClient
.Setup(client => client.Get <GetProvidersListResponse>(It.Is <GetProvidersByCourseRequest>(c =>
c.GetUrl.Contains(query.Id.ToString()) &&
c.GetUrl.Contains(locationServiceResponse.GeoPoint.First().ToString()) &&
c.GetUrl.Contains(locationServiceResponse.GeoPoint.Last().ToString()) &&
c.GetUrl.Contains($"&sortOrder={query.SortOrder}")
)))
.ReturnsAsync(apiResponse);
mockCoursesApiClient
.Setup(client => client.Get <GetStandardsListItem>(It.Is <GetStandardRequest>(c => c.GetUrl.Contains(query.Id.ToString()))))
.ReturnsAsync(apiCourseResponse);
mockApprenticeFeedbackApiClient
.Setup(s => s.PostWithResponseCode <IEnumerable <GetApprenticeFeedbackResponse> >(It.Is <PostApprenticeFeedbackRequest>
(t =>
((PostApprenticeFeedbackRequestData)t.Data).Ukprns.Except(apiResponse.Providers.Select(s => s.Ukprn)).Count() == 0 &&
apiResponse.Providers.Select(s => s.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.Providers.Should().BeEquivalentTo(apiResponse.Providers, options => options.Excluding(s => s.ApprenticeFeedback));
result.Total.Should().Be(apiResponse.TotalResults);
result.Course.Should().BeEquivalentTo(apiCourseResponse);
result.Location.Name.Should().Be(locationServiceResponse.Name);
result.Location.GeoPoint.Should().BeEquivalentTo(locationServiceResponse.GeoPoint);
foreach (var provider in result.Providers)
{
provider.ApprenticeFeedback.Should().BeEquivalentTo(apprenticeFeedbackResponse.First(s => s.Ukprn == provider.Ukprn));
}
}
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);
}
public async Task Then_Gets_The_Standard_And_The_List_Of_Providers_For_That_Course_From_Course_Delivery_Api_Client_With_No_Location_And_ShortlistItem_Count(
GetTrainingCourseProvidersQuery query,
GetProvidersListResponse apiResponse,
GetStandardsListItem apiCourseResponse,
IEnumerable <GetApprenticeFeedbackResponse> apprenticeFeedbackResponse,
int shortlistItemCount,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > mockCoursesApiClient,
[Frozen] Mock <ICourseDeliveryApiClient <CourseDeliveryApiConfiguration> > mockApiClient,
[Frozen] Mock <IApprenticeFeedbackApiClient <ApprenticeFeedbackApiConfiguration> > mockApprenticeFeedbackApiClient,
[Frozen] Mock <IShortlistService> shortlistService,
[Frozen] Mock <ILocationLookupService> mockLocationLookup,
GetTrainingCourseProvidersQueryHandler handler)
{
apiCourseResponse.Level = 1;
query.Location = "";
query.Lat = 0;
query.Lon = 0;
var providerUkprns = apiResponse.Providers.Select(s => s.Ukprn);
for (var i = 0; i < apprenticeFeedbackResponse.Count(); i++)
{
apprenticeFeedbackResponse.ToArray()[i].Ukprn = providerUkprns.ToArray()[i];
}
mockApiClient
.Setup(client => client.Get <GetProvidersListResponse>(It.Is <GetProvidersByCourseRequest>(c =>
c.GetUrl.Contains(query.Id.ToString()) &&
c.GetUrl.Contains($"sectorSubjectArea={apiCourseResponse.SectorSubjectAreaTier2Description}&level={apiCourseResponse.Level}")
)))
.ReturnsAsync(apiResponse);
mockCoursesApiClient
.Setup(client => client.Get <GetStandardsListItem>(It.Is <GetStandardRequest>(c => c.GetUrl.Contains(query.Id.ToString()))))
.ReturnsAsync(apiCourseResponse);
shortlistService.Setup(x => x.GetShortlistItemCount(query.ShortlistUserId))
.ReturnsAsync(shortlistItemCount);
mockLocationLookup
.Setup(service => service.GetLocationInformation(query.Location, query.Lat, query.Lon, false))
.ReturnsAsync((LocationItem)null);
mockApprenticeFeedbackApiClient
.Setup(s => s.PostWithResponseCode <IEnumerable <GetApprenticeFeedbackResponse> >(It.Is <PostApprenticeFeedbackRequest>
(t =>
((PostApprenticeFeedbackRequestData)t.Data).Ukprns.Except(apiResponse.Providers.Select(s => s.Ukprn)).Count() == 0 &&
apiResponse.Providers.Select(s => s.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.Providers.Should().BeEquivalentTo(apiResponse.Providers, options => options.Excluding(s => s.ApprenticeFeedback));
result.Total.Should().Be(apiResponse.TotalResults);
result.Course.Should().BeEquivalentTo(apiCourseResponse);
result.ShortlistItemCount.Should().Be(shortlistItemCount);
result.Location.Should().BeNull();
foreach (var provider in result.Providers)
{
provider.ApprenticeFeedback.Should().BeEquivalentTo(apprenticeFeedbackResponse.First(s => s.Ukprn == provider.Ukprn));
}
}
public void Then_The_Fields_Are_Correctly_Mapped(GetStandardsListItem source)
{
//Act
var actual = (GetStandardsResponseItem)source;
//Assert
actual.Id.Should().Be(source.LarsCode);
}
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 void And_No_Standard_Funding_Periods_Then_Duration_Is_Zero(
GetStandardsListItem source)
{
source.ApprenticeshipFunding = new List <ApprenticeshipFunding>();
var response = (ApprenticeshipCourse)source;
response.Duration.Should().Be(0);
}
public void Then_CoreSkillCount_Is_Set_When_CoreAndOptions_Is_True(
GetStandardsListItem source)
{
source.CoreAndOptions = true;
var response = (GetTrainingCourseListItem)source;
response.CoreSkillsCount.Should().BeEquivalentTo(source.CoreDuties);
}
public void Then_CoreSkillCount_Is_Set_When_CoreAndOptions_Is_False(
GetStandardsListItem source)
{
source.CoreAndOptions = false;
var expectedSkills = string.Join("|", source.Skills.Select(s => s));
var response = (GetTrainingCourseListItem)source;
response.CoreSkillsCount.Should().BeEquivalentTo(expectedSkills);
}
public void Then_Maps_Fields_Appropriately(
GetStandardsListItem source)
{
var response = (GetTrainingCourseListItem)source;
response.Should().BeEquivalentTo(source, options => options
.Excluding(c => c.ApprenticeshipFunding)
.Excluding(c => c.StandardDates)
);
}
public void Then_Maps_Fields_Appropriately(
GetStandardsListItem source)
{
var response = (GetTrainingCoursesListItem)source;
response.Should().BeEquivalentTo(source, options => options
.Excluding(r => r.StandardUId)
.Excluding(r => r.LarsCode));
response.Id.Should().Be(source.LarsCode);
}
public async Task Then_If_Demand_Feature_Is_Not_Enabled_Then_False_Returned_And_Api_Not_Called(
GetTrainingCourseQuery query,
GetStandardsListItem coursesApiResponse,
GetLevelsListResponse levelsApiResponse,
GetUkprnsForStandardAndLocationResponse courseDirectoryApiResponse,
int shortlistItemCount,
GetShowEmployerDemandResponse showEmployerDemandResponse,
[Frozen] Mock <IOptions <FindApprenticeshipTrainingConfiguration> > config,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > mockCoursesApiClient,
[Frozen] Mock <ICourseDeliveryApiClient <CourseDeliveryApiConfiguration> > mockCourseDeliveryApiClient,
[Frozen] Mock <IShortlistService> shortlistService,
[Frozen] Mock <IEmployerDemandApiClient <EmployerDemandApiConfiguration> > mockEmployerDemandApiClient,
GetTrainingCourseQueryHandler handler)
{
//Arrange
config.Object.Value.EmployerDemandFeatureToggle = false;
levelsApiResponse.Levels.First().Name = "GCSE";
levelsApiResponse.Levels.First().Code = 2;
coursesApiResponse.Level = 2;
coursesApiResponse.LevelEquivalent = levelsApiResponse.Levels
.Single(x => x.Code == coursesApiResponse.Level).Name;
var url = new GetUkprnsForStandardAndLocationRequest(query.Id, query.Lat, query.Lon).GetUrl;
mockCoursesApiClient
.Setup(client => client.Get <GetStandardsListItem>(It.Is <GetStandardRequest>(c => c.GetUrl.Contains($"api/courses/standards/{query.Id}"))))
.ReturnsAsync(coursesApiResponse);
shortlistService.Setup(x => x.GetShortlistItemCount(query.ShortlistUserId))
.ReturnsAsync(shortlistItemCount);
mockCourseDeliveryApiClient
.Setup(client =>
client.Get <GetUkprnsForStandardAndLocationResponse>(
It.Is <GetUkprnsForStandardAndLocationRequest>((c =>
c.GetUrl.Equals(url)))))
.ReturnsAsync(courseDirectoryApiResponse);
mockCoursesApiClient
.Setup(client => client.Get <GetLevelsListResponse>(It.IsAny <GetLevelsListRequest>()))
.ReturnsAsync(levelsApiResponse);
mockEmployerDemandApiClient
.Setup(client => client.GetResponseCode(It.IsAny <GetShowEmployerDemandRequest>()))
.ReturnsAsync(HttpStatusCode.OK);
//Act
var result = await handler.Handle(query, CancellationToken.None);
//Assert
result.Course.Should().BeEquivalentTo(coursesApiResponse);
result.Course.LevelEquivalent.Should().Be("GCSE");
result.ProvidersCount.Should().Be(courseDirectoryApiResponse.UkprnsByStandard.ToList().Count);
result.ProvidersCountAtLocation.Should().Be(courseDirectoryApiResponse.UkprnsByStandardAndLocation.ToList().Count);
result.ShortlistItemCount.Should().Be(shortlistItemCount);
result.ShowEmployerDemand.Should().BeFalse();
mockEmployerDemandApiClient
.Verify(client => client.GetResponseCode(It.IsAny <GetShowEmployerDemandRequest>()), Times.Never);
}
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 void And_If_More_Than_One_Typical_Job_Title_Then_Titles_Are_Ordered_Alphabetically(
GetStandardsListItem source)
{
source.TypicalJobTitles = "B|Z|A|V";
var expected = new List <string> {
"A", "B", "V", "Z"
};
var response = (GetTrainingCourseListItem)source;
Assert.AreEqual(response.TypicalJobTitles, expected);
}
