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); } }