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");
}
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 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> OnGetAsync(string specificationId, string calculationId)
{
Guard.IsNullOrWhiteSpace(specificationId, nameof(specificationId));
Specification specification = await GetSpecification(specificationId);
if (specification != null)
{
IsAuthorizedToEdit = await _authorizationHelper.DoesUserHavePermission(User, specification, SpecificationActionTypes.CanEditSpecification);
ApiResponse <CalculationCurrentVersion> calculationResult = await _specsClient.GetCalculationById(specificationId, calculationId);
if (calculationResult == null)
{
_logger.Error("Calculation Result API response returned null for calculation ID '{calculationId}' on specificationId '{specificationId}'", calculationId, specificationId);
return(new InternalServerErrorResult("Calculation Result API response returned null"));
}
if (calculationResult.StatusCode == HttpStatusCode.NotFound)
{
return(new NotFoundObjectResult("Calculation not found"));
}
else if (calculationResult.StatusCode != HttpStatusCode.OK)
{
_logger.Warning($"Unexpected status code from Calculation API call '{calculationResult.StatusCode}'");
return(new InternalServerErrorResult($"Unexpected status code from Calculation API call '{calculationResult.StatusCode}'"));
}
Calculation calculation = calculationResult.Content;
if (calculation == null)
{
_logger.Warning("Calculation Result API response content returned null for calculation ID '{calculationId}' on specificationId '{specificationId}'", calculationId, specificationId);
return(new InternalServerErrorResult("Calculation content returned null"));
}
EditCalculationViewModel = _mapper.Map <EditCalculationViewModel>(calculation);
return(await PopulateForm(specification, calculationId));
}
else
{
return(new PreconditionFailedResult("Specification not found"));
}
}
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 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 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_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 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 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_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_WhenCalculationExistsThenCalculationReturned()
{
// Arrange
ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>();
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
const string calculationId = "5";
const string specificationId = "specId";
const string specificationName = "Spec Name";
Calculation calcsCalculation = new Calculation()
{
Id = calculationId,
CalculationSpecification = new Reference(calculationId, "Test Calculation Specification"),
SpecificationId = specificationId,
SourceCode = "Test Source Code"
};
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));
Clients.SpecsClient.Models.SpecificationSummary specificationSummary = new Clients.SpecsClient.Models.SpecificationSummary()
{
Id = specificationId,
Name = specificationName
};
specsClient
.GetSpecificationSummary(Arg.Is(specificationId))
.Returns(new ApiResponse <Clients.SpecsClient.Models.SpecificationSummary>(System.Net.HttpStatusCode.OK, specificationSummary));
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.SpecificationName.Should().Be(specificationName);
await calcsClient
.Received(1)
.GetCalculationById(Arg.Is(calculationId));
await specsClient
.Received(1)
.GetSpecificationSummary(Arg.Is(specificationId));
await specsClient
.Received(1)
.GetCalculationById(Arg.Is(specificationId), Arg.Is(calculationId));
}
public async Task EditCalculationPageModel_OnGetAsync_WhenCalculationFound_ThenEditFormIsDisplayed()
{
// 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"
};
List <CalculationCurrentVersion> baselineCalculations = new List <CalculationCurrentVersion>();
baselineCalculations.Add(new CalculationCurrentVersion()
{
AllocationLine = new Reference("AL1", "Allocation Line 1"),
});
ApiResponse <IEnumerable <CalculationCurrentVersion> > baselineCalculationsResponse = new ApiResponse <IEnumerable <CalculationCurrentVersion> >(HttpStatusCode.OK, baselineCalculations);
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));
specsClient
.GetBaselineCalculationsBySpecificationId(Arg.Is(specificationId))
.Returns(baselineCalculationsResponse);
EditCalculationPageModel pageModel = CreatePageModel(specsClient);
// Act
IActionResult result = await pageModel.OnGetAsync(specificationId, calculationId);
// Assert
result
.Should()
.BeOfType <PageResult>()
.Which
.Should()
.NotBeNull();
pageModel
.EditCalculationViewModel
.Should()
.BeEquivalentTo <EditCalculationViewModel>(new EditCalculationViewModel()
{
Name = "Calculation Name",
AllocationLineId = "al1",
CalculationType = "Funding",
Description = "Calculation Description",
IsPublic = false,
PolicyId = "policyId",
});
pageModel
.Specification
.Should()
.BeEquivalentTo(new SpecificationViewModel()
{
Id = specificationId,
Name = "Specification Name",
FundingStreams = new List <ReferenceViewModel>()
{
new ReferenceViewModel("fsId", "Funding Stream 1"),
new ReferenceViewModel("fs2Id", "Funding Stream 2"),
},
},
c => c.Excluding(m => m.Policies));
pageModel
.Policies
.Should()
.BeEquivalentTo(new List <SelectListItem>()
{
new SelectListItem()
{
Disabled = false,
Selected = false,
Text = "Policy 1",
Value = "p1",
Group = new SelectListGroup()
{
Name = "Policies",
Disabled = false,
},
},
new SelectListItem()
{
Disabled = false,
Selected = false,
Text = "Sub Policy 1",
Value = "sub1",
Group = new SelectListGroup()
{
Name = "Subpolicies",
Disabled = false,
},
},
new SelectListItem()
{
Disabled = false,
Selected = false,
Text = "Sub Policy 2",
Value = "sub2",
Group = new SelectListGroup()
{
Name = "Subpolicies",
Disabled = false,
},
},
new SelectListItem
{
Disabled = false,
Selected = false,
Text = "Policy 2",
Value = "p2",
Group = new SelectListGroup()
{
Name = "Policies",
Disabled = false,
},
},
new SelectListItem
{
Disabled = false,
Selected = false,
Text = "Policy 3",
Value = "p3",
Group = new SelectListGroup()
{
Name = "Policies",
Disabled = false,
},
},
new SelectListItem()
{
Disabled = false,
Selected = false,
Text = "Sub Policy 3",
Value = "sub3",
Group = new SelectListGroup()
{
Name = "Subpolicies",
Disabled = false,
},
},
new SelectListItem
{
Disabled = false,
Selected = false,
Text = "Policy 4",
Value = "p4",
Group = new SelectListGroup()
{
Name = "Policies",
Disabled = false,
},
}
});
pageModel
.AllocationLines
.Should()
.BeEquivalentTo(new List <SelectListItem>()
{
new SelectListItem()
{
Disabled = false,
Selected = true,
Text = "Funding Stream - Allocation Line 1",
Value = "al1",
},
new SelectListItem
{
Disabled = false,
Selected = false,
Text = "Funding Stream - Allocation Line 2",
Value = "al2",
},
new SelectListItem
{
Disabled = false,
Selected = false,
Text = "Funding Stream 2 - Allocation Line 1",
Value = "al3",
},
new SelectListItem
{
Disabled = false,
Selected = false,
Text = "Funding Stream 2 - Allocation Line 2",
Value = "al4",
}
});
pageModel
.HideAllocationLinesForBaselinesJson
.Should()
.Be("[\"AL1\"]");
pageModel
.IsAuthorizedToEdit
.Should().BeTrue();
}
public async Task <IActionResult> OnGet(IEnumerable <int> versions, string calculationId)
{
if (string.IsNullOrWhiteSpace(calculationId))
{
return(new BadRequestObjectResult(ErrorMessages.CalculationIdNullOrEmpty));
}
Guard.ArgumentNotNull(versions, nameof(versions));
if (versions.Count() != 2)
{
return(new BadRequestObjectResult("Two versions not requested"));
}
ApiResponse <Calculation> calculationResponse = await _calcClient.GetCalculationById(calculationId);
if (calculationResponse == null || calculationResponse.StatusCode == HttpStatusCode.NotFound)
{
return(new NotFoundObjectResult(ErrorMessages.CalculationNotFoundInCalcsService));
}
Calculation calculation = calculationResponse.Content;
CalculationName = calculation.Name;
CalculationPeriodName = calculation.FundingPeriodName;
CalculationId = calculation.Id;
ApiResponse <Clients.SpecsClient.Models.CalculationCurrentVersion> specCalculation = await _specsClient.GetCalculationById(calculation.SpecificationId, calculation.CalculationSpecification.Id);
if (specCalculation == null || specCalculation.StatusCode == HttpStatusCode.NotFound)
{
return(new NotFoundObjectResult(ErrorMessages.CalculationNotFoundInSpecsService));
}
CalculationDescription = specCalculation.Content.Description;
ApiResponse <IEnumerable <CalculationVersion> > calculationVersionsResponse = await _calcClient.GetMultipleVersionsByCalculationId(versions, calculationId);
if (calculationVersionsResponse == null || calculationVersionsResponse.StatusCode != HttpStatusCode.OK)
{
throw new InvalidOperationException($"Unable to retreive selected versions of calculations. Status Code = {calculationVersionsResponse?.StatusCode}");
}
if (calculationVersionsResponse.StatusCode == HttpStatusCode.OK)
{
IEnumerable <CalculationVersion> calculationVersions = calculationVersionsResponse.Content;
if (calculationVersions.IsNullOrEmpty())
{
throw new InvalidOperationException($"Unable to retrieve calculationVersion model from the response. Calculation version value = {calculationVersions.ToString()}");
}
else
{
if (calculationVersions.Count() < 2)
{
throw new InvalidOperationException($"There are less than two previous versions available. Calculation version count ={calculationVersions.Count()}");
}
List <CalculationVersion> calculationVersionsList = calculationVersions.OrderBy(c => c.Version).ToList();
LeftCalcualationDiffModel = _mapper.Map <CalculationVersionViewModel>(calculationVersionsList[0]);
RightCalculationDiffModel = _mapper.Map <CalculationVersionViewModel>(calculationVersionsList[1]);
}
}
return(Page());
}
public async Task EditCalculationPageModel_OnGetAsync_WhenUserDoesNotHaveEditSpecificationPermission_ThenReturnOkWithAuthorizedToEditFlagSetToFalse()
{
// 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));
List <FundingStream> fundingStreams = new List <FundingStream>();
fundingStreams.Add(new FundingStream
{
Id = "fs1",
AllocationLines = new List <AllocationLine>()
{
new AllocationLine()
{
Id = "al1",
Name = "Allocation Line 1",
}
}
});
specsClient
.GetBaselineCalculationsBySpecificationId(Arg.Is(specification.Id))
.Returns(new ApiResponse <IEnumerable <CalculationCurrentVersion> >(HttpStatusCode.OK, Enumerable.Empty <CalculationCurrentVersion>()));
ApiResponse <IEnumerable <FundingStream> > fundingStreamResponse = new ApiResponse <IEnumerable <FundingStream> >(HttpStatusCode.OK, fundingStreams);
specsClient
.GetFundingStreamsForSpecification(Arg.Is(specification.Id))
.Returns(fundingStreamResponse);
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.OnGetAsync(specificationId, calculationId);
// Assert
result
.Should()
.BeOfType <PageResult>()
.Which
.Should()
.NotBeNull();
pageModel
.IsAuthorizedToEdit
.Should()
.BeFalse();
}
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 <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 OnGet_WhenCalculationExistdCalculationTypeIsFundingAndShouldNewEditCalculationPageBeEnabledIsTurnedOnAndResultFound_ThenCalculationDisplayTypeIsFundingSetsHasCalculationResultToTrue()
{
// Arrange
ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>();
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
IFeatureToggle featureToggle = CreateFeatureToggle();
featureToggle
.IsNewEditCalculationPageEnabled()
.Returns(true);
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));
ApiResponse <bool> hasCalcsResponse = new ApiResponse <bool>(HttpStatusCode.OK, true);
IResultsApiClient resultsApiClient = CreateResultsApiClient();
resultsApiClient
.HasCalculationResults(Arg.Is(calcsCalculation.Id))
.Returns(hasCalcsResponse);
EditCalculationPageModel pageModel = CreatePageModel(specsClient: specsClient, calcsClient: calcsClient, mapper: mapper, features: featureToggle, resultsApiClient: resultsApiClient);
// 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);
pageModel.CalculationHasResults.Should().BeTrue();
string shouldShowGreyBackground = pageModel.ViewData["GreyBackground"].ToString();
shouldShowGreyBackground
.Should()
.Be("True");
}
