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