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 ProviderVersionUpdateCheckService(
IPoliciesApiClient policiesApiClient,
ILogger logger,
IProvidersResiliencePolicies resiliencePolicies,
IProviderVersionsMetadataRepository providerVersionMetadata,
IFundingDataZoneApiClient fundingDataZoneApiClient,
ISpecificationsApiClient specificationsApiClient,
IMapper mapper)
{
Guard.ArgumentNotNull(policiesApiClient, nameof(policiesApiClient));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(resiliencePolicies, nameof(resiliencePolicies));
Guard.ArgumentNotNull(resiliencePolicies.PoliciesApiClient, nameof(resiliencePolicies.PoliciesApiClient));
Guard.ArgumentNotNull(resiliencePolicies.ProviderVersionMetadataRepository, nameof(resiliencePolicies.ProviderVersionMetadataRepository));
Guard.ArgumentNotNull(resiliencePolicies.FundingDataZoneApiClient, nameof(resiliencePolicies.FundingDataZoneApiClient));
Guard.ArgumentNotNull(resiliencePolicies.SpecificationsApiClient, nameof(resiliencePolicies.SpecificationsApiClient));
Guard.ArgumentNotNull(providerVersionMetadata, nameof(providerVersionMetadata));
Guard.ArgumentNotNull(fundingDataZoneApiClient, nameof(fundingDataZoneApiClient));
Guard.ArgumentNotNull(specificationsApiClient, nameof(specificationsApiClient));
Guard.ArgumentNotNull(mapper, nameof(mapper));
_policiesApiClient = policiesApiClient;
_providerVersionMetadata = providerVersionMetadata;
_fundingDataZoneApiClient = fundingDataZoneApiClient;
_specificationsApiClient = specificationsApiClient;
_mapper = mapper;
_logger = logger;
_policiesApiClientPolicy = resiliencePolicies.PoliciesApiClient;
_providerVersionMetadataPolicy = resiliencePolicies.ProviderVersionMetadataRepository;
_fundingDataZoneApiClientPolicy = resiliencePolicies.FundingDataZoneApiClient;
_specificationsApiClientPolicy = resiliencePolicies.SpecificationsApiClient;
}
private IProviderVersionSearchService CreateProviderVersionSearchService(
ICacheProvider cacheProvider = null,
ISearchRepository <ProvidersIndex> searchRepository = null,
IProviderVersionsMetadataRepository providerVersionMetadataRepository = null,
IProviderVersionService providerVersionService = null)
{
return(new ProviderVersionSearchService(
CreateLogger(),
searchRepository ?? CreateSearchRepository(),
providerVersionMetadataRepository ?? CreateProviderVersionMetadataRepository(),
CreateResiliencePolicies(),
providerVersionService ?? CreateProviderVersionService()));
}
public ProviderVersionSearchService(ILogger logger,
ISearchRepository <ProvidersIndex> searchRepository,
IProviderVersionsMetadataRepository providerVersionsMetadataRepository,
IProvidersResiliencePolicies resiliencePolicies,
IProviderVersionService providerVersionService)
{
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(searchRepository, nameof(searchRepository));
Guard.ArgumentNotNull(resiliencePolicies?.ProviderVersionsSearchRepository, nameof(resiliencePolicies.ProviderVersionsSearchRepository));
Guard.ArgumentNotNull(resiliencePolicies?.ProviderVersionMetadataRepository, nameof(resiliencePolicies.ProviderVersionMetadataRepository));
_logger = logger;
_searchRepository = searchRepository;
_searchRepositoryPolicy = resiliencePolicies.ProviderVersionsSearchRepository;
_providerVersionsMetadataRepository = providerVersionsMetadataRepository;
_providerVersionsMetadataRepositoryPolicy = resiliencePolicies.ProviderVersionMetadataRepository;
_providerVersionService = providerVersionService;
}
public SetFundingStreamCurrentProviderVersionRequestValidator(IProviderVersionsMetadataRepository providerVersions,
IPoliciesApiClient policiesApiClient,
IProvidersResiliencePolicies resiliencePolicies)
{
Guard.ArgumentNotNull(providerVersions, nameof(providerVersions));
Guard.ArgumentNotNull(policiesApiClient, nameof(policiesApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.ProviderVersionMetadataRepository, nameof(resiliencePolicies.ProviderVersionMetadataRepository));
Guard.ArgumentNotNull(resiliencePolicies?.PoliciesApiClient, nameof(resiliencePolicies.PoliciesApiClient));
RuleFor(_ => _.FundingStreamId)
.Cascade(CascadeMode.StopOnFirstFailure)
.NotEmpty()
.CustomAsync(async(fundingStreamId,
context,
cancellationToken) =>
{
ApiResponse <FundingStream> response = await resiliencePolicies.PoliciesApiClient.ExecuteAsync(() =>
policiesApiClient.GetFundingStreamById(fundingStreamId));
if (response?.Content == null)
{
context.AddFailure(new ValidationFailure("FundingStreamId",
$"No funding stream located with Id {fundingStreamId}"));
}
});
RuleFor(_ => _.ProviderVersionId)
.Cascade(CascadeMode.StopOnFirstFailure)
.NotEmpty()
.CustomAsync(async(providerVersionId,
context,
cancellationToken) =>
{
ProviderVersionMetadata response = await resiliencePolicies.ProviderVersionMetadataRepository.ExecuteAsync(() =>
providerVersions.GetProviderVersionMetadata(providerVersionId));
if (response == null)
{
context.AddFailure(new ValidationFailure("ProviderVersionId",
$"No provider version located with Id {providerVersionId}"));
}
});
}
public ProviderVersionService(ICacheProvider cacheProvider,
IBlobClient blobClient,
ILogger logger,
IValidator <ProviderVersionViewModel> providerVersionModelValidator,
IProviderVersionsMetadataRepository providerVersionMetadataRepository,
IProvidersResiliencePolicies resiliencePolicies,
IMapper mapper,
IFileSystemCache fileSystemCache,
IProviderVersionServiceSettings providerVersionServiceSettings,
ISearchRepository <ProvidersIndex> searchRepository)
{
Guard.ArgumentNotNull(blobClient, nameof(blobClient));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(providerVersionModelValidator, nameof(providerVersionModelValidator));
Guard.ArgumentNotNull(resiliencePolicies?.ProviderVersionMetadataRepository, nameof(resiliencePolicies.ProviderVersionMetadataRepository));
Guard.ArgumentNotNull(resiliencePolicies?.BlobRepositoryPolicy, nameof(resiliencePolicies.BlobRepositoryPolicy));
Guard.ArgumentNotNull(resiliencePolicies?.CacheProvider, nameof(resiliencePolicies.CacheProvider));
Guard.ArgumentNotNull(resiliencePolicies?.ProviderVersionsSearchRepository, nameof(resiliencePolicies.ProviderVersionsSearchRepository));
Guard.ArgumentNotNull(mapper, nameof(mapper));
Guard.ArgumentNotNull(fileSystemCache, nameof(fileSystemCache));
Guard.ArgumentNotNull(providerVersionServiceSettings, nameof(providerVersionServiceSettings));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(searchRepository, nameof(searchRepository));
_cacheProvider = cacheProvider;
_blobClient = blobClient;
_logger = logger;
_providerVersionModelValidator = providerVersionModelValidator;
_providerVersionMetadataRepository = providerVersionMetadataRepository;
_providerVersionMetadataRepositoryPolicy = resiliencePolicies.ProviderVersionMetadataRepository;
_providersSearchPolicy = resiliencePolicies.ProviderVersionsSearchRepository;
_cachePolicy = resiliencePolicies.CacheProvider;
_blobRepositoryPolicy = resiliencePolicies.BlobRepositoryPolicy;
_mapper = mapper;
_fileSystemCache = fileSystemCache;
_providerVersionServiceSettings = providerVersionServiceSettings;
_searchRepository = searchRepository;
}
public async Task GetProviderById_WhenProviderVersionIdDoesNotExistsForDate_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);
IProviderVersionsMetadataRepository providerVersionMetadataRepository = CreateProviderVersionMetadataRepository();
string providerVersionId = Guid.NewGuid().ToString();
providerVersionMetadataRepository
.GetProviderVersionByDate(Arg.Any <int>(), Arg.Any <int>(), Arg.Any <int>())
.Returns <ProviderVersionByDate>((ProviderVersionByDate)null);
IProviderVersionSearchService providerService = CreateProviderVersionSearchService(cacheProvider: cacheProvider, searchRepository: searchRepository, providerVersionMetadataRepository: providerVersionMetadataRepository);
// Act
IActionResult notFoundRequest = await providerService.GetProviderById(year, month, day, "12345");
notFoundRequest
.Should()
.BeOfType <NotFoundResult>();
}
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>();
}
