public void OnPostAsync_GivenNameAlreadyExistsAndPopulateFundingPeriodsReturnsOKButNullContent_ThrowsInvalidOperationException()
{
//Arrange
ApiResponse <IEnumerable <Reference> > fundingPeriodsResponse = new ApiResponse <IEnumerable <Reference> >(HttpStatusCode.OK);
ApiResponse <Specification> existingSpecificationResponse = new ApiResponse <Specification>(HttpStatusCode.OK);
ISpecsApiClient apiClient = CreateApiClient();
apiClient
.GetSpecificationByName(Arg.Is(specName))
.Returns(existingSpecificationResponse);
apiClient
.GetFundingPeriods()
.Returns(fundingPeriodsResponse);
EditSpecificationPageModel pageModel = CreatePageModel(apiClient);
pageModel.PageContext = new PageContext();
pageModel.EditSpecificationViewModel = new EditSpecificationViewModel
{
Name = specName
};
//Act/Assert
Func <Task> test = async() => await pageModel.OnPostAsync();
test
.Should()
.ThrowExactly <InvalidOperationException>();
}
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 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 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 ProviderResultsBasePageModel(IResultsApiClient resultsApiClient, IMapper mapper, ISpecsApiClient specsApiClient, ILogger logger)
{
_resultsApiClient = resultsApiClient;
_mapper = mapper;
_specsApiClient = specsApiClient;
_logger = logger;
}
public void OnGetAsync_ReturnsErrorWhenFundingPeriodResponseIsNull()
{
// Arrange
IResultsApiClient resultsApiClient = CreateApiClient();
ISpecsApiClient specsClient = CreateSpecsApiClient();
ITestScenarioSearchService searchService = CreateTestScenarioSearchService();
ProviderScenarioResultsPageModel providerScenarioResultsPageModel = CreatePageModel(searchService, resultsApiClient, specsApiClient: specsClient);
Provider provider = CreateProvider();
IEnumerable <Reference> fundingPeriods = null;
resultsApiClient.GetProviderByProviderId(Arg.Any <string>())
.Returns(new ApiResponse <Provider>(HttpStatusCode.OK, provider));
SearchRequestViewModel searchRequest = CreateSearchRequest();
specsClient.GetFundingPeriods()
.Returns(new ApiResponse <IEnumerable <Reference> >(HttpStatusCode.NotFound, fundingPeriods));
// Act
Func <Task> test = async() => await providerScenarioResultsPageModel.OnGetAsync("2", 1, "", "1819", "1");
// Assert
test
.Should()
.ThrowExactly <System.InvalidOperationException>().WithMessage("Unable to retreive Periods: Status Code = NotFound");
}
public CalculationProviderResultsPageModel(
ICalculationProviderResultsSearchService resultsSearchService,
ICalculationsApiClient calculationsApiClient,
ISpecsApiClient specsApiClient,
IMapper mapper,
IDatasetsApiClient datasetsClient,
ILogger logger,
IJobsApiClient jobsApiClient,
IFeatureToggle featureToggle)
{
Guard.ArgumentNotNull(resultsSearchService, nameof(resultsSearchService));
Guard.ArgumentNotNull(calculationsApiClient, nameof(calculationsApiClient));
Guard.ArgumentNotNull(specsApiClient, nameof(specsApiClient));
Guard.ArgumentNotNull(mapper, nameof(mapper));
Guard.ArgumentNotNull(datasetsClient, nameof(datasetsClient));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(jobsApiClient, nameof(jobsApiClient));
Guard.ArgumentNotNull(featureToggle, nameof(featureToggle));
_mapper = mapper;
_resultsSearchService = resultsSearchService;
_calculationsApiClient = calculationsApiClient;
_specsClient = specsApiClient;
_datasetsClient = datasetsClient;
_jobsClient = jobsApiClient;
_logger = logger;
ShowExceptionCountAndFacet = featureToggle.IsExceptionMessagesEnabled();
}
public async Task PerformSearch_StartAndEndItemsNumbersDisplayedCorrectlyOnSecondPageOfItemsWithMorePagesAvailable()
{
// Arrange
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
ILogger logger = Substitute.For <ILogger>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
IFeatureToggle featureToggle = CreateFeatureToggle();
ISpecificationSearchService SpecificationSearchService = new SpecificationSearchService(specsClient, mapper, logger, featureToggle);
int numberOfItems = 50;
PagedResult <SpecificationSearchResultItem> itemResult = GeneratePagedResult(numberOfItems);
itemResult.PageNumber = 2;
itemResult.PageSize = 50;
itemResult.TotalItems = 175;
specsClient
.FindSpecifications(Arg.Any <SearchFilterRequest>())
.Returns(itemResult);
SearchRequestViewModel request = new SearchRequestViewModel()
{
PageNumber = 2,
};
// Act
SpecificationSearchResultViewModel results = await SpecificationSearchService.PerformSearch(request);
// Assert
results.StartItemNumber.Should().Be(51);
results.EndItemNumber.Should().Be(100);
}
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 void PerformSearch_WhenFindSpecificationsServiceUnavailable_ThenHttpExceptionThrown()
{
// Arrange
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
ILogger logger = Substitute.For <ILogger>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
IFeatureToggle featureToggle = CreateFeatureToggle();
ISpecificationSearchService SpecificationSearchService = new SpecificationSearchService(specsClient, mapper, logger, featureToggle);
specsClient
.When(a => a.FindSpecifications(Arg.Any <SearchFilterRequest>()))
.Do(x => { throw new HttpRequestException(); });
SearchRequestViewModel request = new SearchRequestViewModel();
// Act
Action pageAction = new Action(() =>
{
SpecificationSearchResultViewModel result = SpecificationSearchService.PerformSearch(request).Result;
});
// Assert
pageAction.Should().Throw <HttpRequestException>();
}
public void EditSpecificationStatus_GivenFailedStatusCode_ThrowsInvalidOperationException()
{
//Arrange
string specificationId = "5";
PublishStatusEditModel model = new PublishStatusEditModel();
ValidatedApiResponse <PublishStatusResult> response = new ValidatedApiResponse <PublishStatusResult>(HttpStatusCode.BadRequest);
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
specsClient
.UpdatePublishStatus(Arg.Is(specificationId), Arg.Is(model))
.Returns(response);
IAuthorizationHelper authorizationHelper = TestAuthHelper.CreateAuthorizationHelperSubstitute(specificationId, SpecificationActionTypes.CanApproveSpecification);
SpecificationController controller = CreateSpecificationController(specsClient, authorizationHelper);
// Act
Func <Task> test = async() => await controller.EditSpecificationStatus(specificationId, model);
// Assert
test
.Should()
.Throw <InvalidOperationException>();
}
public async Task EditSpecificationStatus_GivenSuccessReturnedFromApi_ReturnsOK()
{
//Arrange
string specificationId = "5";
PublishStatusEditModel model = new PublishStatusEditModel();
PublishStatusResult publishStatusResult = new PublishStatusResult();
ValidatedApiResponse <PublishStatusResult> response = new ValidatedApiResponse <PublishStatusResult>(HttpStatusCode.OK, publishStatusResult);
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
specsClient
.UpdatePublishStatus(Arg.Is(specificationId), Arg.Is(model))
.Returns(response);
IAuthorizationHelper authorizationHelper = TestAuthHelper.CreateAuthorizationHelperSubstitute(specificationId, SpecificationActionTypes.CanApproveSpecification);
SpecificationController controller = CreateSpecificationController(specsClient, authorizationHelper);
// Act
IActionResult result = await controller.EditSpecificationStatus(specificationId, model);
// Assert
result
.Should()
.BeOfType <OkObjectResult>()
.Which
.Value
.Should()
.Be(publishStatusResult);
}
public void OnGetAsync_GivenToPopulayeFundingPeriodsIsOKButFundingStreamsReturnsBadRequest_ThrowsInvalidOperationException()
{
//Arrange
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.BadRequest);
ISpecsApiClient apiClient = CreateApiClient();
apiClient
.GetFundingPeriods()
.Returns(fundingPeriodsResponse);
apiClient
.GetFundingStreams()
.Returns(fundingStreamsResponse);
CreateSpecificationPageModel pageModel = CreatePageModel(apiClient);
//Act/Assert
Func <Task> test = async() => await pageModel.OnGetAsync();
test
.Should()
.ThrowExactly <InvalidOperationException>();
}
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 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 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 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 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 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 PerformSearch_FirstSearchResultReturnedCorrectly()
{
// Arrange
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
ILogger logger = Substitute.For <ILogger>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
IFeatureToggle featureToggle = CreateFeatureToggle();
ISpecificationSearchService SpecificationSearchService = new SpecificationSearchService(specsClient, mapper, logger, featureToggle);
int numberOfItems = 25;
PagedResult <SpecificationSearchResultItem> itemResult = GeneratePagedResult(numberOfItems);
specsClient
.FindSpecifications(Arg.Any <SearchFilterRequest>())
.Returns(itemResult);
SearchRequestViewModel request = new SearchRequestViewModel();
// Act
SpecificationSearchResultViewModel results = await SpecificationSearchService.PerformSearch(request);
// Assert
SpecificationSearchResultItemViewModel first = results.Specifications.First();
first.Should().NotBeNull();
first.Id.Should().Be("10");
first.Name.Should().Be("Specification 1");
first.Status.Should().Be("Draft");
first.FundingPeriodName.Should().Be("Test Period");
}
public async Task EditSpecificationStatus_WhenUserDoesNotHaveApproveSpecificationPermission_ThenReturn403()
{
//Arrange
string specificationId = "5";
PublishStatusEditModel model = new PublishStatusEditModel();
PublishStatusResult publishStatusResult = new PublishStatusResult();
ValidatedApiResponse <PublishStatusResult> response = new ValidatedApiResponse <PublishStatusResult>(HttpStatusCode.OK, publishStatusResult);
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
specsClient
.UpdatePublishStatus(Arg.Is(specificationId), Arg.Is(model))
.Returns(response);
IAuthorizationHelper authorizationHelper = Substitute.For <IAuthorizationHelper>();
authorizationHelper.DoesUserHavePermission(Arg.Any <ClaimsPrincipal>(), Arg.Is(specificationId), Arg.Is(SpecificationActionTypes.CanApproveSpecification))
.Returns(false);
SpecificationController controller = CreateSpecificationController(specsClient, authorizationHelper);
// Act
IActionResult result = await controller.EditSpecificationStatus(specificationId, model);
// Assert
result.Should().BeOfType <ForbidResult>();
}
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 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 ChoosePageModel(
ISpecsApiClient specsApiClient,
ICalculationsApiClient calcsClient,
IResultsApiClient resultsClient,
ITestEngineApiClient testEngineClient,
IMapper mapper,
IAuthorizationHelper authorizationHelper,
IFeatureToggle featureToggle)
{
Guard.ArgumentNotNull(specsApiClient, nameof(specsApiClient));
Guard.ArgumentNotNull(calcsClient, nameof(calcsClient));
Guard.ArgumentNotNull(resultsClient, nameof(resultsClient));
Guard.ArgumentNotNull(testEngineClient, nameof(testEngineClient));
Guard.ArgumentNotNull(mapper, nameof(mapper));
Guard.ArgumentNotNull(authorizationHelper, nameof(authorizationHelper));
Guard.ArgumentNotNull(featureToggle, nameof(featureToggle));
_specsClient = specsApiClient;
_calcsClient = calcsClient;
_resultsClient = resultsClient;
_testEngineClient = testEngineClient;
_mapper = mapper;
_authorizationHelper = authorizationHelper;
_featureToggle = featureToggle;
}
public async Task EditTestScenarioPageModel_OnGetAsync_GivenTestScenarioNotFoundFromRepository_ReturnsNotFoundResult()
{
//Arrange
ApiResponse <TestScenario> testScenario = new ApiResponse <TestScenario>(HttpStatusCode.NotFound);
ISpecsApiClient specsClient = CreateSpecsApiClient();
IScenariosApiClient scenarioClient = CreateScenarioApiClient();
scenarioClient
.GetCurrentTestScenarioById(Arg.Is(TestScenarioid))
.Returns(testScenario);
EditTestScenarioPageModel pageModel = CreatePageModel(specsClient, scenarioClient);
//Act
IActionResult result = await pageModel.OnGetAsync(TestScenarioid);
//Assert
result
.Should()
.BeOfType <NotFoundObjectResult>()
.Which
.Value
.Should()
.Be("Test Scenario not found");
}
public async Task EditTestScenarioPageModel_OnGetAsync_GivenSpecificationNotFoundFromRepository_ReturnsPreconditionFailed()
{
// Arrange
ApiResponse <TestScenario> testScenario = new ApiResponse <TestScenario>(HttpStatusCode.OK, new TestScenario()
{
SpecificationId = SpecificationId
});
ISpecsApiClient specsClient = CreateSpecsApiClient();
specsClient
.GetSpecificationSummary(Arg.Is(SpecificationId))
.Returns(new ApiResponse <SpecificationSummary>(HttpStatusCode.NotFound, null));
IScenariosApiClient scenarioClient = CreateScenarioApiClient();
scenarioClient
.GetCurrentTestScenarioById(Arg.Is(TestScenarioid))
.Returns(testScenario);
EditTestScenarioPageModel pageModel = CreatePageModel(specsClient, scenarioClient);
// Act
IActionResult result = await pageModel.OnGetAsync(TestScenarioid);
// Assert
result
.Should()
.BeOfType <PreconditionFailedResult>()
.Which
.Value
.Should()
.Be("Specification not found");
}
public async Task OnGet_WhenGetAllVersionsbyCalculationIdReturnsNull_ThenServerErrorResponseIsReturned()
{
// Arrange
ICalculationsApiClient calcsClient = Substitute.For <ICalculationsApiClient>();
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
ILogger logger = Substitute.For <ILogger>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
string calculationID = "1";
calcsClient
.GetAllVersionsByCalculationId(calculationID)
.Returns((ApiResponse <IEnumerable <CalculationVersion> >)null);
ComparePageModel compPageModel = new ComparePageModel(specsClient, calcsClient, mapper);
// Act
IActionResult result = await compPageModel.OnGet(calculationID);
// Assert
result.Should().BeOfType <StatusCodeResult>();
StatusCodeResult typedResult = result as StatusCodeResult;
typedResult.StatusCode.Should().Be(500);
}
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 OnGetAsync_WhenGettingProviderResultsIsSuccess_CalculationDetails_Populated()
{
// Arrange
IResultsApiClient resultsApiClient = CreateApiClient();
ISpecsApiClient specsClient = CreateSpecsApiClient();
IMapper mapper = CreateMapper();
ILogger logger = CreateLogger();
IFeatureToggle featureToggle = Substitute.For <IFeatureToggle>();
ProviderCalcsResultsPageModel provideCalcPageModel = CreatePageModel(resultsApiClient, specsClient, mapper, logger, featureToggle);
IEnumerable <Reference> fundingPeriods = new[] { new Reference("1617", "2016-2017"), new Reference("1718", "2017-2018"), new Reference("1819", "2018-2019") };
Provider provider = CreateProvider();
IEnumerable <string> specSummary = GetSpecificationsWithResults();
IList <CalculationResultItem> calResult = GetCalcResults();
IList <AllocationLineResultItem> allocResult = GetAllocationResults();
ProviderResults providerResults = new ProviderResults()
{
AllocationResults = allocResult,
CalculationResults = calResult
};
resultsApiClient.GetProviderByProviderId(Arg.Any <string>())
.Returns(new ApiResponse <Provider>(HttpStatusCode.OK, provider));
specsClient.GetFundingPeriods()
.Returns(new ApiResponse <IEnumerable <Reference> >(HttpStatusCode.OK, fundingPeriods));
resultsApiClient.GetProviderResults(Arg.Is("2"), Arg.Is("2"))
.Returns(new ApiResponse <ProviderResults>(HttpStatusCode.OK, providerResults));
resultsApiClient.GetSpecificationIdsForProvider("2")
.Returns(new ApiResponse <IEnumerable <string> >(HttpStatusCode.OK, specSummary));
specsClient
.GetSpecificationSummaries(Arg.Any <IEnumerable <string> >())
.Returns(new ApiResponse <IEnumerable <Clients.SpecsClient.Models.SpecificationSummary> >(HttpStatusCode.OK, new List <Clients.SpecsClient.Models.SpecificationSummary>()));
// Act
IActionResult result = await provideCalcPageModel.OnGetAsync("2", "1617", "2");
// Assert
provideCalcPageModel.CalculationErrorCount.Equals(1);
provideCalcPageModel.ViewModel.CalculationItems.Should().HaveSameCount(calResult);
provideCalcPageModel.ViewModel.CalculationItems.First().CalculationType.Should().Be(Clients.SpecsClient.Models.CalculationSpecificationType.Number);
provideCalcPageModel.ViewModel.CalculationItems.Last().CalculationType.Should().Be(Clients.SpecsClient.Models.CalculationSpecificationType.Funding);
}
public void TestScenarioResultsService_PerformSearch_WhenRowCountsApiCallContentIsNull_ThenExceptionThrown()
{
// Arrange
IScenarioSearchService searchService = CreateScenarioSearchService();
ISpecsApiClient specsApiClient = CreateSpecsApiClient();
ITestEngineApiClient testEngineApiClient = CreateTestEngineApiClient();
ILogger logger = CreateLogger();
TestScenarioResultRequestViewModel resultRequestViewModel = new TestScenarioResultRequestViewModel()
{
SearchTerm = "",
PageNumber = 1,
FundingPeriodId = null,
SpecificationId = null,
};
TestScenarioResultsService testScenarioResultsService = CreateService(searchService, specsApiClient, testEngineApiClient, logger: logger);
searchService.PerformSearch(Arg.Any <SearchRequestViewModel>())
.Returns(new ScenarioSearchResultViewModel()
{
Scenarios = new List <ScenarioSearchResultItemViewModel>()
{
new ScenarioSearchResultItemViewModel()
{
Id = "s1",
Name = "S1",
},
new ScenarioSearchResultItemViewModel()
{
Id = "s2",
Name = "S2",
},
}
});
List <SpecificationSummary> specifications = CreateSpecifications();
specsApiClient
.GetSpecificationSummaries()
.Returns(new ApiResponse <IEnumerable <SpecificationSummary> >(HttpStatusCode.OK, specifications));
testEngineApiClient
.GetTestResultCounts(Arg.Any <TestScenarioResultCountsRequestModel>())
.Returns(new ApiResponse <IEnumerable <TestScenarioResultCounts> >(HttpStatusCode.OK, null));
// Act
Func <Task> action = async() => await testScenarioResultsService.PerformSearch(resultRequestViewModel);
// Assert
action.
Should()
.ThrowExactly <InvalidOperationException>()
.WithMessage("Row counts api request failed with null content");
logger
.Received(1)
.Warning(Arg.Is("Row counts api request failed with null content"));
}
