public void Validate_ValidatesAsExpected(CalculationCreateModel model, bool expectedResult, IEnumerable <string> expectedErrors)
{
//Arrange
ISpecificationsRepository specsRepo = CreateSpecificationsRepository(false);
Specification specification = new Specification
{
Current = new SpecificationVersion()
};
specsRepo
.GetSpecificationById(specificationId)
.Returns(specification);
CalculationCreateModelValidator validator = CreateValidator(specsRepo);
//Act
ValidationResult result = validator.Validate(model);
//Assert
result
.IsValid
.Should()
.Be(expectedResult);
foreach (var error in expectedErrors)
{
result.Errors.Count(e => e.ErrorMessage == error).Should().Be(1, $"Expected to find error message '{error}'");
}
result
.Errors
.Count
.Should()
.Be(expectedErrors.Count());
}
public ProviderResultsRepository(
ICosmosRepository cosmosRepository,
ISearchRepository <CalculationProviderResultsIndex> searchRepository,
ISpecificationsRepository specificationsRepository,
ILogger logger,
ISearchRepository <ProviderCalculationResultsIndex> providerCalculationResultsSearchRepository,
IFeatureToggle featureToggle,
EngineSettings engineSettings)
{
Guard.ArgumentNotNull(cosmosRepository, nameof(cosmosRepository));
Guard.ArgumentNotNull(searchRepository, nameof(searchRepository));
Guard.ArgumentNotNull(specificationsRepository, nameof(specificationsRepository));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(providerCalculationResultsSearchRepository, nameof(providerCalculationResultsSearchRepository));
Guard.ArgumentNotNull(featureToggle, nameof(featureToggle));
Guard.ArgumentNotNull(engineSettings, nameof(engineSettings));
_cosmosRepository = cosmosRepository;
_searchRepository = searchRepository;
_specificationsRepository = specificationsRepository;
_logger = logger;
_providerCalculationResultsSearchRepository = providerCalculationResultsSearchRepository;
_featureToggle = featureToggle;
_engineSettings = engineSettings;
}
public async Task GetSpecificationsSelectedForFundingByPeriod_GivenSpecificationWasNotFound_ReturnsNotFound()
{
//Arrange
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationsByQuery(Arg.Any <Expression <Func <DocumentEntity <Specification>, bool> > >())
.Returns((Enumerable.Empty <Specification>()));
SpecificationsService service = CreateService(specificationsRepository: specificationsRepository, logs: logger);
//Act
IActionResult result = await service.GetSpecificationsSelectedForFundingByPeriod(FundingPeriodId);
//Assert
result
.Should()
.BeOfType <NotFoundResult>();
logger
.Received(1)
.Information(Arg.Is($"Specification was not found for funding period: {FundingPeriodId}"));
}
public void Validate_GivenPolicyIdIsNullOrEmpty_ValidIsFalse()
{
//Arrange
PolicyEditModel model = CreateModel();
model.PolicyId = "";
ISpecificationsRepository repository = CreateSpecificationsRepository(true);
PolicyEditModelValidator validator = CreateValidator(repository);
//Act
ValidationResult result = validator.Validate(model);
//Assert
result
.IsValid
.Should()
.BeFalse();
result
.Errors
.Count
.Should()
.Be(1);
}
public async Task ReIndex_GivenNoDocumentsReturnedFromCosmos_ReturnsNoContent()
{
//Arrange
IEnumerable <SpecificationSearchModel> specifications = new SpecificationSearchModel[0];
ISearchRepository <SpecificationIndex> searchRepository = CreateSearchRepository();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationsByRawQuery <SpecificationSearchModel>(Arg.Any <SqlQuerySpec>())
.Returns(specifications);
ILogger logger = CreateLogger();
ISpecificationsService service = CreateService(searchRepository: searchRepository, logs: logger,
specificationsRepository: specificationsRepository);
//Act
IActionResult result = await service.ReIndex();
//Assert
logger
.Received(1)
.Warning(Arg.Is("No specification documents were returned from cosmos db"));
result
.Should()
.BeOfType <NoContentResult>();
}
public async Task RefreshPublishResults_GivenValidRequestParameters_ShouldReturnNoContentResult()
{
// Arrange
const string specificationId = "123";
HttpRequest httpRequest = Substitute.For <HttpRequest>();
ISpecificationsRepository mockSpecificationsRepository = Substitute.For <ISpecificationsRepository>();
mockSpecificationsRepository.GetSpecificationById(Arg.Any <string>()).Returns(new Specification());
SpecificationCalculationExecutionStatus expectedSpecificationStatusCall1 = new SpecificationCalculationExecutionStatus(specificationId, 0, CalculationProgressStatus.NotStarted);
ICacheProvider mockCacheProvider = Substitute.For <ICacheProvider>();
SpecificationsService specificationsService = CreateService(specificationsRepository: mockSpecificationsRepository,
cacheProvider: mockCacheProvider);
httpRequest.Query.Returns(new QueryCollection(new Dictionary <string, StringValues>()
{
{ "specificationId", new StringValues(specificationId) }
}));
// Act
IActionResult actionResultReturned = await specificationsService.RefreshPublishedResults(httpRequest);
// Assert
actionResultReturned.Should().BeOfType <NoContentResult>();
await mockCacheProvider.Received().SetAsync($"{CalculationProgressPrependKey}{specificationId}", expectedSpecificationStatusCall1, TimeSpan.FromHours(6), false);
}
public void AssignDataDefinitionRelationship_GivenValidMessageButUnableToFindSpecification_ThrowsInvalidModelException()
{
//Arrange
dynamic anyObject = new { specificationId = SpecificationId, relationshipId = RelationshipId };
string json = JsonConvert.SerializeObject(anyObject);
Message message = new Message(Encoding.UTF8.GetBytes(json));
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns((Specification)null);
SpecificationsService service = CreateService(specificationsRepository: specificationsRepository);
//Act
Func <Task> test = async() => await service.Process(message);
//Assert
test
.Should().ThrowExactly <InvalidModelException>();
}
public async Task EditSpecificationStatus_GivenSpecificationWasNotFound_ReturnsNotFoundResult()
{
//Arrange
EditStatusModel specificationEditStatusModel = new EditStatusModel
{
PublishStatus = PublishStatus.Approved
};
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns((Specification)null);
SpecificationsService service = CreateService(logs: logger, specificationsRepository: specificationsRepository);
//Act
IActionResult result = await service.EditSpecificationStatus(SpecificationId, specificationEditStatusModel, null);
//Arrange
result
.Should()
.BeOfType <NotFoundObjectResult>()
.Which
.Value
.Should()
.Be("Specification not found");
logger
.Received(1)
.Warning(Arg.Is($"Failed to find specification for id: {SpecificationId}"));
}
public async Task GetSpecificationByFundingPeriodId_GivenNoSpecificationsReturned_ReturnsSuccess()
{
//Arrange
IEnumerable <Specification> specs = Enumerable.Empty <Specification>();
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationsByQuery(Arg.Any <Expression <Func <DocumentEntity <Specification>, bool> > >())
.Returns(specs);
SpecificationsService service = CreateService(specificationsRepository: specificationsRepository, logs: logger);
//Act
IActionResult result = await service.GetSpecificationsByFundingPeriodId(FundingPeriodId);
//Assert
result
.Should()
.BeOfType <OkObjectResult>();
IEnumerable <SpecificationSummary> objContent = (IEnumerable <SpecificationSummary>)((OkObjectResult)result).Value;
objContent
.Count()
.Should()
.Be(0);
}
public async Task SelectSpecificationForFunding_GivenSpecificationButUpdatingCosmosReturnsBadRequest_ReturnsInternalServerError()
{
//Arrange
Specification specification = CreateSpecification();
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.UpdateSpecification(Arg.Is(specification))
.Returns(HttpStatusCode.BadRequest);
SpecificationsService service = CreateService(logs: logger, specificationsRepository: specificationsRepository);
//Act
IActionResult result = await service.SelectSpecificationForFunding(SpecificationId);
//Assert
result
.Should()
.BeOfType <InternalServerErrorResult>()
.Which
.Value
.Should()
.Be($"Failed to set IsSelectedForFunding on specification for id: {SpecificationId} with status code: BadRequest");
logger
.Received(1)
.Error($"Failed to set IsSelectedForFunding on specification for id: {SpecificationId} with status code: BadRequest");
}
public async Task SelectSpecificationForFunding_GivenNoFundingStreamAlreadySelectedInPeriod_ReturnsConflict()
{
Specification specification = CreateSpecification();
Specification specificationWithFundingStreamClash = CreateSpecification();
SpecificationVersion currentVersionOfSpecification = specification.Current;
string commonFundingStreamId = currentVersionOfSpecification.FundingStreams.First().Id;
specificationWithFundingStreamClash.Current.FundingStreams.First().Id = commonFundingStreamId;
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(SpecificationId)
.Returns(specification);
specificationsRepository
.GetSpecificationsSelectedForFundingByPeriod(currentVersionOfSpecification.FundingPeriod.Id)
.Returns(new[] { specificationWithFundingStreamClash });
IActionResult result = await CreateService(
logs : CreateLogger(),
specificationsRepository : specificationsRepository)
.SelectSpecificationForFunding(SpecificationId);
result
.Should()
.BeOfType <ConflictResult>();
}
public async Task SelectSpecificationForFunding_GivenSpecificationFoundButAlreadySelected_ReturnsNoContentResult()
{
//Arrange
Specification specification = CreateSpecification();
specification.IsSelectedForFunding = true;
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
SpecificationsService service = CreateService(logs: logger, specificationsRepository: specificationsRepository);
//Act
IActionResult result = await service.SelectSpecificationForFunding(SpecificationId);
//Assert
result
.Should()
.BeOfType <NoContentResult>();
logger
.Received(1)
.Warning(Arg.Is($"Attempt to mark specification with id: {SpecificationId} selected when already selected"));
}
public async Task SelectSpecificationForFunding_GivenSpecificationCouldNotBeFound_ReturnsNotFoundObjectResult()
{
//Arrange
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns((Specification)null);
SpecificationsService service = CreateService(logs: logger, specificationsRepository: specificationsRepository);
//Act
IActionResult result = await service.SelectSpecificationForFunding(SpecificationId);
//Assert
result
.Should()
.BeOfType <NotFoundObjectResult>()
.Which
.Value
.Should()
.Be($"Specification not found for id: {SpecificationId}");
logger
.Received(1)
.Warning(Arg.Is($"Specification not found for id: {SpecificationId}"));
}
public async Task GetSpecificationsWithProviderVersionUpdatesAsUseLatest_GivenSpecificationWasNotFound_ReturnsNotFound()
{
//Arrange
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationsByQuery(Arg.Any <Expression <Func <DocumentEntity <Specification>, bool> > >())
.Returns((Enumerable.Empty <Specification>()));
SpecificationsService service = CreateService(specificationsRepository: specificationsRepository, logs: logger);
//Act
IActionResult result = await service.GetSpecificationsWithProviderVersionUpdatesAsUseLatest();
//Assert
result
.Should()
.BeOfType <NotFoundResult>();
logger
.Received(1)
.Information(Arg.Is($"Specifications was not found with CoreProviderVersionUpdates as UseLatest"));
}
public async Task RefreshPublishResults_GivenASpecificationIdThatDoesNotExistAndFeatureToggleIsFalse_ShouldReturnBadRequestObjectResult()
{
// Arrange
const string validSpecificationId = "123";
const string invalidSpecificationId = "333";
IMessengerService messengerService = Substitute.For <IMessengerService>();
ISpecificationsRepository mockSpecificationsRepository = Substitute.For <ISpecificationsRepository>();
mockSpecificationsRepository.GetSpecificationById(validSpecificationId).Returns(new Specification());
SpecificationsService specificationsService = CreateService(messengerService: messengerService);
HttpRequest httpRequest = Substitute.For <HttpRequest>();
httpRequest.Query.Returns(new QueryCollection(new Dictionary <string, StringValues>()
{
{ "specificationIds", new StringValues($"{validSpecificationId}, {invalidSpecificationId}") }
}));
// Act
IActionResult actionResultReturned = await specificationsService.RefreshPublishedResults(httpRequest);
// Assert
actionResultReturned.Should().BeOfType <BadRequestObjectResult>();
}
public async Task GetSpecificationByName_GivenSpecificationWasNotFound_ReturnsNotFoundt()
{
//Arrange
IEnumerable <Specification> specs = Enumerable.Empty <Specification>();
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationsByQuery(Arg.Any <Expression <Func <DocumentEntity <Specification>, bool> > >())
.Returns(specs);
SpecificationsService service = CreateService(specificationsRepository: specificationsRepository, logs: logger);
//Act
IActionResult result = await service.GetSpecificationByName(SpecificationName);
//Assert
result
.Should()
.BeOfType <NotFoundResult>();
logger
.Received(1)
.Information(Arg.Is($"Specification was not found for name: {SpecificationName}"));
}
public async Task RefreshPublishResults_GivenSingleSpecificationId_ShouldReturnNoContentResult()
{
// Arrange
const string specificationId1 = "123";
HttpRequest httpRequest = Substitute.For <HttpRequest>();
ISpecificationsRepository mockSpecificationsRepository = Substitute.For <ISpecificationsRepository>();
mockSpecificationsRepository.GetSpecificationById(Arg.Any <string>()).Returns(new Specification());
SpecificationCalculationExecutionStatus expectedSpecificationStatusCall1 = new SpecificationCalculationExecutionStatus(specificationId1, 0, CalculationProgressStatus.NotStarted);
ICacheProvider mockCacheProvider = Substitute.For <ICacheProvider>();
IJobsApiClient jobsApiClient = CreateJobsApiClient();
SpecificationsService specificationsService = CreateService(specificationsRepository: mockSpecificationsRepository,
cacheProvider: mockCacheProvider, jobsApiClient: jobsApiClient);
httpRequest.Query.Returns(new QueryCollection(new Dictionary <string, StringValues>()
{
{ "specificationId", new StringValues($"{specificationId1}") }
}));
// Act
IActionResult actionResultReturned = await specificationsService.RefreshPublishedResults(httpRequest);
// Assert
actionResultReturned.Should().BeOfType <NoContentResult>();
await mockCacheProvider.Received().SetAsync($"{CalculationProgressPrependKey}{specificationId1}", expectedSpecificationStatusCall1, TimeSpan.FromHours(6), false);
await jobsApiClient.Received(1).CreateJob(Arg.Is <JobCreateModel>(j => j.JobDefinitionId == JobConstants.DefinitionNames.PublishProviderResultsJob && j.SpecificationId == specificationId1 && j.Trigger.Message == $"Refreshing published provider results for specification"));
}
public async Task GetFundingStreamById_StringParam_GivenFundingStreamnWasNotFound_ReturnsNotFound()
{
// Arrange
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetFundingStreamById(Arg.Is(FundingStreamId))
.Returns((FundingStream)null);
IFundingService fundingService = CreateService(specificationsRepository: specificationsRepository, logger: logger);
// Act
IActionResult result = await fundingService.GetFundingStreamById(FundingStreamId);
// Assert
result
.Should()
.BeOfType <NotFoundResult>();
logger
.Received(1)
.Error(Arg.Is($"No funding stream was found for funding stream id : {FundingStreamId}"));
}
public async Task GetPublishDates_SpecDoesNotExistsInSystem_Returns412WithErrorMessage()
{
//Arrange
ILogger logger = CreateLogger();
string specificationId = "test";
string expectedErrorMessage = $"No specification ID {specificationId} were returned from the repository, result came back null";
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(specificationId)
.Returns <Specification>(x => null);
SpecificationsService service = CreateService(logs: logger, specificationsRepository: specificationsRepository);
// Act
IActionResult result = await service.GetPublishDates(specificationId);
//Assert
result
.Should()
.BeOfType <PreconditionFailedResult>()
.Which
.Value
.Should()
.Be(expectedErrorMessage);
logger
.Received(1)
.Error(Arg.Is(expectedErrorMessage));
}
public async Task GetFundingStreamById_StringParam_GivenFundingStreamnWasFound_ReturnsSuccess()
{
// Arrange
ILogger logger = CreateLogger();
FundingStream fundingStream = new FundingStream
{
Id = FundingStreamId
};
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetFundingStreamById(Arg.Is(FundingStreamId))
.Returns(fundingStream);
IFundingService fundingService = CreateService(specificationsRepository: specificationsRepository, logger: logger);
// Act
IActionResult result = await fundingService.GetFundingStreamById(FundingStreamId);
// Assert
result
.Should()
.BeOfType <OkObjectResult>();
}
public ProviderCalculationResultsReIndexerService(
ILogger logger,
ISearchRepository <ProviderCalculationResultsIndex> providerCalculationResultsSearchRepository,
ISpecificationsRepository specificationsRepository,
ICalculationResultsRepository resultsRepository,
IResultsResiliencePolicies resiliencePolicies,
IFeatureToggle featureToggle,
IMessengerService messengerService)
{
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(providerCalculationResultsSearchRepository, nameof(providerCalculationResultsSearchRepository));
Guard.ArgumentNotNull(specificationsRepository, nameof(specificationsRepository));
Guard.ArgumentNotNull(resultsRepository, nameof(resultsRepository));
Guard.ArgumentNotNull(resiliencePolicies, nameof(resiliencePolicies));
Guard.ArgumentNotNull(featureToggle, nameof(featureToggle));
Guard.ArgumentNotNull(messengerService, nameof(messengerService));
_logger = logger;
_providerCalculationResultsSearchRepository = providerCalculationResultsSearchRepository;
_specificationsRepository = specificationsRepository;
_resultsRepository = resultsRepository;
_resultsRepositoryPolicy = resiliencePolicies.ResultsRepository;
_specificationsRepositoryPolicy = resiliencePolicies.SpecificationsRepository;
_resultsSearchRepositoryPolicy = resiliencePolicies.ResultsSearchRepository;
_featureToggle = featureToggle;
_messengerService = messengerService;
}
public async Task GetFundingStreams_GivenNullOrEmptyFundingStreamsReturned_LogsAndReturnsOKWithEmptyList()
{
// Arrange
ILogger logger = CreateLogger();
IEnumerable <FundingStream> fundingStreams = null;
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetFundingStreams()
.Returns(fundingStreams);
IFundingService fundingService = CreateService(logger: logger, specificationsRepository: specificationsRepository);
// Act
IActionResult result = await fundingService.GetFundingStreams();
// Assert
result
.Should()
.BeOfType <OkObjectResult>();
OkObjectResult objectResult = result as OkObjectResult;
IEnumerable <FundingStream> values = objectResult.Value as IEnumerable <FundingStream>;
values
.Should()
.NotBeNull();
logger
.Received(1)
.Error(Arg.Is("No funding streams were returned"));
}
public void Validate_GivenAParentPolicyIdAndPolicyDoesNotExist_ValidIsFalse()
{
//Arrange
PolicyEditModel model = CreateModel();
model.ParentPolicyId = parentPolicyId;
ISpecificationsRepository repository = CreateSpecificationsRepository(false, false);
PolicyEditModelValidator validator = CreateValidator(repository);
//Act
ValidationResult result = validator.Validate(model);
//Assert
result
.IsValid
.Should()
.BeFalse();
result
.Errors
.Count
.Should()
.Be(1);
}
public async Task GetSpecificationById_GivenSpecificationWasNotFound_ReturnsNotFound()
{
//Arrange
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns((Specification)null);
SpecificationsService service = CreateService(specificationsRepository: specificationsRepository, logs: logger);
//Act
IActionResult result = await service.GetSpecificationById(SpecificationId);
//Assert
result
.Should()
.BeOfType <NotFoundResult>();
logger
.Received(1)
.Warning(Arg.Is($"A specification for id {SpecificationId} could not found"));
}
public void Validate_GivenCoreProviderVersionUpdatesUseLatestForNonFDZProviderSource_ValidIsFalse()
{
//Arrange
SpecificationEditModel model = CreateModel();
model.SpecificationId = "specId";
model.CoreProviderVersionUpdates = CoreProviderVersionUpdates.UseLatest;
ISpecificationsRepository repository = CreateSpecificationsRepository();
IPoliciesApiClient policiesApiClient = CreatePoliciesApiClient(providerSource: ProviderSource.CFS);
SpecificationEditModelValidator validator = CreateValidator(repository, policiesApiClient: policiesApiClient);
//Act
ValidationResult result = validator.Validate(model);
//Assert
result
.IsValid
.Should()
.BeFalse();
result
.Errors
.Count
.Should()
.Be(1);
result
.Errors.Select(x => x.ErrorMessage)
.Should()
.Contain("CoreProviderVersionUpdates - UseLatest is not valid for provider source - CFS");
}
public async Task SpecificationsService_GetFundingStreamsForSpecificationById_WhenRequestingASpecificationWhenDoesNotExist_ThenErrorReturned()
{
// Arrange
const string specificationId = "spec1";
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
SpecificationsService specificationsService = CreateService(specificationsRepository: specificationsRepository);
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(specificationId) }
});
HttpRequest request = Substitute.For <HttpRequest>();
request
.Query
.Returns(queryStringValues);
// Act
IActionResult actionResult = await specificationsService.GetFundingStreamsForSpecificationById(request);
// Assert
List <FundingStream> expectedFundingStreams = new List <FundingStream>();
actionResult
.Should()
.BeOfType <PreconditionFailedResult>()
.Which
.Value
.Should()
.Be("Specification not found");
}
public async Task GetSpecificationsSelectedForFundingByPeriod_GivenSpecificationWasFound_ReturnsSpecification()
{
//Arrange
SpecificationVersion sv1 = new SpecificationVersion {
SpecificationId = "spec1", FundingPeriod = new Reference {
Id = "18/19", Name = "18/19"
}
};
SpecificationVersion sv2 = new SpecificationVersion {
SpecificationId = "spec2", FundingPeriod = new Reference {
Id = "17/18", Name = "17/18"
}
};
Specification spec1 = new Specification {
Id = "spec1", IsSelectedForFunding = true, Current = sv1
};
Specification spec2 = new Specification {
Id = "spec2", IsSelectedForFunding = true, Current = sv2
};
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "fundingPeriodId", new StringValues(FundingPeriodId) }
});
HttpRequest request = Substitute.For <HttpRequest>();
request
.Query
.Returns(queryStringValues);
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationsByQuery(Arg.Any <Expression <Func <Specification, bool> > >())
.Returns(new[] { spec1 });
SpecificationsService service = CreateService(specificationsRepository: specificationsRepository, logs: logger);
//Act
IActionResult result = await service.GetSpecificationsSelectedForFundingByPeriod(request);
//Assert
result
.Should()
.BeOfType <OkObjectResult>();
OkObjectResult okObjectResult = result as OkObjectResult;
IEnumerable <SpecificationSummary> summaries = okObjectResult.Value as IEnumerable <SpecificationSummary>;
summaries
.Count()
.Should()
.Be(1);
}
public async Task SpecificationsService_GetFundingStreamsForSpecificationById_WhenHasMissingSpecificationId_ThenErrorReturned()
{
// Arrange
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
SpecificationsService specificationsService = CreateService(specificationsRepository: specificationsRepository);
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(string.Empty) }
});
HttpRequest request = Substitute.For <HttpRequest>();
request
.Query
.Returns(queryStringValues);
// Act
IActionResult actionResult = await specificationsService.GetFundingStreamsForSpecificationById(request);
// Assert
List <FundingStream> expectedFundingStreams = new List <FundingStream>();
actionResult
.Should()
.BeOfType <BadRequestObjectResult>()
.Which
.Value
.Should()
.Be("Null or empty specificationId provided");
}
public async Task GetSpecificationById_GivenSpecificationWasFound_ReturnsSuccess()
{
//Arrange
Specification specification = new Specification();
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(SpecificationId) }
});
HttpRequest request = Substitute.For <HttpRequest>();
request
.Query
.Returns(queryStringValues);
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
SpecificationsService service = CreateService(specificationsRepository: specificationsRepository, logs: logger);
//Act
IActionResult result = await service.GetSpecificationById(request);
//Assert
result
.Should()
.BeOfType <OkObjectResult>();
}
public void Validate_GivenValidModelWithBaselineCalculationHasSpecificationThatDoesNotExist_ValidIsFalse()
{
//Arrange
CalculationEditModel model = CreateModel();
model.CalculationType = CalculationType.Baseline;
ISpecificationsRepository specsRepo = CreateSpecificationsRepository(false);
Specification specification = null;
specsRepo
.GetSpecificationById(specificationId)
.Returns(specification);
CalculationEditModelValidator validator = CreateValidator(specsRepo);
//Act
ValidationResult result = validator.Validate(model);
//Assert
result
.IsValid
.Should()
.BeFalse();
IEnumerable <string> expectedErrors = new[] { "Specification not found", "Unable to find Allocation Line with provided ID" };
result.Errors.Count().Should().Be(expectedErrors.Count());
foreach (string error in expectedErrors)
{
result.Errors.Count(e => e.ErrorMessage == error).Should().Be(1);
}
}
