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)); }