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 <IActionResult> OnGetAsync(string specificationId, bool wasSuccess = false)
{
Guard.IsNullOrWhiteSpace(specificationId, nameof(specificationId));
ShowSuccessMessage = wasSuccess;
ApiResponse <SpecificationSummary> specificationResponse = await _specsApiClient.GetSpecificationSummary(specificationId);
if (specificationResponse.StatusCode != HttpStatusCode.OK)
{
_logger.Error($"Failed to fetch specification with status code {specificationResponse.StatusCode.ToString()}");
return(new StatusCodeResult((int)specificationResponse.StatusCode));
}
IsAuthorizedToMap = await _authorizationHelper.DoesUserHavePermission(User, specificationResponse.Content,
SpecificationActionTypes.CanMapDatasets);
SpecificationDatasetRelationshipsViewModel viewModel = await PopulateViewModel(specificationResponse.Content);
if (viewModel == null)
{
_logger.Error($"A null view model was returned");
return(new StatusCodeResult(500));
}
ViewModel = viewModel;
return(Page());
}
public async Task OnGetAsync_GivenCountTaskReturnsNoItems_ThenCoverageIsSetCorrectly()
{
//Arrange
ApiResponse <TestScenario> scenario = new ApiResponse <TestScenario>(HttpStatusCode.OK, new TestScenario());
IScenariosApiClient apiClient = CreateScenariosClient();
apiClient
.GetCurrentTestScenarioById(Arg.Is(Scenarioid))
.Returns(scenario);
ProviderTestsSearchResultViewModel viewModel = new ProviderTestsSearchResultViewModel();
ITestResultsSearchService resultsService = CreateResultsService();
resultsService
.PerformProviderTestResultsSearch(Arg.Any <SearchRequestViewModel>())
.Returns(viewModel);
ITestEngineApiClient testEngineApiClient = CreateTestEngineClient();
testEngineApiClient
.GetTestResultCounts(Arg.Any <TestScenarioResultCountsRequestModel>())
.Returns(new ApiResponse <IEnumerable <TestScenarioResultCounts> >(HttpStatusCode.OK, Enumerable.Empty <TestScenarioResultCounts>()));
ISpecsApiClient specsApiClient = CreateSpecsClient();
specsApiClient
.GetSpecificationSummary(Arg.Any <string>())
.Returns(new ApiResponse <Clients.SpecsClient.Models.SpecificationSummary>(HttpStatusCode.OK, new Clients.SpecsClient.Models.SpecificationSummary()));
ViewProviderTestResultsPageModel pageModel = CreatePageModel(
resultsService, testEngineApiClient,
scenariosApiClient: apiClient,
specsApiClient: specsApiClient);
//Act
IActionResult result = await pageModel.OnGetAsync(Scenarioid, null, "");
//Assert
result
.Should()
.BeOfType <PageResult>()
.Which
.Should()
.NotBeNull();
await testEngineApiClient
.Received(1)
.GetTestResultCounts(Arg.Any <TestScenarioResultCountsRequestModel>());
pageModel
.TestCoverage
.Should()
.Be(0);
}
public async Task SpecificationRelationshipsPageModel_GivenDatasetRelationshipsResponseReturnsBadRequest_ReturnsStatusCode500()
{
// Arrange
string specificationId = Guid.NewGuid().ToString();
SpecificationSummary specification = new SpecificationSummary
{
Id = specificationId
};
ApiResponse <SpecificationSummary> specificationResponse = new ApiResponse <SpecificationSummary>(HttpStatusCode.OK, specification);
ISpecsApiClient specsApiClient = CreateSpecsApiClient();
specsApiClient
.GetSpecificationSummary(Arg.Is(specificationId))
.Returns(specificationResponse);
ApiResponse <IEnumerable <DatasetSpecificationRelationshipModel> > relationshipsResponse = new ApiResponse <IEnumerable <DatasetSpecificationRelationshipModel> >(HttpStatusCode.BadRequest);
IDatasetsApiClient datasetsApiClient = CreateDatasetApiClient();
datasetsApiClient
.GetDatasetSpecificationRelationshipsBySpecificationId(Arg.Is(specificationId))
.Returns(relationshipsResponse);
ILogger logger = CreateLogger();
SpecificationRelationshipsPageModel pageModel = CreatePageModel(specsApiClient, datasetsApiClient, logger);
// Act
IActionResult result = await pageModel.OnGetAsync(specificationId);
// Assert
result
.Should()
.BeOfType <StatusCodeResult>();
StatusCodeResult statusCodeResult = result as StatusCodeResult;
statusCodeResult
.StatusCode
.Should()
.Be(500);
logger
.Received(1)
.Error($"Failed to fetch specification relationships for specification id: {specificationId}");
logger
.Received(1)
.Error($"A null view model was returned");
}
public void OnPost_WhenModelIsInvalidAndDatasetDefinitionListReturnedIsNull_ShoulThrowInvalidOperationException()
{
// Arrange
string anyString = "anyString";
string expectedSpecificationId = "spec123";
SpecificationSummary expectedSpecification = new SpecificationSummary()
{
FundingPeriod = new Reference(anyString, anyString),
Name = anyString,
Description = anyString
};
ISpecsApiClient mockSpecsClient = Substitute.For <ISpecsApiClient>();
mockSpecsClient
.GetSpecificationSummary(Arg.Is(expectedSpecificationId))
.Returns(new ApiResponse <SpecificationSummary>(HttpStatusCode.OK, expectedSpecification));
IDatasetsApiClient mockDatasetsApiClient = Substitute.For <IDatasetsApiClient>();
mockDatasetsApiClient
.GetDataDefinitions()
.Returns(new ApiResponse <IEnumerable <DatasetDefinition> >(HttpStatusCode.OK));
mockDatasetsApiClient
.AssignDatasetSchema(Arg.Any <AssignDatasetSchemaModel>())
.Returns(HttpStatusCode.OK);
IAuthorizationHelper mockAuthorizationHelper = Substitute.For <IAuthorizationHelper>();
mockAuthorizationHelper
.DoesUserHavePermission(Arg.Any <ClaimsPrincipal>(), Arg.Any <ISpecificationAuthorizationEntity>(), Arg.Is(SpecificationActionTypes.CanEditSpecification))
.Returns(true);
AssignDatasetSchemaPageModel datasetSchemaPageModel = CreatePageModel(specsClient: mockSpecsClient,
authorizationHelper: mockAuthorizationHelper, datasetsClient: mockDatasetsApiClient, mapper: MappingHelper.CreateFrontEndMapper());
datasetSchemaPageModel.AssignDatasetSchemaViewModel = new AssignDatasetSchemaViewModel();
datasetSchemaPageModel.ModelState.AddModelError(anyString, anyString);
// Act
Func <Task <IActionResult> > postAction = async() => await datasetSchemaPageModel.OnPostAsync(expectedSpecificationId);
// Assert
postAction
.Should()
.Throw <InvalidOperationException>()
.Which
.Message
.Should().Be(
$"Unable to retrieve Dataset definition from the response. Specification Id value = {expectedSpecificationId}");
}
public async Task OnGet_WhenDatasetResponseIsNullThenNotObjectFoundResultIsReturned()
{
// Arrange
IDatasetsApiClient datasetClient = Substitute.For <IDatasetsApiClient>();
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
ILogger logger = Substitute.For <ILogger>();
string expectedSpecificationId = "1";
SpecificationSummary expectedSpecification = new SpecificationSummary
{
FundingPeriod = new Reference("2018", "17-18"),
FundingStreams = new List <Reference>()
{
new Reference("2018", "18-19"),
},
Description = "Test Spec",
Id = "1",
Name = "APT Final Baselines current year"
};
AssignDatasetSchemaPageModel datasetSchemaPageModel = CreatePageModel(specsClient, datasetClient, mapper);
specsClient
.GetSpecificationSummary(expectedSpecificationId)
.Returns(new ApiResponse <SpecificationSummary>(HttpStatusCode.OK, expectedSpecification));
IEnumerable <DatasetDefinition> dataDefn = null;
datasetClient
.GetDataDefinitions()
.Returns(new ApiResponse <IEnumerable <DatasetDefinition> >(HttpStatusCode.NotFound, 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("Check the data schema - one or more the data definitions aren't working");
}
public async Task OnPost_WhenModelIsInvalidAndUserIsUnauthorizedToEditSpecification_ShouldReturnForbidResult()
{
// Arrange
const string anyString = "any";
string expectedSpecificationId = "spec123";
const string fundingPeriodId = "2018";
const string fundingPeriodName = "1819";
const string specificationName = "Pe and sports spec";
const string specDescription = "test spec";
SpecificationSummary expectedSpecification = new SpecificationSummary()
{
FundingPeriod = new Reference(fundingPeriodId, fundingPeriodName),
Name = specificationName,
Description = specDescription
};
ISpecsApiClient mockSpecsClient = Substitute.For <ISpecsApiClient>();
mockSpecsClient
.GetSpecificationSummary(Arg.Is(expectedSpecificationId))
.Returns(new ApiResponse <SpecificationSummary>(HttpStatusCode.OK, expectedSpecification));
IDatasetsApiClient mockDatasetsApiClient = Substitute.For <IDatasetsApiClient>();
mockDatasetsApiClient
.GetDataDefinitions()
.Returns(new ApiResponse <IEnumerable <DatasetDefinition> >(HttpStatusCode.OK, GetDummyDataDefinitions()));
mockDatasetsApiClient
.AssignDatasetSchema(Arg.Any <AssignDatasetSchemaModel>())
.Returns(HttpStatusCode.OK);
IAuthorizationHelper mockAuthorizationHelper = Substitute.For <IAuthorizationHelper>();
mockAuthorizationHelper
.DoesUserHavePermission(Arg.Any <ClaimsPrincipal>(), Arg.Any <ISpecificationAuthorizationEntity>(), Arg.Is(SpecificationActionTypes.CanEditSpecification))
.Returns(false);
AssignDatasetSchemaPageModel datasetSchemaPageModel = CreatePageModel(specsClient: mockSpecsClient,
authorizationHelper: mockAuthorizationHelper, datasetsClient: mockDatasetsApiClient, mapper: MappingHelper.CreateFrontEndMapper());
datasetSchemaPageModel.AssignDatasetSchemaViewModel = new AssignDatasetSchemaViewModel();
datasetSchemaPageModel.ModelState.AddModelError(anyString, anyString);
// Act
IActionResult result = await datasetSchemaPageModel.OnPostAsync(expectedSpecificationId);
// Assert
result
.Should().BeOfType <ForbidResult>();
}
public async Task OnPost_WhenModelIsInvalidAndDataDefinitionsNotReturnedCorrectly_ShoulReturnNotFoundObjectResult()
{
// Arrange
string anyString = "anyString";
string expectedSpecificationId = "spec123";
SpecificationSummary expectedSpecification = new SpecificationSummary()
{
FundingPeriod = new Reference(anyString, anyString),
Name = anyString,
Description = anyString
};
ISpecsApiClient mockSpecsClient = Substitute.For <ISpecsApiClient>();
mockSpecsClient
.GetSpecificationSummary(Arg.Is(expectedSpecificationId))
.Returns(new ApiResponse <SpecificationSummary>(HttpStatusCode.OK, expectedSpecification));
IDatasetsApiClient mockDatasetsApiClient = Substitute.For <IDatasetsApiClient>();
mockDatasetsApiClient
.GetDataDefinitions()
.Returns(new ApiResponse <IEnumerable <DatasetDefinition> >(HttpStatusCode.NotFound));
mockDatasetsApiClient
.AssignDatasetSchema(Arg.Any <AssignDatasetSchemaModel>())
.Returns(HttpStatusCode.OK);
IAuthorizationHelper mockAuthorizationHelper = Substitute.For <IAuthorizationHelper>();
mockAuthorizationHelper
.DoesUserHavePermission(Arg.Any <ClaimsPrincipal>(), Arg.Any <ISpecificationAuthorizationEntity>(), Arg.Is(SpecificationActionTypes.CanEditSpecification))
.Returns(true);
AssignDatasetSchemaPageModel datasetSchemaPageModel = CreatePageModel(specsClient: mockSpecsClient,
authorizationHelper: mockAuthorizationHelper, datasetsClient: mockDatasetsApiClient, mapper: MappingHelper.CreateFrontEndMapper());
datasetSchemaPageModel.AssignDatasetSchemaViewModel = new AssignDatasetSchemaViewModel();
datasetSchemaPageModel.ModelState.AddModelError(anyString, anyString);
// Act
IActionResult result = await datasetSchemaPageModel.OnPostAsync(expectedSpecificationId);
// Assert
result
.Should().BeOfType <NotFoundObjectResult>()
.Which
.Value
.Should().Be("Check the data schema - one or more the data definitions aren't working");
}
private async Task <SpecificationSummary> GetSpecification(string specificationId)
{
Guard.IsNullOrWhiteSpace(specificationId, nameof(specificationId));
ApiResponse <SpecificationSummary> specificationResponse = await _specsClient.GetSpecificationSummary(specificationId);
if (specificationResponse != null && specificationResponse.StatusCode == HttpStatusCode.OK)
{
return(specificationResponse.Content);
}
return(null);
}
public async Task OnPost_WhenModelIsInvalidShouldPopulate_ShoulReturnCorrectRedirect()
{
// Arrange
string anyString = "anyString";
string expectedSpecificationId = "spec123";
SpecificationSummary expectedSpecification = new SpecificationSummary()
{
FundingPeriod = new Reference(anyString, anyString),
Name = anyString,
Description = anyString
};
ISpecsApiClient mockSpecsClient = Substitute.For <ISpecsApiClient>();
mockSpecsClient
.GetSpecificationSummary(Arg.Is(expectedSpecificationId))
.Returns(new ApiResponse <SpecificationSummary>(HttpStatusCode.OK, expectedSpecification));
IDatasetsApiClient mockDatasetsApiClient = Substitute.For <IDatasetsApiClient>();
mockDatasetsApiClient
.GetDataDefinitions()
.Returns(new ApiResponse <IEnumerable <DatasetDefinition> >(HttpStatusCode.OK, GetDummyDataDefinitions()));
mockDatasetsApiClient
.AssignDatasetSchema(Arg.Any <AssignDatasetSchemaModel>())
.Returns(HttpStatusCode.OK);
IAuthorizationHelper mockAuthorizationHelper = Substitute.For <IAuthorizationHelper>();
mockAuthorizationHelper
.DoesUserHavePermission(Arg.Any <ClaimsPrincipal>(), Arg.Any <ISpecificationAuthorizationEntity>(), Arg.Is(SpecificationActionTypes.CanEditSpecification))
.Returns(true);
AssignDatasetSchemaPageModel datasetSchemaPageModel = CreatePageModel(specsClient: mockSpecsClient,
authorizationHelper: mockAuthorizationHelper, datasetsClient: mockDatasetsApiClient, mapper: MappingHelper.CreateFrontEndMapper());
datasetSchemaPageModel.AssignDatasetSchemaViewModel = new AssignDatasetSchemaViewModel();
// Act
IActionResult result = await datasetSchemaPageModel.OnPostAsync(expectedSpecificationId);
// Assert
result
.Should().BeOfType <RedirectResult>()
.Subject
.Url
.Should().EndWith($"datasets/ListDatasetSchemas/{expectedSpecificationId}");
}
public void OnGet_WhenSpecificationContentIsNullThenInvalidOperationExpectionIsReturned()
{
// Arrange
IDatasetsApiClient datasetClient = Substitute.For <IDatasetsApiClient>();
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
ILogger logger = Substitute.For <ILogger>();
string expectedSpecificationId = "1";
SpecificationSummary expectedSpecification = null;
AssignDatasetSchemaPageModel datasetSchemaPageModel = CreatePageModel(specsClient, datasetClient, mapper);
specsClient
.GetSpecificationSummary(expectedSpecificationId)
.Returns(new ApiResponse <SpecificationSummary>(HttpStatusCode.OK, 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
Func <Task> test = async() => await datasetSchemaPageModel.OnGet(expectedSpecificationId);
// Assert
test.Should().ThrowExactly <InvalidOperationException>();
}
public void OnGet_WhenDatasetDefinitionIsNullThenInvalidOperationExpectionIsReturned()
{
// Arrange
IDatasetsApiClient datasetClient = Substitute.For <IDatasetsApiClient>();
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
ILogger logger = Substitute.For <ILogger>();
string expectedSpecificationId = "1";
SpecificationSummary expectedSpecification = new SpecificationSummary
{
FundingPeriod = new Reference("2018", "17-18"),
FundingStreams = new List <Reference>()
{
new Reference("2018", "18-19"),
},
Description = "Test Spec",
Id = "1",
Name = "APT Final Baselines current year"
};
// InvalidOperationException expectedException = null;
AssignDatasetSchemaPageModel datasetSchemaPageModel = CreatePageModel(specsClient, datasetClient, mapper);
specsClient
.GetSpecificationSummary(expectedSpecificationId)
.Returns(new ApiResponse <SpecificationSummary>(HttpStatusCode.OK, expectedSpecification));
IEnumerable <DatasetDefinition> dataDefn = null;
datasetClient
.GetDataDefinitions()
.Returns(new ApiResponse <IEnumerable <DatasetDefinition> >(HttpStatusCode.OK, dataDefn));
// Act
Func <Task> test = async() => await datasetSchemaPageModel.OnGet(expectedSpecificationId);
// Assert
test.Should().ThrowExactly <InvalidOperationException>();
}
public async Task OnGetAsync_GivenResultsReturned_ReturnsPage()
{
//Arrange
ApiResponse <TestScenario> scenario = new ApiResponse <TestScenario>(HttpStatusCode.OK, new TestScenario());
IScenariosApiClient scenariosClient = CreateScenariosClient();
scenariosClient
.GetCurrentTestScenarioById(Arg.Is(Scenarioid))
.Returns(scenario);
TestScenarioViewModel scenarioViewModel = new TestScenarioViewModel();
ProviderTestsSearchResultViewModel viewModel = new ProviderTestsSearchResultViewModel();
ITestResultsSearchService resultsService = CreateResultsService();
resultsService
.PerformProviderTestResultsSearch(Arg.Any <SearchRequestViewModel>())
.Returns(viewModel);
ITestEngineApiClient testEngineClient = CreateTestEngineClient();
List <TestScenarioResultCounts> countResults = new List <TestScenarioResultCounts>();
testEngineClient
.GetTestResultCounts(Arg.Is <TestScenarioResultCountsRequestModel>(c => c.TestScenarioIds.Count() == 1 && c.TestScenarioIds.First() == Scenarioid))
.Returns(new ApiResponse <IEnumerable <TestScenarioResultCounts> >(HttpStatusCode.OK, countResults));
ISpecsApiClient specsApiClient = CreateSpecsClient();
specsApiClient
.GetSpecificationSummary(Arg.Any <string>())
.Returns(new ApiResponse <Clients.SpecsClient.Models.SpecificationSummary>(HttpStatusCode.OK, new Clients.SpecsClient.Models.SpecificationSummary()));
ViewProviderTestResultsPageModel pageModel = CreatePageModel(resultsService, testEngineClient, scenariosClient, specsApiClient: specsApiClient);
//Act
IActionResult result = await pageModel.OnGetAsync(Scenarioid, null, "");
//Assert
result
.Should()
.BeAssignableTo <PageResult>();
}
public async Task OnGet_WhenUserDoesNotHaveEditSpecificationPermission_ThenReturnPageResultWithAuthorizedToEditFlagSetToFalse()
{
// Arrange
string anyString = "anyString";
string expectedSpecificationId = "spec123";
SpecificationSummary expectedSpecification = new SpecificationSummary()
{
FundingPeriod = new Reference(anyString, anyString),
Name = anyString,
Description = anyString
};
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
specsClient
.GetSpecificationSummary(Arg.Is(expectedSpecificationId))
.Returns(new ApiResponse <SpecificationSummary>(HttpStatusCode.OK, expectedSpecification));
IDatasetsApiClient mockDatasetsApiClient = Substitute.For <IDatasetsApiClient>();
mockDatasetsApiClient
.GetDataDefinitions()
.Returns(new ApiResponse <IEnumerable <DatasetDefinition> >(HttpStatusCode.OK, GetDummyDataDefinitions()));
IAuthorizationHelper authorizationHelper = Substitute.For <IAuthorizationHelper>();
authorizationHelper
.DoesUserHavePermission(Arg.Any <ClaimsPrincipal>(), Arg.Any <ISpecificationAuthorizationEntity>(), Arg.Is(SpecificationActionTypes.CanEditSpecification))
.Returns(false);
AssignDatasetSchemaPageModel datasetSchemaPageModel = CreatePageModel(specsClient: specsClient, authorizationHelper: authorizationHelper, datasetsClient: mockDatasetsApiClient);
// Act
IActionResult result = await datasetSchemaPageModel.OnGet(expectedSpecificationId);
// Assert
result
.Should().BeOfType <PageResult>();
datasetSchemaPageModel
.IsAuthorizedToEdit
.Should().BeFalse();
}
public async Task SpecificationRelationshipsPageModel_GivenSpecResponseReturnsBadRequest_ReturnsStatusCode400()
{
// Arrange
string specificationId = Guid.NewGuid().ToString();
ApiResponse <SpecificationSummary> specificationResponse = new ApiResponse <SpecificationSummary>(HttpStatusCode.BadRequest);
ISpecsApiClient specsApiClient = CreateSpecsApiClient();
specsApiClient
.GetSpecificationSummary(Arg.Is(specificationId))
.Returns(specificationResponse);
ILogger logger = CreateLogger();
SpecificationRelationshipsPageModel pageModel = CreatePageModel(specsApiClient, logger: logger);
// Act
IActionResult result = await pageModel.OnGetAsync(specificationId);
// Assert
result
.Should()
.BeOfType <StatusCodeResult>();
StatusCodeResult statusCodeResult = result as StatusCodeResult;
statusCodeResult
.StatusCode
.Should()
.Be(400);
logger
.Received(1)
.Error("Failed to fetch specification with status code BadRequest");
}
public async Task OnGet_WhenSpecificationExistsThenSpecificationReturned()
{
// Arrange
IDatasetsApiClient datasetClient = Substitute.For <IDatasetsApiClient>();
ISpecsApiClient specsClient = Substitute.For <ISpecsApiClient>();
IMapper mapper = MappingHelper.CreateFrontEndMapper();
ILogger logger = Substitute.For <ILogger>();
string expectedSpecificationId = "1";
SpecificationSummary expectedSpecification = new SpecificationSummary
{
FundingPeriod = new Reference("2018", "17-18"),
FundingStreams = new List <Reference>()
{
new Reference("2018", "18-19"),
},
Description = "Test Spec",
Id = "1",
Name = "APT Final Baselines current year"
};
AssignDatasetSchemaPageModel datasetSchemaPageModel = CreatePageModel(specsClient, datasetClient, mapper);
specsClient
.GetSpecificationSummary(expectedSpecificationId)
.Returns(new ApiResponse <SpecificationSummary>(HttpStatusCode.OK, 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();
datasetSchemaPageModel.SpecificationDescription.Should().Be(expectedSpecification.Description);
datasetSchemaPageModel.SpecificationId.Should().Be(expectedSpecification.Id);
datasetSchemaPageModel.SpecificationName.Should().Be(expectedSpecification.Name);
datasetSchemaPageModel.FundingPeriodId.Should().Be(expectedSpecification.FundingPeriod.Id);
datasetSchemaPageModel.FundingPeriodName.Should().Be(expectedSpecification.FundingPeriod.Name);
datasetSchemaPageModel.IsAuthorizedToEdit.Should().BeTrue();
List <SelectListItem> datasetDefinition = new List <SelectListItem>(datasetSchemaPageModel.Datasets);
datasetDefinition[0].Value.Should().Be(d1.Id);
datasetDefinition[0].Text.Should().Be(d1.Name);
datasetDefinition[1].Value.Should().Be(d2.Id);
datasetDefinition[1].Text.Should().Be(d2.Name);
}
private async Task <IActionResult> Populate(string calculationId, int?pageNumber, string searchTerm)
{
if (string.IsNullOrWhiteSpace(calculationId))
{
return(new BadRequestObjectResult(ErrorMessages.CalculationIdNullOrEmpty));
}
await PopulateCalculation(calculationId);
if (Calculation == null)
{
_logger.Error($"Failed to find calculation for id {calculationId}");
return(new NotFoundResult());
}
Task <ApiResponse <SpecificationSummary> > specLookupTask = _specsClient.GetSpecificationSummary(Calculation.SpecificationId);
Task <ApiResponse <IEnumerable <DatasetSchemasAssigned> > > datasetSchemaTask = _datasetsClient.GetAssignedDatasetSchemasForSpecification(Calculation.SpecificationId);
Task <ApiResponse <JobSummary> > latestJobTask = _jobsClient.GetLatestJobForSpecification(Calculation.SpecificationId, new[] { JobTypes.CalculationInstruct, JobTypes.CalculationAggregration });
await TaskHelper.WhenAllAndThrow(specLookupTask, datasetSchemaTask, latestJobTask);
ApiResponse <JobSummary> latestJobResponse = latestJobTask.Result;
// There may not be a latest job for the current spec so don't fail if there isn't one
if (latestJobResponse != null)
{
if (latestJobResponse.Content == null)
{
LatestJobJson = "null";
}
else
{
LatestJobJson = JsonConvert.SerializeObject(latestJobResponse.Content);
}
}
ApiResponse <IEnumerable <DatasetSchemasAssigned> > datasetSchemaResponse = datasetSchemaTask.Result;
if (datasetSchemaResponse == null || (!datasetSchemaResponse.StatusCode.IsSuccess() || datasetSchemaResponse.Content == null))
{
_logger.Error("A Problem occcured getting assigned dataset schemas");
return(new StatusCodeResult(500));
}
ApiResponse <SpecificationSummary> specResponse = specLookupTask.Result;
if (specResponse == null || (!specResponse.StatusCode.IsSuccess() || specResponse.Content == null))
{
_logger.Warning("Unable to retrieve Specification Summary with Spec ID '{SpecificationId}' for Calculation ID '{Id}", Calculation.SpecificationId, Calculation.Id);
return(new InternalServerErrorResult($"Unable to retrieve Specification Summary with Spec ID '{Calculation.SpecificationId}' for Calculation ID '{Calculation.Id}"));
}
Specification = _mapper.Map <SpecificationSummaryViewModel>(specResponse.Content);
HasProviderDatasetsAssigned = datasetSchemaResponse.Content.Any(d => d.IsSetAsProviderData);
if (HasProviderDatasetsAssigned)
{
await PerformSearch(calculationId, pageNumber, searchTerm);
if (CalculationProviderResults == null)
{
_logger.Error("Null calculation provider results were returned from the search api");
return(new StatusCodeResult(500));
}
SearchTerm = searchTerm;
}
return(Page());
}
public async Task <IActionResult> OnGetAsync(string searchTerm = null, int?pageNumber = null, SpecificationPageBannerOperationType?operationType = null, string operationId = null)
{
SearchRequestViewModel searchRequest = new SearchRequestViewModel()
{
PageNumber = pageNumber ?? 1,
IncludeFacets = true,
SearchTerm = searchTerm
};
SearchTerm = searchTerm;
OperationType = operationType;
if (operationType.HasValue)
{
if (string.IsNullOrWhiteSpace(operationId))
{
return(new PreconditionFailedResult("Operation ID not provided"));
}
ApiResponse <SpecificationSummary> specificationResponse = await _specsClient.GetSpecificationSummary(operationId);
IActionResult errorResult = specificationResponse.IsSuccessOrReturnFailureResult("Specification");
if (errorResult != null)
{
return(errorResult);
}
SpecificationSummary specificationSummary = specificationResponse.Content;
PageBanner = new PageBannerOperation()
{
EntityName = specificationSummary.Name,
EntityType = "Specification",
OperationId = operationId,
ActionText = "Edit",
ActionUrl = $"/specs/policies/{specificationSummary.Id}",
SecondaryActionUrl = $"/specs/EditSpecification/{specificationSummary.Id}?returnPage=Specifications",
};
switch (operationType)
{
case SpecificationPageBannerOperationType.SpecificationCreated:
PageBanner.OperationAction = "created";
break;
case SpecificationPageBannerOperationType.SpecificationUpdated:
PageBanner.OperationAction = "edited";
break;
}
}
SearchResults = await _searchService.PerformSearch(searchRequest);
if (SearchResults == null)
{
return(new InternalServerErrorResult("There was an error retrieving Specifications from the Search Index."));
}
InitialSearchResults = JsonConvert.SerializeObject(SearchResults, Formatting.Indented, new JsonSerializerSettings()
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
StringEscapeHandling = StringEscapeHandling.EscapeHtml
});
return(Page());
}
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 EditTestScenarioPageModel_OnGetAsync_GivenValidCurrentTestScenario_ThenPageIsReturned()
{
// Arrange
ApiResponse <TestScenario> testScenario = new ApiResponse <TestScenario>(HttpStatusCode.OK, new TestScenario()
{
Description = "Test Scenario for testing",
Gherkin = "Given test scenario Then validate test scenario",
Id = "100",
Name = "Test scenario for Spec - Test Spec",
SpecificationId = SpecificationId,
Author = new Reference()
{
Id = "", Name = ""
},
Version = 1
});
ISpecsApiClient specsClient = CreateSpecsApiClient();
IScenariosApiClient scenarioClient = CreateScenarioApiClient();
scenarioClient
.GetCurrentTestScenarioById(Arg.Is(TestScenarioid))
.Returns(testScenario);
IEnumerable <Reference> FundingStreamList = new[]
{
new Reference
{
Id = "fs1",
Name = "Funding Stream Name"
}
};
SpecificationSummary specification = new SpecificationSummary()
{
Id = SpecificationId,
Name = "Test Specification",
FundingPeriod = new Reference("1617", "2016/2017"),
Description = "Test Description",
FundingStreams = FundingStreamList,
};
specsClient
.GetSpecificationSummary(Arg.Is(SpecificationId))
.Returns(new ApiResponse <SpecificationSummary>(HttpStatusCode.OK, specification));
EditTestScenarioPageModel pageModel = CreatePageModel(specsClient, scenarioClient);
// Act
IActionResult result = await pageModel.OnGetAsync(TestScenarioid);
// Assert
result
.Should()
.BeOfType <PageResult>();
pageModel.TestScenarioId.Should().Be("scenario-id");
pageModel.SpecificationId.Should().Be(SpecificationId);
pageModel.SpecificationName.Should().Be("Test Specification");
pageModel.EditScenarioViewModel.Description.Should().Be("Test Scenario for testing");
pageModel.EditScenarioViewModel.Name.Should().Be("Test scenario for Spec - Test Spec");
pageModel.EditScenarioViewModel.Gherkin.Should().Be("Given test scenario Then validate test scenario");
}
public async Task EditTestScenarioPageModel_OnGetAsync_WhenUserDoesNotHaveEditQaTestPermission_ThenDoesUserHavePermissionToSaveisFalse()
{
// Arrange
ApiResponse <TestScenario> testScenario = new ApiResponse <TestScenario>(HttpStatusCode.OK, new TestScenario()
{
Description = "Test Scenario for testing",
Gherkin = "Given test scenario Then validate test scenario",
Id = "100",
Name = "Test scenario for Spec - Test Spec",
SpecificationId = SpecificationId,
Author = new Reference()
{
Id = "", Name = ""
},
Version = 1
});
ISpecsApiClient specsClient = CreateSpecsApiClient();
IScenariosApiClient scenarioClient = CreateScenarioApiClient();
scenarioClient
.GetCurrentTestScenarioById(Arg.Is(TestScenarioid))
.Returns(testScenario);
IEnumerable <Reference> FundingStreamList = new[]
{
new Reference
{
Id = "fs1",
Name = "Funding Stream Name"
}
};
SpecificationSummary specification = new SpecificationSummary()
{
Id = SpecificationId,
Name = "Test Specification",
FundingPeriod = new Reference("1617", "2016/2017"),
Description = "Test Description",
FundingStreams = FundingStreamList,
};
specsClient
.GetSpecificationSummary(Arg.Is(SpecificationId))
.Returns(new ApiResponse <SpecificationSummary>(HttpStatusCode.OK, specification));
IAuthorizationHelper authorizationHelper = Substitute.For <IAuthorizationHelper>();
authorizationHelper
.DoesUserHavePermission(Arg.Any <ClaimsPrincipal>(), Arg.Any <ISpecificationAuthorizationEntity>(), Arg.Is(SpecificationActionTypes.CanEditQaTests))
.Returns(false);
EditTestScenarioPageModel pageModel = CreatePageModel(specsClient, scenarioClient, authorizationHelper: authorizationHelper);
// Act
await pageModel.OnGetAsync(TestScenarioid);
// Assert
pageModel.DoesUserHavePermissionToSave.Should().Be("false");
}
public async Task OnPostAsync_GivenCalculationFoundButGettingAssignedSchemasForSpecRetunsOKWithNullContent_ReturnsStatusCode500()
{
const string calculationId = "calc-id";
const string specificationId = "spec-id";
Calculation calculation = new Calculation
{
Id = calculationId,
SpecificationId = specificationId
};
CalculationViewModel calculationViewModel = new CalculationViewModel
{
Id = calculationId,
SpecificationId = specificationId
};
ApiResponse <Calculation> CalculationResponse = new ApiResponse <Calculation>(HttpStatusCode.OK, calculation);
ICalculationsApiClient calculationsApiClient = CreateCalculationsApiClient();
calculationsApiClient
.GetCalculationById(Arg.Is(calculationId))
.Returns(CalculationResponse);
IMapper mapper = CreateMapper();
mapper
.Map <CalculationViewModel>(Arg.Is(calculation))
.Returns(calculationViewModel);
ICalculationProviderResultsSearchService calculationProviderResultsSearchService = CreateResultsSearchService();
IEnumerable <DatasetSchemasAssigned> datasetSchemasAssignedList = new[]
{
new DatasetSchemasAssigned
{
IsSetAsProviderData = true
}
};
ApiResponse <IEnumerable <DatasetSchemasAssigned> > datasetSchemaResponse = new ApiResponse <IEnumerable <DatasetSchemasAssigned> >(HttpStatusCode.OK);
IDatasetsApiClient datasetsApiClient = CreateDatasetsApiClient();
datasetsApiClient
.GetAssignedDatasetSchemasForSpecification(Arg.Is(specificationId))
.Returns(datasetSchemaResponse);
ISpecsApiClient specsApiClient = CreateSpecsApiClient();
specsApiClient.GetSpecificationSummaries(Arg.Any <IEnumerable <string> >())
.Returns(new ApiResponse <IEnumerable <Clients.SpecsClient.Models.SpecificationSummary> >(HttpStatusCode.OK, Enumerable.Empty <Clients.SpecsClient.Models.SpecificationSummary>()));
Clients.SpecsClient.Models.SpecificationSummary specificationSummary = new Clients.SpecsClient.Models.SpecificationSummary()
{
Id = specificationId,
};
specsApiClient
.GetSpecificationSummary(Arg.Is(specificationId))
.Returns(new ApiResponse <Clients.SpecsClient.Models.SpecificationSummary>(HttpStatusCode.OK, specificationSummary));
CalculationProviderResultsPageModel pageModel = CreatePageModel(
calculationProviderResultsSearchService,
calculationsApiClient,
mapper: mapper,
datasetsApiClient: datasetsApiClient,
specsApiClient: specsApiClient);
//Act
IActionResult result = await pageModel.OnPostAsync(calculationId, null, "");
//Assert
result
.Should()
.BeOfType <StatusCodeResult>();
StatusCodeResult statusCodeResult = result as StatusCodeResult;
statusCodeResult
.StatusCode
.Should()
.Be(500);
}
public async Task <IActionResult> OnGet(string specificationId)
{
if (string.IsNullOrWhiteSpace(specificationId))
{
return(new BadRequestObjectResult(ErrorMessages.SpecificationIdNullOrEmpty));
}
SpecificationId = specificationId;
ApiResponse <SpecificationSummary> specificationResponse = await _specsClient.GetSpecificationSummary(specificationId);
if (specificationResponse == null || specificationResponse.StatusCode == HttpStatusCode.NotFound)
{
return(new NotFoundObjectResult($"Unable to get specification response. Specification Id value = {SpecificationId}"));
}
if (specificationResponse.StatusCode.IsSuccess())
{
SpecificationSummary specContent = specificationResponse.Content;
if (specContent == null)
{
throw new InvalidOperationException(message: $"Unable to retrieve specification model from the response. Specification Id value = {SpecificationId}");
}
IsAuthorizedToEdit = await _authorizationHelper.DoesUserHavePermission(User, specContent, SpecificationActionTypes.CanEditSpecification);
SpecificationName = specContent.Name;
SpecificationDescription = specContent.Description;
FundingPeriodId = specContent.FundingPeriod.Id;
FundingPeriodName = specContent.FundingPeriod.Name;
ApiResponse <IEnumerable <DatasetDefinition> > datasetResponse = await _datasetsClient.GetDataDefinitions();
if (datasetResponse == null || datasetResponse.StatusCode == HttpStatusCode.NotFound)
{
return(new NotFoundObjectResult(ErrorMessages.DatasetDefinitionNotFoundInDatasetService));
}
if (datasetResponse.StatusCode.IsSuccess())
{
IEnumerable <DatasetDefinition> datasetDefinitionList = datasetResponse.Content;
if (datasetDefinitionList.IsNullOrEmpty())
{
throw new InvalidOperationException($"Unable to retrieve Dataset definition from the response. Specification Id value = {SpecificationId}");
}
else
{
PopulateDatasetSchemas(datasetDefinitionList);
}
}
else
{
return(new StatusCodeResult(500));
}
}
else
{
return(new StatusCodeResult(500));
}
return(Page());
}
public async Task OnGetAsync_GivenCalculationFoundWithEmptySearchResults_ReturnsPage()
{
//Arrange
const string calculationId = "calc-id";
const string specificationId = "spec-id";
Calculation calculation = new Calculation
{
Id = calculationId,
SpecificationId = specificationId
};
CalculationViewModel calculationViewModel = new CalculationViewModel
{
Id = calculationId,
SpecificationId = specificationId
};
IEnumerable <DatasetSchemasAssigned> datasetSchemasAssignedList = new[]
{
new DatasetSchemasAssigned
{
IsSetAsProviderData = true
}
};
ApiResponse <IEnumerable <DatasetSchemasAssigned> > datasetSchemaResponse = new ApiResponse <IEnumerable <DatasetSchemasAssigned> >(HttpStatusCode.OK, datasetSchemasAssignedList);
IDatasetsApiClient datasetsApiClient = CreateDatasetsApiClient();
datasetsApiClient
.GetAssignedDatasetSchemasForSpecification(Arg.Is(specificationId))
.Returns(datasetSchemaResponse);
CalculationProviderResultSearchResultViewModel calculationProviderResultSearchResultViewModel = new CalculationProviderResultSearchResultViewModel
{
CalculationProviderResults = Enumerable.Empty <CalculationProviderResultSearchResultItemViewModel>()
};
ApiResponse <Calculation> CalculationResponse = new ApiResponse <Calculation>(HttpStatusCode.OK, calculation);
ICalculationsApiClient calculationsApiClient = CreateCalculationsApiClient();
calculationsApiClient
.GetCalculationById(Arg.Is(calculationId))
.Returns(CalculationResponse);
IMapper mapper = CreateMapper();
mapper
.Map <CalculationViewModel>(Arg.Is(calculation))
.Returns(calculationViewModel);
ICalculationProviderResultsSearchService calculationProviderResultsSearchService = CreateResultsSearchService();
calculationProviderResultsSearchService
.PerformSearch(Arg.Any <SearchRequestViewModel>())
.Returns(calculationProviderResultSearchResultViewModel);
ISpecsApiClient specsApiClient = CreateSpecsApiClient();
specsApiClient.GetSpecificationSummaries(Arg.Any <IEnumerable <string> >())
.Returns(new ApiResponse <IEnumerable <Clients.SpecsClient.Models.SpecificationSummary> >(HttpStatusCode.OK, Enumerable.Empty <Clients.SpecsClient.Models.SpecificationSummary>()));
Clients.SpecsClient.Models.SpecificationSummary specificationSummary = new Clients.SpecsClient.Models.SpecificationSummary()
{
Id = specificationId,
};
specsApiClient
.GetSpecificationSummary(Arg.Is(specificationId))
.Returns(new ApiResponse <Clients.SpecsClient.Models.SpecificationSummary>(HttpStatusCode.OK, specificationSummary));
CalculationProviderResultsPageModel pageModel = CreatePageModel(
calculationProviderResultsSearchService,
calculationsApiClient,
mapper: mapper,
datasetsApiClient: datasetsApiClient,
specsApiClient: specsApiClient);
//Act
IActionResult result = await pageModel.OnGetAsync(calculationId, null, "");
//Assert
result
.Should()
.BeOfType <PageResult>();
pageModel
.CalculationProviderResults
.CalculationProviderResults
.Any()
.Should()
.BeFalse();
}
public async Task <IActionResult> OnGetAsync(string scenarioId, int?pageNumber, string searchTerm)
{
TestScenario = await GetTestScenario(scenarioId);
if (TestScenario == null)
{
return(new NotFoundResult());
}
SearchRequestViewModel searchRequest = new SearchRequestViewModel()
{
PageNumber = pageNumber,
IncludeFacets = false,
SearchTerm = searchTerm,
Filters = new Dictionary <string, string[]> {
{ "testScenarioId", new[] { scenarioId } }
}
};
SearchTerm = searchTerm;
Task <ProviderTestsSearchResultViewModel> providerResultsTask = _testResultsSearchService.PerformProviderTestResultsSearch(searchRequest);
Task <ApiResponse <IEnumerable <TestScenarioResultCounts> > > countTask = _testEngineClient.GetTestResultCounts(new TestScenarioResultCountsRequestModel()
{
TestScenarioIds = new string[] { scenarioId }
});
await TaskHelper.WhenAllAndThrow(providerResultsTask, countTask);
ProviderResults = providerResultsTask.Result;
if (ProviderResults == null)
{
return(new InternalServerErrorResult("Provider Results returned null"));
}
if (countTask.Result == null)
{
return(new InternalServerErrorResult("Count Task result was null"));
}
if (countTask.Result.StatusCode != System.Net.HttpStatusCode.OK)
{
return(new InternalServerErrorResult($"Count Task didn't return OK, but instead '{countTask.Result.StatusCode}'"));
}
if (countTask.Result.Content == null)
{
return(new InternalServerErrorResult("Count Task result content was null"));
}
TestScenarioResultCounts scenarioResultCounts = countTask.Result.Content.FirstOrDefault();
if (scenarioResultCounts != null)
{
TestCoverage = scenarioResultCounts.TestCoverage;
}
else
{
TestCoverage = 0;
}
ApiResponse <SpecificationSummary> specResponse = await _specsClient.GetSpecificationSummary(TestScenario.SpecificationId);
if (specResponse == null)
{
return(new InternalServerErrorResult("Specification summary API call result was null"));
}
if (specResponse.StatusCode != System.Net.HttpStatusCode.OK)
{
return(new InternalServerErrorResult($"Specification summary API call didn't return OK, but instead '{countTask.Result.StatusCode}'"));
}
if (specResponse.Content == null)
{
return(new InternalServerErrorResult("Specification summary API call content was null"));
}
Specification = _mapper.Map <SpecificationSummaryViewModel>(specResponse.Content);
return(Page());
}
public async Task SpecificationRelationshipsPageModel_GivenDatasetRelationshipsResponseReturnsOKWithContent_ReturnsPage()
{
// Arrange
string specificationId = Guid.NewGuid().ToString();
SpecificationSummary specification = new SpecificationSummary
{
Id = specificationId
};
ApiResponse <SpecificationSummary> specificationResponse = new ApiResponse <SpecificationSummary>(HttpStatusCode.OK, specification);
ISpecsApiClient specsApiClient = CreateSpecsApiClient();
specsApiClient
.GetSpecificationSummary(Arg.Is(specificationId))
.Returns(specificationResponse);
IEnumerable <DatasetSpecificationRelationshipModel> relationships = new[]
{
new DatasetSpecificationRelationshipModel
{
DatasetId = "any-ds-id",
DatasetName = "any ds name",
RelationshipDescription = "any relationship description",
Definition = new SpecificationDataDefinitionRelationshipModel
{
Id = "def-id",
Name = "def name",
Description = "def desc"
},
Version = 1,
Id = "rel-id",
Name = "rel name",
IsProviderData = true
}
};
ApiResponse <IEnumerable <DatasetSpecificationRelationshipModel> > relationshipsResponse = new ApiResponse <IEnumerable <DatasetSpecificationRelationshipModel> >(HttpStatusCode.OK, relationships);
IDatasetsApiClient datasetsApiClient = CreateDatasetApiClient();
datasetsApiClient
.GetDatasetSpecificationRelationshipsBySpecificationId(Arg.Is(specificationId))
.Returns(relationshipsResponse);
ILogger logger = CreateLogger();
SpecificationRelationshipsPageModel pageModel = CreatePageModel(specsApiClient, datasetsApiClient, logger);
// Act
IActionResult result = await pageModel.OnGetAsync(specificationId);
// Assert
result
.Should()
.BeOfType <PageResult>();
pageModel
.ShowSuccessMessage
.Should()
.BeFalse();
pageModel
.ViewModel
.Items
.Count()
.Should()
.Be(1);
pageModel
.ViewModel
.Items
.First()
.DatasetId
.Should()
.Be("any-ds-id");
pageModel
.ViewModel
.Items
.First()
.DatasetName
.Should()
.Be("any ds name");
pageModel
.ViewModel
.Items
.First()
.RelationshipDescription
.Should()
.Be("any relationship description");
pageModel
.ViewModel
.Items
.First()
.DatasetVersion
.Should()
.Be(1);
pageModel
.ViewModel
.Items
.First()
.RelationshipId
.Should()
.Be("rel-id");
pageModel
.ViewModel
.Items
.First()
.IsProviderData
.Should().BeTrue();
pageModel
.IsAuthorizedToMap
.Should().BeTrue();
}
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 SpecificationRelationshipsPageModel_GivenUserHasNoPermissionToMapDataSetsForSpecification_ThenReturnPageResultWithAuthorizedToEditFlagSetToFalse()
{
// Arrange
string specificationId = Guid.NewGuid().ToString();
SpecificationSummary specification = new SpecificationSummary
{
Id = specificationId
};
ApiResponse <SpecificationSummary> specificationResponse = new ApiResponse <SpecificationSummary>(HttpStatusCode.OK, specification);
ISpecsApiClient specsApiClient = CreateSpecsApiClient();
specsApiClient
.GetSpecificationSummary(Arg.Is(specificationId))
.Returns(specificationResponse);
IEnumerable <DatasetSpecificationRelationshipModel> relationships = new[]
{
new DatasetSpecificationRelationshipModel
{
DatasetId = "any-ds-id",
DatasetName = "any ds name",
RelationshipDescription = "any relationship description",
Definition = new SpecificationDataDefinitionRelationshipModel
{
Id = "def-id",
Name = "def name",
Description = "def desc"
},
Version = 1,
Id = "rel-id",
Name = "rel name",
IsProviderData = true
}
};
ApiResponse <IEnumerable <DatasetSpecificationRelationshipModel> > relationshipsResponse = new ApiResponse <IEnumerable <DatasetSpecificationRelationshipModel> >(HttpStatusCode.OK, relationships);
IDatasetsApiClient datasetsApiClient = CreateDatasetApiClient();
datasetsApiClient
.GetDatasetSpecificationRelationshipsBySpecificationId(Arg.Is(specificationId))
.Returns(relationshipsResponse);
ILogger logger = CreateLogger();
SpecificationRelationshipsPageModel pageModel = CreatePageModel(specsApiClient, datasetsApiClient, logger,
authorizationHelper: CreateMockAuthenticationHelper(false));
// Act
IActionResult result = await pageModel.OnGetAsync(specificationId);
// Assert
result
.Should()
.BeOfType <PageResult>();
pageModel
.IsAuthorizedToMap
.Should()
.BeFalse();
}
