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_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 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>();
}
private ProviderVersionViewModel CreateProviderVersionViewModel(string fundingStreamId, string providerVersionId, ProviderSnapshot providerSnapshot, IEnumerable <Common.ApiClient.FundingDataZone.Models.Provider> fdzProviders)
{
IEnumerable <Models.Providers.Provider> providers = fdzProviders.Select(_ =>
{
return(_mapper.Map <Common.ApiClient.FundingDataZone.Models.Provider, Models.Providers.Provider>(_, opt =>
opt.AfterMap((src, dest) =>
{
dest.ProviderVersionId = providerVersionId;
dest.ProviderVersionIdProviderId = $"{providerVersionId}_{dest.ProviderId}";
})));
});
ProviderVersionViewModel providerVersionViewModel = new ProviderVersionViewModel()
{
FundingStream = fundingStreamId,
ProviderVersionId = providerVersionId,
VersionType = ProviderVersionType.SystemImported,
TargetDate = providerSnapshot.TargetDate,
Created = DateTimeOffset.Now,
Name = providerSnapshot.Name,
Description = providerSnapshot.Description,
Version = 1,
Providers = providers
};
return(providerVersionViewModel);
}
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 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 async Task <bool> Exists(ProviderVersionViewModel providerVersionModel)
{
Guard.ArgumentNotNull(providerVersionModel, nameof(providerVersionModel));
return(await _providerVersionMetadataRepository.Exists(providerVersionModel.Name,
providerVersionModel.ProviderVersionTypeString,
providerVersionModel.Version,
providerVersionModel.FundingStream));
}
public async Task <IActionResult> UploadProviderVersion(string actionName,
string controller,
string providerVersionId,
ProviderVersionViewModel providerVersionModel)
{
Guard.IsNullOrWhiteSpace(actionName, nameof(actionName));
Guard.IsNullOrWhiteSpace(controller, nameof(controller));
Guard.IsNullOrWhiteSpace(providerVersionId, nameof(providerVersionId));
Guard.ArgumentNotNull(providerVersionModel, nameof(providerVersionModel));
(bool success, IActionResult actionResult) = await UploadProviderVersion(providerVersionId, providerVersionModel);
return(success ? new CreatedAtActionResult(actionName, controller, new { providerVersionId }, providerVersionId) : actionResult);
}
public async Task UploadProviderVersion()
{
string providerVersionId = NewRandomString();
ProviderVersionViewModel model = new ProviderVersionViewModel();
GivenTheStatusCode($"providers/versions/{providerVersionId}", HttpStatusCode.OK, HttpMethod.Post);
NoValidatedContentApiResponse apiResponse = await _client.UploadProviderVersion(providerVersionId, model);
apiResponse?
.StatusCode
.Should()
.Be(HttpStatusCode.OK);
AndTheRequestContentsShouldHaveBeen(model.AsJson());
}
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_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>();
}
private async Task <IActionResult> UploadProviderVersionValidate(ProviderVersionViewModel providerVersionModel,
string providerVersionId)
{
BadRequestObjectResult validationResult = (await _providerVersionModelValidator.ValidateAsync(providerVersionModel)).PopulateModelState();
if (validationResult != null)
{
return(validationResult);
}
if (await Exists(providerVersionId.ToLowerInvariant()))
{
return(new ConflictResult());
}
if (await Exists(providerVersionModel))
{
return(new ConflictResult());
}
return(null);
}
public async Task <(bool Success, IActionResult ActionResult)> UploadProviderVersion(string providerVersionId, ProviderVersionViewModel providerVersionModel)
{
Guard.IsNullOrWhiteSpace(providerVersionId, nameof(providerVersionId));
Guard.ArgumentNotNull(providerVersionModel, nameof(providerVersionModel));
IActionResult validationResult = await UploadProviderVersionValidate(providerVersionModel, providerVersionId);
if (validationResult != null)
{
return(false, validationResult);
}
ProviderVersion providerVersion = _mapper.Map <ProviderVersion>(providerVersionModel);
providerVersion.Id = $"providerVersion-{providerVersionId}";
await UploadProviderVersionBlob(providerVersionId, providerVersion);
providerVersion.Providers = null;
ProviderVersionMetadata providerVersionMetadata = providerVersion;
HttpStatusCode result = await _providerVersionMetadataRepositoryPolicy.ExecuteAsync(() => _providerVersionMetadataRepository.CreateProviderVersion(providerVersionMetadata));
if (result.IsSuccess())
{
await _providersSearchPolicy.ExecuteAsync(() => _searchRepository.RunIndexer());
}
return(true, null);
}
public Task <NoValidatedContentApiResponse> UploadProviderVersion(string providerVersionId, ProviderVersionViewModel providers)
{
throw new NotImplementedException();
}
public override async Task Process(Message message)
{
Guard.ArgumentNotNull(message, nameof(message));
string specificationId = message.GetUserProperty <string>(SpecificationIdKey);
string fundingStreamId = message.GetUserProperty <string>(FundingStreamIdKey);
string providerSnapshotIdValue = message.GetUserProperty <string>(ProviderSnapshotIdKey);
string disableQueueCalculationJob = message.GetUserProperty <string>(DisableQueueCalculationJobKey);
Reference user = message.GetUserDetails();
string correlationId = message.GetCorrelationId();
if (string.IsNullOrWhiteSpace(providerSnapshotIdValue) || !int.TryParse(providerSnapshotIdValue, out int providerSnapshotId))
{
throw new NonRetriableException("Invalid provider snapshot id");
}
ProviderSnapshot providerSnapshot = await GetProviderSnapshot(fundingStreamId, providerSnapshotId);
string providerVersionId = $"{fundingStreamId}-{providerSnapshot.TargetDate:yyyy}-{providerSnapshot.TargetDate:MM}-{providerSnapshot.TargetDate:dd}-{providerSnapshotId}";
bool isProviderVersionExists = await _providerVersionService.Exists(providerVersionId);
if (!isProviderVersionExists)
{
IEnumerable <Common.ApiClient.FundingDataZone.Models.Provider> fdzProviders = await GetProvidersInSnapshot(providerSnapshotId);
ProviderVersionViewModel providerVersionViewModel = CreateProviderVersionViewModel(fundingStreamId, providerVersionId, providerSnapshot, fdzProviders);
(bool success, IActionResult actionResult) = await _providerVersionService.UploadProviderVersion(providerVersionId, providerVersionViewModel);
if (!success)
{
string errorMessage = $"Failed to upload provider version {providerVersionId}. {GetErrorMessage(actionResult, providerVersionId)}";
_logger.Error(errorMessage);
throw new Exception(errorMessage);
}
}
HttpStatusCode httpStatusCode = await _specificationsApiClientPolicy.ExecuteAsync(() => _specificationsApiClient.SetProviderVersion(specificationId, providerVersionId));
if (!httpStatusCode.IsSuccess())
{
string errorMessage = $"Unable to update the specification - {specificationId}, with provider version id - {providerVersionId}. HttpStatusCode - {httpStatusCode}";
_logger.Error(errorMessage);
throw new Exception(errorMessage);
}
JobCreateModel mapFdzDatasetsJobCreateModel = new JobCreateModel
{
Trigger = new Trigger
{
EntityId = specificationId,
EntityType = "Specification",
Message = "Map datasets for all relationships in specification"
},
InvokerUserId = user.Id,
InvokerUserDisplayName = user.Name,
JobDefinitionId = JobConstants.DefinitionNames.MapFdzDatasetsJob,
ParentJobId = null,
SpecificationId = specificationId,
CorrelationId = correlationId,
Properties = new Dictionary <string, string>
{
{ "specification-id", specificationId },
{ "disableQueueCalculationJob", disableQueueCalculationJob },
}
};
try
{
await _jobManagement.QueueJob(mapFdzDatasetsJobCreateModel);
}
catch (Exception ex)
{
string errorMessage = $"Failed to queue MapFdzDatasetsJob for specification - {specificationId}";
_logger.Error(ex, errorMessage);
throw;
}
}
public async Task <IActionResult> UploadProviderVersion([FromRoute] string providerVersionId, [FromBody] ProviderVersionViewModel providers)
{
string controllerName = string.Empty;
if (ControllerContext.RouteData.Values.ContainsKey("controller"))
{
controllerName = (string)ControllerContext.RouteData.Values["controller"];
}
return(await _providerVersionService.UploadProviderVersion(nameof(GetProvidersByVersion), controllerName, providerVersionId, providers));
}
public async Task <NoValidatedContentApiResponse> UploadProviderVersion(string providerVersionId, ProviderVersionViewModel providers)
{
Guard.IsNullOrWhiteSpace(providerVersionId, nameof(providerVersionId));
Guard.ArgumentNotNull(providers, nameof(providers));
string url = $"providers/versions/{providerVersionId}";
return(await ValidatedPostAsync <ProviderVersionViewModel>(url, providers));
}
