public async Task GetResultsListReturnsSuccessForHappyPath()
{
// Arrange
const string requestUrl = "http://Something.com/";
const string searchTerm = "nurse";
const int page = 1;
const int pageSize = 10;
const int expectedItemCount = 2;
var searchResults = new SearchResult <JobProfileIndex>()
{
Results = A.CollectionOfFake <SearchResultItem <JobProfileIndex> >(expectedItemCount),
Count = expectedItemCount,
};
var expectedResult = A.Fake <SearchApiModel>();
expectedResult.Count = expectedItemCount;
expectedResult.Results = A.CollectionOfFake <SearchItemApiModel>(expectedItemCount);
var summaryService = new SearchService(mapper, searchQueryService);
A.CallTo(() => searchQueryService.SearchAsync(A <string> .Ignored, A <SearchProperties> .Ignored)).Returns(searchResults);
A.CallTo(() => mapper.Map <SearchApiModel>(searchResults)).Returns(expectedResult);
// Act
var results = await summaryService.GetResultsList(requestUrl, searchTerm, page, pageSize).ConfigureAwait(false);
// Assert
A.CallTo(() => searchQueryService.SearchAsync(A <string> .Ignored, A <SearchProperties> .Ignored)).MustHaveHappenedOnceExactly();
A.CallTo(() => mapper.Map <SearchApiModel>(searchResults)).MustHaveHappenedOnceExactly();
Assert.Equal(expectedResult.Count, results.Count);
}
private void SetUpDependeciesAndCall(bool validJobProfile, bool isContentPreviewMode)
{
////Set up comman call
mapperCfg = new MapperConfiguration(cfg => { cfg.AddProfile <JobProfilesAutoMapperProfile>(); });
dummyJobProfile = validJobProfile
? new JobProfile
{
AlternativeTitle = nameof(JobProfile.AlternativeTitle),
SalaryRange = nameof(JobProfile.SalaryRange),
Overview = nameof(JobProfile.Overview),
Title = nameof(JobProfile.Title),
MaximumHours = 40,
MinimumHours = 10,
UrlName = nameof(JobProfile.UrlName),
WorkingHoursDetails = nameof(JobProfile.WorkingHoursDetails),
WorkingPattern = nameof(JobProfile.WorkingPattern),
WorkingPatternDetails = nameof(JobProfile.WorkingPatternDetails)
}
: null;
var dummyIndex = new JobProfileIndex
{
Title = nameof(JobProfileIndex.Title),
AlternativeTitle = new[] { "alt" },
SalaryStarter = starterSalary,
SalaryExperienced = experiencedSalary,
Overview = "overview",
UrlName = "dummy-url",
JobProfileCategoriesWithUrl = new[] { "CatOneURL|Cat One", "CatTwoURL|Cat Two" }
};
var resultsCount = 1;
var dummySearchResult = A.Dummy <SearchResult <JobProfileIndex> >();
dummySearchResult.Count = resultsCount;
dummySearchResult.Results = A.CollectionOfDummy <SearchResultItem <JobProfileIndex> >(resultsCount);
var rawResultItems = new List <SearchResultItem <JobProfileIndex> >
{
new SearchResultItem <JobProfileIndex> {
ResultItem = dummyIndex
}
};
dummySearchResult.Results = rawResultItems;
// Set up calls
A.CallTo(() => searchQueryService.SearchAsync(A <string> ._, A <SearchProperties> ._)).Returns(dummySearchResult);
A.CallTo(() => repositoryFake.GetByUrlName(A <string> ._)).Returns(dummyJobProfile);
A.CallTo(() => repositoryFake.GetByUrlNameForPreview(A <string> ._)).Returns(dummyJobProfile);
A.CallTo(() => webAppContextFake.IsContentPreviewMode).Returns(isContentPreviewMode);
A.CallTo(() => sitefinityPage.GetDefaultJobProfileToUse(A <string> ._))
.ReturnsLazily((string defaultProfile) => defaultProfile);
A.CallTo(() => govUkNotifyFake.SubmitEmail(A <string> ._, null)).Returns(false);
A.CallTo(() => webAppContextFake.SetVocCookie(Constants.VocPersonalisationCookieName, A <string> ._)).DoesNothing();
A.CallTo(() => loggerFake.Trace(A <string> ._)).DoesNothing();
}
public void ShowMatchingProfileCountOnPageTest(int pageNumber, bool showMatchingProfileCount, bool expectingToShowCount)
{
//Setup the fakes and dummies for test
SetUpFakesAndCalls();
SetUpStateMangerFakesAndCalls(PreSearchFilterType.Interest, true);
var config = new MapperConfiguration(cfg =>
{
cfg.AddProfile <JobProfilesAutoMapperProfile>();
});
var mapper = config.CreateMapper();
var searchResults = new SearchResult <JobProfileIndex>()
{
Count = 5
};
A.CallTo(() => fakeBuildSearchFilterService.BuildPreSearchFilters(A <PreSearchFiltersResultsModel> ._, A <Dictionary <string, PreSearchFilterLogicalOperator> > ._)).Returns(nameof(SearchProperties.FilterBy));
A.CallTo(() => fakeBuildSearchFilterService.GetIndexFieldDefinitions(A <string> .Ignored)).Returns(new List <KeyValuePair <string, PreSearchFilterLogicalOperator> >());
A.CallTo(() => fakeSearchQueryService.SearchAsync(A <string> ._, A <SearchProperties> ._)).Returns(searchResults);
//Instantiate & Act
var preSearchFiltersController =
new PreSearchFiltersController(loggerFake, mapper, psfRepositoryFactoryFake, fakePsfStateManager, fakeSearchQueryService, fakeBuildSearchFilterService, fakeAsyncHelper, fakeTaxonomyRepository)
{
FilterType = PreSearchFilterType.Interest
};
preSearchFiltersController.ThisPageNumber = pageNumber;
preSearchFiltersController.UsePageProfileCount = showMatchingProfileCount;
//Act on the index
var firstVm = new PsfModel();
var resultsViewModel = new PsfSearchResultsViewModel
{
PreSearchFiltersModel = GeneratePreSEarchFiltersViewModel(PreSearchFilterType.Interest)
};
var postFromResultsPageCall = preSearchFiltersController.WithCallTo(c => c.Index(firstVm, resultsViewModel));
postFromResultsPageCall.ShouldRenderDefaultView().WithModel <PsfModel>(vm =>
{
vm.UsePageProfileCount.Should().Be(expectingToShowCount);
}).AndNoModelErrors();
if (expectingToShowCount)
{
A.CallTo(() => fakeSearchQueryService.SearchAsync(A <string> ._, A <SearchProperties> ._)).MustHaveHappened();
}
else
{
A.CallTo(() => fakeSearchQueryService.SearchAsync(A <string> ._, A <SearchProperties> ._)).MustNotHaveHappened();
}
}
private async Task <ActionResult> DisplaySearchResultsAsync(PsfModel model, int page, bool notPaging = true)
{
var resultModel = GetPsfSearchResultsViewModel(model, notPaging);
var pageNumber = page > 0 ? page : 1;
var fieldDefinitions = GetIndexFieldDefinitions();
var resultsModel = mapper.Map <PreSearchFiltersResultsModel>(model);
var properties = new SearchProperties
{
Page = pageNumber,
Count = this.PageSize,
FilterBy = buildSearchFilterService.BuildPreSearchFilters(resultsModel, fieldDefinitions.ToDictionary(k => k.Key, v => v.Value))
};
var results = await searchQueryService.SearchAsync("*", properties);
resultModel.Count = results.Count;
resultModel.PageNumber = pageNumber;
resultModel.SearchResults = mapper.Map <IEnumerable <JobProfileSearchResultItemViewModel> >(results.Results);
foreach (var resultItem in resultModel.SearchResults)
{
resultItem.ResultItemUrlName = $"{JobProfileDetailsPage}{resultItem.ResultItemUrlName}";
}
SetTotalResultsMessage(resultModel);
SetupPagination(resultModel);
return(View("SearchResult", resultModel));
}
private async Task <ActionResult> DisplaySearchResultsAsync(string searchTerm, int page)
{
var resultModel = new JobProfileSearchResultViewModel
{
PlaceholderText = PlaceholderText,
SearchTerm = searchTerm,
AutoCompleteMinimumCharacters = AutoCompleteMinimumCharacters,
AutoCompleteMaximumCharacters = AutoCompleteMaximumCharacters,
MaximumNumberOfDisplayedSuggestions = MaximumNumberOfDisplayedSuggestions,
UseFuzzyAutoCompleteMatching = UseFuzzyAutoCompleteMatching,
JobProfileCategoryPage = JobProfileCategoryPage,
SalaryBlankText = SalaryBlankText,
ShowSearchedTerm = ShowComputedSearchTerm
};
if (!string.IsNullOrWhiteSpace(searchTerm))
{
var pageNumber = page > 0 ? page : 1;
var searchTask = searchQueryService.SearchAsync(searchTerm, new SearchProperties {
Page = pageNumber, Count = this.PageSize, UseRawSearchTerm = UseRawSearchTerm
});
var spellCheckTask = spellcheckService.CheckSpellingAsync(searchTerm);
await Task.WhenAll(searchTask, spellCheckTask);
var results = searchTask.Result;
resultModel.Count = results.Count;
resultModel.Coverage = results.Coverage;
resultModel.ComputedSearchTerm = results.ComputedSearchTerm;
resultModel.PageNumber = pageNumber;
resultModel.SearchResults = mapper.Map <IEnumerable <JobProfileSearchResultItemViewModel> >(results.Results);
foreach (var resultItem in resultModel.SearchResults)
{
resultItem.ResultItemUrlName = $"{JobProfileDetailsPage}{resultItem.ResultItemUrlName}";
}
SetTotalResultsMessage(resultModel);
SetupPagination(searchTerm, resultModel);
var spellCheckResult = spellCheckTask.Result;
if (spellCheckResult.HasCorrected)
{
resultModel.DidYouMeanUrl = GetSearchResultsPageUrl(spellCheckResult.CorrectedTerm);
resultModel.DidYouMeanTerm = spellCheckResult.CorrectedTerm;
}
}
return(View("SearchResult", resultModel));
}
private async Task <ActionResult> DisplaySearchResultsAsync(PsfModel model, int page, bool notPaging = true)
{
var resultModel = GetPsfSearchResultsViewModel(model, notPaging);
var pageNumber = page > 0 ? page : 1;
var fieldDefinitions = GetIndexFieldDefinitions();
var resultsModel = mapper.Map <PreSearchFiltersResultsModel>(model);
var properties = new SearchProperties
{
Page = pageNumber,
SearchFields = new List <string>()
{
IndexSearchField
},
Count = this.PageSize,
UseRawSearchTerm = true,
FilterBy = buildSearchFilterService.BuildPreSearchFilters(resultsModel, fieldDefinitions.ToDictionary(k => k.Key, v => v.Value)),
OrderByFields = IndexSortField.TrimEnd(',').Split(',').ToList(),
};
var searchTerm = buildSearchFilterService.GetSearchTerm(properties, resultsModel, IndexSearchField.Split(','));
var results = await searchQueryService.SearchAsync(searchTerm, properties);
resultModel.Count = results.Count;
resultModel.PageNumber = pageNumber;
resultModel.SearchResults = mapper.Map <IEnumerable <JobProfileSearchResultItemViewModel> >(results.Results, opts =>
{
opts.Items.Add(nameof(CaveatFinderIndexFieldName), CaveatFinderIndexFieldName);
opts.Items.Add(nameof(CaveatFinderIndexValue), CaveatFinderIndexValue);
});
if (ShowMacthingSkillCount)
{
SetMatchingSkillsCount(resultModel, resultsModel, results);
}
foreach (var resultItem in resultModel.SearchResults)
{
resultItem.ResultItemUrlName = $"{JobProfileDetailsPage}{resultItem.ResultItemUrlName}";
}
SetTotalResultsMessage(resultModel);
SetupPagination(resultModel);
return(View("SearchResult", resultModel));
}
private async Task <JobProfileDetailsViewModel> PopulateSalaryAsync(JobProfileDetailsViewModel model)
{
var properties = new SearchProperties
{
FilterBy = $"{nameof(JobProfileIndex.UrlName)} eq '{model.UrlName.Replace("'", "''")}'"
};
var jobProfileSearchResult = await searchQueryService.SearchAsync(model.Title, properties);
var jobProfileIndexItem = jobProfileSearchResult.Results.FirstOrDefault()?.ResultItem;
if (jobProfileIndexItem != null)
{
model.SalaryStarter = jobProfileIndexItem.SalaryStarter;
model.SalaryExperienced = jobProfileIndexItem.SalaryExperienced;
}
return(model);
}
private async Task <int> GetNumberOfMatches(PsfModel model)
{
var fieldDefinitions = buildSearchFilterService.GetIndexFieldDefinitions(IndexFieldOperators);
preSearchFilterStateManager.RestoreState(model.OptionsSelected);
var filterState = preSearchFilterStateManager.GetPreSearchFilterState();
model.Sections = autoMapper.Map <List <PsfSection> >(filterState.Sections);
var resultsModel = autoMapper.Map <PreSearchFiltersResultsModel>(model);
var properties = new SearchProperties
{
Page = 0,
Count = 0,
FilterBy = buildSearchFilterService.BuildPreSearchFilters(resultsModel, fieldDefinitions.ToDictionary(k => k.Key, v => v.Value))
};
var results = await searchQueryService.SearchAsync("*", properties);
return((int)results.Count);
}
public async Task <SearchApiModel> GetResultsList(string requestUrl, string searchTerm, int page, int pageSize)
{
var pageNumber = page > 0 ? page : 1;
var searchProperties = new SearchProperties {
Page = pageNumber, Count = pageSize
};
var searchResult = await searchQueryService.SearchAsync(searchTerm, searchProperties).ConfigureAwait(false);
if (searchResult?.Results is null)
{
return(null);
}
var viewModels = mapper.Map <SearchApiModel>(searchResult);
viewModels.Results.ToList().ForEach(v => v.ResultItemUrlName = $"{requestUrl}{v.ResultItemUrlName?.TrimStart('/')}");
viewModels.CurrentPage = page;
viewModels.PageSize = pageSize;
return(viewModels);
}
