public async Task <IActionResult> SaveCalculation(string specificationId, string calculationId, [FromBody] CalculationUpdateViewModel vm)
{
Guard.ArgumentNotNull(specificationId, nameof(specificationId));
Guard.ArgumentNotNull(calculationId, nameof(calculationId));
Guard.ArgumentNotNull(vm, nameof(vm));
if (!await _authorizationHelper.DoesUserHavePermission(User, specificationId, SpecificationActionTypes.CanEditCalculations))
{
return(new ForbidResult());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ApiResponse <Calculation> existingCalculationResponse = await _calcClient.GetCalculationById(calculationId);
IActionResult errorResult = existingCalculationResponse.IsSuccessOrReturnFailureResult("Calculation");
if (errorResult != null)
{
return(errorResult);
}
Calculation existingCalculation = existingCalculationResponse.Content;
CalculationEditModel update = new CalculationEditModel()
{
CalculationId = calculationId,
Description = existingCalculation.Description,
Name = existingCalculation.Name,
SpecificationId = specificationId,
ValueType = existingCalculation.ValueType,
SourceCode = vm.SourceCode,
};
ValidatedApiResponse <Calculation> response = await _calcClient.EditCalculation(specificationId, calculationId, update);
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 OnGet_WhenCalculationDoesNotExist_ThenNotFoundReturned()
{
// Arrange
ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>();
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
ILogger logger = Substitute.For <ILogger>();
Calculation expectedCalculation = null;
calcsClient
.GetCalculationById(Arg.Any <string>())
.Returns(new ApiResponse <Calculation>(System.Net.HttpStatusCode.NotFound, expectedCalculation));
string calculationId = "1";
ComparePageModel comparePageModel = new ComparePageModel(specsClient, calcsClient, mapper);
// Act
IActionResult result = await comparePageModel.OnGet(calculationId);
// Assert
result.Should().NotBeNull();
result.Should().BeOfType <NotFoundObjectResult>();
}
public async Task OnGet_WhenCalculationIdDoesNotExistThenNotFoundReturned()
{
// Arrange
ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>();
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
ILogger logger = Substitute.For <ILogger>();
Calculation expectedCalculation = null;
IEnumerable <int> versions = new List <int> {
1, 2
};
string calculationId = null;
calcsClient
.GetCalculationById(Arg.Any <string>())
.Returns(new ApiResponse <Calculation>(System.Net.HttpStatusCode.NotFound, expectedCalculation));
DiffCalculationModel diffCalcModel = new DiffCalculationModel(specsClient, calcsClient, mapper);
// Act
IActionResult result = await diffCalcModel.OnGet(versions, calculationId);
// Assert
result.Should().NotBeNull();
result.Should().BeOfType <BadRequestObjectResult>();
}
public async Task OnGet_WhenUserDoesHaveEditCalculationsPermission_ThenDoesUserHavePermissionToApproveOrEditIsTrue()
{
// Arrange
string calculationId = "5";
Calculation calcsCalculation = new Calculation()
{
SpecificationId = "abc123",
CalculationSpecification = new Reference {
Id = "cs345", Name = "calc name"
}
};
ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>();
calcsClient
.GetCalculationById(calculationId)
.Returns(new ApiResponse <Calculation>(System.Net.HttpStatusCode.OK, calcsCalculation));
IAuthorizationHelper authorizationHelper = Substitute.For <IAuthorizationHelper>();
authorizationHelper
.DoesUserHavePermission(Arg.Any <ClaimsPrincipal>(), Arg.Any <ISpecificationAuthorizationEntity>(), Arg.Is(SpecificationActionTypes.CanEditCalculations))
.Returns(true);
EditCalculationPageModel pageModel = CreatePageModel(calcsClient: calcsClient, authorizationHelper: authorizationHelper);
// Act
IActionResult result = await pageModel.OnGet("5");
// Assert
pageModel.DoesUserHavePermissionToApproveOrEdit.Should().Be("true");
}
public async Task <Calculation> GetCalculationById(string calculationId)
{
Guard.ArgumentNotNull(calculationId, nameof(calculationId));
ApiResponse <Calculation> apiResponse = await _calcsApiClient.GetCalculationById(calculationId);
return(apiResponse?.Content);
}
public async Task OnGet_WhenSpecCalculationDoesntExistThenErrorReturned()
{
// Arrange
ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>();
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
ILogger logger = Substitute.For <ILogger>();
Calculation expectedCalculation = new Calculation()
{
CalculationSpecification = new Reference("1", "Calc spec"),
Id = "2",
Name = "Specs Calculation",
FundingPeriodName = "2018/19",
SpecificationId = "3",
PublishStatus = PublishStatus.Draft,
LastModifiedBy = new Reference("1", "Matt Vallily"),
SourceCode = "Public Function GetProductResult(rid As String) As Decimal 'change to As String if text product Dim result As Decimal = 0 'change to As String if text product Dim P04_Learners As Decimal = products.1819_Additional_Funding.P04_Learner_Numbers Dim P03_Rate As Decimal = products.1819_Additional_Funding.P03_Maths_Top_Up_Rate result = P03_Rate * P04_learners Return result End Function",
Version = 4
};
IEnumerable <int> versions = new List <int> {
1, 2
};
string calculationId = "1";
Clients.SpecsClient.Models.CalculationCurrentVersion specCalculation = new Clients.SpecsClient.Models.CalculationCurrentVersion()
{
Id = "1",
Name = "Test spec",
Description = "Test description",
AllocationLine = new Reference("1", "Test Allocation")
};
calcsClient
.GetCalculationById(calculationId)
.Returns(new ApiResponse <Clients.CalcsClient.Models.Calculation>(System.Net.HttpStatusCode.OK, expectedCalculation));
specsClient
.GetCalculationById(calculationId, "3")
.Returns(new ApiResponse <Clients.SpecsClient.Models.CalculationCurrentVersion>(System.Net.HttpStatusCode.NotFound, specCalculation));
DiffCalculationModel diffCalcModel = new DiffCalculationModel(specsClient, calcsClient, mapper);
// Act
IActionResult result = await diffCalcModel.OnGet(versions, calculationId);
// Assert
result.Should().NotBeNull();
result.Should().BeOfType <NotFoundObjectResult>();
NotFoundObjectResult typeResult = result as NotFoundObjectResult;
typeResult.Value.Should().Be("Check the specification you entered - one or more of the specifications you entered aren't working");
}
private async Task PopulateCalculation(string calculationId)
{
ApiResponse <Clients.CalcsClient.Models.Calculation> calculation = await _calculationsApiClient.GetCalculationById(calculationId);
if (calculation != null || calculation.StatusCode == System.Net.HttpStatusCode.OK)
{
Calculation = _mapper.Map <ViewModels.Calculations.CalculationViewModel>(calculation.Content);
}
}
private void AndCalculationExistsForCalcId(string calculationId)
{
Calculation calculation = new Calculation()
{
CalculationType = Common.ApiClient.Calcs.Models.CalculationType.Additional,
ValueType = CalculationValueType.Currency,
};
_calculationsClient
.GetCalculationById(Arg.Is(calculationId))
.Returns(new ApiResponse <Calculation>(HttpStatusCode.OK, calculation));
}
public async Task <IActionResult> OnGet(string calculationId)
{
if (string.IsNullOrWhiteSpace(calculationId))
{
return(new BadRequestObjectResult(ErrorMessages.CalculationIdNullOrEmpty));
}
ViewData["GreyBackground"] = ShouldNewEditCalculationPageBeEnabled.ToString();
ApiResponse <Calculation> calculation = await _calcClient.GetCalculationById(calculationId);
if (calculation == null || calculation.StatusCode != HttpStatusCode.OK)
{
return(new NotFoundObjectResult(ErrorMessages.CalculationNotFoundInCalcsService));
}
this.DoesUserHavePermissionToApproveOrEdit = (await _authorizationHelper.DoesUserHavePermission(User, calculation.Content, SpecificationActionTypes.CanEditCalculations)).ToString().ToLowerInvariant();
ApiResponse <Clients.SpecsClient.Models.CalculationCurrentVersion> specCalculation = await _specsClient.GetCalculationById(calculation.Content.SpecificationId, calculation.Content.CalculationSpecification.Id);
if (specCalculation == null || specCalculation.StatusCode == HttpStatusCode.NotFound)
{
return(new NotFoundObjectResult(ErrorMessages.CalculationNotFoundInSpecsService));
}
Calculation = _mapper.Map <CalculationViewModel>(calculation.Content);
Calculation.Description = specCalculation.Content.Description;
SpecificationId = calculation.Content.SpecificationId;
EditModel = _mapper.Map <CalculationEditViewModel>(calculation.Content);
ApiResponse <Clients.SpecsClient.Models.SpecificationSummary> specificationResponse = await _specsClient.GetSpecificationSummary(SpecificationId);
if (specificationResponse != null && specificationResponse.StatusCode == HttpStatusCode.OK)
{
SpecificationName = specificationResponse.Content.Name;
}
else
{
SpecificationName = "Unknown";
}
if (ShouldNewEditCalculationPageBeEnabled)
{
ApiResponse <bool> hasCalculationResponse = await _resultsApiClient.HasCalculationResults(Calculation.Id);
if (hasCalculationResponse != null && hasCalculationResponse.StatusCode == HttpStatusCode.OK)
{
CalculationHasResults = hasCalculationResponse.Content;
}
}
return(Page());
}
public async Task SaveCalculation_OnSuccessfulSaveRequest_ThenResponseSentToClient()
{
// Arrange
ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
string specificationId = "1";
string calculationId = "5";
IAuthorizationHelper authorizationHelper = TestAuthHelper.CreateAuthorizationHelperSubstitute(specificationId, SpecificationActionTypes.CanEditCalculations);
CalculationController controller = CreateCalculationController(calcsClient, mapper, authorizationHelper, resultsApiClient);
CalculationUpdateViewModel updateViewModel = new CalculationUpdateViewModel()
{
SourceCode = "Updated source code"
};
Calculation existingCalculation = new Calculation()
{
Id = calculationId,
SpecificationId = specificationId,
SourceCode = "Existing source code"
};
calcsClient
.GetCalculationById(Arg.Is(calculationId))
.Returns(new ApiResponse <Calculation>(HttpStatusCode.OK, existingCalculation));
Calculation apiResultCalculation = new Calculation()
{
Id = calculationId,
SpecificationId = specificationId,
SourceCode = updateViewModel.SourceCode
};
calcsClient
.EditCalculation(specificationId, calculationId, Arg.Any <CalculationEditModel>())
.Returns(new ValidatedApiResponse <Common.ApiClient.Calcs.Models.Calculation>(HttpStatusCode.OK, apiResultCalculation));
// Act
IActionResult result = await controller.SaveCalculation(specificationId, calculationId, updateViewModel);
// Assert
result.Should().NotBeNull();
result.Should().BeOfType <OkObjectResult>();
OkObjectResult typedResult = result as OkObjectResult;
Calculation resultCalculation = typedResult.Value as Calculation;
resultCalculation?.SourceCode.Should().Be(updateViewModel.SourceCode);
}
public async Task EditCalculationStatus_GivenUserDoesNotHaveCanApproveAnyCalculationPermission_Returns403()
{
//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);
IMapper mapper = MappingHelper.CreateFrontEndMapper();
IAuthorizationHelper authorizationHelper = Substitute.For <IAuthorizationHelper>();
authorizationHelper.DoesUserHavePermission(Arg.Any <ClaimsPrincipal>(), Arg.Is(specificationId), Arg.Is(SpecificationActionTypes.CanEditCalculations))
.Returns(true);
authorizationHelper.GetUserFundingStreamPermissions(Arg.Any <ClaimsPrincipal>(), Arg.Any <string>())
.Returns(Task.FromResult(new Common.ApiClient.Users.Models.FundingStreamPermission()));
CalculationController controller = CreateCalculationController(calcsClient, mapper, authorizationHelper, resultsApiClient);
// Act
IActionResult result = await controller.ApproveCalculation(specificationId, calculationId, model);
// Assert
result.Should().BeOfType <ForbidResult>();
await authorizationHelper
.Received(1)
.DoesUserHavePermission(Arg.Any <ClaimsPrincipal>(), Arg.Is(specificationId), Arg.Is(SpecificationActionTypes.CanApproveAnyCalculations));
await authorizationHelper
.Received(1)
.DoesUserHavePermission(Arg.Any <ClaimsPrincipal>(), Arg.Is(specificationId), Arg.Is(SpecificationActionTypes.CanApproveCalculations));
}
public async Task OnGet_WhenCalculationExistdCalculationTypeIsFunding_ThenCalculationDisplayTypeIsFunding()
{
// Arrange
ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>();
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
string calculationId = "5";
Calculation calcsCalculation = new Calculation()
{
Id = calculationId,
CalculationSpecification = new Reference(calculationId, "Test Calculation Specification"),
SpecificationId = "54",
SourceCode = "Test Source Code",
CalculationType = Clients.SpecsClient.Models.CalculationSpecificationType.Funding
};
Clients.SpecsClient.Models.CalculationCurrentVersion specsCalculation = new Clients.SpecsClient.Models.CalculationCurrentVersion()
{
Id = calculationId,
Name = "Specs Calculation",
Description = "Spec Description",
};
calcsClient
.GetCalculationById(calculationId)
.Returns(new ApiResponse <Calculation>(System.Net.HttpStatusCode.OK, calcsCalculation));
specsClient
.GetCalculationById(calcsCalculation.SpecificationId, calculationId)
.Returns(new ApiResponse <Clients.SpecsClient.Models.CalculationCurrentVersion>(System.Net.HttpStatusCode.OK, specsCalculation));
EditCalculationPageModel pageModel = CreatePageModel(specsClient: specsClient, calcsClient: calcsClient, mapper: mapper);
// Act
IActionResult result = await pageModel.OnGet(calculationId);
// Assert
result.Should().NotBeNull();
result.Should().BeOfType <PageResult>();
pageModel.Calculation.Should().NotBeNull();
pageModel.Calculation.Name.Should().Be(calcsCalculation.Name);
pageModel.Calculation.Description.Should().Be(specsCalculation.Description);
pageModel.SpecificationId.Should().Be(calcsCalculation.SpecificationId);
pageModel.EditModel.SourceCode.Should().Be(calcsCalculation.SourceCode);
pageModel.Calculation.CalculationType.Should().Be(CalculationSpecificationTypeViewModel.Funding);
}
public async Task <IActionResult> OnGet(string calculationId)
{
if (string.IsNullOrWhiteSpace(calculationId))
{
return(new BadRequestObjectResult(ErrorMessages.CalculationIdNullOrEmpty));
}
ApiResponse <Calculation> calculationResponse = await _calcClient.GetCalculationById(calculationId);
if (calculationResponse == null)
{
return(new StatusCodeResult(500));
}
Calculation calculation = calculationResponse.Content;
if (calculation == null)
{
return(new NotFoundObjectResult(ErrorMessages.CalculationNotFoundInCalcsService));
}
ApiResponse <Clients.SpecsClient.Models.CalculationCurrentVersion> specCalculation = await _specsClient.GetCalculationById(calculation.SpecificationId, calculation.CalculationSpecification.Id);
if (specCalculation == null || specCalculation.StatusCode == System.Net.HttpStatusCode.NotFound)
{
return(new NotFoundObjectResult(ErrorMessages.CalculationNotFoundInSpecsService));
}
ApiResponse <IEnumerable <CalculationVersion> > calculationAllVersionsResponse = await _calcClient.GetAllVersionsByCalculationId(calculationId);
if (calculationAllVersionsResponse == null)
{
return(new StatusCodeResult(500));
}
List <CalculationVersionViewModel> calculationVersions = new List <CalculationVersionViewModel>();
foreach (CalculationVersion calculationVersion in calculationAllVersionsResponse.Content.OrderByDescending(c => c.Version, new VersionStringComparer()))
{
calculationVersions.Add(_mapper.Map <CalculationVersionViewModel>(calculationVersion));
}
Calculations = calculationVersions.AsEnumerable();
Calculation = _mapper.Map <CalculationViewModel>(calculation);
Calculation.Description = specCalculation.Content.Description;
return(Page());
}
public async Task EditCalculationStatus_GivenRequestContainsACalculationInADifferentSpecification_ReturnsError()
{
//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 = "anotherSpec"
});
ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>();
calcsClient
.GetCalculationById(Arg.Is(calculationId))
.Returns(response);
IMapper mapper = MappingHelper.CreateFrontEndMapper();
IAuthorizationHelper authorizationHelper = Substitute.For <IAuthorizationHelper>();
authorizationHelper.DoesUserHavePermission(Arg.Any <ClaimsPrincipal>(), Arg.Is(specificationId), Arg.Is(SpecificationActionTypes.CanEditCalculations))
.Returns(true);
authorizationHelper.GetUserFundingStreamPermissions(Arg.Any <ClaimsPrincipal>(), Arg.Any <string>())
.Returns(Task.FromResult(new Common.ApiClient.Users.Models.FundingStreamPermission()));
CalculationController controller = CreateCalculationController(calcsClient, mapper, authorizationHelper, resultsApiClient);
// Act
IActionResult result = await controller.ApproveCalculation(specificationId, calculationId, model);
// Assert
result
.Should()
.BeOfType <PreconditionFailedResult>()
.Which
.Value
.Should()
.Be("The calculation requested is not contained within the specification requested");
}
public async Task OnGet_WhenSpecificationDoesntExist_ThenErrorReturned()
{
ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>();
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
ILogger logger = Substitute.For <ILogger>();
string calculationId = "1";
Calculation expectedCalculation = new Calculation()
{
Id = "2",
Name = "Specs Calculation",
FundingPeriodName = "2018/19",
SpecificationId = "3",
PublishStatus = PublishStatus.Draft,
LastModifiedBy = new Reference("1", "Matt Vallily"),
SourceCode = "Public Function GetProductResult(rid As String) As Decimal 'change to As String if text product Dim result As Decimal = 0 'change to As String if text product Dim P04_Learners As Decimal = products.1819_Additional_Funding.P04_Learner_Numbers Dim P03_Rate As Decimal = products.1819_Additional_Funding.P03_Maths_Top_Up_Rate result = P03_Rate * P04_learners Return result End Function",
Version = 4
};
calcsClient
.GetCalculationById("2")
.Returns(new ApiResponse <Calculation>(System.Net.HttpStatusCode.OK, expectedCalculation));
Clients.SpecsClient.Models.CalculationCurrentVersion specCalculation = new Clients.SpecsClient.Models.CalculationCurrentVersion()
{
Id = "1",
Name = "Test spec",
Description = "Test description",
AllocationLine = new Reference("1", "Test Allocation")
};
specsClient
.GetCalculationById(calculationId, "3")
.Returns(new ApiResponse <CalculateFunding.Frontend.Clients.SpecsClient.Models.CalculationCurrentVersion>(System.Net.HttpStatusCode.NotFound, specCalculation));
ComparePageModel compPageModel = new ComparePageModel(specsClient, calcsClient, mapper);
// Act
IActionResult result = await compPageModel.OnGet(calculationId);
// Assert
result.Should().NotBeNull();
result.Should().BeOfType <StatusCodeResult>();
Assert.IsInstanceOfType(result, typeof(StatusCodeResult));
}
public async Task OnGet_WhenPublishedCalculationRequested_ThenSuccessfullyShown()
{
// Arrange
ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>();
ILogger logger = Substitute.For <ILogger>();
IFeatureToggle featureToggle = Substitute.For <IFeatureToggle>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
ICalculationSearchService calculationSearchService = Substitute.For <ICalculationSearchService>();
PagedResult <CalculationSearchResultItem> itemResult = GeneratePagedResult(10);
string publishedCalculationId = "15";
Calculation expectedPublishedCalculation = new Calculation()
{
Id = publishedCalculationId,
Name = "Published Calculation 5"
};
ApiResponse <Calculation> calculationResponse = new ApiResponse <Calculation>(System.Net.HttpStatusCode.OK, expectedPublishedCalculation);
calcsClient
.FindCalculations(Arg.Any <SearchFilterRequest>())
.Returns(itemResult);
calcsClient
.GetCalculationById(expectedPublishedCalculation.Id)
.Returns(calculationResponse);
IndexPageModel pageModel = new IndexPageModel(calcsClient, calculationSearchService, featureToggle);
// Act
IActionResult result = await pageModel.OnGetAsync(null, null, publishedCalculationId, null);
// Assert
pageModel.PublishedCalculation.Should().NotBeNull();
pageModel.PublishedCalculation.Name.Should().Be(expectedPublishedCalculation.Name);
pageModel
.ShouldViewResultsLinkBeEnabled
.Should()
.Be(false);
}
public void SaveCalculation_OnBackendError_ThenExceptionThrown()
{
// Arrange
ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
string specificationId = "1";
string calculationId = "5";
IAuthorizationHelper authorizationHelper = TestAuthHelper.CreateAuthorizationHelperSubstitute(specificationId, SpecificationActionTypes.CanEditCalculations);
CalculationController controller = CreateCalculationController(calcsClient, mapper, authorizationHelper, resultsApiClient);
calcsClient
.EditCalculation(specificationId, calculationId, Arg.Any <CalculationEditModel>())
.Returns(Task.FromResult(new ValidatedApiResponse <Calculation>(HttpStatusCode.ServiceUnavailable, null)));
Calculation existingCalculation = new Calculation()
{
Id = calculationId,
SpecificationId = specificationId,
SourceCode = "Existing source code"
};
calcsClient
.GetCalculationById(Arg.Is(calculationId))
.Returns(new ApiResponse <Calculation>(HttpStatusCode.OK, existingCalculation));
CalculationUpdateViewModel updateViewModel = new CalculationUpdateViewModel()
{
SourceCode = "Source code",
};
// Act
Action a = new Action(() =>
{
IActionResult result = controller.SaveCalculation(specificationId, calculationId, updateViewModel).Result;
});
// Assert
a.Should().Throw <InvalidOperationException>();
}
public async Task OnGet_WhenUserDoesNotHaveEditCalculationsPermission_ThenDoesUserHavePermissionToApproveOrEditIsFalse()
{
// Arrange
IMapper mapper = MappingHelper.CreateFrontEndMapper();
string calculationId = "5";
Calculation calcsCalculation = new Calculation()
{
SpecificationId = "abc123",
CalculationSpecification = new Reference {
Id = "cs345", Name = "calc name"
}
};
ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>();
calcsClient
.GetCalculationById(calculationId)
.Returns(new ApiResponse <Calculation>(System.Net.HttpStatusCode.OK, calcsCalculation));
IAuthorizationHelper authorizationHelper = Substitute.For <IAuthorizationHelper>();
authorizationHelper
.DoesUserHavePermission(Arg.Any <ClaimsPrincipal>(), Arg.Any <ISpecificationAuthorizationEntity>(), Arg.Is(SpecificationActionTypes.CanEditCalculations))
.Returns(false);
EditCalculationPageModel pageModel = CreatePageModel(calcsClient: calcsClient, mapper: mapper, authorizationHelper: authorizationHelper);
// Act
IActionResult result = await pageModel.OnGet(calculationId);
// Assert
pageModel.DoesUserHavePermissionToApproveOrEdit.Should().Be("false");
string shouldShowGreyBackground = pageModel.ViewData["GreyBackground"].ToString();
shouldShowGreyBackground
.Should()
.Be("False");
}
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 OnPostAsync_GivenCalculationCouldNotBeFound_ReturnsNotFound()
{
//Arrange
const string calculationId = "calc-id";
ApiResponse <Clients.CalcsClient.Models.Calculation> calculation = new ApiResponse <Clients.CalcsClient.Models.Calculation>(HttpStatusCode.NotFound);
ICalculationsApiClient calculationsApiClient = CreateCalculationsApiClient();
calculationsApiClient
.GetCalculationById(Arg.Is(calculationId))
.Returns(calculation);
CalculationProviderResultsPageModel pageModel = CreatePageModel(calculationsApiClient: calculationsApiClient);
//Act
IActionResult result = await pageModel.OnPostAsync(calculationId, null, "");
//Assert
result
.Should()
.BeOfType <NotFoundResult>();
}
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>();
}
public async Task OnGet_WhenSpecCalculationDoesNotExistThenNotFoundReturned()
{
// Arrange
ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
string calculationId = "5";
calcsClient.GetCalculationById(calculationId).Returns(new ApiResponse <Calculation>(System.Net.HttpStatusCode.OK, new Calculation()
{
Id = calculationId,
CalculationSpecification = new Reference("1", "Test Calculation Specification"),
SpecificationId = "54",
}));
EditCalculationPageModel pageModel = CreatePageModel(calcsClient: calcsClient, mapper: mapper);
// Act
IActionResult result = await pageModel.OnGet(calculationId);
// Assert
result.Should().NotBeNull();
result.Should().BeOfType <NotFoundObjectResult>();
}
public async Task <CalculationProviderResultSearchResultViewModel> PerformSearch(SearchRequestViewModel request)
{
int pageNumber = request.PageNumber.GetValueOrDefault(1);
int pageSize = request.PageSize.GetValueOrDefault(50);
ApiResponse <CalculationProviderResultSearchResults> searchRequestResult = await _resultsClient.SearchCalculationProviderResults(new SearchModel
{
PageNumber = pageNumber,
Top = pageSize,
SearchTerm = request.SearchTerm,
IncludeFacets = request.IncludeFacets,
ErrorToggle = string.IsNullOrWhiteSpace(request.ErrorToggle) ? (bool?)null : (request.ErrorToggle == "Errors"),
Filters = request.Filters,
SearchFields = request.SearchFields
});
if (searchRequestResult?.Content == null)
{
_logger.Error("Find providers HTTP request failed");
return(null);
}
CalculationProviderResultSearchResults calculationProviderResultSearchResults = searchRequestResult.Content;
CalculationProviderResultSearchResultViewModel result = new CalculationProviderResultSearchResultViewModel
{
TotalResults = calculationProviderResultSearchResults.TotalCount,
CurrentPage = pageNumber,
TotalErrorResults = calculationProviderResultSearchResults.TotalErrorCount
};
List <SearchFacetViewModel> searchFacets = new List <SearchFacetViewModel>();
if (calculationProviderResultSearchResults.Facets != null)
{
foreach (Facet facet in calculationProviderResultSearchResults.Facets)
{
searchFacets.Add(_mapper.Map <SearchFacetViewModel>(facet));
}
}
result.Facets = searchFacets.AsEnumerable();
List <CalculationProviderResultSearchResultItemViewModel> itemResults = new List <CalculationProviderResultSearchResultItemViewModel>();
Dictionary <string, CalculationValueTypeViewModel> calcTypes = new Dictionary <string, CalculationValueTypeViewModel>();
foreach (CalculationProviderResultSearchResult searchresult in calculationProviderResultSearchResults.Results)
{
CalculationProviderResultSearchResultItemViewModel vmResult = _mapper.Map <CalculationProviderResultSearchResultItemViewModel>(searchresult);
if (!calcTypes.ContainsKey(searchresult.CalculationId))
{
ApiResponse <Common.ApiClient.Calcs.Models.Calculation> calcResult = await _calculationsApiClient.GetCalculationById(searchresult.CalculationId);
if (calcResult == null || calcResult.Content == null || calcResult.StatusCode != System.Net.HttpStatusCode.OK)
{
throw new InvalidOperationException($"Unable to get calculation details for calculation ID '{searchresult.CalculationId}'");
}
CalculationValueTypeViewModel calculationValueTypeViewModel = _mapper.Map <CalculationValueTypeViewModel>(calcResult.Content.ValueType);
calcTypes.Add(searchresult.CalculationId, calculationValueTypeViewModel);
}
vmResult.SetCalculationResultDisplay(calcTypes[searchresult.CalculationId]);
itemResults.Add(vmResult);
}
result.CalculationProviderResults = itemResults.AsEnumerable();
if (result.TotalResults == 0)
{
result.StartItemNumber = 0;
result.EndItemNumber = 0;
}
else
{
result.StartItemNumber = ((pageNumber - 1) * pageSize) + 1;
result.EndItemNumber = result.StartItemNumber + pageSize - 1;
}
if (result.EndItemNumber > calculationProviderResultSearchResults.TotalCount)
{
result.EndItemNumber = calculationProviderResultSearchResults.TotalCount;
}
result.PagerState = new PagerState(pageNumber, (int)Math.Ceiling(calculationProviderResultSearchResults.TotalCount / (double)pageSize), 4);
return(result);
}
public async Task OnGet_WhenCalculationExists_ThenCalculationReturned()
{
// Arrange
ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>();
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
ILogger logger = Substitute.For <ILogger>();
string calculationId = "1";
Calculation expectedCalculation = new Calculation()
{
Id = "1",
Name = "Specs Calculation",
FundingPeriodName = "2018/19",
SpecificationId = "3",
PublishStatus = PublishStatus.Draft,
LastModifiedBy = new Reference("1", "Matt Vallily"),
SourceCode = "Public Function GetProductResult(rid As String) As Decimal 'change to As String if text product Dim result As Decimal = 0 'change to As String if text product Dim P04_Learners As Decimal = products.1819_Additional_Funding.P04_Learner_Numbers Dim P03_Rate As Decimal = products.1819_Additional_Funding.P03_Maths_Top_Up_Rate result = P03_Rate * P04_learners Return result End Function",
Version = 4,
CalculationSpecification = new Reference("1", "Test Spec")
};
calcsClient
.GetCalculationById(calculationId)
.Returns(new ApiResponse <Calculation>(System.Net.HttpStatusCode.OK, expectedCalculation));
Clients.SpecsClient.Models.CalculationCurrentVersion specCalculation = new Clients.SpecsClient.Models.CalculationCurrentVersion()
{
Id = "1",
Name = "Test spec",
Description = "Test description",
AllocationLine = new Reference("1", "Test Allocation")
};
specsClient
.GetCalculationById(expectedCalculation.SpecificationId, calculationId)
.Returns(new ApiResponse <Clients.SpecsClient.Models.CalculationCurrentVersion>(System.Net.HttpStatusCode.OK, specCalculation));
CalculationVersion calcsVersion1 = new CalculationVersion()
{
Status = "Draft",
Version = "1",
DecimalPlaces = 4,
Date = new DateTime(2018, 1, 1, 12, 34, 45, 03),
Author = new Reference("1", "Matt Vallily"),
SourceCode = "Public Function GetProductResult(rid As String) As Decimal 'change to As String if text product Dim result As Decimal = 0 'change to As String if text product Dim P04_Learners As Decimal = products.1819_Additional_Funding.P04_Learner_Numbers Dim P03_Rate As Decimal = products.1819_Additional_Funding.P03_Maths_Top_Up_Rate result = P03_Rate * P04_learners Return result End Function",
};
CalculationVersion calcsVersion2 = new CalculationVersion()
{
Status = "Draft",
Version = "2",
DecimalPlaces = 4,
Date = new DateTime(2018, 1, 2, 12, 34, 45, 03),
Author = new Reference("1", "Matt Vallily"),
SourceCode = "Public Function GetProductResult(rid As String) As Decimal 'change to As String if text product Dim result As Decimal = 0 'change to As String if text product Dim P04_Learners As Decimal = products.1819_Additional_Funding.P04_Learner_Numbers Dim P03_Rate As Decimal = products.1819_Additional_Funding.P03_Maths_Top_Up_Rate result = P03_Rate * P04_learners Return result End Function",
};
CalculationVersion calcsVersion3 = new CalculationVersion()
{
Status = "Draft",
Version = "3",
DecimalPlaces = 4,
Date = new DateTime(2018, 1, 3, 12, 34, 45, 03),
Author = new Reference("1", "Matt Vallily"),
SourceCode = "Public Function GetProductResult(rid As String) As Decimal 'change to As String if text product Dim result As Decimal = 0 'change to As String if text product Dim P04_Learners As Decimal = products.1819_Additional_Funding.P04_Learner_Numbers Dim P03_Rate As Decimal = products.1819_Additional_Funding.P03_Maths_Top_Up_Rate result = P03_Rate * P04_learners Return result End Function",
};
IEnumerable <CalculationVersion> calculationVersion = new List <CalculationVersion>()
{
calcsVersion1,
calcsVersion2,
calcsVersion3
};
calcsClient
.GetAllVersionsByCalculationId(calculationId)
.Returns(new ApiResponse <IEnumerable <CalculationVersion> >(System.Net.HttpStatusCode.OK, calculationVersion));
ComparePageModel comparePageModel = new ComparePageModel(specsClient, calcsClient, mapper);
// Act
IActionResult result = await comparePageModel.OnGet(calculationId);
// Assert
result.Should().NotBeNull();
comparePageModel.Calculation.Should().NotBeNull();
comparePageModel.Calculation.Description.Should().Be(specCalculation.Description);
comparePageModel.Calculation.Name.Should().Be(expectedCalculation.Name);
comparePageModel.Calculations.Select(f => f.Version).Should().BeInDescendingOrder();
comparePageModel.Calculations.Should().HaveCount(3);
ViewModels.Calculations.CalculationVersionViewModel firstCalculation = comparePageModel.Calculations.First();
firstCalculation.Version.Should().Be(calcsVersion3.Version);
}
public async Task OnGet_WhenCalculationHasManyVersions_ThenReturnsVersionsInDescendingOrder()
{
// Arrange
ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>();
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
ILogger logger = Substitute.For <ILogger>();
string calculationId = "1";
Calculation expectedCalculation = new Calculation()
{
Id = "1",
Name = "Specs Calculation",
FundingPeriodName = "2018/19",
SpecificationId = "3",
PublishStatus = PublishStatus.Draft,
LastModifiedBy = new Reference("1", "Matt Vallily"),
SourceCode = "Public Function GetProductResult(rid As String) As Decimal 'change to As String if text product Dim result As Decimal = 0 'change to As String if text product Dim P04_Learners As Decimal = products.1819_Additional_Funding.P04_Learner_Numbers Dim P03_Rate As Decimal = products.1819_Additional_Funding.P03_Maths_Top_Up_Rate result = P03_Rate * P04_learners Return result End Function",
Version = 10,
CalculationSpecification = new Reference("1", "Test Spec")
};
calcsClient
.GetCalculationById(calculationId)
.Returns(new ApiResponse <Calculation>(System.Net.HttpStatusCode.OK, expectedCalculation));
Clients.SpecsClient.Models.CalculationCurrentVersion specCalculation = new Clients.SpecsClient.Models.CalculationCurrentVersion()
{
Id = "1",
Name = "Test spec",
Description = "Test description",
AllocationLine = new Reference("1", "Test Allocation")
};
specsClient
.GetCalculationById(expectedCalculation.SpecificationId, calculationId)
.Returns(new ApiResponse <Clients.SpecsClient.Models.CalculationCurrentVersion>(System.Net.HttpStatusCode.OK, specCalculation));
List <CalculationVersion> calculationVersions = new List <CalculationVersion>();
DateTime startCalcTime = DateTime.UtcNow.AddDays(-1);
for (int i = 1; i < 11; i++)
{
calculationVersions.Add(new CalculationVersion()
{
Status = "Draft",
Version = i.ToString(),
DecimalPlaces = 4,
Date = startCalcTime.AddHours(i),
Author = new Reference("1", "Matt Vallily"),
SourceCode = "Public Function GetProductResult(rid As String) As Decimal 'change to As String if text product Dim result As Decimal = 0 'change to As String if text product Dim P04_Learners As Decimal = products.1819_Additional_Funding.P04_Learner_Numbers Dim P03_Rate As Decimal = products.1819_Additional_Funding.P03_Maths_Top_Up_Rate result = P03_Rate * P04_learners Return result End Function",
});
}
calcsClient
.GetAllVersionsByCalculationId(calculationId)
.Returns(new ApiResponse <IEnumerable <CalculationVersion> >(System.Net.HttpStatusCode.OK, calculationVersions));
ComparePageModel comparePageModel = new ComparePageModel(specsClient, calcsClient, mapper);
// Act
IActionResult result = await comparePageModel.OnGet(calculationId);
// Assert
result.Should().NotBeNull();
comparePageModel.Calculations.Should().HaveCount(10);
comparePageModel.Calculations.Select(f => int.Parse(f.Version)).Should().BeInDescendingOrder();
}
public async Task OnGet_WhencalculationVersionsListReturned()
{
// Arrange
ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>();
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
ILogger logger = Substitute.For <ILogger>();
Calculation expectedCalculation = new Calculation()
{
CalculationSpecification = new Reference("1", "Calc spec"),
Id = "2",
Name = "Specs Calculation",
FundingPeriodName = "2018/19",
SpecificationId = "1",
PublishStatus = PublishStatus.Draft,
LastModifiedBy = new Reference("1", "Matt Vallily"),
SourceCode = "Public Function GetProductResult(rid As String) As Decimal 'change to As String if text product Dim result As Decimal = 0 'change to As String if text product Dim P04_Learners As Decimal = products.1819_Additional_Funding.P04_Learner_Numbers Dim P03_Rate As Decimal = products.1819_Additional_Funding.P03_Maths_Top_Up_Rate result = P03_Rate * P04_learners Return result End Function",
Version = 4
};
IEnumerable <int> versions = new List <int> {
1, 2
};
string calculationId = "1";
Clients.SpecsClient.Models.CalculationCurrentVersion specCalculation = new Clients.SpecsClient.Models.CalculationCurrentVersion()
{
Id = "1",
Name = "Test spec",
Description = "Test description",
AllocationLine = new Reference("1", "Test Allocation")
};
// build two versions for feeding the left and right panel
CalculationVersion calver1 = new CalculationVersion()
{
DecimalPlaces = 2,
Version = "1",
Date = new DateTime(2018, 1, 1, 10, 23, 34),
Author = new Reference("1", "Clifford"),
Status = "Draft",
SourceCode = "Test"
};
CalculationVersion calver2 = new CalculationVersion()
{
DecimalPlaces = 2,
Version = "2",
Date = new DateTime(2018, 1, 1, 10, 23, 34),
Author = new Reference("2", "Clifford"),
Status = "Draft",
SourceCode = "Test"
};
IEnumerable <CalculationVersion> calcVerArray = new List <CalculationVersion> {
calver1, calver2
};
calcVerArray.AsEnumerable();
calcsClient
.GetCalculationById(calculationId)
.Returns(new ApiResponse <Clients.CalcsClient.Models.Calculation>(System.Net.HttpStatusCode.OK, expectedCalculation));
specsClient
.GetCalculationById("1", calculationId)
.Returns(new ApiResponse <CalculateFunding.Frontend.Clients.SpecsClient.Models.CalculationCurrentVersion>(System.Net.HttpStatusCode.OK, specCalculation)); // CalculateFunding.Frontend.Clients.SpecsClient.Models
calcsClient
.GetMultipleVersionsByCalculationId(versions, calculationId)
.Returns(new ApiResponse <IEnumerable <CalculationVersion> >(System.Net.HttpStatusCode.OK, calcVerArray));
DiffCalculationModel diffCalcPageModel = new DiffCalculationModel(specsClient, calcsClient, mapper);
// Act
IActionResult result = await diffCalcPageModel.OnGet(versions, calculationId);
// Assert
result.Should().NotBeNull();
diffCalcPageModel.RightCalculationDiffModel.Version.Should().Be(calver2.Version);
diffCalcPageModel.LeftCalcualationDiffModel.Version.Should().Be(calver1.Version);
}
public async Task OnPostAsync_GivenCalculationFoundButGettingAssignedSchemasForSpecRetunsOKWithNullContent_ReturnsStatusCode500()
{
const string calculationId = "calc-id";
const string specificationId = "spec-id";
Calculation calculation = new Calculation
{
Id = calculationId,
SpecificationId = specificationId
};
CalculationViewModel calculationViewModel = new CalculationViewModel
{
Id = calculationId,
SpecificationId = specificationId
};
ApiResponse <Calculation> CalculationResponse = new ApiResponse <Calculation>(HttpStatusCode.OK, calculation);
ICalculationsApiClient calculationsApiClient = CreateCalculationsApiClient();
calculationsApiClient
.GetCalculationById(Arg.Is(calculationId))
.Returns(CalculationResponse);
IMapper mapper = CreateMapper();
mapper
.Map <CalculationViewModel>(Arg.Is(calculation))
.Returns(calculationViewModel);
ICalculationProviderResultsSearchService calculationProviderResultsSearchService = CreateResultsSearchService();
IEnumerable <DatasetSchemasAssigned> datasetSchemasAssignedList = new[]
{
new DatasetSchemasAssigned
{
IsSetAsProviderData = true
}
};
ApiResponse <IEnumerable <DatasetSchemasAssigned> > datasetSchemaResponse = new ApiResponse <IEnumerable <DatasetSchemasAssigned> >(HttpStatusCode.OK);
IDatasetsApiClient datasetsApiClient = CreateDatasetsApiClient();
datasetsApiClient
.GetAssignedDatasetSchemasForSpecification(Arg.Is(specificationId))
.Returns(datasetSchemaResponse);
ISpecsApiClient specsApiClient = CreateSpecsApiClient();
specsApiClient.GetSpecificationSummaries(Arg.Any <IEnumerable <string> >())
.Returns(new ApiResponse <IEnumerable <Clients.SpecsClient.Models.SpecificationSummary> >(HttpStatusCode.OK, Enumerable.Empty <Clients.SpecsClient.Models.SpecificationSummary>()));
Clients.SpecsClient.Models.SpecificationSummary specificationSummary = new Clients.SpecsClient.Models.SpecificationSummary()
{
Id = specificationId,
};
specsApiClient
.GetSpecificationSummary(Arg.Is(specificationId))
.Returns(new ApiResponse <Clients.SpecsClient.Models.SpecificationSummary>(HttpStatusCode.OK, specificationSummary));
CalculationProviderResultsPageModel pageModel = CreatePageModel(
calculationProviderResultsSearchService,
calculationsApiClient,
mapper: mapper,
datasetsApiClient: datasetsApiClient,
specsApiClient: specsApiClient);
//Act
IActionResult result = await pageModel.OnPostAsync(calculationId, null, "");
//Assert
result
.Should()
.BeOfType <StatusCodeResult>();
StatusCodeResult statusCodeResult = result as StatusCodeResult;
statusCodeResult
.StatusCode
.Should()
.Be(500);
}
public async Task OnGetAsync_GivenCalculationFoundWithEmptySearchResults_ReturnsPage()
{
//Arrange
const string calculationId = "calc-id";
const string specificationId = "spec-id";
Calculation calculation = new Calculation
{
Id = calculationId,
SpecificationId = specificationId
};
CalculationViewModel calculationViewModel = new CalculationViewModel
{
Id = calculationId,
SpecificationId = specificationId
};
IEnumerable <DatasetSchemasAssigned> datasetSchemasAssignedList = new[]
{
new DatasetSchemasAssigned
{
IsSetAsProviderData = true
}
};
ApiResponse <IEnumerable <DatasetSchemasAssigned> > datasetSchemaResponse = new ApiResponse <IEnumerable <DatasetSchemasAssigned> >(HttpStatusCode.OK, datasetSchemasAssignedList);
IDatasetsApiClient datasetsApiClient = CreateDatasetsApiClient();
datasetsApiClient
.GetAssignedDatasetSchemasForSpecification(Arg.Is(specificationId))
.Returns(datasetSchemaResponse);
CalculationProviderResultSearchResultViewModel calculationProviderResultSearchResultViewModel = new CalculationProviderResultSearchResultViewModel
{
CalculationProviderResults = Enumerable.Empty <CalculationProviderResultSearchResultItemViewModel>()
};
ApiResponse <Calculation> CalculationResponse = new ApiResponse <Calculation>(HttpStatusCode.OK, calculation);
ICalculationsApiClient calculationsApiClient = CreateCalculationsApiClient();
calculationsApiClient
.GetCalculationById(Arg.Is(calculationId))
.Returns(CalculationResponse);
IMapper mapper = CreateMapper();
mapper
.Map <CalculationViewModel>(Arg.Is(calculation))
.Returns(calculationViewModel);
ICalculationProviderResultsSearchService calculationProviderResultsSearchService = CreateResultsSearchService();
calculationProviderResultsSearchService
.PerformSearch(Arg.Any <SearchRequestViewModel>())
.Returns(calculationProviderResultSearchResultViewModel);
ISpecsApiClient specsApiClient = CreateSpecsApiClient();
specsApiClient.GetSpecificationSummaries(Arg.Any <IEnumerable <string> >())
.Returns(new ApiResponse <IEnumerable <Clients.SpecsClient.Models.SpecificationSummary> >(HttpStatusCode.OK, Enumerable.Empty <Clients.SpecsClient.Models.SpecificationSummary>()));
Clients.SpecsClient.Models.SpecificationSummary specificationSummary = new Clients.SpecsClient.Models.SpecificationSummary()
{
Id = specificationId,
};
specsApiClient
.GetSpecificationSummary(Arg.Is(specificationId))
.Returns(new ApiResponse <Clients.SpecsClient.Models.SpecificationSummary>(HttpStatusCode.OK, specificationSummary));
CalculationProviderResultsPageModel pageModel = CreatePageModel(
calculationProviderResultsSearchService,
calculationsApiClient,
mapper: mapper,
datasetsApiClient: datasetsApiClient,
specsApiClient: specsApiClient);
//Act
IActionResult result = await pageModel.OnGetAsync(calculationId, null, "");
//Assert
result
.Should()
.BeOfType <PageResult>();
pageModel
.CalculationProviderResults
.CalculationProviderResults
.Any()
.Should()
.BeFalse();
}
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));
}
