public async Task PoliciesPageModel_OnGet_WhenSpecificationsApiFailed_ThenErrorShouldBeReturned()
{
// Arrange
ISpecsApiClient specsApiClient = CreateSpecsApiClient();
IDatasetsApiClient datasetsApiClient = CreateDatasetsApiClient();
PoliciesModel policiesModel = GetPoliciesModel(specsApiClient, datasetsApiClient);
string specificationId = "spec123";
specsApiClient.GetSpecification(Arg.Any <string>())
.Returns(new ApiResponse <Specification>(HttpStatusCode.InternalServerError, null));
datasetsApiClient
.GetAssignedDatasetSchemasForSpecification(specificationId)
.Returns(new ApiResponse <IEnumerable <DatasetSchemasAssigned> >(HttpStatusCode.OK, Enumerable.Empty <DatasetSchemasAssigned>()));
// Act
IActionResult result = await policiesModel.OnGet(specificationId, null, null);
// Assert
result.Should().BeOfType <ObjectResult>()
.Which.Value.Should().Be("Specification Lookup API Failed");
result.Should().BeOfType <ObjectResult>()
.Which.StatusCode.Should().Be(500);
}
public async Task <IActionResult> OnGetAsync(string specificationId, string fundingPeriodId, string fundingStreamId)
{
Guard.IsNullOrWhiteSpace(specificationId, nameof(specificationId));
Guard.IsNullOrWhiteSpace(fundingPeriodId, nameof(fundingPeriodId));
Guard.IsNullOrWhiteSpace(fundingStreamId, nameof(fundingStreamId));
SpecificationId = specificationId;
FundingPeriodId = fundingPeriodId;
FundingStreamId = fundingStreamId;
ApiResponse <Specification> specificationLookupTask = await _specsClient.GetSpecification(specificationId);
IActionResult specificationLookupError = specificationLookupTask.IsSuccessOrReturnFailureResult("Specification");
if (specificationLookupError == null)
{
SpecificationViewModel = new SpecificationSummaryViewModel
{
Name = specificationLookupTask.Content.Name,
FundingStreams = specificationLookupTask.Content.FundingStreams.Select(m => new ReferenceViewModel(m.Id, m.Name)),
FundingPeriod = new ReferenceViewModel(specificationLookupTask.Content.FundingPeriod.Id, specificationLookupTask.Content.FundingPeriod.Name)
};
return(Page());
}
else
{
return(specificationLookupError);
}
}
public async Task PoliciesPageModel_OnGet_WhenOperationTypeIsSpecifiedButNoOperationId_ThenPrecondionFailedReturned()
{
// Arrange
ISpecsApiClient specsApiClient = CreateSpecsApiClient();
IDatasetsApiClient datasetsApiClient = CreateDatasetsApiClient();
PoliciesModel policiesModel = GetPoliciesModel(specsApiClient, datasetsApiClient);
string specificationId = "spec123";
Specification specification = CreateSpecificationForBannerChecks(specificationId);
specsApiClient.GetSpecification(Arg.Any <string>())
.Returns(new ApiResponse <Specification>(HttpStatusCode.OK, specification));
datasetsApiClient
.GetAssignedDatasetSchemasForSpecification(specificationId)
.Returns(new ApiResponse <IEnumerable <DatasetSchemasAssigned> >(HttpStatusCode.OK, Enumerable.Empty <DatasetSchemasAssigned>()));
// Act
IActionResult result = await policiesModel.OnGet(specificationId, PoliciesPageBannerOperationType.CalculationUpdated, null);
// Assert
result
.Should()
.BeOfType <PreconditionFailedResult>()
.Which
.Value
.Should()
.Be("Operation ID not provided");
}
public async Task OnPostAsync_GivenUserDoesNotHaveEditSpecificationPermission_ThenForbidResultReturned()
{
// Arrange
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
specsClient
.GetSpecification(Arg.Is(specificationId))
.Returns(new ApiResponse <Specification>(HttpStatusCode.OK, new Specification {
Id = specificationId
}));
IAuthorizationHelper authorizationHelper = Substitute.For <IAuthorizationHelper>();
authorizationHelper
.DoesUserHavePermission(Arg.Any <ClaimsPrincipal>(), Arg.Any <ISpecificationAuthorizationEntity>(), Arg.Is(SpecificationActionTypes.CanEditSpecification))
.Returns(false);
EditSpecificationPageModel pageModel = CreatePageModel(specsClient: specsClient, authorizationHelper: authorizationHelper);
// Act
IActionResult result = await pageModel.OnPostAsync(specificationId);
// Assert
pageModel
.IsAuthorizedToEdit
.Should().BeFalse();
result.Should().BeOfType <ForbidResult>();
}
public async Task PoliciesPageModel_OnGet_WhenUserHasApproveSpecificationPermission_ThenDoesUserHavePermissionToApproveIsTrue()
{
// Arrange
ISpecsApiClient specsApiClient = CreateSpecsApiClient();
IDatasetsApiClient datasetsApiClient = CreateDatasetsApiClient();
PoliciesModel policiesModel = GetPoliciesModel(specsApiClient, datasetsApiClient);
string specificationId = "spec123";
Specification specification = new Specification()
{
Id = specificationId,
Name = "Test Specification",
FundingPeriod = new Reference("1617", "2016/2017"),
Description = "Test Description",
FundingStreams = new List <FundingStream>()
{
new FundingStream("fs1", "Funding Stream Name"),
}
};
specsApiClient.GetSpecification(Arg.Any <string>())
.Returns(new ApiResponse <Specification>(HttpStatusCode.OK, specification));
datasetsApiClient
.GetAssignedDatasetSchemasForSpecification(specificationId)
.Returns(new ApiResponse <IEnumerable <DatasetSchemasAssigned> >(HttpStatusCode.OK, Enumerable.Empty <DatasetSchemasAssigned>()));
// Act
IActionResult result = await policiesModel.OnGet(specificationId, null, null);
// Assert
policiesModel.DoesUserHavePermissionToApprove.Should().Be("true");
}
public async Task ListDatasetSchemasModel_OnGet_WhenUnableToRetrieveSpecificationThenStatusCode500Returned()
{
// Arrange
IDatasetsApiClient datasetClient = Substitute.For <IDatasetsApiClient>();
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
ILogger logger = Substitute.For <ILogger>();
string expectedSpecificationId = "1";
Specification expectedSpecification = null;
specsClient
.GetSpecification(Arg.Any <string>())
.Returns(new ApiResponse <Specification>(HttpStatusCode.BadRequest, expectedSpecification));
ListDatasetSchemasModel listDatasetSchemasPageModel = new ListDatasetSchemasModel(specsClient, datasetClient, mapper);
// Act
IActionResult result = await listDatasetSchemasPageModel.OnGet(expectedSpecificationId);
// Assert
result.Should().NotBeNull();
result.Should().BeOfType <StatusCodeResult>().Which.StatusCode.Should().Be(500);
}
public async Task OnGetAsync_GivenSpecificationCouldNotBeFound_ReturnsPreconditionFailed()
{
//Arrange
ApiResponse <Specification> apiResponse = new ApiResponse <Specification>(HttpStatusCode.NotFound);
ISpecsApiClient specsClient = CreateSpecsApiClient();
specsClient
.GetSpecification(Arg.Is(specificationId))
.Returns(apiResponse);
CreateCalculationPageModel pageModel = CreatePageModel(specsClient);
//Act
IActionResult result = await pageModel.OnGetAsync(specificationId);
//Assert
result
.Should()
.NotBeNull();
result
.Should()
.BeAssignableTo <PreconditionFailedResult>()
.Which
.Value
.Should()
.Be("Specification not found");
}
public async Task <IActionResult> OnGetAsync(string specificationId)
{
Guard.IsNullOrWhiteSpace(specificationId, nameof(specificationId));
ApiResponse <Specification> specificationResponse = await _specsClient.GetSpecification(specificationId);
if (specificationResponse.StatusCode == HttpStatusCode.OK && specificationResponse.Content != null)
{
EditSpecificationViewModel = _mapper.Map <EditSpecificationViewModel>(specificationResponse.Content);
IsAuthorizedToEdit = await _authorizationHelper.DoesUserHavePermission(User,
specificationResponse.Content, SpecificationActionTypes.CanEditSpecification);
EditSpecificationViewModel.OriginalSpecificationName = specificationResponse.Content.Name;
EditSpecificationViewModel.OriginalFundingStreams = string.Join(",", EditSpecificationViewModel.FundingStreamIds);
EditSpecificationViewModel.OriginalFundingPeriodId = EditSpecificationViewModel.FundingPeriodId;
await TaskHelper.WhenAllAndThrow(PopulateFundingPeriods(EditSpecificationViewModel.FundingPeriodId), PopulateFundingStreams(EditSpecificationViewModel.FundingStreamIds));
return(Page());
}
else
{
throw new InvalidOperationException($"Unable to retreive specification. Status Code = {specificationResponse.StatusCode}");
}
}
public async Task ListDatasetSchemasModel_OnGet_WhenSpecificationNotFoundThenStatusCodeNotFoundReturned()
{
// Arrange
IDatasetsApiClient datasetClient = Substitute.For <IDatasetsApiClient>();
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
ILogger logger = Substitute.For <ILogger>();
string expectedSpecificationId = "1";
Specification expectedSpecification = null;
specsClient
.GetSpecification(Arg.Any <string>())
.Returns(new ApiResponse <Specification>(HttpStatusCode.NotFound, expectedSpecification));
ListDatasetSchemasModel listDatasetSchemasPageModel = new ListDatasetSchemasModel(specsClient, datasetClient, mapper);
// Act
IActionResult result = await listDatasetSchemasPageModel.OnGet(expectedSpecificationId);
// Assert
result.Should().NotBeNull();
result.Should().BeOfType <NotFoundObjectResult>();
NotFoundObjectResult typeResult = result as NotFoundObjectResult;
typeResult.Value.Should().Be("Specification not found");
}
public async Task PoliciesPageModel_OnGet_WhenDatasetsApiFailedReturningNull_ThenErrorShouldBeReturned()
{
// Arrange
ISpecsApiClient specsApiClient = CreateSpecsApiClient();
IDatasetsApiClient datasetsApiClient = CreateDatasetsApiClient();
ILogger logger = CreateLogger();
PoliciesModel policiesModel = GetPoliciesModel(specsApiClient, datasetsApiClient, logger);
string specificationId = "spec123";
specsApiClient.GetSpecification(Arg.Any <string>())
.Returns(new ApiResponse <Specification>(HttpStatusCode.OK, new Specification()));
datasetsApiClient
.GetAssignedDatasetSchemasForSpecification(specificationId)
.Returns((ApiResponse <IEnumerable <DatasetSchemasAssigned> >)null);
// Act
IActionResult result = await policiesModel.OnGet(specificationId, null, null);
// Assert
result.Should().BeOfType <ObjectResult>()
.Which.Value.Should().Be("Datasets Lookup API Failed and returned null");
result.Should().BeOfType <ObjectResult>()
.Which.StatusCode.Should().Be(500);
logger
.Received(1)
.Warning("Dataset Schema Response API Request came back null for Specification ID = '{specificationId}'", specificationId);
}
public async Task OnGet_WhenSpecificationIdDoesNotExistThenBadRequestReturned()
{
// Arrange
IDatasetsApiClient datasetClient = Substitute.For <IDatasetsApiClient>();
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
ILogger logger = Substitute.For <ILogger>();
string expectedSpecificationId = string.Empty;
Specification expectedSpecification = null;
specsClient
.GetSpecification(Arg.Any <string>())
.Returns(new ApiResponse <Specification>(HttpStatusCode.NotFound, expectedSpecification));
AssignDatasetSchemaPageModel datasetSchemaPageModel = CreatePageModel(specsClient, datasetClient, mapper);
// Act
IActionResult result = await datasetSchemaPageModel.OnGet(expectedSpecificationId);
// Assert
result.Should().NotBeNull();
result.Should().BeOfType <BadRequestObjectResult>().Which.Value.Should().Be("Select a specification");
}
public async Task EditCalculationPageModel_OnGetAsync_WhenSpecificationNotFound_ThenPreconditionFailedReturned()
{
// Arrange
const string specificationId = "spec1";
const string calculationId = "calculationId";
ISpecsApiClient specsClient = CreateSpecsClient();
ILogger logger = CreateLogger();
specsClient
.GetSpecification(Arg.Is(specificationId))
.Returns(new ApiResponse <Specification>(HttpStatusCode.NotFound, new Specification()));
EditCalculationPageModel pageModel = CreatePageModel(specsClient, logger);
// Act
IActionResult result = await pageModel.OnGetAsync(specificationId, calculationId);
// Assert
result
.Should()
.BeOfType <PreconditionFailedResult>()
.Which
.Value
.Should()
.Be("Specification not found");
await specsClient
.Received(1)
.GetSpecification(Arg.Is(specificationId));
await specsClient
.Received(0)
.GetCalculationById(Arg.Is(specificationId), Arg.Is(calculationId));
}
public async Task OnGetAsync_GivenResponseReturnsNullWhenFetchingAllocationLines_ReturnsInternalServerError()
{
//Arrange
Specification specification = CreateSpecification();
ApiResponse <Specification> apiResponse = new ApiResponse <Specification>(HttpStatusCode.OK, specification);
ISpecsApiClient specsClient = CreateSpecsApiClient();
specsClient
.GetSpecification(Arg.Is(specificationId))
.Returns(apiResponse);
specsClient
.GetFundingStreamByFundingStreamId(Arg.Is(fundingStreamId))
.Returns((ApiResponse <FundingStream>)null);
CreateCalculationPageModel pageModel = CreatePageModel(specsClient);
//Act
IActionResult result = await pageModel.OnGetAsync(specificationId);
//Assert
result
.Should()
.BeAssignableTo <InternalServerErrorResult>();
}
public async Task ListDatasetSchemasModel_OnGet_WhenProviderDatasetsIsPresent_ThenHasProviderDatasetsAssignedIsTrue()
{
// Arrange
IDatasetsApiClient datasetClient = Substitute.For <IDatasetsApiClient>();
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
ILogger logger = Substitute.For <ILogger>();
string specificationId = "10";
Specification specification = new Specification()
{
Id = specificationId
};
specsClient
.GetSpecification(specificationId)
.Returns(new ApiResponse <Specification>(HttpStatusCode.OK, specification));
List <DatasetSchemasAssigned> datasetSchemasAssigned = new List <DatasetSchemasAssigned>()
{
new DatasetSchemasAssigned()
{
Id = "ds1",
Name = "Dataset Schema 1",
IsSetAsProviderData = false,
DatasetDefinition = new Reference("1234", "Definition 1234"),
Description = "Datasets Schema 1 Description",
UsedInDataAggregations = false,
},
new DatasetSchemasAssigned()
{
Id = "providerDs",
Name = "Provider Dataset",
IsSetAsProviderData = true,
DatasetDefinition = new Reference("5678", "Provider Dataset Definition"),
}
};
datasetClient
.GetAssignedDatasetSchemasForSpecification(specificationId)
.Returns(new ApiResponse <IEnumerable <DatasetSchemasAssigned> >(HttpStatusCode.OK, datasetSchemasAssigned.AsEnumerable()));
ListDatasetSchemasModel listDatasetSchemasPageModel = new ListDatasetSchemasModel(specsClient, datasetClient, mapper);
// Act
IActionResult result = await listDatasetSchemasPageModel.OnGet(specificationId);
// Assert
result.Should().BeOfType <PageResult>()
.Which.Should().NotBeNull();
listDatasetSchemasPageModel.DatasetDefinitions.Should().NotBeNull();
listDatasetSchemasPageModel.HasProviderDatasetsAssigned.Should().BeTrue();
}
private async Task <(Specification specification, IActionResult error)> GetSpecification(string specificationId)
{
Guard.IsNullOrWhiteSpace(specificationId, nameof(specificationId));
ApiResponse <Specification> specification = await _specsClient.GetSpecification(specificationId);
IActionResult error = specification.IsSuccessOrReturnFailureResult("Specification");
return(specification.Content, error);
}
public async Task OnGet_WhenSpecificationStatusCodeIsNotFoundThenNotFoundObjectResultReturned()
{
// Arrange
IDatasetsApiClient datasetClient = Substitute.For <IDatasetsApiClient>();
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
ILogger logger = Substitute.For <ILogger>();
string expectedSpecificationId = "1";
Specification expectedSpecification = null;
AssignDatasetSchemaPageModel datasetSchemaPageModel = CreatePageModel(specsClient, datasetClient, mapper);
specsClient
.GetSpecification(expectedSpecificationId)
.Returns(new ApiResponse <Specification>(HttpStatusCode.NotFound, expectedSpecification));
DatasetDefinition d1 = new DatasetDefinition()
{
Id = "1",
Name = "APT Final Baselines",
Description = "Local Authority return of provider baselines",
};
DatasetDefinition d2 = new DatasetDefinition()
{
Id = "2",
Name = "School Provider Dataset",
Description = "List of providers",
};
IEnumerable <DatasetDefinition> dataDefn = new List <DatasetDefinition> {
d1, d2
};
datasetClient
.GetDataDefinitions()
.Returns(new ApiResponse <IEnumerable <DatasetDefinition> >(HttpStatusCode.OK, dataDefn));
// Act
IActionResult result = await datasetSchemaPageModel.OnGet(expectedSpecificationId);
// Assert
result.Should().NotBeNull();
result.Should().BeOfType <NotFoundObjectResult>();
NotFoundObjectResult typeResult = result as NotFoundObjectResult;
typeResult.Value.Should().Be("Unable to get specification response. Specification Id value = 1");
Assert.IsInstanceOfType(result, typeof(NotFoundObjectResult));
}
private async Task <Specification> GetSpecification(string specificationId)
{
Guard.IsNullOrWhiteSpace(specificationId, nameof(specificationId));
ApiResponse <Specification> specificationResponse = await _specsClient.GetSpecification(specificationId);
if (specificationResponse != null && specificationResponse.StatusCode == HttpStatusCode.OK)
{
return(specificationResponse.Content);
}
return(null);
}
public async Task EditCalculationPageModel_OnPostAsync_WhenUserDoesNotHaveEditSpecificationPermission_ThenForbidResultReturned()
{
// Arrange
const string specificationId = "spec1";
const string calculationId = "calculationId";
CalculationCurrentVersion calculation = new CalculationCurrentVersion()
{
Id = calculationId,
Name = "Calculation Name",
AllocationLine = new Reference("al1", "Allocation Line"),
CalculationType = CalculationSpecificationType.Funding,
Description = "Calculation Description",
IsPublic = false,
PolicyId = "policyId",
PolicyName = "Policy Name"
};
Specification specification = CreateSpecification(specificationId);
ISpecsApiClient specsClient = CreateSpecsClient();
specsClient
.GetCalculationById(Arg.Is(specificationId), Arg.Is(calculationId))
.Returns(new ApiResponse <CalculationCurrentVersion>(HttpStatusCode.OK, calculation));
specsClient
.GetSpecification(Arg.Is(specificationId))
.Returns(new ApiResponse <Specification>(HttpStatusCode.OK, specification));
IAuthorizationHelper authorizationHelper = Substitute.For <IAuthorizationHelper>();
authorizationHelper
.DoesUserHavePermission(Arg.Any <ClaimsPrincipal>(), Arg.Any <ISpecificationAuthorizationEntity>(), Arg.Is(SpecificationActionTypes.CanEditSpecification))
.Returns(false);
EditCalculationPageModel pageModel = CreatePageModel(specsClient, authorizationHelper: authorizationHelper);
// Act
IActionResult result = await pageModel.OnPostAsync(specificationId, calculationId);
// Assert
result
.Should()
.BeOfType <ForbidResult>();
pageModel
.IsAuthorizedToEdit
.Should().BeFalse();
}
public void OnGetAsync_GivenToPopulateFundingPeriodsIsOKButFundingStreamsReturnsOKButNullContent_ThrowsInvalidOperationException()
{
//Arrange
Specification specification = new Specification();
EditSpecificationViewModel viewModel = CreateEditSpecificationViewModel();
IEnumerable <Reference> fundingPeriods = new[]
{
new Reference {
Id = "fp1", Name = "funding"
}
};
ApiResponse <IEnumerable <Reference> > fundingPeriodsResponse = new ApiResponse <IEnumerable <Reference> >(HttpStatusCode.OK, fundingPeriods);
ApiResponse <IEnumerable <FundingStream> > fundingStreamsResponse = new ApiResponse <IEnumerable <FundingStream> >(HttpStatusCode.OK);
ApiResponse <Specification> specificationResponse = new ApiResponse <Specification>(HttpStatusCode.OK, specification);
ISpecsApiClient apiClient = CreateApiClient();
apiClient
.GetSpecification(Arg.Is(specificationId))
.Returns(specificationResponse);
apiClient
.GetFundingPeriods()
.Returns(fundingPeriodsResponse);
apiClient
.GetFundingStreams()
.Returns(fundingStreamsResponse);
IMapper mapper = CreateMapper();
mapper
.Map <EditSpecificationViewModel>(Arg.Is(specification))
.Returns(viewModel);
EditSpecificationPageModel pageModel = CreatePageModel(apiClient, mapper);
//Act/Assert
Func <Task> test = async() => await pageModel.OnGetAsync(specificationId);
test
.Should()
.ThrowExactly <InvalidOperationException>();
}
public async Task ListDatasetSchemasModel_OnGet_WhenDatasetSchemasAssignedNotFoundThenNotFoundReturned()
{
// Arrange
IDatasetsApiClient datasetClient = Substitute.For <IDatasetsApiClient>();
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
ILogger logger = Substitute.For <ILogger>();
string expectedSpecificationId = "1";
Specification expectedSpecification = new Specification
{
FundingPeriod = new Reference("2018", "17-18"),
FundingStreams = new List <FundingStream>()
{
new FundingStream("2018", "18-19"),
},
Description = "Test Spec",
Id = "1",
Name = "APT Final Baselines current year"
};
specsClient
.GetSpecification(Arg.Any <string>())
.Returns(new ApiResponse <Specification>(HttpStatusCode.OK, expectedSpecification));
ListDatasetSchemasModel listDatasetSchemasPageModel = new ListDatasetSchemasModel(specsClient, datasetClient, mapper);
datasetClient
.GetAssignedDatasetSchemasForSpecification(expectedSpecificationId)
.Returns(new ApiResponse <IEnumerable <DatasetSchemasAssigned> >(HttpStatusCode.NotFound, null));
// Act
IActionResult result = await listDatasetSchemasPageModel.OnGet(expectedSpecificationId);
// Assert
result.Should().NotBeNull();
result.Should().BeOfType <NotFoundObjectResult>();
}
public async Task EditCalculationPageModel_OnGetAsync_WhenCalculationApiResponseIsNotSuccessful_ThenInternalErrorIsReturned()
{
// Arrange
const string specificationId = "spec1";
const string calculationId = "calculationId";
ISpecsApiClient specsClient = CreateSpecsClient();
ILogger logger = CreateLogger();
specsClient
.GetCalculationById(Arg.Is(specificationId), Arg.Is(calculationId))
.Returns(new ApiResponse <CalculationCurrentVersion>(HttpStatusCode.InternalServerError, null));
specsClient
.GetSpecification(Arg.Is(specificationId))
.Returns(new ApiResponse <Specification>(HttpStatusCode.OK, new Specification()));
EditCalculationPageModel pageModel = CreatePageModel(specsClient, logger);
// Act
IActionResult result = await pageModel.OnGetAsync(specificationId, calculationId);
// Assert
result
.Should()
.BeOfType <InternalServerErrorResult>()
.Which
.Value
.Should()
.Be("Unexpected status code from Calculation API call 'InternalServerError'");
logger
.Received(1)
.Warning($"Unexpected status code from Calculation API call 'InternalServerError'");
await specsClient
.Received(1)
.GetSpecification(Arg.Is(specificationId));
await specsClient
.Received(1)
.GetCalculationById(Arg.Is(specificationId), Arg.Is(calculationId));
}
public async Task EditCalculationPageModel_OnGetAsync_WhenCalculationApiResponseContentIsNull_ThenInternalErrorIsReturned()
{
// Arrange
const string specificationId = "spec1";
const string calculationId = "calculationId";
ISpecsApiClient specsClient = CreateSpecsClient();
ILogger logger = CreateLogger();
specsClient
.GetCalculationById(Arg.Is(specificationId), Arg.Is(calculationId))
.Returns(new ApiResponse <CalculationCurrentVersion>(HttpStatusCode.OK, null));
specsClient
.GetSpecification(Arg.Is(specificationId))
.Returns(new ApiResponse <Specification>(HttpStatusCode.OK, new Specification()));
EditCalculationPageModel pageModel = CreatePageModel(specsClient, logger);
// Act
IActionResult result = await pageModel.OnGetAsync(specificationId, calculationId);
// Assert
result
.Should()
.BeOfType <InternalServerErrorResult>()
.Which
.Value
.Should()
.Be("Calculation content returned null");
logger
.Received(1)
.Warning("Calculation Result API response content returned null for calculation ID '{calculationId}' on specificationId '{specificationId}'", calculationId, specificationId);
await specsClient
.Received(1)
.GetSpecification(Arg.Is(specificationId));
await specsClient
.Received(1)
.GetCalculationById(Arg.Is(specificationId), Arg.Is(calculationId));
}
public async Task PoliciesPageModel_OnGet_WhenUserDoesNotHaveApproveSpecificationPermission_ThenDoesUserHavePermissionToApproveIsFalse()
{
// Arrange
ISpecsApiClient specsApiClient = CreateSpecsApiClient();
IDatasetsApiClient datasetsApiClient = CreateDatasetsApiClient();
IAuthorizationHelper authorizationHelper = Substitute.For <IAuthorizationHelper>();
PoliciesModel policiesModel = GetPoliciesModel(specsApiClient, datasetsApiClient, authorizationHelper: authorizationHelper);
string specificationId = "spec123";
Specification specification = new Specification()
{
Id = specificationId,
Name = "Test Specification",
FundingPeriod = new Reference("1617", "2016/2017"),
Description = "Test Description",
FundingStreams = new List <FundingStream>()
{
new FundingStream("fs1", "Funding Stream Name"),
}
};
specsApiClient.GetSpecification(Arg.Any <string>())
.Returns(new ApiResponse <Specification>(HttpStatusCode.OK, specification));
datasetsApiClient
.GetAssignedDatasetSchemasForSpecification(specificationId)
.Returns(new ApiResponse <IEnumerable <DatasetSchemasAssigned> >(HttpStatusCode.OK, Enumerable.Empty <DatasetSchemasAssigned>()));
authorizationHelper.DoesUserHavePermission(Arg.Any <ClaimsPrincipal>(), Arg.Any <ISpecificationAuthorizationEntity>(), Arg.Is(SpecificationActionTypes.CanApproveSpecification))
.Returns(false);
// Act
IActionResult result = await policiesModel.OnGet(specificationId, null, null);
// Assert
policiesModel.DoesUserHavePermissionToApprove.Should().Be("false");
}
public async Task PoliciesPageModel_OnGet_WhenOperationTypeIsSubPolicyCalculationUpdated_ThenBannerPopulated()
{
// Arrange
ISpecsApiClient specsApiClient = CreateSpecsApiClient();
IDatasetsApiClient datasetsApiClient = CreateDatasetsApiClient();
PoliciesModel policiesModel = GetPoliciesModel(specsApiClient, datasetsApiClient);
string specificationId = "spec123";
Specification specification = CreateSpecificationForBannerChecks(specificationId);
specsApiClient.GetSpecification(Arg.Any <string>())
.Returns(new ApiResponse <Specification>(HttpStatusCode.OK, specification));
datasetsApiClient
.GetAssignedDatasetSchemasForSpecification(specificationId)
.Returns(new ApiResponse <IEnumerable <DatasetSchemasAssigned> >(HttpStatusCode.OK, Enumerable.Empty <DatasetSchemasAssigned>()));
// Act
IActionResult result = await policiesModel.OnGet(specificationId, PoliciesPageBannerOperationType.CalculationUpdated, "subpolicyCalculation1");
// Assert
result
.Should()
.BeOfType <PageResult>();
policiesModel
.PageBanner
.Should()
.BeEquivalentTo(new PageBannerOperation()
{
EntityName = "Sub Policy 2 Calculation 1",
EntityType = "Calculation specification",
OperationAction = "updated",
OperationId = null,
ActionText = "Edit",
ActionUrl = $"/specs/EditCalculation/subpolicyCalculation1?specificationId={specificationId}",
});
}
public async Task EditCalculationPageModel_OnGetAsync_WhenCalculationNotFound_ThenNotFoundIsReturned()
{
// Arrange
const string specificationId = "spec1";
const string calculationId = "calculationId";
ISpecsApiClient specsClient = CreateSpecsClient();
specsClient
.GetCalculationById(Arg.Is(specificationId), Arg.Is(calculationId))
.Returns(new ApiResponse <CalculationCurrentVersion>(HttpStatusCode.NotFound, null));
specsClient
.GetSpecification(Arg.Is(specificationId))
.Returns(new ApiResponse <Specification>(HttpStatusCode.OK, new Specification()));
EditCalculationPageModel pageModel = CreatePageModel(specsClient);
// Act
IActionResult result = await pageModel.OnGetAsync(specificationId, calculationId);
// Assert
result
.Should()
.BeOfType <NotFoundObjectResult>()
.Which
.Value
.Should()
.Be("Calculation not found");
await specsClient
.Received(1)
.GetSpecification(Arg.Is(specificationId));
await specsClient
.Received(1)
.GetCalculationById(Arg.Is(specificationId), Arg.Is(calculationId));
}
public void OnGetAsync_GivenSpecificationIdWithOKResponseButContentIsNull_ThrowsInvalidOperationException()
{
//Arrange
ApiResponse <Specification> specificationResponse = new ApiResponse <Specification>(HttpStatusCode.OK);
ISpecsApiClient apiClient = CreateApiClient();
apiClient
.GetSpecification(Arg.Is(specificationId))
.Returns(specificationResponse);
EditSpecificationPageModel pageModel = CreatePageModel(apiClient);
//Act/Assert
Func <Task> test = async() => await pageModel.OnGetAsync(specificationId);
test
.Should()
.ThrowExactly <InvalidOperationException>()
.Which
.Message
.Should()
.Be("Unable to retreive specification. Status Code = OK");
}
public void OnPostAsync_GivenCalculationDoesNotAlreadyExistButSavingIsNotOK_InvalidOperationException()
{
//Arrange
CreateCalculationViewModel viewModel = new CreateCalculationViewModel
{
Name = "any name"
};
Specification specification = CreateSpecification();
IEnumerable <Reference> allocationLines = new[]
{
new Reference
{
Id = "alloc-id",
Name = "alloc-name"
}
};
CalculationCreateModel createModel = new CalculationCreateModel
{
SpecificationId = specificationId
};
IMapper mapper = CreateMapper();
mapper
.Map <CalculationCreateModel>(Arg.Is(viewModel))
.Returns(createModel);
ApiResponse <Calculation> calcApiRespnse = new ApiResponse <Calculation>(HttpStatusCode.NotFound);
ValidatedApiResponse <Calculation> newCalcApiResponse = new ValidatedApiResponse <Calculation>(HttpStatusCode.InternalServerError, new Calculation
{
Id = "new-calc-id",
});
newCalcApiResponse.ModelState = new Dictionary <string, IEnumerable <string> >();
ISpecsApiClient specsClient = CreateSpecsApiClient();
specsClient
.GetCalculationBySpecificationIdAndCalculationName(Arg.Is(specificationId), Arg.Is(viewModel.Name))
.Returns(calcApiRespnse);
specsClient
.CreateCalculation(Arg.Is(createModel))
.Returns(newCalcApiResponse);
List <FundingStream> fundingStreams = new List <FundingStream>();
fundingStreams.Add(new FundingStream
{
Id = fundingStreamId,
AllocationLines = new List <AllocationLine>()
{
new AllocationLine()
{
Id = "al1",
Name = "Allocation Line 1",
}
}
});
ApiResponse <IEnumerable <FundingStream> > fundingStreamResponse = new ApiResponse <IEnumerable <FundingStream> >(HttpStatusCode.OK, fundingStreams);
specsClient
.GetFundingStreamsForSpecification(Arg.Is(specification.Id))
.Returns(fundingStreamResponse);
specsClient
.GetBaselineCalculationsBySpecificationId(Arg.Is(specificationId))
.Returns(new ApiResponse <IEnumerable <CalculationCurrentVersion> >(HttpStatusCode.OK, Enumerable.Empty <CalculationCurrentVersion>()));
specsClient.GetSpecification(Arg.Is(specificationId))
.Returns(new ApiResponse <Specification>(HttpStatusCode.OK, specification));
CreateCalculationPageModel pageModel = CreatePageModel(specsClient, mapper);
pageModel.PageContext = new PageContext();
pageModel.CreateCalculationViewModel = viewModel;
//Act
Func <Task> test = async() => await pageModel.OnPostAsync(specificationId);
//Assert
test
.Should()
.ThrowExactly <InvalidOperationException>();
}
public async Task OnPostAsync_GivenCalculationDoesNotAlreadyExistAndCalcTypeIsFundingButNoAllocationLineSelected_ReturnsPage()
{
//Arrange
CreateCalculationViewModel viewModel = new CreateCalculationViewModel
{
Name = "any name",
CalculationType = "Funding"
};
Specification specification = CreateSpecification();
IEnumerable <AllocationLine> allocationLines = new[]
{
new AllocationLine
{
Id = "alloc-id",
Name = "alloc-name"
}
};
List <FundingStream> fundingStreams = new List <FundingStream>();
FundingStream fundingStream = new FundingStream
{
Id = fundingStreamId,
AllocationLines = allocationLines
};
fundingStreams.Add(fundingStream);
List <CalculationCurrentVersion> baselineCalculations = new List <CalculationCurrentVersion>();
ApiResponse <IEnumerable <FundingStream> > fundingStreamResponse = new ApiResponse <IEnumerable <FundingStream> >(HttpStatusCode.OK, fundingStreams);
CalculationCreateModel createModel = new CalculationCreateModel
{
SpecificationId = specificationId
};
ApiResponse <Calculation> calcApiResponse = new ApiResponse <Calculation>(HttpStatusCode.NotFound);
ApiResponse <Specification> apiResponse = new ApiResponse <Specification>(HttpStatusCode.OK, specification);
ApiResponse <IEnumerable <CalculationCurrentVersion> > baselineCalculationsResponse = new ApiResponse <IEnumerable <CalculationCurrentVersion> >(HttpStatusCode.OK, baselineCalculations);
ISpecsApiClient specsClient = CreateSpecsApiClient();
specsClient
.GetCalculationBySpecificationIdAndCalculationName(Arg.Is(specificationId), Arg.Is(viewModel.Name))
.Returns(calcApiResponse);
specsClient
.GetSpecification(Arg.Is(specificationId))
.Returns(apiResponse);
specsClient
.GetFundingStreamsForSpecification(Arg.Is(specification.Id))
.Returns(fundingStreamResponse);
specsClient
.GetBaselineCalculationsBySpecificationId(Arg.Is(specificationId))
.Returns(baselineCalculationsResponse);
CreateCalculationPageModel pageModel = CreatePageModel(specsClient);
pageModel.PageContext = new PageContext();
pageModel.CreateCalculationViewModel = viewModel;
//Act
IActionResult result = await pageModel.OnPostAsync(specificationId);
//Assert
result
.Should()
.NotBeNull();
result
.Should()
.BeAssignableTo <PageResult>();
pageModel
.ModelState
.ErrorCount
.Should()
.Be(1);
}
public async Task OnGet_WhenUserDoesNotHaveEditSpecificationPermission_ThenReturnPageResultWithAuthorizedToEditFlagSetToFalse()
{
// Arrange
IAuthorizationHelper mockAuthHelper = Substitute.For <IAuthorizationHelper>();
mockAuthHelper
.DoesUserHavePermission(Arg.Any <ClaimsPrincipal>(), Arg.Any <ISpecificationAuthorizationEntity>(), Arg.Is(SpecificationActionTypes.CanEditSpecification))
.Returns(false);
ISpecsApiClient specsClient = CreateSpecsApiClient();
Specification specification = new Specification()
{
Id = specificationId,
FundingPeriod = new Reference("fp1", "FP 2"),
};
specsClient.GetSpecification(Arg.Is(specificationId))
.Returns(new ApiResponse <Specification>(HttpStatusCode.OK, specification));
specsClient
.GetBaselineCalculationsBySpecificationId(Arg.Is(specificationId))
.Returns(new ApiResponse <IEnumerable <CalculationCurrentVersion> >(HttpStatusCode.OK, Enumerable.Empty <CalculationCurrentVersion>()));
List <FundingStream> fundingStreams = new List <FundingStream>();
fundingStreams.Add(new FundingStream
{
Id = fundingStreamId,
AllocationLines = new List <AllocationLine>()
{
new AllocationLine()
{
Id = "al1",
Name = "Allocation Line 1",
}
}
});
ApiResponse <IEnumerable <FundingStream> > fundingStreamResponse = new ApiResponse <IEnumerable <FundingStream> >(HttpStatusCode.OK, fundingStreams);
specsClient
.GetFundingStreamsForSpecification(Arg.Is(specification.Id))
.Returns(fundingStreamResponse);
specsClient
.GetBaselineCalculationsBySpecificationId(Arg.Is(specificationId))
.Returns(new ApiResponse <IEnumerable <CalculationCurrentVersion> >(HttpStatusCode.OK, Enumerable.Empty <CalculationCurrentVersion>()));
CreateCalculationPageModel pageModel = CreatePageModel(specsClient: specsClient, authorizationHelper: mockAuthHelper);
// Act
IActionResult result = await pageModel.OnGetAsync(specificationId);
// Assert
result
.Should()
.BeOfType <PageResult>();
pageModel
.IsAuthorizedtoEdit
.Should()
.BeFalse();
}
public async Task OnGetAsync_GivenSpecificationFound_PopulatesFormReturnsPage()
{
//Arrange
Specification specification = CreateSpecification();
IEnumerable <AllocationLine> allocationLines = new[]
{
new AllocationLine
{
Id = "alloc-id",
Name = "alloc-name"
}
};
List <FundingStream> fundingStreams = new List <FundingStream>();
FundingStream fundingStream = new FundingStream
{
Id = fundingStreamId,
AllocationLines = allocationLines
};
fundingStreams.Add(fundingStream);
List <CalculationCurrentVersion> baselineCalculations = new List <CalculationCurrentVersion>();
baselineCalculations.Add(new CalculationCurrentVersion()
{
AllocationLine = new Reference("AL1", "Allocation Line Name"),
});
ApiResponse <IEnumerable <FundingStream> > fundingStreamResponse = new ApiResponse <IEnumerable <FundingStream> >(HttpStatusCode.OK, fundingStreams);
ApiResponse <Specification> apiResponse = new ApiResponse <Specification>(HttpStatusCode.OK, specification);
ApiResponse <IEnumerable <CalculationCurrentVersion> > baselineCalculationsResult = new ApiResponse <IEnumerable <CalculationCurrentVersion> >(HttpStatusCode.OK, baselineCalculations);
ISpecsApiClient specsClient = CreateSpecsApiClient();
specsClient
.GetSpecification(Arg.Is(specificationId))
.Returns(apiResponse);
specsClient
.GetFundingStreamsForSpecification(Arg.Is(specification.Id))
.Returns(fundingStreamResponse);
specsClient
.GetBaselineCalculationsBySpecificationId(Arg.Is(specificationId))
.Returns(baselineCalculationsResult);
CreateCalculationPageModel pageModel = CreatePageModel(specsClient);
//Act
IActionResult result = await pageModel.OnGetAsync(specificationId);
//Assert
result
.Should()
.NotBeNull();
result
.Should()
.BeAssignableTo <PageResult>();
pageModel
.FundingPeriodName
.Should()
.Be("2018 - 19");
pageModel
.FundingPeriodId
.Should()
.Be("2018/19");
pageModel
.SpecificationName
.Should()
.Be("spec-name");
pageModel
.Policies
.Count
.Should()
.Be(2);
pageModel
.AllocationLines
.Count()
.Should()
.Be(1);
pageModel
.CalculationTypes
.Any()
.Should()
.BeTrue();
pageModel
.IsAuthorizedtoEdit
.Should().BeTrue();
pageModel
.HideAllocationLinesForBaselinesJson
.Should()
.Be("[\"AL1\"]");
}
