public async Task ApproveFundingForSpecificationPostsToPublishingService(HttpStatusCode expectedStatusCode) { string specificationId = NewRandomString(); string expectedUri = $"specifications/{specificationId}/approve"; GivenTheStatusCode(expectedUri, expectedStatusCode, HttpMethod.Post); ValidatedApiResponse <JobCreationResponse> response = await _client.ApproveFundingForSpecification(specificationId); response .Should() .NotBeNull(); response .StatusCode .Should() .Be(expectedStatusCode); }
public async Task ValidateDataset_GivenViewModelButResponseIsBadRequestAndHasModelState_ReturnsBadRequestObjectResult() { string fundingStreamId = Guid.NewGuid().ToString(); // Arrange ValidateDatasetModel viewModel = new ValidateDatasetModel { FundingStreamId = fundingStreamId }; GivenTheUserHasPermissionToUploadDataSourceFilesForFundingStream(fundingStreamId, new FundingStreamPermission { CanUploadDataSourceFiles = true }); IDictionary <string, IEnumerable <string> > modelState = new Dictionary <string, IEnumerable <string> >(); modelState.Add("error", new List <string> { "an error occured" }); ValidatedApiResponse <DatasetValidationStatusModel> response = new ValidatedApiResponse <DatasetValidationStatusModel>(HttpStatusCode.BadRequest) { ModelState = modelState }; _apiClient .ValidateDataset(Arg.Any <GetDatasetBlobModel>()) .Returns(response); // Act IActionResult result = await _controller.ValidateDataset(viewModel); // Assert result .Should() .BeOfType <BadRequestObjectResult>(); _logger .Received(1) .Warning(Arg.Is("Failed to validate dataset with status code: {statusCode}"), Arg.Is(HttpStatusCode.BadRequest)); }
public async Task ValidateSpecificationForRefresh_ReturnsOK() { string specificationId = NewRandomString(); IEnumerable <string> expectedErrors = new List <string> { "Error1" }; string expectedUri = $"specifications/{specificationId}/validate-specification-for-refresh"; GivenTheResponse(expectedUri, expectedErrors, HttpMethod.Post); ValidatedApiResponse <IEnumerable <string> > response = await _client.ValidateSpecificationForRefresh(specificationId); response?.Content .Should() .BeEquivalentTo(expectedErrors); AndTheUrisShouldHaveBeenRequested(expectedUri); }
public async Task <IActionResult> EditSpecificationStatus(string specificationId, [FromBody] PublishStatusEditModel publishStatusEditModel) { Guard.IsNullOrWhiteSpace(specificationId, nameof(specificationId)); Guard.ArgumentNotNull(publishStatusEditModel, nameof(publishStatusEditModel)); if (!await _authorizationHelper.DoesUserHavePermission(User, specificationId, SpecificationActionTypes.CanApproveSpecification)) { return(new ForbidResult()); } ValidatedApiResponse <PublishStatusResult> response = await _specsClient.UpdatePublishStatus(specificationId, publishStatusEditModel); if (response.StatusCode == HttpStatusCode.OK) { return(Ok(response.Content)); } throw new InvalidOperationException($"An error occurred while retrieving code context. Status code={response.StatusCode}"); }
public static void AddValidationResultErrors <T>(this ValidatedApiResponse <T> response, ModelStateDictionary modelState) { if (modelState != null && response != null) { foreach (var validationResult in response.ModelState) { List <string> errors = new List <string>(validationResult.Value); for (int i = 0; i < errors.Count; i++) { string key = validationResult.Key; if (modelState.ContainsKey(validationResult.Key)) { key = $"{validationResult.Key}.{i}"; } modelState.AddModelError(key, errors[i]); } } } }
public async Task SaveMultipleSameFundinglines_GivenPublishedProfilingRequests() { //Arrange List <FundingLine> fundingLines = new List <FundingLine> { new FundingLine { Name = "Abc", FundingLineCode = "FL1", Type = FundingLineType.Payment, Value = 500, TemplateLineId = 123, DistributionPeriods = null }, new FundingLine { Name = "Abc", FundingLineCode = "FL1", Type = FundingLineType.Payment, Value = 500, TemplateLineId = 123, DistributionPeriods = null } }; ILogger logger = CreateLogger(); ValidatedApiResponse <ProviderProfilingResponseModel> profileResponse = SetUpProviderProfilingResponse(); IProfilingApiClient providerProfilingRepository = Substitute.For <IProfilingApiClient>(); providerProfilingRepository .GetProviderProfilePeriods(Arg.Any <ProviderProfilingRequestModel>()) .Returns(Task.FromResult(profileResponse)); ProfilingService serviceapi = CreateProfilingService( logger: logger, profilingApiClient: providerProfilingRepository); //Act await serviceapi.ProfileFundingLines(fundingLines, "PSG", "AY-1819"); //Assert fundingLines .Where(y => y.Value == 500) .Select(r => r.DistributionPeriods) .Should() .NotBeNullOrEmpty(); await providerProfilingRepository .Received(1) .GetProviderProfilePeriods(Arg.Is <ProviderProfilingRequestModel>(m => m.FundingValue == 500)); }
public async Task SaveFundingTotals_GivenPublishedProfilingRequests() { //Arrange IEnumerable <FundingLine> fundingLines = SetUpInput(); ILogger logger = CreateLogger(); ValidatedApiResponse <ProviderProfilingResponseModel> profileResponse = SetUpProviderProfilingResponse(); IProfilingApiClient providerProfilingRepository = Substitute.For <IProfilingApiClient>(); providerProfilingRepository .GetProviderProfilePeriods(Arg.Any <ProviderProfilingRequestModel>()) .Returns(Task.FromResult(profileResponse)); ProfilingService serviceapi = CreateProfilingService( logger: logger, profilingApiClient: providerProfilingRepository); //Act await serviceapi.ProfileFundingLines(fundingLines, "PSG", "AY-1819"); //Assert fundingLines.Where(y => y.Type == FundingLineType.Payment) .Select(r => r.DistributionPeriods) .Should() .NotBeNullOrEmpty(); IEnumerable <FundingLine> expectedFundingLines; expectedFundingLines = ExpectedOutput(); JsonConvert .SerializeObject(expectedFundingLines) .Should() .BeEquivalentTo(JsonConvert.SerializeObject(fundingLines)); await providerProfilingRepository .Received(1) .GetProviderProfilePeriods(Arg.Is <ProviderProfilingRequestModel>(m => m.FundingValue == 500)); }
public async Task SaveDataset_GivenViewModelIsNotNullButResponseContainsModelErrors_ReturnsBadRequest() { // Arrange ValidatedApiResponse <NewDatasetVersionResponseModel> response = new ValidatedApiResponse <NewDatasetVersionResponseModel>(HttpStatusCode.BadRequest) { ModelState = new Dictionary <string, IEnumerable <string> > { { "Name", new[] { "Invalid name" } } } }; CreateDatasetViewModel viewModel = new CreateDatasetViewModel { Description = "Description", Filename = "Filename.xlsx", Name = "Name", DataDefinitionId = "0123456789", FundingStreamId = "DSG" }; _apiClient .CreateNewDataset(Arg.Any <CreateNewDatasetModel>()) .Returns(response); // Act IActionResult result = await _controller.SaveDataset(viewModel); // Assert _logger .Received(1) .Warning(Arg.Is("Invalid model provided")); result .Should() .BeOfType <BadRequestObjectResult>(); }
public async Task <IActionResult> ApproveFunding(string specificationId) { if (!await _authorizationHelper.DoesUserHavePermission( User, specificationId, SpecificationActionTypes.CanApproveFunding)) { return(new ForbidResult()); } ValidatedApiResponse <JobCreationResponse> response = await _publishingApiClient.ApproveFundingForSpecification(specificationId); if (response.StatusCode == HttpStatusCode.PreconditionFailed) { return(new PreconditionFailedResult("Preconditions for this approval have not been met.")); } return(response.Handle("Release Funding", onSuccess: x => x.Content.JobId != null ? (IActionResult)Ok(new { jobId = x.Content.JobId }) : BadRequest())); }
public async Task SaveDataset_GivenResponseIsSuccess_ReturnsSuccess() { // Arrange NewDatasetVersionResponseModel responseModel = new NewDatasetVersionResponseModel { DatasetId = "dataset-id" }; ValidatedApiResponse <NewDatasetVersionResponseModel> response = new ValidatedApiResponse <NewDatasetVersionResponseModel>(HttpStatusCode.OK, responseModel); CreateDatasetViewModel viewModel = new CreateDatasetViewModel { Description = "Description", Filename = "Filename.xlsx", Name = "Name", DataDefinitionId = "0123456789", FundingStreamId = "DSG" }; _apiClient .CreateNewDataset(Arg.Any <CreateNewDatasetModel>()) .Returns(response); // Act IActionResult result = await _controller.SaveDataset(viewModel); // Assert result .Should() .BeOfType <OkObjectResult>(); OkObjectResult objectResult = result as OkObjectResult; NewDatasetVersionResponseModel content = objectResult.Value as NewDatasetVersionResponseModel; content .DatasetId .Should() .Be("dataset-id"); }
public async Task <IActionResult> OnPostAsync(string specificationId, string calculationId) { Guard.IsNullOrWhiteSpace(specificationId, nameof(specificationId)); Specification specification = await GetSpecification(specificationId); IsAuthorizedToEdit = await _authorizationHelper.DoesUserHavePermission(User, specification, SpecificationActionTypes.CanEditSpecification); if (!IsAuthorizedToEdit) { return(new ForbidResult()); } if (!ModelState.IsValid) { return(await PopulateForm(specification, calculationId)); } CalculationUpdateModel updateModel = _mapper.Map <CalculationUpdateModel>(EditCalculationViewModel); ValidatedApiResponse <Calculation> editCalculationResponse = await _specsClient.UpdateCalculation(specificationId, calculationId, updateModel); if (editCalculationResponse.StatusCode == HttpStatusCode.OK) { Calculation editedCalculation = editCalculationResponse.Content; return(Redirect($"/specs/policies/{specificationId}?operationId={editedCalculation.Id}&operationType=CalculationUpdated")); } else if (editCalculationResponse.StatusCode == HttpStatusCode.BadRequest) { editCalculationResponse.AddValidationResultErrors(ModelState); await PopulateForm(specification, calculationId); return(Page()); } else { throw new InvalidOperationException($"Unable to edit calculation specification. Status Code = {editCalculationResponse.StatusCode}"); } }
public async Task <IActionResult> EditAdditionalCalculation(string specificationId, string calculationId, [FromBody] EditAdditionalCalculationViewModel vm) { Guard.ArgumentNotNull(specificationId, nameof(specificationId)); Guard.ArgumentNotNull(vm, nameof(vm)); if (!await _authorizationHelper.DoesUserHavePermission(User, specificationId, SpecificationActionTypes.CanEditCalculations)) { return(new ForbidResult()); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } CalculationEditModel editCalculation = _mapper.Map <CalculationEditModel>(vm); editCalculation.SpecificationId = specificationId; editCalculation.CalculationId = calculationId; editCalculation.Name = vm.CalculationName; editCalculation.ValueType = vm.ValueType; editCalculation.DataType = vm.DataType; ValidatedApiResponse <Calculation> response = await _calcClient.EditCalculation(specificationId, calculationId, editCalculation); if (response.IsBadRequest(out BadRequestObjectResult badRequest)) { return(badRequest); } if (response.StatusCode == HttpStatusCode.OK) { return(Ok(response.Content)); } else { throw new InvalidOperationException($"An error occurred while saving calculation. Status code={response.StatusCode}"); } }
public async Task <IActionResult> UpdateDatasetVersion([FromRoute] string fundingStreamId, [FromRoute] string datasetId, [FromBody] DatasetUpdateViewModel vm) { Guard.ArgumentNotNull(vm, nameof(vm)); if (!ModelState.IsValid) { return(BadRequest(ModelState)); } ValidatedApiResponse <NewDatasetVersionResponseModel> response = await _datasetApiClient.DatasetVersionUpdate(new DatasetVersionUpdateModel { DatasetId = datasetId, FundingStreamId = fundingStreamId, Filename = vm.Filename }); if (response.IsBadRequest(out BadRequestObjectResult badRequest)) { _logger.Warning("Invalid model provided"); return(badRequest); } else { if (!response.StatusCode.IsSuccess()) { int statusCode = (int)response.StatusCode; _logger.Error("Error when posting data set with status code: {statusCode}", statusCode); return(new InternalServerErrorResult($"Error when posting data set with status code: {statusCode}")); } } return(new OkObjectResult(response.Content)); }
public void EditCalculationStatus_GivenFailedStatusCodeFromApprovingCalc_ThrowsInvalidOperationException() { //Arrange string specificationId = "abc123"; string calculationId = "5"; PublishStatusEditModel model = new PublishStatusEditModel(); ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>(); ValidatedApiResponse <PublishStatusResult> response = new ValidatedApiResponse <PublishStatusResult>(HttpStatusCode.Forbidden); calcsClient .UpdatePublishStatus(Arg.Is(calculationId), Arg.Is(model)) .Returns(response); ValidatedApiResponse <Calculation> calculation = new ValidatedApiResponse <Calculation>(HttpStatusCode.OK, new Calculation() { FundingStreamId = "fs1", SpecificationId = specificationId }); calcsClient .GetCalculationById(Arg.Is(calculationId)) .Returns(calculation); IMapper mapper = MappingHelper.CreateFrontEndMapper(); IAuthorizationHelper authorizationHelper = TestAuthHelper.CreateAuthorizationHelperSubstitute(specificationId, SpecificationActionTypes.CanApproveAnyCalculations); CalculationController controller = CreateCalculationController(calcsClient, mapper, authorizationHelper, resultsApiClient); // Act Func <Task> test = async() => await controller.ApproveCalculation(specificationId, calculationId, model); // Assert test .Should() .Throw <InvalidOperationException>(); }
public async Task <ValidatedApiResponse <TResponse> > ValidatedPostAsync <TResponse, TRequest>(string url, TRequest request, CancellationToken cancellationToken = default(CancellationToken), TimeSpan?timeout = null) { if (url == null) { throw new ArgumentNullException(nameof(url)); } HttpClient httpClient = GetHttpClient(); if (timeout.HasValue) { httpClient.Timeout = timeout.Value; } string json = JsonConvert.SerializeObject(request, _serializerSettings); _logger.Debug($"ApiClient Validated POST: {{clientKey}}://{{url}} ({typeof(TRequest).Name} => {typeof(TResponse).Name})", _clientKey, url); using (HttpResponseMessage response = await httpClient.PostAsync(url, new StringContent(json, Encoding.UTF8, "application/json"), cancellationToken)) { if (response == null) { throw new HttpRequestException($"Unable to connect to server. Url={httpClient.BaseAddress.AbsoluteUri}{url}"); } if (response.IsSuccessStatusCode) { return(new ValidatedApiResponse <TResponse>(response.StatusCode, JsonConvert.DeserializeObject <TResponse>(await response.Content.ReadAsStringAsync(), _serializerSettings))); } ValidatedApiResponse <TResponse> apiResponse = new ValidatedApiResponse <TResponse>(response.StatusCode); if (apiResponse.StatusCode == HttpStatusCode.BadRequest) { apiResponse.ModelState = JsonConvert.DeserializeObject <IDictionary <string, IEnumerable <string> > >(await response.Content.ReadAsStringAsync(), _serializerSettings); } return(apiResponse); } }
public async Task SaveDataset_GivenResponseIsSuccess_ReturnsSuccess() { // Arrange NewDatasetVersionResponseModel responseModel = new NewDatasetVersionResponseModel { DatasetId = "dataset-id" }; ValidatedApiResponse <NewDatasetVersionResponseModel> response = new ValidatedApiResponse <NewDatasetVersionResponseModel>(HttpStatusCode.OK, responseModel); CreateDatasetViewModel viewModel = new CreateDatasetViewModel(); IDatasetsApiClient apiClient = CreateApiClient(); apiClient .CreateDataset(Arg.Any <CreateNewDatasetModel>()) .Returns(response); ILogger logger = CreateLogger(); DatasetController controller = CreateController(apiClient, logger); // Act IActionResult result = await controller.SaveDataset(viewModel); // Assert result .Should() .BeOfType <OkObjectResult>(); OkObjectResult objectResult = result as OkObjectResult; NewDatasetVersionResponseModel content = objectResult.Value as NewDatasetVersionResponseModel; content .DatasetId .Should() .Be("dataset-id"); }
public async Task RedirectToEditCalc_WhenValidRequestAndCalculationIsFound_ShouldRedirectToEditCalculationPage() { // Arrange const string calculationSpecificationId = "calcSpecId"; const string calculationIdReturned = "Calc55"; Calculation calculationReturned = new Calculation() { Id = calculationIdReturned }; ValidatedApiResponse <Calculation> apiResponse = new ValidatedApiResponse <Calculation>(HttpStatusCode.OK, calculationReturned); ICalculationsApiClient mockCalculationApiClient = Substitute.For <ICalculationsApiClient>(); mockCalculationApiClient .GetCalculationByCalculationSpecificationId(calculationSpecificationId) .Returns(apiResponse); IAuthorizationHelper mockAuthorizationHelper = TestAuthHelper.CreateAuthorizationHelperSubstitute("doesnt matter", SpecificationActionTypes.CanApproveSpecification); IMapper mockMapper = Substitute.For <IMapper>(); CalculationController controller = new CalculationController(mockCalculationApiClient, mockMapper, mockAuthorizationHelper); // Act IActionResult actionResult = await controller.RedirectToEditCalc(calculationSpecificationId); // Assert actionResult .Should() .BeOfType <RedirectResult>(); RedirectResult redirectResult = actionResult as RedirectResult; redirectResult .Url .Should() .EndWith($"calcs/editCalculation/{calculationIdReturned}"); }
public async Task <IActionResult> SaveDataset([FromBody] CreateDatasetViewModel vm) { Guard.ArgumentNotNull(vm.Name, nameof(vm.Name)); Guard.ArgumentNotNull(vm.Description, nameof(vm.Description)); Guard.ArgumentNotNull(vm.Filename, nameof(vm.Filename)); Guard.ArgumentNotNull(vm.FundingStreamId, nameof(vm.FundingStreamId)); Guard.ArgumentNotNull(vm.DataDefinitionId, nameof(vm.DataDefinitionId)); ValidatedApiResponse <NewDatasetVersionResponseModel> response = await _datasetApiClient.CreateNewDataset( new CreateNewDatasetModel { Name = vm.Name, DefinitionId = vm.DataDefinitionId, Description = vm.Description, Filename = vm.Filename, FundingStreamId = vm.FundingStreamId }); if (response.IsBadRequest(out BadRequestObjectResult badRequest)) { _logger.Warning("Invalid model provided"); return(badRequest); } else { if (!response.StatusCode.IsSuccess()) { int statusCode = (int)response.StatusCode; _logger.Error($"Error when posting data set with status code: {statusCode}"); return(new StatusCodeResult(statusCode)); } } return(new OkObjectResult(response.Content)); }
public async Task SaveDataset_GivenResponseIsInternalServerError_ReturnsStatusCode500() { // Arrange ValidatedApiResponse <NewDatasetVersionResponseModel> response = new ValidatedApiResponse <NewDatasetVersionResponseModel>(HttpStatusCode.InternalServerError); CreateDatasetViewModel viewModel = new CreateDatasetViewModel { Description = "Description", Filename = "Filename.xlsx", Name = "Name", DataDefinitionId = "0123456789", FundingStreamId = "DSG" }; _apiClient .CreateNewDataset(Arg.Any <CreateNewDatasetModel>()) .Returns(response); // Act IActionResult result = await _controller.SaveDataset(viewModel); // Assert _logger .Received(1) .Error(Arg.Is("Error when posting data set with status code: 500")); result .Should() .BeOfType <StatusCodeResult>(); StatusCodeResult statusCodeResult = result as StatusCodeResult; statusCodeResult .StatusCode .Should() .Be(500); }
public async Task <IActionResult> CreateDraftTemplate([FromBody] TemplateCreateModel createModel) { Guard.ArgumentNotNull(createModel, nameof(createModel)); if (!ModelState.IsValid) { return(BadRequest(ModelState)); } FundingStreamPermission permissions = await _authorizationHelper.GetUserFundingStreamPermissions(User, createModel.FundingStreamId); if (!permissions.CanCreateTemplates) { _logger.Error($"User [{User?.Identity?.Name}] has insufficient permissions to create a {createModel.FundingStreamId} template"); return(Forbid(new AuthenticationProperties())); } ValidatedApiResponse <string> result = await _client.CreateDraftTemplate(new TemplateCreateCommand { Description = createModel.Description, FundingStreamId = createModel.FundingStreamId, FundingPeriodId = createModel.FundingPeriodId, SchemaVersion = "1.1" }); switch (result.StatusCode) { case HttpStatusCode.Created: return(Created($"api/templates/build/{result.Content}", result.Content)); case HttpStatusCode.BadRequest: return(BadRequest(result.ModelState)); default: return(StatusCode((int)result.StatusCode)); } }
public async Task ValidateDataset_GivenViewModelButResponseIsBadRequestAndHasModelState_ReturnsStatusCode400() { // Arrange ValidateDatasetModel viewModel = new ValidateDatasetModel(); IDictionary <string, IEnumerable <string> > modelState = new Dictionary <string, IEnumerable <string> >(); modelState.Add("error", new List <string> { "an error occured" }); ValidatedApiResponse <DatasetValidationStatusModel> response = new ValidatedApiResponse <DatasetValidationStatusModel>(HttpStatusCode.BadRequest); response.ModelState = modelState; IDatasetsApiClient apiClient = CreateApiClient(); apiClient .ValidateDataset(Arg.Is(viewModel)) .Returns(response); ILogger logger = CreateLogger(); DatasetController controller = CreateController(apiClient, logger); // Act IActionResult result = await controller.ValidateDataset(viewModel); // Assert result .Should() .BeOfType <BadRequestObjectResult>(); logger .Received(1) .Warning(Arg.Is("Failed to validate dataset with status code: {statusCode}"), Arg.Is(HttpStatusCode.BadRequest)); }
public async Task EditCalculationStatus_GivenBadRequestStatusCodeFromApprovingCalc_ReturnsBadRequestObjectResponse() { //Arrange string specificationId = "abc123"; string calculationId = "5"; PublishStatusEditModel model = new PublishStatusEditModel(); ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>(); ValidatedApiResponse <PublishStatusResult> response = new ValidatedApiResponse <PublishStatusResult>(HttpStatusCode.BadRequest); calcsClient .UpdatePublishStatus(Arg.Is(calculationId), Arg.Is(model)) .Returns(response); ValidatedApiResponse <Calculation> calculation = new ValidatedApiResponse <Calculation>(HttpStatusCode.OK, new Calculation() { FundingStreamId = "fs1", SpecificationId = specificationId }); calcsClient .GetCalculationById(Arg.Is(calculationId)) .Returns(calculation); IMapper mapper = MappingHelper.CreateFrontEndMapper(); IAuthorizationHelper authorizationHelper = TestAuthHelper.CreateAuthorizationHelperSubstitute(specificationId, SpecificationActionTypes.CanApproveAnyCalculations); CalculationController controller = CreateCalculationController(calcsClient, mapper, authorizationHelper, resultsApiClient); IActionResult actionResult = await controller.ApproveCalculation(specificationId, calculationId, model); actionResult .Should() .BeOfType <BadRequestObjectResult>(); }
private async Task <Specification> GenerateSpecification(SpecGeneratorConfiguration configuration) { string periodId = configuration.PeriodId; if (string.IsNullOrWhiteSpace(periodId)) { ApiResponse <IEnumerable <Reference> > periodResponse = await _specsClient.GetFundingPeriods(); Reference firstPeriod = periodResponse.Content.First(); periodId = firstPeriod.Id; } IEnumerable <string> fundingStreamIds = configuration.FundingStreamIds; if (fundingStreamIds == null || !fundingStreamIds.Any()) { ApiResponse <IEnumerable <FundingStream> > fundingStreamResponse = await _specsClient.GetFundingStreams(); fundingStreamIds = new string[] { fundingStreamResponse.Content.First().Id }; } CreateSpecificationModel createModel = new CreateSpecificationModel() { Name = configuration.SpecificationName, FundingPeriodId = periodId, FundingStreamIds = fundingStreamIds, Description = "SpecGenerator " + DateTime.Now.ToLongDateString(), }; _logger.Information("Generating specification called '{Name}' in period '{FundingPeriodId}'", createModel.Name, createModel.FundingPeriodId); ValidatedApiResponse <Specification> specificationResult = await _specsClient.CreateSpecification(createModel); _logger.Information("Created Specification {Id}", specificationResult.Content.Id); return(specificationResult.Content); }
public async Task UpsertChannel(HttpStatusCode expectedStatusCode) { ChannelRequest request = new ChannelRequest { ChannelCode = "ABC", ChannelName = "ABC", UrlKey = "abc" }; string expectedUri = "releasemanagement/channels"; GivenTheStatusCode(expectedUri, expectedStatusCode, HttpMethod.Post); ValidatedApiResponse <Channel> response = await _client.UpsertChannel(request); response .Should() .NotBeNull(); response .StatusCode .Should() .Be(expectedStatusCode); }
public async Task <IActionResult> OnPostAsync(string fundingPeriodId = null) { if (!ModelState.IsValid) { await TaskHelper.WhenAllAndThrow(PopulateFundingPeriods(fundingPeriodId), PopulateFundingStreams()); IsAuthorizedToCreate = FundingStreams.Count() != 0; return(Page()); } CreateSpecificationModel specification = _mapper.Map <CreateSpecificationModel>(CreateSpecificationViewModel); if (!await _authorizationHelper.DoesUserHavePermission(User, specification.FundingStreamIds, FundingStreamActionTypes.CanCreateSpecification)) { return(new ForbidResult()); } ValidatedApiResponse <Specification> result = await _specsClient.CreateSpecification(specification); if (result.StatusCode.IsSuccess()) { return(Redirect($"/specs/policies/{result.Content.Id}?operationType=SpecificationCreated&operationId={result.Content.Id}")); } else if (result.StatusCode == HttpStatusCode.BadRequest) { result.AddValidationResultErrors(ModelState); await TaskHelper.WhenAllAndThrow(PopulateFundingPeriods(fundingPeriodId), PopulateFundingStreams()); return(Page()); } else { return(new InternalServerErrorResult($"Unable to create specification - result '{result.StatusCode}'")); } }
public void RedirectToEditCalc_WhenValidRequestButCalculationNotFoundResult_ShouldThrowException() { // Arrange const string calculationSpecificationId = "calcSpecId"; ValidatedApiResponse <Calculation> apiResponse = new ValidatedApiResponse <Calculation>(HttpStatusCode.NotFound); ICalculationsApiClient calculationsApiClient = Substitute.For <ICalculationsApiClient>(); calculationsApiClient .GetCalculationByCalculationSpecificationId(calculationSpecificationId) .Returns(apiResponse); IAuthorizationHelper mockAuthorizationHelper = TestAuthHelper.CreateAuthorizationHelperSubstitute("doesnt matter", SpecificationActionTypes.CanApproveSpecification); IMapper mockMapper = Substitute.For <IMapper>(); CalculationController controller = new CalculationController(calculationsApiClient, mockMapper, mockAuthorizationHelper); // Act Func <Task <IActionResult> > redirectToEditCalc = async() => await controller.RedirectToEditCalc(calculationSpecificationId); // Assert redirectToEditCalc.Should().Throw <ApplicationException>(); }
public async Task SaveDataset_GivenResponseIsInternalServerError_ReturnsStatusCode500() { // Arrange ValidatedApiResponse <NewDatasetVersionResponseModel> response = new ValidatedApiResponse <NewDatasetVersionResponseModel>(HttpStatusCode.InternalServerError); CreateDatasetViewModel viewModel = new CreateDatasetViewModel(); IDatasetsApiClient apiClient = CreateApiClient(); apiClient .CreateDataset(Arg.Any <CreateNewDatasetModel>()) .Returns(response); ILogger logger = CreateLogger(); DatasetController controller = CreateController(apiClient, logger); // Act IActionResult result = await controller.SaveDataset(viewModel); // Assert logger .Received(1) .Error(Arg.Is($"Error when posting data set with status code: 500")); result .Should() .BeOfType <StatusCodeResult>(); StatusCodeResult statusCodeResult = result as StatusCodeResult; statusCodeResult .StatusCode .Should() .Be(500); }
public async Task <IActionResult> OnPostAsync(string specificationId) { Guard.IsNullOrWhiteSpace(specificationId, nameof(specificationId)); Specification specification = await GetSpecification(specificationId); if (!await _authorizationHelper.DoesUserHavePermission(User, specification, SpecificationActionTypes.CanEditSpecification)) { return(new ForbidResult()); } if (!string.IsNullOrWhiteSpace(CreateCalculationViewModel.Name)) { ApiResponse <Calculation> existingCalculationResponse = await _specsClient .GetCalculationBySpecificationIdAndCalculationName(specificationId, CreateCalculationViewModel.Name); if (existingCalculationResponse.StatusCode != HttpStatusCode.NotFound) { this.ModelState.AddModelError($"{nameof(CreateCalculationViewModel)}.{nameof(CreateCalculationViewModel.Name)}", ValidationMessages.CalculationNameAlreadyExists); } } if (CreateCalculationViewModel.CalculationType == "Funding" && string.IsNullOrWhiteSpace(CreateCalculationViewModel.AllocationLineId)) { this.ModelState.AddModelError($"{nameof(CreateCalculationViewModel)}.{nameof(CreateCalculationViewModel.AllocationLineId)}", ValidationMessages.CalculationAllocationLineRequired); } if (!ModelState.IsValid) { SpecificationName = specification.Name; SpecificationId = specificationId; FundingPeriodName = specification.FundingPeriod.Name; FundingPeriodId = specification.FundingPeriod.Id; return(await PopulateForm(specification)); } CalculationCreateModel calculation = _mapper.Map <CalculationCreateModel>(CreateCalculationViewModel); calculation.SpecificationId = specificationId; ValidatedApiResponse <Calculation> newCalculationResponse = await _specsClient.CreateCalculation(calculation); if (newCalculationResponse.StatusCode == HttpStatusCode.OK) { Calculation newCalculation = newCalculationResponse.Content; return(Redirect($"/specs/policies/{specificationId}?operationType=CalculationCreated&operationId={newCalculation.Id}")); } else if (newCalculationResponse.StatusCode == HttpStatusCode.BadRequest) { newCalculationResponse.AddValidationResultErrors(ModelState); SpecificationName = specification.Name; SpecificationId = specificationId; FundingPeriodName = specification.FundingPeriod.Name; FundingPeriodId = specification.FundingPeriod.Id; return(await PopulateForm(specification)); } else { throw new InvalidOperationException($"Unable to create calculation specifications. Status Code = {newCalculationResponse.StatusCode}"); } }
public async Task EditCalculationStatus_GivenUserHaveCanApproveCalculationPermissionAndIsLastAuthor_ReturnsForbid() { //Arrange string specificationId = "abc123"; string calculationId = "5"; PublishStatusEditModel model = new PublishStatusEditModel() { PublishStatus = PublishStatus.Approved }; ValidatedApiResponse <Calculation> response = new ValidatedApiResponse <Calculation>(HttpStatusCode.OK, new Calculation() { FundingStreamId = "fs1", Author = new Reference() { Id = "SomeOne" }, SpecificationId = specificationId }); ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>(); calcsClient .GetCalculationById(Arg.Is(calculationId)) .Returns(response); calcsClient .UpdatePublishStatus(Arg.Is(calculationId), Arg.Is(model)) .Returns(new ValidatedApiResponse <PublishStatusResult>(HttpStatusCode.OK, new PublishStatusResult())); var identity = Substitute.For <IIdentity>(); identity.Name.Returns("BSir"); ClaimsPrincipal user = new ClaimsPrincipal(new List <ClaimsIdentity>() { new ClaimsIdentity(identity, new [] { new Claim("http://schemas.microsoft.com/identity/claims/objectidentifier", "SomeOne"), new Claim(ClaimTypes.GivenName, "Bob"), new Claim(ClaimTypes.Surname, "Sir") }) }); IMapper mapper = MappingHelper.CreateFrontEndMapper(); IAuthorizationHelper authorizationHelper = Substitute.For <IAuthorizationHelper>(); authorizationHelper.DoesUserHavePermission(Arg.Any <ClaimsPrincipal>(), Arg.Is(specificationId), Arg.Is(SpecificationActionTypes.CanApproveCalculations)) .Returns(true); CalculationController controller = CreateCalculationController(calcsClient, mapper, authorizationHelper, resultsApiClient, user); // Act IActionResult result = await controller.ApproveCalculation(specificationId, calculationId, model); // Assert result.Should() .BeOfType <ForbidResult>(); await authorizationHelper .Received(1) .DoesUserHavePermission(Arg.Is(user), Arg.Is(specificationId), Arg.Is(SpecificationActionTypes.CanApproveAnyCalculations)); await authorizationHelper .Received(1) .DoesUserHavePermission(Arg.Is(user), Arg.Is(specificationId), Arg.Is(SpecificationActionTypes.CanApproveCalculations)); }
public async Task EditCalculationStatus_GivenUserHaveCanApproveAnyCalculationPermissionAndCalcIsAlreadyApproved_ReturnsOK() { //Arrange string specificationId = "abc123"; string calculationId = "5"; PublishStatusEditModel model = new PublishStatusEditModel() { PublishStatus = PublishStatus.Approved }; ValidatedApiResponse <Calculation> response = new ValidatedApiResponse <Calculation>(HttpStatusCode.OK, new Calculation() { FundingStreamId = "fs1", SpecificationId = specificationId, }); ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>(); calcsClient .GetCalculationById(Arg.Is(calculationId)) .Returns(response); calcsClient .UpdatePublishStatus(Arg.Is(calculationId), Arg.Is(model)) .Returns(new ValidatedApiResponse <PublishStatusResult>(HttpStatusCode.OK, new PublishStatusResult() { PublishStatus = PublishStatus.Approved })); IMapper mapper = MappingHelper.CreateFrontEndMapper(); IAuthorizationHelper authorizationHelper = Substitute.For <IAuthorizationHelper>(); authorizationHelper .DoesUserHavePermission(Arg.Any <ClaimsPrincipal>(), Arg.Is(specificationId), Arg.Is(SpecificationActionTypes.CanApproveAnyCalculations)) .Returns(true); CalculationController controller = CreateCalculationController(calcsClient, mapper, authorizationHelper, resultsApiClient); // Act IActionResult result = await controller.ApproveCalculation(specificationId, calculationId, model); // Assert result.Should() .BeOfType <OkObjectResult>() .Which .Value .Should() .BeOfType <PublishStatusResult>() .Which .Should() .BeEquivalentTo(new PublishStatusResult() { PublishStatus = PublishStatus.Approved }); await authorizationHelper .Received(1) .DoesUserHavePermission(Arg.Any <ClaimsPrincipal>(), Arg.Is(specificationId), Arg.Is(SpecificationActionTypes.CanApproveAnyCalculations)); await authorizationHelper .Received(0) .DoesUserHavePermission(Arg.Any <ClaimsPrincipal>(), Arg.Is(specificationId), Arg.Is(SpecificationActionTypes.CanApproveCalculations)); }