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_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_The_Api_Is_Called_With_The_Request_And_Sectors_Returned_And_Added_To_Cache(
GetRoutesListResponse apiResponse,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > apiClient,
[Frozen] Mock <ICacheStorageService> cacheStorageService,
CourseService service)
{
//Arrange
cacheStorageService.Setup(x => x.RetrieveFromCache <GetRoutesListResponse>(nameof(GetRoutesListResponse)))
.ReturnsAsync((GetRoutesListResponse) default);
public async Task <IActionResult> GetList()
{
var queryResult = await _mediator.Send(new GetRoutesQuery());
var response = new GetRoutesListResponse
{
Routes = queryResult.Routes.Select(c => (GetRouteResponse)c)
};
return(Ok(response));
}
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);
}
public async Task Then_The_Service_Called_And_Data_Returned(
GetRoutesQuery query,
GetRoutesListResponse response,
[Frozen] Mock <ICourseService> service,
GetRoutesQueryHandler handler)
{
//Arrange
service.Setup(x => x.GetRoutes())
.ReturnsAsync(response);
//Act
var actual = await handler.Handle(query, CancellationToken.None);
//Assert
actual.Routes.Should().BeEquivalentTo(response.Routes);
}
public async Task Then_If_The_Postcode_Is_Not_Valid_Then_No_Results_Returned(
GetAdvertsQuery query,
GetRoutesListResponse getRoutesListResponse,
[Frozen] Mock <ICourseService> courseService,
[Frozen] Mock <ILocationLookupService> locationLookupService,
GetAdvertsQueryHandler handler)
{
locationLookupService.Setup(x => x.GetLocationInformation(query.Postcode, 0, 0, false))
.ReturnsAsync((LocationItem)null);
courseService.Setup(x => x.GetRoutes()).ReturnsAsync(getRoutesListResponse);
var actual = await handler.Handle(query, CancellationToken.None);
actual.Routes.Should().BeEquivalentTo(getRoutesListResponse.Routes);
actual.TotalFound.Should().Be(0);
actual.Location.Should().BeNull();
actual.Vacancies.Should().BeEmpty();
}
public async Task Then_If_The_Sector_Does_Not_Exist_Then_No_Standards_Are_Returned(
GetStandardsQuery query,
GetStandardsListResponse apiResponse,
GetRoutesListResponse routesApiResponse,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > apiClient,
[Frozen] Mock <ICourseService> courseService,
GetStandardsQueryHandler handler)
{
//Arrange
courseService
.Setup(x => x.GetRoutes())
.ReturnsAsync(routesApiResponse);
//Act
var actual = await handler.Handle(query, CancellationToken.None);
//Assert
actual.Standards.Should().BeNull();
}
public async Task Then_The_Routes_Are_Filtered_And_Postcode_Searched_And_Adverts_Returned(
string findAnApprenticeshipBaseUrl,
GetAdvertsQuery query,
List <string> categories,
LocationItem locationItem,
GetVacanciesResponse vacanciesResponse,
GetRoutesListResponse getRoutesListResponse,
GetStandardsListResponse standards,
[Frozen] Mock <IOptions <CampaignConfiguration> > configuration,
[Frozen] Mock <ICourseService> courseService,
[Frozen] Mock <ILocationLookupService> locationLookupService,
[Frozen] Mock <IFindApprenticeshipApiClient <FindApprenticeshipApiConfiguration> > faaApiClient,
GetAdvertsQueryHandler handler)
{
//Arrange
query.Route = standards.Standards.First().Route.ToLower();
configuration.Object.Value.FindAnApprenticeshipBaseUrl = findAnApprenticeshipBaseUrl;
var expectedAdvertUrl = new GetVacanciesRequest(0, 20, null, null, null, new List <int> {
standards.Standards.First().LarsCode
}, null,
locationItem.GeoPoint.First(), locationItem.GeoPoint.Last(), query.Distance, null, null, "DistanceAsc");
locationLookupService.Setup(x => x.GetLocationInformation(query.Postcode, 0, 0, false))
.ReturnsAsync(locationItem);
faaApiClient
.Setup(x => x.Get <GetVacanciesResponse>(It.Is <GetVacanciesRequest>(c =>
c.GetUrl.Equals(expectedAdvertUrl.GetUrl)))).ReturnsAsync(vacanciesResponse);
courseService.Setup(x => x.GetRoutes()).ReturnsAsync(getRoutesListResponse);
courseService.Setup(x => x.GetActiveStandards <GetStandardsListResponse>(nameof(GetStandardsListResponse))).ReturnsAsync(standards);
var actual = await handler.Handle(query, CancellationToken.None);
actual.Vacancies.Should().BeEquivalentTo(vacanciesResponse.ApprenticeshipVacancies);
actual.TotalFound.Should().Be(vacanciesResponse.ApprenticeshipVacancies.Count());
actual.Routes.Should().BeEquivalentTo(getRoutesListResponse.Routes);
actual.Location.Should().BeEquivalentTo(locationItem);
foreach (var vacancy in actual.Vacancies)
{
vacancy.VacancyUrl.Should().Be($"{findAnApprenticeshipBaseUrl}/apprenticeship/reference/{vacancy.VacancyReference}");
}
}
public async Task Then_Gets_Demands_And_Courses_From_Apis_And_Adds_Courses_And_Routes_To_Cache(
GetAggregatedCourseDemandListQuery query,
GetStandardsListResponse coursesApiStandardsResponse,
GetRoutesListResponse coursesApiRoutesResponse,
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);
cacheStorageService
.Setup(client => client.RetrieveFromCache <GetRoutesListResponse>(nameof(GetRoutesListResponse)))
.ReturnsAsync((GetRoutesListResponse)null);
mockLocationLookup
.Setup(service => service.GetLocationInformation(null, default, default, false))
public async Task Then_The_Levels_Are_Added_To_The_Cache_If_Not_Available(GetTrainingCoursesListQuery query,
GetStandardsListResponse apiResponse,
GetRoutesListResponse routesApiResponse,
GetLevelsListResponse levelsApiResponse,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > mockApiClient,
[Frozen] Mock <ICacheStorageService> cacheStorageService,
GetTrainingCoursesListQueryHandler handler)
{
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);
mockApiClient
.Setup(client => client.Get <GetLevelsListResponse>(It.IsAny <GetLevelsListRequest>()))
.ReturnsAsync(levelsApiResponse);
await handler.Handle(query, CancellationToken.None);
cacheStorageService.Verify(x => x.SaveToCache(nameof(GetLevelsListResponse), levelsApiResponse, TimeSpan.FromHours(2)));
}
public async Task Then_Caches_The_Courses_If_The_Cache_Has_An_Empty_Course_List(
GetStandardsListResponse cachedStandards,
GetStandardsListResponse apiResponse,
GetRoutesListResponse routesApiResponse,
GetLevelsListResponse levelsApiResponse,
[Frozen] Mock <ICacheStorageService> cacheStorageService,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > mockApiClient,
GetTrainingCoursesListQueryHandler handler)
{
cachedStandards.Total = 0;
var query = new GetTrainingCoursesListQuery
{
Levels = new List <int>(),
RouteIds = new List <string>()
};
cacheStorageService
.Setup(cache => cache.RetrieveFromCache <GetStandardsListResponse>(nameof(GetStandardsListResponse)))
.ReturnsAsync(cachedStandards);
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);
}
public async Task Then_Sector_Ids_Are_Looked_Up_If_There_Is_A_Sector_Filter(
int sectorId,
GetTrainingCoursesListQuery query,
GetStandardsListResponse apiResponse,
GetLevelsListResponse levelsApiResponse,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > mockApiClient,
[Frozen] Mock <ICacheStorageService> cacheStorageService,
GetTrainingCoursesListQueryHandler handler)
{
var sectorsApiResponse = new GetRoutesListResponse
{
Routes = new List <GetRoutesListItem>
{
new GetRoutesListItem
{
Id = sectorId,
Name = query.RouteIds.First()
}
}
};
mockApiClient
.Setup(client => client.Get <GetRoutesListResponse>(It.IsAny <GetRoutesListRequest>()))
.ReturnsAsync(sectorsApiResponse);
mockApiClient
.Setup(client => client.Get <GetLevelsListResponse>(It.IsAny <GetLevelsListRequest>()))
.ReturnsAsync(levelsApiResponse);
mockApiClient
.Setup(client => client.Get <GetStandardsListResponse>(
It.Is <GetAvailableToStartStandardsListRequest>(c => c.Keyword.Equals(query.Keyword) && c.RouteIds.Contains(sectorId))))
.ReturnsAsync(apiResponse);
var actual = await handler.Handle(query, CancellationToken.None);
Assert.IsNotNull(actual);
}
public async Task Then_If_The_Sectors_Cache_Is_Empty_They_Are_Looked_Up_And_Added(
int routeId,
GetStandardsQuery query,
GetStandardsListResponse apiResponse,
[Frozen] Mock <ICoursesApiClient <CoursesApiConfiguration> > apiClient,
[Frozen] Mock <ICacheStorageService> cacheStorageService,
GetStandardsQueryHandler handler)
{
//Arrange
var sectorsApiResponse = new GetRoutesListResponse
{
Routes = new List <GetRoutesListItem>
{
new GetRoutesListItem
{
Id = routeId,
Name = query.Sector
}
}
};
cacheStorageService
.Setup(x => x.RetrieveFromCache <GetRoutesListResponse>(nameof(GetRoutesListResponse)))
.ReturnsAsync((GetRoutesListResponse) default);
