public ViewResult SearchPage(SearchRequestViewModel searchRequestViewModel)
{
if (!ModelState.IsValid)
{
return View(new SearchResultViewModel{PageTitle = "Please Try Again"});
}
var searchTerm = searchRequestViewModel.SearchTerm;
var movies = _movieCatalogue.SearchMovies(searchTerm).ToList().Take(searchRequestViewModel.NumRows);
var viewModel = new SearchResultViewModel { PageTitle = "Search Results", Movies = movies };
return View(viewModel);
}
public async Task OnPostAsync_WhenFirstPageRequestedWithNoFilters_ThenSuccessfullyShown()
{
// Arrange
ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>();
ICalculationSearchService calculationSearchService = Substitute.For <ICalculationSearchService>();
IFeatureToggle featureToggle = Substitute.For <IFeatureToggle>();
int generatedNumberOfItems = 10;
SearchRequestViewModel searchRequest = new SearchRequestViewModel()
{
SearchTerm = null,
PageNumber = null,
IncludeFacets = false,
Filters = null,
};
CalculationSearchResultViewModel expectedCalculationResult = GenerateSearchResult(generatedNumberOfItems);
calculationSearchService.PerformSearch(Arg.Is <SearchRequestViewModel>(
m => m.PageNumber == searchRequest.PageNumber &&
m.SearchTerm == searchRequest.SearchTerm &&
m.IncludeFacets == searchRequest.IncludeFacets &&
m.Filters == searchRequest.Filters))
.Returns(expectedCalculationResult);
IndexPageModel pageModel = new IndexPageModel(calcsClient, calculationSearchService, featureToggle);
// Act
IActionResult result = await pageModel.OnPostAsync(null);
// Assert
result.Should().BeOfType <PageResult>();
pageModel.SearchResults.Should().NotBeNull();
pageModel.SearchResults.Calculations.Should().HaveCount(generatedNumberOfItems, "The number of items returned in the calculations list should equal the expected results");
pageModel.SearchResults.PagerState.Should().NotBeNull("Pager State should not be null");
pageModel.SearchTerm.Should().Be(searchRequest.SearchTerm);
pageModel.SearchResults.PagerState.CurrentPage.Should().Be(1);
pageModel.SearchResults.PagerState.DisplayNumberOfPages.Should().Be(4);
pageModel.SearchResults.PagerState.NextPage.Should().BeNull("Next Page should be null");
pageModel.SearchResults.PagerState.PreviousPage.Should().BeNull("Preview Page should be null");
}
public async Task <IActionResult> OnGetAsync(int?pageNumber, string searchTerm)
{
SearchRequestViewModel searchRequest = new SearchRequestViewModel()
{
PageNumber = pageNumber,
IncludeFacets = false,
SearchTerm = searchTerm,
};
SearchTerm = searchTerm;
SearchResults = await _searchService.PerformSearch(searchRequest);
if (SearchResults == null)
{
return(new InternalServerErrorResult("Null results returned when searching calculations"));
}
return(Page());
}
public async Task <IActionResult> OnGetAsync(int?pageNumber, string searchTerm)
{
SearchRequestViewModel searchRequest = new SearchRequestViewModel()
{
PageNumber = pageNumber,
IncludeFacets = false,
SearchTerm = searchTerm,
};
SearchTerm = searchTerm;
ProviderResults = await _providerSearchService.PerformSearch(searchRequest);
if (ProviderResults == null)
{
return(new StatusCodeResult(500));
}
return(Page());
}
private static void SetFilterValue(SearchRequestViewModel searchRequest, string fieldKey, string value)
{
if (!string.IsNullOrWhiteSpace(value))
{
if (!searchRequest.Filters.ContainsKey(fieldKey))
{
searchRequest.Filters.Add(fieldKey, new string[] { value });
}
if (searchRequest.Filters[fieldKey] == null)
{
searchRequest.Filters.Add(fieldKey, new string[] { value });
}
if (!searchRequest.Filters[fieldKey].Contains(value))
{
searchRequest.Filters[fieldKey] = searchRequest.Filters[fieldKey].Append(value).ToArray();
}
}
}
public async Task PerformSearch_GivenFirstSearchResultReturnedCorrectly_EnsuresResult()
{
// Arrange
IDatasetsApiClient apiClient = CreateApiClient();
ILogger logger = CreateLogger();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
DatasetDefinitionSearchService searchService = CreateSearchService(apiClient, mapper, logger);
int numberOfItems = 25;
PagedResult <DatasetDefinitionSearchResultItem> itemResult = GeneratePagedResult(numberOfItems);
apiClient
.FindDatasetDefinitions(Arg.Any <SearchFilterRequest>())
.Returns(itemResult);
SearchRequestViewModel request = new SearchRequestViewModel();
// Act
DatasetDefinitionSearchResultViewModel results = await searchService.PerformSearch(request);
// Assert
results
.DatasetDefinitions
.First()
.Should()
.BeEquivalentTo(new DatasetDefinitionSearchResultItemViewModel()
{
Id = "10",
Description = "Description 0",
LastUpdatedDate = new DateTimeOffset(2018, 1, 2, 3, 4, 0, TimeSpan.Zero),
Name = "ds-1",
ProviderIdentifier = "Provider 0",
});
await apiClient
.Received(1)
.FindDatasetDefinitions(Arg.Any <SearchFilterRequest>());
}
public async Task OnGetAsync_GivenSearchReturnsEmptyListForAllVersions_ShouldReturnInternalServerError()
{
// Arrange
const int pageSize = 20;
const string datasetidvalue = "datasetIdValue";
SearchRequestViewModel expectedSearchRequest = new SearchRequestViewModel()
{
PageSize = pageSize,
PageNumber = 1,
Filters = new Dictionary <string, string[]>()
{
{ "datasetId", new[] { datasetidvalue } }
},
IncludeFacets = false,
FacetCount = 0,
SearchTerm = null
};
IEnumerable <DatasetVersionSearchResultModel> datasetVersionModels = new List <DatasetVersionSearchResultModel>()
{
new DatasetVersionSearchResultModel()
};
IDatasetSearchService mockDatasetSearchService = Substitute.For <IDatasetSearchService>();
mockDatasetSearchService
.PerformSearchDatasetVersion(Arg.Is <SearchRequestViewModel>(sr => sr.PageSize == 20))
.Returns(new DatasetVersionSearchResultViewModel(Enumerable.Empty <DatasetVersionSearchResultModel>(), 1, 1, 1, 20));
mockDatasetSearchService
.PerformSearchDatasetVersion(Arg.Is <SearchRequestViewModel>(sr => sr.PageSize == 1))
.Returns(new DatasetVersionSearchResultViewModel(datasetVersionModels, 20, 1, 1, 1));
DatasetHistoryModel datasetHistoryModel = new DatasetHistoryModel(mockDatasetSearchService);
// Act
IActionResult result = await datasetHistoryModel.OnGetAsync(datasetidvalue, 1, 20);
// Assert
result.Should().BeOfType <InternalServerErrorResult>();
}
public async Task PerformSearch_FirstSearchResultWithFacets_ReturnedCorrectly()
{
// Arrange
ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>();
ILogger logger = Substitute.For <ILogger>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
IFeatureToggle featureToggle = CreateFeatureToggle();
ICalculationSearchService calculationSearchService = new CalculationSearchService(calcsClient, mapper, logger, featureToggle);
int numberOfItems = 25;
IEnumerable <SearchFacet> facets = new[]
{
new SearchFacet(), new SearchFacet()
};
PagedResult <CalculationSearchResultItem> itemResult = GeneratePagedResult(numberOfItems, facets);
calcsClient
.FindCalculations(Arg.Any <SearchFilterRequest>())
.Returns(itemResult);
SearchRequestViewModel request = new SearchRequestViewModel();
// Act
CalculationSearchResultViewModel results = await calculationSearchService.PerformSearch(request);
// Assert
CalculationSearchResultItemViewModel first = results.Calculations.First();
first.Should().NotBeNull();
first.Id.Should().Be("10");
first.SpecificationName.Should().Be("Spec Name");
first.Status.Should().Be("Unknown");
first.FundingPeriodName.Should().Be("Test Period");
first.Name.Should().Be("Calculation 1");
results.Facets.Count().Should().Be(2);
}
public async Task <CalculationSearchResultViewModel> PerformSearch(SearchRequestViewModel request)
{
SearchFilterRequest requestOptions = new SearchFilterRequest()
{
Page = request.PageNumber.HasValue ? request.PageNumber.Value : 1,
PageSize = request.PageSize.HasValue ? request.PageSize.Value : 50,
SearchTerm = request.SearchTerm,
IncludeFacets = request.IncludeFacets,
Filters = request.Filters,
FacetCount = request.FacetCount,
SearchMode = SearchMode.All
};
if (request.PageNumber.HasValue && request.PageNumber.Value > 0)
{
requestOptions.Page = request.PageNumber.Value;
}
ApiResponse <SearchResults <CalculationSearchResult> > calculationsResult = await _calculationsApiClient.FindCalculations(requestOptions);
return(BuildResults(calculationsResult, requestOptions.Page, requestOptions.PageSize));
}
public async Task PerformSearch_GivenFirstSearchResultReturnedCorrectly_EnsuresResults()
{
// Arrange
int numberOfItems = 25;
CalculationProviderResultSearchResults itemResult = GenerateSearchResults(numberOfItems);
_resultsClient
.SearchCalculationProviderResults(Arg.Any <SearchModel>())
.Returns(new ApiResponse <CalculationProviderResultSearchResults>(HttpStatusCode.OK, itemResult));
SearchRequestViewModel request = new SearchRequestViewModel();
AndCalculationExistsForCalcId("calcId");
// Act
CalculationProviderResultSearchResultViewModel results = await _resultsSearchService.PerformSearch(request);
// Assert
results.TotalResults.Should().Be(numberOfItems + 1);
results.TotalErrorResults.Should().Be(1);
}
public void PerformSearch_GivenFindCalculationProviderResultsServiceUnavailable_ThenHttpExceptionThrown()
{
// Arrange
IResultsApiClient resultClient = Substitute.For <IResultsApiClient>();
ILogger logger = CreateLogger();
IMapper mapper = CreateMapper();
CalculationProviderResultsSearchService resultsSearchService = CreateSearchService(resultClient, mapper, logger);
resultClient
.When(a => a.FindCalculationProviderResults(Arg.Any <SearchFilterRequest>()))
.Do(x => { throw new HttpRequestException(); });
SearchRequestViewModel request = new SearchRequestViewModel();
// Act
Func <Task> test = () => resultsSearchService.PerformSearch(request);
// Assert
test
.Should()
.Throw <HttpRequestException>();
}
public SearchResultsViewModel Search(string phrase)
{
var data = new Dictionary <string, string>
{
{ TwitterParameterKey.Query, phrase },
{ TwitterParameterKey.Count, "10" }
};
var twitterAutorization = new TwitterAuthorization(TwitterEndpointUrlConstants.GetSearchTweets, data);
var repsonse = SendToRequestToTwitter(TwitterEndpointUrlConstants.GetSearchTweets, twitterAutorization.OAuthHeader, twitterAutorization.Query);
var model = new SearchRequestViewModel();
if (repsonse == null)
{
Log.Warn("[TwitterService][Search] - SendToRequestToTwitter response is null");
}
var deserializedData = JsonConvert.DeserializeObject <SearchContract>(repsonse);
if (deserializedData == null)
{
Log.Warn("[TwitterService][Search] - deserialize object is null");
}
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <SearchContract, SearchResultsViewModel>();
cfg.CreateMap <TweetContract, TweetViewModel>();
cfg.CreateMap <UserContract, UserViewModel>();
});
var mapper = config.CreateMapper();
var searchResultsViewModel = mapper.Map <SearchContract, SearchResultsViewModel>(deserializedData);
return(searchResultsViewModel);
}
public void PerformSearch_GivenFindDatasetDefinitionsServiceUnavailable_ThenHttpExceptionThrown()
{
// Arrange
IDatasetsApiClient apiClient = CreateApiClient();
ILogger logger = CreateLogger();
IMapper mapper = CreateMapper();
DatasetDefinitionSearchService searchService = CreateSearchService(apiClient, mapper, logger);
apiClient
.When(a => a.FindDatasetDefinitions(Arg.Any <SearchFilterRequest>()))
.Do(x => { throw new HttpRequestException(); });
SearchRequestViewModel request = new SearchRequestViewModel();
// Act
Func <Task> test = () => searchService.PerformSearch(request);
// Assert
test
.Should()
.Throw <HttpRequestException>();
}
public async Task PerformSearch_FirstSearchResultWithFacets_ReturnedCorrectly()
{
// Arrange
IDatasetsApiClient datasetClient = Substitute.For <IDatasetsApiClient>();
ILogger logger = Substitute.For <ILogger>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
IFeatureToggle featureToggle = CreateFeatureToggle();
IDatasetSearchService datasetSearchService = new DatasetSearchService(datasetClient, mapper, logger, featureToggle);
int numberOfItems = 25;
IEnumerable <SearchFacet> facets = new[]
{
new SearchFacet(), new SearchFacet()
};
PagedResult <DatasetSearchResultItem> itemResult = GeneratePagedResult(numberOfItems, facets);
datasetClient
.FindDatasets(Arg.Any <SearchFilterRequest>())
.Returns(itemResult);
SearchRequestViewModel request = new SearchRequestViewModel();
// Act
DatasetSearchResultViewModel results = await datasetSearchService.PerformSearch(request);
// Assert
DatasetSearchResultItemViewModel first = results.Datasets.First();
first.Should().NotBeNull();
first.Id.Should().Be("10");
first.LastUpdated.Should().Be(new DateTime(2018, 2, 6, 15, 31, 0));
first.Status.Should().Be("Unknown");
first.Name.Should().Be("Dataset 1");
results.Facets.Count().Should().Be(2);
}
public async Task PerformSearch_FirstSearchResultWithFacets_ReturnedCorrectly()
{
// Arrange
ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>();
ILogger logger = Substitute.For <ILogger>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
ICalculationSearchService calculationSearchService = new CalculationSearchService(calcsClient, mapper, logger);
int numberOfItems = 25;
IEnumerable <SearchFacet> facets = new[]
{
new SearchFacet(), new SearchFacet()
};
ApiResponse <SearchResults <CalculationSearchResult> > itemResult = GeneratePagedResult(numberOfItems, facets);
calcsClient
.FindCalculations(Arg.Any <SearchFilterRequest>())
.Returns(itemResult);
SearchRequestViewModel request = new SearchRequestViewModel();
// Act
CalculationSearchResultViewModel results = await calculationSearchService.PerformSearch(request);
// Assert
CalculationSearchResultItemViewModel[] calcs = results.Calculations.ToArray();
for (int i = 0; i < calcs.Length; i++)
{
calcs[i].Id.Should().Be((i + 10).ToString());
calcs[i].Name.Should().Be($"Calculation {i + 1}");
}
results.Facets.Count().Should().Be(2);
}
public async Task PerformSearch_WhenFindSpecificationsServiceReturnsNotFound_ThenNullReturned()
{
// Arrange
ISpecificationsApiClient specsClient = Substitute.For <ISpecificationsApiClient>();
ILogger logger = Substitute.For <ILogger>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
ISpecificationSearchService SpecificationSearchService = new SpecificationSearchService(specsClient, mapper, logger);
PagedResult <SpecificationSearchResultItem> expectedServiceResult = null;
specsClient
.FindSpecifications(Arg.Any <SearchFilterRequest>())
.Returns(expectedServiceResult);
SearchRequestViewModel request = new SearchRequestViewModel();
// Act
SpecificationSearchResultViewModel result = await SpecificationSearchService.PerformSearch(request);
// Assert
result.Should().BeNull();
}
public async Task PerformSearch_WhenFindDatasetsServiceReturnsNotFound_ThenNullReturned()
{
// Arrange
IDatasetsApiClient datasetClient = Substitute.For <IDatasetsApiClient>();
ILogger logger = Substitute.For <ILogger>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
IDatasetSearchService datasetSearchService = new DatasetSearchService(datasetClient, mapper, logger);
ApiResponse <SearchResults <DatasetIndex> > expectedServiceResult = null;
datasetClient
.SearchDatasets(Arg.Any <SearchModel>())
.Returns(expectedServiceResult);
SearchRequestViewModel request = new SearchRequestViewModel();
// Act
DatasetSearchResultViewModel result = await datasetSearchService.PerformSearch(request);
// Assert
result.Should().BeNull();
}
public async Task <IActionResult> OnPostAsync(int?pageNumber, string searchTerm)
{
SearchRequestViewModel searchRequest = new SearchRequestViewModel()
{
PageNumber = pageNumber,
SearchTerm = SearchTerm,
IncludeFacets = true,
};
SearchTerm = searchTerm;
ProviderResults = await _providerSearchService.PerformSearch(searchRequest);
// ApiResponse<ProviderSearchResultViewModel> apiResponse = await GetProviderSearchResultsAsync(searchRequest);
// ProviderResults = apiResponse.Content;
if (ProviderResults == null)
{
return(new StatusCodeResult(500));
}
return(Page());
}
public async Task SearchProvider_GivenNResultReturnedFromSearch_ReturnsOKResult()
{
//Arrange
SearchRequestViewModel requestModel = new SearchRequestViewModel();
ProviderTestsSearchResultViewModel viewModel = new ProviderTestsSearchResultViewModel();
ITestResultsSearchService resultsSearchService = CreateResultsSearchService();
resultsSearchService
.PerformProviderTestResultsSearch(Arg.Is(requestModel))
.Returns(viewModel);
TestEngineController testEngineController = CreateController(testResultsSearchService: resultsSearchService);
//Act
IActionResult result = await testEngineController.SearchProviders(requestModel);
//Assert
result
.Should()
.BeAssignableTo <OkObjectResult>();
}
public async Task PerformSearch_GivenIsSearchModeAllEnabledFeatureToggleIsSwitchedOn_SearchModeIsAll()
{
// Arrange
ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>();
ILogger logger = Substitute.For <ILogger>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
IFeatureToggle featureToggle = CreateFeatureToggle(true);
ICalculationSearchService calculationSearchService = new CalculationSearchService(calcsClient, mapper, logger, featureToggle);
SearchRequestViewModel request = new SearchRequestViewModel()
{
PageNumber = 2,
};
// Act
CalculationSearchResultViewModel results = await calculationSearchService.PerformSearch(request);
// Assert
await
calcsClient
.FindCalculations(Arg.Is <SearchFilterRequest>(m => m.SearchMode == SearchMode.All));
}
public async Task <IActionResult> OnPostAsync(int?pageNumber)
{
await PopulatePeriods();
SearchRequestViewModel searchRequest = new SearchRequestViewModel()
{
PageNumber = pageNumber,
SearchTerm = SearchTerm,
IncludeFacets = false,
Filters = new Dictionary <string, string[]> {
{ "fundingPeriodId", new[] { FundingPeriodId } }
}
};
SearchResults = await _datasetRelationshipsSearchService.PerformSearch(searchRequest);
if (SearchResults == null)
{
return(new StatusCodeResult(500));
}
return(Page());
}
public async Task SearchDatasetRelationships_GivenResultsReturnedFromSearch_ReturnsOK()
{
// Arrange
SearchRequestViewModel requestModel = new SearchRequestViewModel();
SpecificationDatasourceRelationshipSearchResultViewModel results = new SpecificationDatasourceRelationshipSearchResultViewModel();
IDatasetRelationshipsSearchService searchService = CreateSearchService();
searchService
.PerformSearch(Arg.Any <SearchRequestViewModel>())
.Returns(results);
DatasetRelationshipsSearchController controller = CreateController(searchService);
// Act
IActionResult actionResult = await controller.SearchDatasetRelationships(requestModel);
// Asserts
actionResult
.Should()
.BeOfType <OkObjectResult>();
}
public async Task SearchProviders_GivenResultsReturnedFromSearch_ReturnsOK()
{
// Arrange
SearchRequestViewModel requestModel = new SearchRequestViewModel();
ProviderSearchResultViewModel results = new ProviderSearchResultViewModel();
IProviderSearchService searchService = CreateSearchService();
searchService
.PerformSearch(Arg.Any <SearchRequestViewModel>())
.Returns(results);
ProviderSearchController controller = CreateController(searchService);
// Act
IActionResult actionResult = await controller.SearchProviders(requestModel);
// Asserts
actionResult
.Should()
.BeOfType <OkObjectResult>();
}
public async Task PerformSearch_WhenFindCalculationsServiceReturnsNotFound_ThenNullReturned()
{
// Arrange
ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>();
ILogger logger = Substitute.For <ILogger>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
ICalculationSearchService calculationSearchService = new CalculationSearchService(calcsClient, mapper, logger);
ApiResponse <SearchResults <CalculationSearchResult> > expectedServiceResult = null;
calcsClient
.FindCalculations(Arg.Any <SearchFilterRequest>())
.Returns(expectedServiceResult);
SearchRequestViewModel request = new SearchRequestViewModel();
// Act
CalculationSearchResultViewModel result = await calculationSearchService.PerformSearch(request);
// Assert
result.Should().BeNull();
}
public void PerformSearch_WhenFindDatasetsServiceUnavailable_ThenHttpExceptionThrown()
{
// Arrange
IDatasetsApiClient datasetClient = Substitute.For <IDatasetsApiClient>();
ILogger logger = Substitute.For <ILogger>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
IDatasetSearchService datasetSearchService = new DatasetSearchService(datasetClient, mapper, logger);
datasetClient
.When(a => a.SearchDatasets(Arg.Any <SearchModel>()))
.Do(x => { throw new HttpRequestException(); });
SearchRequestViewModel request = new SearchRequestViewModel();
// Act
Action pageAction = new Action(() =>
{
DatasetSearchResultViewModel result = datasetSearchService.PerformSearch(request).Result;
});
// Assert
pageAction.Should().Throw <HttpRequestException>();
}
private void GetSelectedStandardViewModel(SearchRequestViewModel result)
{
var resultViewModel = result.SearchResults.First();
var selectedStandardViewModel = new SelectedStandardViewModel()
{
Standard = resultViewModel.Standard,
StdCode = resultViewModel.StdCode,
Uln = resultViewModel.Uln,
GivenNames = resultViewModel.GivenNames,
FamilyName = resultViewModel.FamilyName,
CertificateReference = resultViewModel.CertificateReference,
OverallGrade = resultViewModel.OverallGrade,
Level = resultViewModel.Level,
SubmittedAt = GetSubmittedAtString(resultViewModel.SubmittedAt),
SubmittedBy = resultViewModel.SubmittedBy,
LearnerStartDate = resultViewModel.LearnStartDate.GetValueOrDefault().ToString("d MMMM yyyy"),
AchievementDate = resultViewModel.AchDate.GetValueOrDefault().ToString("d MMMM yyyy"),
ShowExtraInfo = resultViewModel.ShowExtraInfo,
UlnAlreadyExists = resultViewModel.UlnAlreadyExists,
IsNoMatchingFamilyName = resultViewModel.IsNoMatchingFamilyName
};
_sessionService.Set("SelectedStandard", selectedStandardViewModel);
}
public async Task PerformSearch_WhenFindDatasetsServiceReturnsNotFound_ThenNullReturned()
{
// Arrange
IDatasetsApiClient datasetClient = Substitute.For <IDatasetsApiClient>();
ILogger logger = Substitute.For <ILogger>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
IFeatureToggle featureToggle = CreateFeatureToggle();
IDatasetSearchService datasetSearchService = new DatasetSearchService(datasetClient, mapper, logger, featureToggle);
PagedResult <DatasetSearchResultItem> expectedServiceResult = null;
datasetClient
.FindDatasets(Arg.Any <SearchFilterRequest>())
.Returns(expectedServiceResult);
SearchRequestViewModel request = new SearchRequestViewModel();
// Act
DatasetSearchResultViewModel result = await datasetSearchService.PerformSearch(request);
// Assert
result.Should().BeNull();
}
public void PerformSearch_WhenFindCalculationsServiceUnavailable_ThenHttpExceptionThrown()
{
// Arrange
ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>();
ILogger logger = Substitute.For <ILogger>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
ICalculationSearchService calculationSearchService = new CalculationSearchService(calcsClient, mapper, logger);
calcsClient
.When(a => a.FindCalculations(Arg.Any <SearchFilterRequest>()))
.Do(x => { throw new HttpRequestException(); });
SearchRequestViewModel request = new SearchRequestViewModel();
// Act
Action pageAction = new Action(() =>
{
CalculationSearchResultViewModel result = calculationSearchService.PerformSearch(request).Result;
});
// Assert
pageAction.Should().Throw <HttpRequestException>();
}
public async Task<IActionResult> SearchDatasets([FromBody]DatasetSearchRequestViewModel request)
{
Guard.ArgumentNotNull(request, nameof(request));
SearchRequestViewModel searchRequest = new SearchRequestViewModel
{
Filters = new Dictionary<string, string[]>(),
ErrorToggle = request.ErrorToggle,
FacetCount = request.FacetCount,
IncludeFacets = request.IncludeFacets,
PageNumber = request.PageNumber,
PageSize = request.PageSize,
SearchMode = request.SearchMode,
SearchTerm = request.SearchTerm
};
if (request.FundingStreams?.Length > 0)
{
searchRequest.Filters.Add("fundingStreamName", request.FundingStreams.ToArray());
}
if (request.DataSchemas?.Length > 0)
{
searchRequest.Filters.Add("definitionName", request.DataSchemas.ToArray());
}
DatasetSearchResultViewModel result = await _datasetSearchService.PerformSearch(searchRequest);
if (result != null)
{
return Ok(result);
}
else
{
return new StatusCodeResult(500);
}
}
public async Task PerformSearch_WhenFeatureToggleIsSwitchedOn_EnsureSearchModeIsAll()
{
// Arrange
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
ILogger logger = Substitute.For <ILogger>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
IFeatureToggle featureToggle = CreateFeatureToggle(true);
ISpecificationSearchService SpecificationSearchService = new SpecificationSearchService(specsClient, mapper, logger, featureToggle);
SearchRequestViewModel request = new SearchRequestViewModel()
{
PageNumber = 2,
};
// Act
SpecificationSearchResultViewModel results = await SpecificationSearchService.PerformSearch(request);
// Assert
await
specsClient
.Received(1)
.FindSpecifications(Arg.Is <SearchFilterRequest>(m => m.SearchMode == SearchMode.All));
}
public async Task <PublishProviderSearchResultViewModel> PerformSearch(SearchRequestViewModel request)
{
Guard.ArgumentNotNull(request.PageSize, "PageSize");
SearchModel requestOptions = new SearchModel
{
PageNumber = request.PageNumber ?? 1,
Top = request.PageSize.Value,
SearchTerm = request.SearchTerm,
IncludeFacets = request.IncludeFacets,
Filters = request.Filters,
SearchMode = Common.Models.Search.SearchMode.All,
SearchFields = request.SearchFields
};
if (request.PageNumber.HasValue && request.PageNumber.Value > 0)
{
requestOptions.PageNumber = request.PageNumber.Value;
}
var searchTask = _publishingApiClient.SearchPublishedProvider(requestOptions);
var fundingConfigTask = _policiesApiClient.GetFundingConfiguration(request.FundingStreamId, request.FundingPeriodId);
ApiResponse <SearchResults <PublishedProviderSearchItem> > searchResponse = await searchTask;
if (searchResponse == null)
{
_logger.Error("Find providers HTTP request failed");
return(null);
}
PublishProviderSearchResultViewModel result = new PublishProviderSearchResultViewModel
{
TotalResults = searchResponse.Content?.TotalCount ?? 0,
TotalErrorResults = searchResponse.Content?.TotalErrorCount ?? 0,
CurrentPage = requestOptions.PageNumber,
Facets = searchResponse.Content?.Facets?.Select(facet => _mapper.Map <SearchFacetViewModel>(facet)),
Providers = searchResponse.Content?.Results?.Select(provider => _mapper.Map <PublishedProviderSearchResultItemViewModel>(provider)),
FilteredFundingAmount = searchResponse.Content?.Results?.Sum(x => x.FundingValue) ?? 0
};
int totalPages = (int)Math.Ceiling((double)result.TotalResults / (double)request.PageSize.Value);
result.PagerState = new PagerState(requestOptions.PageNumber, totalPages, 4);
int numberOfResultsInThisPage = result.Providers?.Count() ?? 0;
if (numberOfResultsInThisPage > 0)
{
result.StartItemNumber = (result.PagerState.CurrentPage - 1) * request.PageSize.Value + 1;
result.EndItemNumber = result.StartItemNumber + numberOfResultsInThisPage - 1;
}
ApiResponse <FundingConfiguration> fundingConfigurationResponse = await fundingConfigTask;
if (fundingConfigurationResponse.StatusCode != HttpStatusCode.OK)
{
_logger.Error($"Request failed to find funding configuration for stream {request.FundingStreamId} and period {request.FundingPeriodId}");
return(null);
}
bool isBatchModeEnabled = fundingConfigurationResponse.Content.ApprovalMode == ApprovalMode.Batches;
if (result.Providers != null && result.Providers.Any())
{
string[] providerTypes = request.Filters.GetValueOrDefault("providerType") ?? new string[0];
string[] localAuthorities = request.Filters.GetValueOrDefault("localAuthority") ?? new string[0];
string[] fundingStatuses = request.Filters.GetValueOrDefault("fundingStatus") ?? new string[0];
ApiResponse <IEnumerable <ProviderFundingStreamStatusResponse> > providerStatusCounts =
await _publishingApiClient.GetProviderStatusCounts(
result.Providers.First().SpecificationId,
providerTypes.FirstOrDefault(),
localAuthorities.FirstOrDefault(),
fundingStatuses.FirstOrDefault()
);
foreach (var providerStats in providerStatusCounts.Content)
{
if (isBatchModeEnabled && providerStats.ProviderApprovedCount > 0)
{
result.CanPublish = true;
}
if (providerStats.ProviderDraftCount == 0 &&
providerStats.ProviderApprovedCount > 0 &&
providerStats.ProviderUpdatedCount == 0)
{
result.CanPublish = true;
result.TotalProvidersToPublish += providerStats.ProviderApprovedCount;
}
if (providerStats.ProviderDraftCount > 0 ||
providerStats.ProviderUpdatedCount > 0)
{
result.CanApprove = true;
result.TotalProvidersToApprove += providerStats.ProviderUpdatedCount;
result.TotalProvidersToApprove += providerStats.ProviderDraftCount;
}
if (providerStats.TotalFunding.HasValue)
{
result.TotalFundingAmount = +providerStats.TotalFunding.Value;
}
}
}
return(result);
}
