public async Task SearchProviders_WhenNoProviderVersionSetAsMaster_NotFoundReturned(int day, int month, int year)
{
// Arrange
ProviderVersionViewModel providerVersionViewModel = CreateProviderVersion();
Provider provider = GetProvider();
providerVersionViewModel.Providers = providerVersionViewModel.Providers.Concat(new[] { provider });
providerVersionViewModel.VersionType = ProviderVersionType.Custom;
ICacheProvider cacheProvider = CreateCacheProvider();
SearchResults <ProvidersIndex> searchResults = new SearchResults <ProvidersIndex>();
ISearchRepository <ProvidersIndex> searchRepository = CreateSearchRepository();
searchRepository
.Search(Arg.Any <string>(), Arg.Any <SearchParameters>())
.Returns(searchResults);
IProviderVersionService providerVersionService = CreateProviderVersionService();
providerVersionService
.GetMasterProviderVersion()
.Returns <MasterProviderVersion>((MasterProviderVersion)null);
IProviderVersionSearchService providerService = CreateProviderVersionSearchService(cacheProvider: cacheProvider, searchRepository: searchRepository, providerVersionService: providerVersionService);
// Act
IActionResult notFoundResult = await providerService.SearchProviders(year, month, day, new Models.SearchModel());
notFoundResult
.Should()
.BeOfType <NotFoundResult>();
}
public FundingStreamProviderVersionService(IProviderVersionsMetadataRepository providerVersionMetadata,
IProviderVersionService providerVersionService,
IProviderVersionSearchService providerVersionSearch,
IValidator <SetFundingStreamCurrentProviderVersionRequest> setCurrentRequestValidator,
IProvidersResiliencePolicies resiliencePolicies,
ILogger logger,
IMapper mapper)
{
Guard.ArgumentNotNull(providerVersionMetadata, nameof(providerVersionMetadata));
Guard.ArgumentNotNull(providerVersionService, nameof(providerVersionService));
Guard.ArgumentNotNull(providerVersionSearch, nameof(providerVersionSearch));
Guard.ArgumentNotNull(resiliencePolicies?.ProviderVersionMetadataRepository, nameof(resiliencePolicies.ProviderVersionMetadataRepository));
Guard.ArgumentNotNull(resiliencePolicies?.ProviderVersionsSearchRepository, nameof(resiliencePolicies.ProviderVersionsSearchRepository));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(mapper, nameof(mapper));
_providerVersionMetadata = providerVersionMetadata;
_providerVersionMetadataPolicy = resiliencePolicies.ProviderVersionMetadataRepository;
_providerVersionSearchPolicy = resiliencePolicies.ProviderVersionsSearchRepository;
_logger = logger;
_providerVersionSearch = providerVersionSearch;
_setCurrentRequestValidator = setCurrentRequestValidator;
_providerVersionService = providerVersionService;
_mapper = mapper;
}
public async Task UploadProviderVersion_CallsCorrectly(
string providerVersionId)
{
IProviderVersionService providerVersionService = Substitute.For <IProviderVersionService>();
IProviderVersionSearchService providerVersionSearchService = Substitute.For <IProviderVersionSearchService>();
ProviderVersionViewModel providers = new ProviderVersionViewModel();
ProviderByVersionController controller = new ProviderByVersionController(
providerVersionService,
providerVersionSearchService);
controller.ControllerContext = new Microsoft.AspNetCore.Mvc.ControllerContext()
{
RouteData = new Microsoft.AspNetCore.Routing.RouteData
(
new Microsoft.AspNetCore.Routing.RouteValueDictionary
(
new Dictionary <string, string>()
{
{ "controller", "ProviderByVersion" }
}
)
)
};
await controller.UploadProviderVersion(providerVersionId, providers);
await providerVersionService
.Received(1)
.UploadProviderVersion("GetProvidersByVersion", "ProviderByVersion", providerVersionId, providers);
}
public async Task GetProviderById_WhenProviderIdDoesNotExistForProviderVersion_NotFoundReturned()
{
// Arrange
ProviderVersionViewModel providerVersionViewModel = CreateProviderVersion();
Provider provider = GetProvider();
providerVersionViewModel.Providers = providerVersionViewModel.Providers.Concat(new[] { provider });
providerVersionViewModel.VersionType = ProviderVersionType.Custom;
ICacheProvider cacheProvider = CreateCacheProvider();
SearchResults <ProvidersIndex> searchResults = new SearchResults <ProvidersIndex>();
ISearchRepository <ProvidersIndex> searchRepository = CreateSearchRepository();
searchRepository
.Search(Arg.Any <string>(), Arg.Any <SearchParameters>())
.Returns(searchResults);
IProviderVersionSearchService providerService = CreateProviderVersionSearchService(cacheProvider: cacheProvider, searchRepository: searchRepository);
// Act
IActionResult notFoundRequest = await providerService.GetProviderById(providerVersionViewModel.ProviderVersionId, string.Empty);
await searchRepository.Received(1)
.Search(Arg.Any <string>(), Arg.Is <SearchParameters>(c => c.Filter.Contains(providerVersionViewModel.ProviderVersionId)));
notFoundRequest
.Should()
.BeOfType <NotFoundResult>();
}
public async Task GetProviderById_WhenSearchThrowsError_InternalServerErrorThrown()
{
// Arrange
ProviderVersionViewModel providerVersionViewModel = CreateProviderVersion();
Provider provider = GetProvider();
providerVersionViewModel.Providers = providerVersionViewModel.Providers.Concat(new[] { provider });
providerVersionViewModel.VersionType = ProviderVersionType.Custom;
ICacheProvider cacheProvider = CreateCacheProvider();
SearchResults <ProvidersIndex> searchResults = new SearchResults <ProvidersIndex>();
ISearchRepository <ProvidersIndex> searchRepository = CreateSearchRepository();
searchRepository
.When(s => s.Search(Arg.Any <string>(), Arg.Any <SearchParameters>()))
.Do(x => { throw new FailedToQuerySearchException("Test Message", null); });
IProviderVersionSearchService providerService = CreateProviderVersionSearchService(cacheProvider: cacheProvider, searchRepository: searchRepository);
// Act
IActionResult internalServerResult = await providerService.GetProviderById(providerVersionViewModel.ProviderVersionId, string.Empty);
await searchRepository.Received(1)
.Search(Arg.Any <string>(), Arg.Is <SearchParameters>(c => c.Filter.Contains(providerVersionViewModel.ProviderVersionId)));
internalServerResult
.Should()
.BeOfType <InternalServerErrorResult>();
}
public async Task GetLocalAuthoritiesByProviderVersionId_WhenProviderVersionIdFacetProvidedWithNoAuthorities_OkWithEmptyResultReturned()
{
// Arrange
string authorityFacet = "authority";
string providerVersionIdFacet = "providerVersionId";
string providerVersionId = "dsg-2020-07-03";
SearchResults <ProvidersIndex> authorityResults = new SearchResults <ProvidersIndex>
{
Facets = new List <Facet>
{
new Facet
{
Name = authorityFacet,
FacetValues = Enumerable.Empty <FacetValue>()
}
}
};
SearchResults <ProvidersIndex> providerVersionResults = new SearchResults <ProvidersIndex>
{
Facets = new List <Facet>
{
new Facet
{
Name = providerVersionIdFacet,
FacetValues = new List <FacetValue>
{
new FacetValue {
Name = providerVersionId
}
}
}
}
};
ISearchRepository <ProvidersIndex> searchRepository = CreateSearchRepository();
searchRepository
.Search(string.Empty, Arg.Is <SearchParameters>(x => x.Facets.Any(x => x.Contains(authorityFacet))))
.Returns(authorityResults);
searchRepository
.Search(string.Empty, Arg.Is <SearchParameters>(x => x.Facets.Any(x => x.Contains(providerVersionIdFacet))))
.Returns(providerVersionResults);
searchRepository
.Search(string.Empty, Arg.Is <SearchParameters>(x => x.Facets == null || !x.Facets.Any()))
.Returns(new SearchResults <ProvidersIndex>());
IProviderVersionSearchService providerService = CreateProviderVersionSearchService(searchRepository: searchRepository);
// Act
IActionResult notFoundRequest = await providerService.GetLocalAuthoritiesByProviderVersionId(providerVersionId);
// Assert
notFoundRequest
.Should()
.BeOfType <OkObjectResult>();
((IEnumerable <string>)((OkObjectResult)notFoundRequest).Value).Should().BeEmpty();
}
public async Task SearchProviders_WhenProviderIdExistsForDate_ProviderReturned(int day, int month, int year)
{
// Arrange
ProviderVersionViewModel providerVersionViewModel = CreateProviderVersion();
Provider provider = GetProvider();
providerVersionViewModel.Providers = providerVersionViewModel.Providers.Concat(new[] { provider });
providerVersionViewModel.VersionType = ProviderVersionType.Custom;
ICacheProvider cacheProvider = CreateCacheProvider();
SearchResults <ProvidersIndex> searchResults = new SearchResults <ProvidersIndex> {
Results = new List <Repositories.Common.Search.SearchResult <ProvidersIndex> > {
new Repositories.Common.Search.SearchResult <ProvidersIndex> {
Result = new ProvidersIndex {
ProviderVersionId = provider.ProviderVersionId, UKPRN = provider.UKPRN
}
}
}
};
IProviderVersionService providerVersionService = CreateProviderVersionService();
ISearchRepository <ProvidersIndex> searchRepository = CreateSearchRepository();
searchRepository
.Search(Arg.Any <string>(), Arg.Any <SearchParameters>())
.Returns(searchResults);
IProviderVersionSearchService providerService = CreateProviderVersionSearchService(cacheProvider: cacheProvider, searchRepository: searchRepository, providerVersionService: providerVersionService);
providerVersionService
.GetProviderVersionByDate(Arg.Any <int>(), Arg.Any <int>(), Arg.Any <int>())
.Returns <ProviderVersionByDate>(new ProviderVersionByDate {
Day = day, Month = month, Year = year, ProviderVersionId = provider.ProviderVersionId
});
// Act
IActionResult okRequest = await providerService.SearchProviders(year, month, day, new Models.SearchModel {
Filters = new Dictionary <string, string[]> {
{ "providerId", new List <string> {
provider.ProviderId
}.ToArray() }
}
});
await searchRepository.Received(1)
.Search(Arg.Any <string>(), Arg.Is <SearchParameters>(c => c.Filter.Contains(provider.ProviderId)));
okRequest
.Should()
.BeOfType <OkObjectResult>();
((OkObjectResult)okRequest).Value
.Should()
.BeOfType <ProviderVersionSearchResults>();
}
public ProviderByDateController(IProviderVersionService providerVersionService,
IProviderVersionSearchService providerVersionSearchService)
{
Guard.ArgumentNotNull(providerVersionService, nameof(providerVersionService));
Guard.ArgumentNotNull(providerVersionSearchService, nameof(providerVersionSearchService));
_providerVersionService = providerVersionService;
_providerVersionSearchService = providerVersionSearchService;
}
public async Task GetFacetValues_WhenValidFacetProvided_FacetDistinctValuesReturned()
{
// Arrange
string authorityFacet = "authority";
string facetValue1 = "Kent";
string facetValue2 = "Essex";
SearchResults <ProvidersIndex> searchResults = new SearchResults <ProvidersIndex>
{
Facets = new List <Facet>
{
new Facet
{
Name = authorityFacet,
FacetValues = new List <FacetValue>
{
new FacetValue {
Name = facetValue1
},
new FacetValue {
Name = facetValue2
}
}
}
}
};
ISearchRepository <ProvidersIndex> searchRepository = CreateSearchRepository();
searchRepository
.Search(string.Empty, Arg.Any <SearchParameters>())
.Returns(searchResults);
IProviderVersionSearchService providerService = CreateProviderVersionSearchService(searchRepository: searchRepository);
// Act
IActionResult okObjectRequest = await providerService.GetFacetValues(authorityFacet);
// Assert
okObjectRequest
.Should()
.BeOfType <OkObjectResult>();
await searchRepository
.Received(1)
.Search(string.Empty, Arg.Is <SearchParameters>(x => x.Top == 0 && x.Facets.Count == 1 && x.Facets.First().Contains(authorityFacet)));
((okObjectRequest as OkObjectResult).Value as IEnumerable <string>)
.Should()
.HaveCount(2);
}
public async Task GetLocalAuthorityNames_CallsCorrectly()
{
IProviderVersionSearchService providerVersionSearchService = Substitute.For <IProviderVersionSearchService>();
ProvidersController controller = new ProvidersController(
providerVersionSearchService);
await controller.GetLocalAuthorityNames();
await providerVersionSearchService
.Received(1)
.GetFacetValues("authority");
}
public async Task GetFacetValues_WhenFacetNotProvided_NotFoundResultReturned()
{
// Arrange
IProviderVersionSearchService providerService = CreateProviderVersionSearchService();
// Act
IActionResult notFoundRequest = await providerService.GetFacetValues(string.Empty);
// Assert
notFoundRequest
.Should()
.BeOfType <NotFoundResult>();
}
public void GetAvailableProvidersByMonth_CallsCorrectly(int year, int month)
{
IProviderVersionService providerVersionService = Substitute.For <IProviderVersionService>();
IProviderVersionSearchService providerVersionSearchService = Substitute.For <IProviderVersionSearchService>();
ProviderByDateController controller = Substitute.For <ProviderByDateController>(
providerVersionService,
providerVersionSearchService);
controller.GetAvailableProvidersByMonth(year, month);
controller
.Received(1)
.Ok(Arg.Any <IEnumerable>());
}
public async Task GetProviderByIdFromProviderVersion_CallsCorrectly(int year, int month, int day, string providerId)
{
IProviderVersionService providerVersionService = Substitute.For <IProviderVersionService>();
IProviderVersionSearchService providerVersionSearchService = Substitute.For <IProviderVersionSearchService>();
ProviderByDateController controller = new ProviderByDateController(
providerVersionService,
providerVersionSearchService);
await controller.GetProviderByIdFromProviderVersion(year, month, day, providerId);
await providerVersionSearchService
.Received(1)
.GetProviderById(year, month, day, providerId);
}
public async Task DoesProviderVersionExist_CallsCorrectly(
string providerVersionId)
{
IProviderVersionService providerVersionService = Substitute.For <IProviderVersionService>();
IProviderVersionSearchService providerVersionSearchService = Substitute.For <IProviderVersionSearchService>();
ProviderByVersionController controller = new ProviderByVersionController(
providerVersionService,
providerVersionSearchService);
await controller.DoesProviderVersionExist(providerVersionId);
await providerVersionService
.Received(1)
.DoesProviderVersionExist(providerVersionId);
}
public async Task GetProvidersByVersion_CallsCorrectly(
string providerVersionId)
{
IProviderVersionService providerVersionService = Substitute.For <IProviderVersionService>();
IProviderVersionSearchService providerVersionSearchService = Substitute.For <IProviderVersionSearchService>();
ProviderByVersionController controller = new ProviderByVersionController(
providerVersionService,
providerVersionSearchService);
await controller.GetProvidersByVersion(providerVersionId);
await providerVersionService
.Received(1)
.GetAllProviders(providerVersionId);
}
public async Task GetProviderById_WhenProviderIdExistsForProviderVersion_ProviderReturned()
{
// Arrange
ProviderVersionViewModel providerVersionViewModel = CreateProviderVersion();
Provider provider = GetProvider();
providerVersionViewModel.Providers = providerVersionViewModel.Providers.Concat(new[] { provider });
providerVersionViewModel.VersionType = ProviderVersionType.Custom;
ICacheProvider cacheProvider = CreateCacheProvider();
SearchResults <ProvidersIndex> searchResults = new SearchResults <ProvidersIndex> {
Results = new List <Repositories.Common.Search.SearchResult <ProvidersIndex> > {
new Repositories.Common.Search.SearchResult <ProvidersIndex> {
Result = new ProvidersIndex {
ProviderVersionId = provider.ProviderVersionId, UKPRN = provider.UKPRN
}
}
}
};
ISearchRepository <ProvidersIndex> searchRepository = CreateSearchRepository();
searchRepository
.Search(Arg.Any <string>(), Arg.Any <SearchParameters>())
.Returns(searchResults);
IProviderVersionSearchService providerService = CreateProviderVersionSearchService(cacheProvider: cacheProvider, searchRepository: searchRepository);
// Act
IActionResult okRequest = await providerService.GetProviderById(providerVersionViewModel.ProviderVersionId, provider.ProviderId);
await searchRepository.Received(1)
.Search(Arg.Any <string>(), Arg.Is <SearchParameters>(c => c.Filter.Contains(provider.ProviderId)));
okRequest
.Should()
.BeOfType <OkObjectResult>();
((OkObjectResult)okRequest).Value
.Should()
.BeOfType <ProviderVersionSearchResult>();
Assert.AreEqual(((ProviderVersionSearchResult)((OkObjectResult)okRequest).Value).Id, provider.ProviderVersionId + "_" + provider.UKPRN);
}
public async Task SearchProviderVersions_CallsCorrectly()
{
IProviderVersionService providerVersionService = Substitute.For <IProviderVersionService>();
IProviderVersionSearchService providerVersionSearchService = Substitute.For <IProviderVersionSearchService>();
ProviderByVersionController controller = new ProviderByVersionController(
providerVersionService,
providerVersionSearchService);
SearchModel searchModel = new SearchModel();
await controller.SearchProviderVersions(searchModel);
await providerVersionSearchService
.Received(1)
.SearchProviderVersions(searchModel);
}
public async Task SearchProvidersInProviderVersionAssociatedWithDate_CallsCorrectly(int year, int month, int day)
{
IProviderVersionService providerVersionService = Substitute.For <IProviderVersionService>();
IProviderVersionSearchService providerVersionSearchService = Substitute.For <IProviderVersionSearchService>();
ProviderByDateController controller = new ProviderByDateController(
providerVersionService,
providerVersionSearchService);
SearchModel searchModel = new SearchModel();
await controller.SearchProvidersInProviderVersionAssociatedWithDate(year, month, day, searchModel);
await providerVersionSearchService
.Received(1)
.SearchProviders(year, month, day, searchModel);
}
public async Task SearchProviderVersions_WhenSearchThrowsError_InternalServerErrorThrown()
{
// Arrange
ProviderVersionViewModel providerVersionViewModel = CreateProviderVersion();
Provider provider = GetProvider();
providerVersionViewModel.Providers = providerVersionViewModel.Providers.Concat(new[] { provider });
providerVersionViewModel.VersionType = ProviderVersionType.Custom;
ICacheProvider cacheProvider = CreateCacheProvider();
SearchResults <ProvidersIndex> searchResults = new SearchResults <ProvidersIndex> {
Results = new List <Repositories.Common.Search.SearchResult <ProvidersIndex> > {
new Repositories.Common.Search.SearchResult <ProvidersIndex> {
Result = new ProvidersIndex {
ProviderVersionId = provider.ProviderVersionId, UKPRN = provider.UKPRN
}
}
}
};
ISearchRepository <ProvidersIndex> searchRepository = CreateSearchRepository();
searchRepository
.When(s => s.Search(Arg.Any <string>(), Arg.Any <SearchParameters>()))
.Do(x => { throw new FailedToQuerySearchException("Test Message", null); });
IProviderVersionSearchService providerService = CreateProviderVersionSearchService(cacheProvider: cacheProvider, searchRepository: searchRepository);
// Act
IActionResult okRequest = await providerService.SearchProviderVersions(new Models.SearchModel {
Filters = new Dictionary <string, string[]> {
{ "providerId", new List <string> {
provider.ProviderId
}.ToArray() }
}
});
await searchRepository.Received(1)
.Search(Arg.Any <string>(), Arg.Is <SearchParameters>(c => c.Filter.Contains(provider.ProviderId)));
okRequest
.Should()
.BeOfType <InternalServerErrorResult>();
}
public async Task GetProviderById_WhenProviderIdDoesNotExistsForDate_NotFoundReturned(int day, int month, int year)
{
// Arrange
ProviderVersionViewModel providerVersionViewModel = CreateProviderVersion();
Provider provider = GetProvider();
providerVersionViewModel.Providers = providerVersionViewModel.Providers.Concat(new[] { provider });
providerVersionViewModel.VersionType = ProviderVersionType.Custom;
ICacheProvider cacheProvider = CreateCacheProvider();
SearchResults <ProvidersIndex> searchResults = new SearchResults <ProvidersIndex>();
ISearchRepository <ProvidersIndex> searchRepository = CreateSearchRepository();
searchRepository
.Search(Arg.Any <string>(), Arg.Any <SearchParameters>())
.Returns(searchResults);
IProviderVersionService providerVersionService = CreateProviderVersionService();
string providerVersionId = Guid.NewGuid().ToString();
providerVersionService
.GetProviderVersionByDate(Arg.Any <int>(), Arg.Any <int>(), Arg.Any <int>())
.Returns <ProviderVersionByDate>(new ProviderVersionByDate {
Day = day, Month = month, Year = year, ProviderVersionId = providerVersionId
});
IProviderVersionSearchService providerService = CreateProviderVersionSearchService(cacheProvider: cacheProvider, searchRepository: searchRepository, providerVersionService: providerVersionService);
// Act
IActionResult notFoundRequest = await providerService.GetProviderById(year, month, day, "12345");
await searchRepository.Received(1)
.Search(Arg.Any <string>(), Arg.Is <SearchParameters>(c => c.Filter.Contains(providerVersionId)));
notFoundRequest
.Should()
.BeOfType <NotFoundResult>();
}
public async Task SetProviderDateProviderVersion_CallsCorrectly(int year, int month, int day)
{
IProviderVersionService providerVersionService = Substitute.For <IProviderVersionService>();
IProviderVersionSearchService providerVersionSearchService = Substitute.For <IProviderVersionSearchService>();
providerVersionService
.GetAllProviders(Arg.Any <string>())
.Returns(new OkObjectResult(new Provider {
ProviderVersionId = "providerVersionId"
}));
ProviderByDateController controller = Substitute.For <ProviderByDateController>(providerVersionService, providerVersionSearchService);
await controller.SetProviderDateProviderVersion(year, month, day, "providerVersionId");
await providerVersionService
.Received(1)
.SetProviderVersionByDate(Arg.Any <int>(), Arg.Any <int>(), Arg.Any <int>(), Arg.Any <string>());
}
public async Task GetLocalAuthoritiesByFundingStreamId_WhenAuthoritiesProvidedForProviderVersionId_OkesultsReturned()
{
// Arrange
string authorityFacet = "authority";
string providerVersionIdFacet = "providerVersionId";
string aFacetValue1 = "Kent";
string aFacetValue2 = "Essex";
string providerVersionId = "dsg-2020-07-03";
SearchResults <ProvidersIndex> authorityResults = new SearchResults <ProvidersIndex>
{
Facets = new List <Facet>
{
new Facet
{
Name = authorityFacet,
FacetValues = new List <FacetValue>()
{
new FacetValue {
Name = aFacetValue1
},
new FacetValue {
Name = aFacetValue2
}
}
}
}
};
SearchResults <ProvidersIndex> providerVersionResults = new SearchResults <ProvidersIndex>
{
Facets = new List <Facet>
{
new Facet
{
Name = providerVersionIdFacet,
FacetValues = new List <FacetValue>
{
new FacetValue {
Name = providerVersionId
}
}
}
}
};
ISearchRepository <ProvidersIndex> searchRepository = CreateSearchRepository();
searchRepository
.Search(string.Empty, Arg.Is <SearchParameters>(x => x.Facets.Any(x => x.Contains(authorityFacet))))
.Returns(authorityResults);
searchRepository
.Search(string.Empty, Arg.Is <SearchParameters>(x => x.Facets.Any(x => x.Contains(providerVersionIdFacet))))
.Returns(providerVersionResults);
searchRepository
.Search(string.Empty, Arg.Is <SearchParameters>(x => x.Facets == null || !x.Facets.Any()))
.Returns(new SearchResults <ProvidersIndex>());
CurrentProviderVersion currentProviderVersion = NewCurrentProviderVersion(_ => _.ForFundingStreamId("fundingStreamId"));
currentProviderVersion.ProviderVersionId = providerVersionId;
IProviderVersionsMetadataRepository providerVersionsMetadataRepository = CreateProviderVersionMetadataRepository();
providerVersionsMetadataRepository.GetCurrentProviderVersion(Arg.Any <string>())
.Returns(currentProviderVersion);
IProviderVersionSearchService providerService = CreateProviderVersionSearchService(searchRepository: searchRepository,
providerVersionMetadataRepository: providerVersionsMetadataRepository);
// Act
IActionResult notFoundRequest = await providerService.GetLocalAuthoritiesByFundingStreamId("fundingStreamId");
// Assert
notFoundRequest
.Should()
.BeOfType <OkObjectResult>();
((IEnumerable <string>)((OkObjectResult)notFoundRequest).Value).Should().Contain(aFacetValue1);
((IEnumerable <string>)((OkObjectResult)notFoundRequest).Value).Should().Contain(aFacetValue2);
}
public async Task GetLocalAuthoritiesByFundingStreamId_WhenFundingStreamIdFacetNotProvided_NotFoundResultReturned()
{
// Arrange
string authorityFacet = "authority";
string providerVersionIdFacet = "providerVersionId";
SearchResults <ProvidersIndex> authorityResults = new SearchResults <ProvidersIndex>
{
Facets = new List <Facet>
{
new Facet
{
Name = authorityFacet,
FacetValues = new List <FacetValue>()
}
}
};
SearchResults <ProvidersIndex> providerVersionResults = new SearchResults <ProvidersIndex>
{
Facets = new List <Facet>
{
new Facet
{
Name = providerVersionIdFacet,
FacetValues = new List <FacetValue>()
}
}
};
ISearchRepository <ProvidersIndex> searchRepository = CreateSearchRepository();
searchRepository
.Search(string.Empty, Arg.Is <SearchParameters>(x => x.Facets.Any(x => x.Contains(authorityFacet))))
.Returns(authorityResults);
searchRepository
.Search(string.Empty, Arg.Is <SearchParameters>(x => x.Facets.Any(x => x.Contains(providerVersionIdFacet))))
.Returns(providerVersionResults);
searchRepository
.Search(string.Empty, Arg.Is <SearchParameters>(x => x.Facets == null || !x.Facets.Any()))
.Returns(new SearchResults <ProvidersIndex>());
CurrentProviderVersion currentProviderVersion = NewCurrentProviderVersion(_ => _.ForFundingStreamId("fundingStreamId"));
IProviderVersionsMetadataRepository providerVersionsMetadataRepository = CreateProviderVersionMetadataRepository();
providerVersionsMetadataRepository.GetCurrentProviderVersion(Arg.Any <string>())
.Returns(currentProviderVersion);
IProviderVersionSearchService providerService = CreateProviderVersionSearchService(searchRepository: searchRepository,
providerVersionMetadataRepository: providerVersionsMetadataRepository);
// Act
IActionResult notFoundRequest = await providerService.GetLocalAuthoritiesByFundingStreamId("fundingStreamId");
// Assert
notFoundRequest
.Should()
.BeOfType <NotFoundResult>();
}
