public void GivenSearchParametersStatusFilterUpperCaseMatchingOrganisationsGetReturned()
{
var organisations = EntityHelpers.CreateOrganisations(10).ToList();
var orgToFind = EntityHelpers.CreateOrganisation();
orgToFind.Status = "published";
organisations.Add(orgToFind);
DatabaseContext.AddRange(organisations);
DatabaseContext.SaveChanges();
var searchParams = new OrganisationSearchRequest();
searchParams.Search = orgToFind.Name;
searchParams.Sort = "Name";
searchParams.Status = "PUBLISHED";
searchParams.Direction = SortDirection.Asc.ToString();
var gatewayResult = _classUnderTest.SearchOrganisations(searchParams).Result;
gatewayResult.Should().NotBeNull();
gatewayResult.First().Should().BeEquivalentTo(orgToFind, options =>
{
options.Excluding(ex => ex.ReviewerU);
options.Excluding(ex => ex.Services);
options.Excluding(ex => ex.UserOrganisations);
return(options);
});
}
public void Organisation_search_by_company_name()
{
_validator.Setup(x => x.IsValidUKPRN(It.IsAny <string>())).Returns(false);
var organisations = new List <Organisation>
{
new Organisation {
UKPRN = 10001234, LegalName = "TEST PROVIDER"
}
};
var organisationSearchResults = new OrganisationSearchResults
{
SearchResults = organisations,
TotalCount = 1
};
_repository.Setup(x => x.OrganisationSearchByName(It.IsAny <string>())).ReturnsAsync(organisationSearchResults);
_repository.Setup(x => x.OrganisationSearchByUkPrn(It.IsAny <string>()));
var organisationSearchRequest = new OrganisationSearchRequest {
SearchTerm = "TEST"
};
Task <OrganisationSearchResults> searchResults =
_organisationSearchHandler.Handle(organisationSearchRequest, new CancellationToken());
searchResults.Result.SearchResults.Count().Should().Be(1);
_repository.Verify(x => x.OrganisationSearchByName(It.IsAny <string>()), Times.Once);
_repository.Verify(x => x.OrganisationSearchByUkPrn(It.IsAny <string>()), Times.Never);
}
public void Organisation_search_will_not_search_by_legal_name_if_valid_UKPRN_but_no_match_found()
{
_validator.Setup(x => x.IsValidUKPRN(It.IsAny <string>())).Returns(true);
var organisationSearchResults = new OrganisationSearchResults
{
SearchResults = new List <Organisation>(),
TotalCount = 0
};
_repository.Setup(x => x.OrganisationSearchByName(It.IsAny <string>())).ReturnsAsync(organisationSearchResults);
_repository.Setup(x => x.OrganisationSearchByUkPrn(It.IsAny <string>())).ReturnsAsync(organisationSearchResults);
var organisationSearchRequest = new OrganisationSearchRequest {
SearchTerm = "10002345"
};
Task <OrganisationSearchResults> searchResults =
_organisationSearchHandler.Handle(organisationSearchRequest, new CancellationToken());
searchResults.Result.SearchResults.Count().Should().Be(0);
searchResults.Result.TotalCount.Should().Be(0);
_repository.Verify(x => x.OrganisationSearchByName(It.IsAny <string>()), Times.Never);
_repository.Verify(x => x.OrganisationSearchByUkPrn(It.IsAny <string>()), Times.Once);
}
public void Organisation_search_with_invalid_search_term()
{
_validator.Setup(x => x.IsValidSearchTerm(It.IsAny <string>())).Returns(false);
var organisationSearchRequest = new OrganisationSearchRequest {
SearchTerm = "10001234"
};
Func <Task> result = async() => await
_organisationSearchHandler.Handle(organisationSearchRequest, new CancellationToken());
result.Should().Throw <BadRequestException>();
}
public void Organisation_search_with_more_results_than_result_limit()
{
_validator.Setup(x => x.IsValidUKPRN(It.IsAny <string>())).Returns(false);
var organisations = new List <Organisation>
{
new Organisation {
UKPRN = 10001001, LegalName = "TEST PROVIDER 1"
},
new Organisation {
UKPRN = 10001002, LegalName = "TEST PROVIDER 2"
},
new Organisation {
UKPRN = 10001003, LegalName = "TEST PROVIDER 3"
},
new Organisation {
UKPRN = 10001004, LegalName = "TEST PROVIDER 4"
},
new Organisation {
UKPRN = 10001005, LegalName = "TEST PROVIDER 5"
}
};
var organisationSearchResults = new OrganisationSearchResults
{
SearchResults = organisations,
TotalCount = 17
};
_repository.Setup(x => x.OrganisationSearchByName(It.IsAny <string>())).ReturnsAsync(organisationSearchResults);
_repository.Setup(x => x.OrganisationSearchByUkPrn(It.IsAny <string>()));
var organisationSearchRequest = new OrganisationSearchRequest {
SearchTerm = "TEST PROVIDER"
};
Task <OrganisationSearchResults> searchResults =
_organisationSearchHandler.Handle(organisationSearchRequest, new CancellationToken());
searchResults.Result.SearchResults.Count().Should().Be(5);
searchResults.Result.TotalCount.Should().Be(17);
_repository.Verify(x => x.OrganisationSearchByName(It.IsAny <string>()), Times.Once);
_repository.Verify(x => x.OrganisationSearchByUkPrn(It.IsAny <string>()), Times.Never);
}
public IActionResult SearchOrganisations([FromQuery] OrganisationSearchRequest requestParams)
{
//add validation
try
{
var response = _organisationsUseCase.ExecuteGet(requestParams).Result;
return(Ok(response));
}
catch (Exception e)
{
LoggingHandler.LogError(e.Message);
return(BadRequest(
new ErrorResponse($"An error occurred")
{
Status = "Error", Errors = new List <string> {
$"An error occurred while processing this request. Please see logs for details."
}
}));
}
}
public void GivenSearchParametersStatusFilterNoMatchingOrganisationsGetReturned()
{
var organisations = EntityHelpers.CreateOrganisations(10).ToList();
var orgToFind = EntityHelpers.CreateOrganisation();
orgToFind.Status = "published";
organisations.Add(orgToFind);
DatabaseContext.AddRange(organisations);
DatabaseContext.SaveChanges();
var searchParams = new OrganisationSearchRequest();
searchParams.Search = orgToFind.Name;
searchParams.Sort = "Name";
searchParams.Status = "rejected";
searchParams.Direction = SortDirection.Asc.ToString();
var gatewayResult = _classUnderTest.SearchOrganisations(searchParams).Result;
gatewayResult.Should().NotBeNull();
gatewayResult.Count.Should().Be(0);
}
public void Organisation_search_by_company_name_with_no_results_found()
{
_validator.Setup(x => x.IsValidUKPRN(It.IsAny <string>())).Returns(false);
var emptyResults = new OrganisationSearchResults
{
SearchResults = new List <Organisation>(),
TotalCount = 0
};
_repository.Setup(x => x.OrganisationSearchByName(It.IsAny <string>())).ReturnsAsync(emptyResults);
_repository.Setup(x => x.OrganisationSearchByUkPrn(It.IsAny <string>()));
var organisationSearchRequest = new OrganisationSearchRequest {
SearchTerm = "10001234"
};
Task <OrganisationSearchResults> searchResults =
_organisationSearchHandler.Handle(organisationSearchRequest, new CancellationToken());
searchResults.Result.SearchResults.Should().BeEmpty();
_repository.Verify(x => x.OrganisationSearchByName(It.IsAny <string>()), Times.Once);
_repository.Verify(x => x.OrganisationSearchByUkPrn(It.IsAny <string>()), Times.Never);
}
public async Task <List <OrganisationDomain> > SearchOrganisations(OrganisationSearchRequest requestParams)
{
// Search search term to use (searches on [name] column for the MVP)
// Sort the column name by which to sort
// Direction sort order; asc, desc
// Limit maximum number of records to return
// Offset number of records to skip for pagination
List <OrganisationDomain> response = new List <OrganisationDomain>();
var direction = ConvertToEnum(requestParams.Direction);
if (direction == SortDirection.None)
{
throw new UseCaseException()
{
UserErrorMessage = "The sort direction was not valid (must be one of asc, desc)"
}
}
;
var matchingOrganisations = Context.Organisations.AsQueryable();
// handle search
if (!string.IsNullOrWhiteSpace(requestParams.Search))
{
matchingOrganisations = matchingOrganisations.Where(o => EF.Functions.ILike(o.Name, $"%{requestParams.Search}%"));
}
if (!string.IsNullOrWhiteSpace(requestParams.Status))
{
matchingOrganisations = matchingOrganisations.Where(o => o.Status == requestParams.Status.ToLower());
}
// handle sort by column name and sort direction
var entityPropName = GetEntityPropertyForColumnName(typeof(Organisation), requestParams.Sort);
if (entityPropName == null)
{
throw new UseCaseException()
{
UserErrorMessage = $"The 'Sort' parameter contained the value '{requestParams.Sort}' " +
"which is not a valid column name"
}
}
;
matchingOrganisations = (direction == SortDirection.Asc) ?
matchingOrganisations.OrderBy(u => EF.Property <Organisation>(u, entityPropName)) :
matchingOrganisations.OrderByDescending(u => EF.Property <Organisation>(u, entityPropName));
// handle pagination options
if (requestParams.Offset.HasValue)
{
matchingOrganisations = matchingOrganisations.Skip(requestParams.Offset.Value);
}
if (requestParams.Limit.HasValue)
{
matchingOrganisations = matchingOrganisations.Take(requestParams.Limit.Value);
}
try
{
var organisationList = await matchingOrganisations
.Include(o => o.ReviewerU)
.Include(o => o.UserOrganisations)
.ThenInclude(uo => uo.User)
.AsNoTracking()
.ToListAsync()
.ConfigureAwait(false);
response = _mapper.ToDomain(organisationList);
}
catch (InvalidOperationException e)
{
throw new UseCaseException()
{
UserErrorMessage = "Could not run the user search query with the supplied input parameters",
DevErrorMessage = e.Message
};
}
return(response);
}
public async Task <OrganisationResponseList> ExecuteGet(OrganisationSearchRequest requestParams)
{
var gatewayResponse = await _organisationsGateway.SearchOrganisations(requestParams).ConfigureAwait(false);
return(gatewayResponse == null ? new OrganisationResponseList() : gatewayResponse.ToResponse());
}
public async Task <IActionResult> Index(OrganisationSearchRequest searchQuery)
{
return(Ok(await _mediator.Send(searchQuery)));
}
