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 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 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 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 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); } }
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 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 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 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_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_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 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 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 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 EditSpecificationStatus_GivenSpecificationWasNotFound_ReturnsNotFoundResult() { //Arrange EditStatusModel specificationEditStatusModel = new EditStatusModel { PublishStatus = PublishStatus.Approved }; string json = JsonConvert.SerializeObject(specificationEditStatusModel); byte[] byteArray = Encoding.UTF8.GetBytes(json); MemoryStream stream = new MemoryStream(byteArray); HttpContext context = Substitute.For <HttpContext>(); HttpRequest request = Substitute.For <HttpRequest>(); IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues> { { "specificationId", new StringValues(SpecificationId) }, }); request .Query .Returns(queryStringValues); request .Body .Returns(stream); request .HttpContext .Returns(context); 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(request); //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 SelectSpecificationForFunding_GivenValidSpecification_ReturnsNoContentResult() { // Arrange IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues> { { "specificationId", new StringValues(SpecificationId) } }); HttpRequest request = Substitute.For <HttpRequest>(); request .Query .Returns(queryStringValues); Specification specification = CreateSpecification(); ILogger logger = CreateLogger(); ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository(); specificationsRepository .GetSpecificationById(Arg.Is(SpecificationId)) .Returns(specification); specificationsRepository .UpdateSpecification(Arg.Is(specification)) .Returns(HttpStatusCode.OK); IJobsApiClient jobsApiClient = CreateJobsApiClient(); ICacheProvider cacheProvider = CreateCacheProvider(); SpecificationsService service = CreateService( logs: logger, specificationsRepository: specificationsRepository, jobsApiClient: jobsApiClient, cacheProvider: cacheProvider); // Act IActionResult result = await service.SelectSpecificationForFunding(request); // Assert result .Should() .BeOfType <NoContentResult>(); await jobsApiClient .Received(1) .CreateJob(Arg.Is <JobCreateModel>(j => j.JobDefinitionId == JobConstants.DefinitionNames.PublishProviderResultsJob && j.SpecificationId == SpecificationId && j.Trigger.Message == $"Selecting specification for funding")); await cacheProvider .Received(1) .RemoveAsync <SpecificationSummary>($"{CacheKeys.SpecificationSummaryById}{specification.Id}"); await cacheProvider .Received(1) .RemoveAsync <SpecificationCurrentVersion>($"{CacheKeys.SpecificationCurrentVersionById}{specification.Id}"); }
public async Task CreateCalculation_GivenValidModelButNoPolicyFound_ReturnsPreconditionFailed() { //Arrange Specification specification = new Specification() { Current = new SpecificationVersion(), }; CalculationCreateModel model = new CalculationCreateModel { SpecificationId = SpecificationId, PolicyId = PolicyId }; string json = JsonConvert.SerializeObject(model); byte[] byteArray = Encoding.UTF8.GetBytes(json); MemoryStream stream = new MemoryStream(byteArray); HttpRequest request = Substitute.For <HttpRequest>(); request .Body .Returns(stream); ILogger logger = CreateLogger(); ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository(); specificationsRepository .GetSpecificationById(Arg.Is(SpecificationId)) .Returns(specification); Calculation calculation = new Calculation(); IMapper mapper = CreateMapper(); mapper .Map <Calculation>(model) .Returns(calculation); SpecificationsService service = CreateService(logs: logger, specificationsRepository: specificationsRepository, mapper: mapper); //Act IActionResult result = await service.CreateCalculation(request); //Assert result .Should() .BeOfType <PreconditionFailedResult>() .Which .Value .Should() .Be("Policy not found for policy id 'dda8ccb3-eb8e-4658-8b3f-f1e4c3a8f322'"); logger .Received(1) .Warning($"Policy not found for policy id '{PolicyId}'"); }
public async Task SelectSpecificationForFunding_GivenSpecificationButUpdatingSearchFails_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.OK); // IEnumerable<IndexError> errors = new[] // { // new IndexError{ ErrorMessage = "failed" } // }; // ISearchRepository<SpecificationIndex> searchRepository = CreateSearchRepository(); // searchRepository // .Index(Arg.Any<IEnumerable<SpecificationIndex>>()) // .Returns(errors); _specificationIndexer .When(_ => _.Index(Arg.Is <Specification>(sp => sp.IsSelectedForFunding))) .Throw(new Exception()); ICacheProvider cacheProvider = CreateCacheProvider(); SpecificationsService service = CreateService( logs: logger, specificationsRepository: specificationsRepository, cacheProvider: cacheProvider); // Act IActionResult result = await service.SelectSpecificationForFunding(SpecificationId); // Assert result .Should() .BeOfType <InternalServerErrorResult>(); // logger // .Received(1) // .Error(Arg.Is($"Failed to index search for specification {SpecificationId} with the following errors: failed")); // // logger // .Received(1) // .Error(Arg.Any<Exception>(), Arg. ($"Failed to index search for specification {SpecificationId} with the following errors: failed")); await cacheProvider .Received(1) .RemoveAsync <SpecificationSummary>($"{CacheKeys.SpecificationSummaryById}{specification.Id}"); }
public async Task CreateCalculation_GivenDuplicateCalculationName_ReturnsBadRequest() { // Arrange Specification specification = CreateSpecification(); CalculationCreateModel model = new CalculationCreateModel { SpecificationId = SpecificationId, PolicyId = PolicyId, Name = "calc1", CalculationType = CalculationType.Number }; string json = JsonConvert.SerializeObject(model); byte[] byteArray = Encoding.UTF8.GetBytes(json); MemoryStream stream = new MemoryStream(byteArray); ClaimsPrincipal principal = new ClaimsPrincipal(new[] { new ClaimsIdentity(new [] { new Claim(ClaimTypes.Sid, UserId), new Claim(ClaimTypes.Name, Username) }) }); HttpContext context = Substitute.For <HttpContext>(); context .User .Returns(principal); HttpRequest request = Substitute.For <HttpRequest>(); request .Body .Returns(stream); request .HttpContext .Returns(context); ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository(); specificationsRepository .GetSpecificationById(Arg.Is(SpecificationId)) .Returns(specification); IValidator <CalculationCreateModel> validator = CreateCalculationValidator(new ValidationResult(new[] { new ValidationFailure("prop1", "any error") })); SpecificationsService service = CreateService(specificationsRepository: specificationsRepository, calculationCreateModelValidator: validator); // Act IActionResult result = await service.CreateCalculation(request); // Assert result .Should() .BeOfType <BadRequestObjectResult>(); }
public async Task AssignDataDefinitionRelationship_GivenUpdatedCosmosAndSearch_LogsSuccess() { //Arrange dynamic anyObject = new { specificationId = SpecificationId, relationshipId = RelationshipId }; string json = JsonConvert.SerializeObject(anyObject); Message message = new Message(Encoding.UTF8.GetBytes(json)); Specification specification = new Specification { Id = SpecificationId, Name = SpecificationName, Current = new Models.Specs.SpecificationVersion() { FundingStreams = new List <Reference>() { new Reference("fs-id", "fs-name") }, FundingPeriod = new Reference("18/19", "2018/19"), }, }; ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository(); specificationsRepository .GetSpecificationById(Arg.Is(SpecificationId)) .Returns(specification); specificationsRepository .UpdateSpecification(Arg.Is(specification)) .Returns(HttpStatusCode.OK); ILogger logger = CreateLogger(); Models.Specs.SpecificationVersion newSpecVersion = specification.Current.Clone() as Models.Specs.SpecificationVersion; IVersionRepository <Models.Specs.SpecificationVersion> versionRepository = CreateVersionRepository(); versionRepository .CreateVersion(Arg.Any <Models.Specs.SpecificationVersion>(), Arg.Any <Models.Specs.SpecificationVersion>()) .Returns(newSpecVersion); SpecificationsService service = CreateService(specificationsRepository: specificationsRepository, logs: logger, specificationVersionRepository: versionRepository); //Act await service.Process(message); //Assert logger .Received(1) .Information($"Successfully assigned relationship id: {RelationshipId} to specification with id: {SpecificationId}"); await _specificationIndexer .Received(1) .Index(Arg.Is <Specification>(_ => ReferenceEquals(_.Current, newSpecVersion))); }
public async Task EditSpecification_GivenSpecificationWasfoundAndFundingPeriodChangedButFailedToGetFundingPeriodsFromCosmos_ReturnsPreConditionFailedresult() { //Arrange SpecificationEditModel specificationEditModel = new SpecificationEditModel { FundingPeriodId = "fp10" }; string json = JsonConvert.SerializeObject(specificationEditModel); byte[] byteArray = Encoding.UTF8.GetBytes(json); MemoryStream stream = new MemoryStream(byteArray); HttpContext context = Substitute.For <HttpContext>(); HttpRequest request = Substitute.For <HttpRequest>(); IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues> { { "specificationId", new StringValues(SpecificationId) }, }); request .Query .Returns(queryStringValues); request .Body .Returns(stream); request .HttpContext .Returns(context); ILogger logger = CreateLogger(); Specification specification = CreateSpecification(); ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository(); specificationsRepository .GetSpecificationById(Arg.Is(SpecificationId)) .Returns(specification); SpecificationsService service = CreateService(logs: logger, specificationsRepository: specificationsRepository); //Act IActionResult result = await service.EditSpecification(request); //Arrange result .Should() .BeOfType <PreconditionFailedResult>() .Which .Value .Should() .Be($"Unable to find funding period with ID '{specificationEditModel.FundingPeriodId}'."); }
public async Task EditPolicy_WhenValidModelButPolicyCouldNotBeFound_ThenReturnsNotFoundResult() { // Arrange PolicyEditModel policyEditModel = new PolicyEditModel { SpecificationId = SpecificationId }; string json = JsonConvert.SerializeObject(policyEditModel); byte[] byteArray = Encoding.UTF8.GetBytes(json); MemoryStream stream = new MemoryStream(byteArray); HttpContext context = Substitute.For <HttpContext>(); HttpRequest request = Substitute.For <HttpRequest>(); IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues> { { "specificationId", new StringValues(SpecificationId) }, { "policyId", new StringValues(PolicyId) }, }); request .Query .Returns(queryStringValues); request .Body .Returns(stream); request .HttpContext .Returns(context); Specification specification = CreateSpecification(); ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository(); specificationsRepository .GetSpecificationById(Arg.Is(SpecificationId)) .Returns(specification); SpecificationsService specificationsService = CreateService(specificationsRepository: specificationsRepository); // Act IActionResult result = await specificationsService.EditPolicy(request); // Assert result .Should() .BeOfType <NotFoundObjectResult>() .Which .Value .Should() .Be($"Failed to find policy for policy id: {PolicyId}"); }
public async Task GetPolicyByName_GivenSpecificationExistsAndPolicyExists_ReturnsSuccess() { //Arrange Specification spec = new Specification { Current = new SpecificationVersion() { Policies = new[] { new Policy { Name = PolicyName } }, }, }; PolicyGetModel model = new PolicyGetModel { SpecificationId = SpecificationId, Name = PolicyName }; string json = JsonConvert.SerializeObject(model); byte[] byteArray = Encoding.UTF8.GetBytes(json); MemoryStream stream = new MemoryStream(byteArray); HttpRequest request = Substitute.For <HttpRequest>(); request .Body .Returns(stream); ILogger logger = CreateLogger(); ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository(); specificationsRepository .GetSpecificationById(Arg.Is(SpecificationId)) .Returns(spec); SpecificationsService service = CreateService(specificationsRepository: specificationsRepository, logs: logger); //Act IActionResult result = await service.GetPolicyByName(request); //Assert result .Should() .BeOfType <OkObjectResult>(); logger .Received(1) .Information(Arg.Is($"A policy was found for specification id {SpecificationId} and name {PolicyName}")); }
public async Task GetSpecificationSummaryById_GivenSpecificationSummaryWasNotFound_ReturnsNotFoundResult() { //Arrange Specification specification = null; 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); IMapper mapper = CreateImplementedMapper(); ICacheProvider cacheProvider = CreateCacheProvider(); cacheProvider .GetAsync <SpecificationSummary>(Arg.Is($"{CacheKeys.SpecificationSummaryById}{SpecificationId}")) .Returns((SpecificationSummary)null); SpecificationsService service = CreateService( specificationsRepository: specificationsRepository, cacheProvider: cacheProvider, logs: logger, mapper: mapper); //Act IActionResult result = await service.GetSpecificationSummaryById(request); //Assert result .Should() .BeOfType <NotFoundResult>(); await specificationsRepository .Received(1) .GetSpecificationById(Arg.Is(SpecificationId)); await cacheProvider .Received(1) .GetAsync <SpecificationSummary>(Arg.Is($"{CacheKeys.SpecificationSummaryById}{SpecificationId}")); }
public async Task EditSpecificationStatus_GivenSpecificationISApprovedButNewStatusIsDraft_ThenBadRequestReturned() { //Arrange EditStatusModel specificationEditStatusModel = new EditStatusModel { PublishStatus = PublishStatus.Draft }; ILogger logger = CreateLogger(); Specification specification = CreateSpecification(); specification.Current.PublishStatus = PublishStatus.Approved; ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository(); specificationsRepository .GetSpecificationById(Arg.Is(SpecificationId)) .Returns(specification); specificationsRepository .UpdateSpecification(Arg.Any <Specification>()) .Returns(HttpStatusCode.OK); ISearchRepository <SpecificationIndex> searchRepository = CreateSearchRepository(); SpecificationsService service = CreateService( logs: logger, specificationsRepository: specificationsRepository, searchRepository: searchRepository); // Act IActionResult result = await service.EditSpecificationStatus(SpecificationId, specificationEditStatusModel, null); // Arrange result .Should() .BeOfType <BadRequestObjectResult>() .Which .Value .Should() .Be("Publish status can't be changed to Draft from Updated or Approved"); specification .Current .PublishStatus .Should() .Be(PublishStatus.Approved); await searchRepository .Received(0) .Index(Arg.Any <IEnumerable <SpecificationIndex> >()); }
public async Task EditCalculation_WhenValidModelButSpecificationCouldNotBeFound_ThenReturnsPreConditionFailed() { // Arrange CalculationEditModel policyEditModel = new CalculationEditModel(); string json = JsonConvert.SerializeObject(policyEditModel); byte[] byteArray = Encoding.UTF8.GetBytes(json); MemoryStream stream = new MemoryStream(byteArray); HttpContext context = Substitute.For <HttpContext>(); HttpRequest request = Substitute.For <HttpRequest>(); IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues> { { "specificationId", new StringValues(SpecificationId) }, { "calculationId", new StringValues(CalculationId) }, }); request .Query .Returns(queryStringValues); request .Body .Returns(stream); request .HttpContext .Returns(context); ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository(); specificationsRepository .GetSpecificationById(Arg.Is(SpecificationId)) .Returns((Specification)null); SpecificationsService specificationsService = CreateService(specificationsRepository: specificationsRepository); // Act IActionResult result = await specificationsService.EditCalculation(request); // Assert result .Should() .BeOfType <PreconditionFailedResult>() .Which .Value .Should() .Be($"Specification not found for specification id {SpecificationId}"); }
public void Validate_GivenNameAlreadyExists_ValidIsFalse() { //Arrange CalculationEditModel model = CreateModel(); ISpecificationsRepository repository = CreateSpecificationsRepository(true); Specification specification = new Specification() { Current = new SpecificationVersion() }; repository .GetSpecificationById(specificationId) .Returns(specification); ICalculationsRepository calculationsRepository = Substitute.For <ICalculationsRepository>(); calculationsRepository .IsCalculationNameValid(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <string>()) .Returns(false); CalculationEditModelValidator validator = CreateValidator(repository, calculationsRepository); //Act ValidationResult result = validator.Validate(model); //Assert result .IsValid .Should() .BeFalse(); result .Errors .Count .Should() .Be(1); result .Errors .Single() .ErrorMessage .Should() .Be("Calculation with the same generated source code name already exists in this specification"); calculationsRepository .Received(1) .IsCalculationNameValid(specificationId, name, calculationId); }
public AssignSpecificationProviderVersionModelValidator( ISpecificationsRepository specificationsRepository, IProvidersApiClient providersApiClient, ISpecificationsResiliencePolicies resiliencePolicies) { Guard.ArgumentNotNull(specificationsRepository, nameof(specificationsRepository)); Guard.ArgumentNotNull(providersApiClient, nameof(providersApiClient)); Guard.ArgumentNotNull(resiliencePolicies?.ProvidersApiClient, nameof(resiliencePolicies.ProvidersApiClient)); _specificationsRepository = specificationsRepository; _providersApiClient = providersApiClient; _providersApiClientPolicy = resiliencePolicies.ProvidersApiClient; RuleFor(model => model.SpecificationId) .NotEmpty() .WithMessage("Null or Empty SpecificationId provided") .CustomAsync(async(name, context, cancellationToken) => { AssignSpecificationProviderVersionModel model = context.ParentContext.InstanceToValidate as AssignSpecificationProviderVersionModel; if (!string.IsNullOrWhiteSpace(model.SpecificationId)) { Specification specification = await _specificationsRepository.GetSpecificationById(model.SpecificationId); if (specification == null) { context.AddFailure(nameof(model.SpecificationId), $"Specification not found for SpecificationId - {model.SpecificationId}"); } else if (specification.Current.ProviderSource != ProviderSource.FDZ) { context.AddFailure($"Specification ProviderSource is not set to FDZ"); } } }); RuleFor(model => model.ProviderVersionId) .NotEmpty() .WithMessage("Null or Empty ProviderVersionId provided") .CustomAsync(async(name, context, cancellationToken) => { AssignSpecificationProviderVersionModel model = context.ParentContext.InstanceToValidate as AssignSpecificationProviderVersionModel; if (!string.IsNullOrWhiteSpace(model.ProviderVersionId)) { HttpStatusCode providerVersionStatusCode = await _providersApiClientPolicy.ExecuteAsync(() => _providersApiClient.DoesProviderVersionExist(model.ProviderVersionId)); if (providerVersionStatusCode == HttpStatusCode.NotFound) { context.AddFailure(nameof(model.ProviderVersionId), $"Provider version id specified does not exist"); } } }); }
public async Task UpdateCacheWithCalculationStarted_GivenSpecificationButUpdatingFails_ReturnsInternalServerError() { //Arrange Specification specification = new Specification { Id = SpecificationId }; 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); specificationsRepository .UpdateSpecification(Arg.Is(specification)) .Returns(HttpStatusCode.BadRequest); SpecificationsService service = CreateService(logs: logger, specificationsRepository: specificationsRepository); //Act IActionResult actionResult = await service.UpdateCalculationLastUpdatedDate(request); //Assert actionResult .Should() .BeOfType <InternalServerErrorResult>() .Which .Value .Should() .Be($"Failed to update calculation last updated date on specification {SpecificationId}"); logger .Received(1) .Error($"Failed to update calculation last updated date on specification {SpecificationId}"); }
public async Task GetPolicyByName_GivenSpecificationDoesNotExist_ReturnsPreConditionFailed() { //Arrange PolicyGetModel model = new PolicyGetModel { SpecificationId = SpecificationId, Name = PolicyName }; string json = JsonConvert.SerializeObject(model); byte[] byteArray = Encoding.UTF8.GetBytes(json); MemoryStream stream = new MemoryStream(byteArray); HttpRequest request = Substitute.For <HttpRequest>(); request .Body .Returns(stream); 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.GetPolicyByName(request); //Assert result .Should() .BeOfType <StatusCodeResult>(); StatusCodeResult statusCodeResult = (StatusCodeResult)result; statusCodeResult .StatusCode .Should() .Be(412); logger .Received(1) .Error(Arg.Is($"No specification was found for specification id {SpecificationId}")); }