public async Task GetMappedCalculationsOfSpecificationTemplate_TemplateMappingNotFound_Returns404() { //Arrange ILogger logger = CreateLogger(); string specificationId = "test"; string fundingStreamId = "test"; string expectedErrorMessage = $"A template mapping was not found for specification id {specificationId} and funding stream Id {fundingStreamId}"; TemplateMapping templateMapping = null; ICalculationsRepository calculationsRepository = CreateCalculationsRepository(); calculationsRepository .GetTemplateMapping(specificationId, fundingStreamId) .Returns(templateMapping); CalculationService service = CreateCalculationService( logger: logger, calculationsRepository: calculationsRepository); // Act IActionResult result = await service.GetMappedCalculationsOfSpecificationTemplate(specificationId, fundingStreamId); // Assert result .Should() .BeOfType <NotFoundObjectResult>() .Which .Value .Should() .Be(expectedErrorMessage); }
public CreateCalculationService(ICalculationNameInUseCheck calculationNameInUseCheck, ICalculationsRepository calculationsRepository, IVersionRepository <CalculationVersion> calculationVersionRepository, ICalcsResiliencePolicies calculationsResiliencePolicies, IValidator <CalculationCreateModel> calculationCreateModelValidator, ICacheProvider cacheProvider, ISearchRepository <CalculationIndex> searchRepository, ILogger logger, IInstructionAllocationJobCreation instructionAllocationJobCreation) { Guard.ArgumentNotNull(searchRepository, nameof(searchRepository)); Guard.ArgumentNotNull(calculationNameInUseCheck, nameof(calculationNameInUseCheck)); Guard.ArgumentNotNull(calculationsRepository, nameof(calculationsRepository)); Guard.ArgumentNotNull(calculationVersionRepository, nameof(calculationVersionRepository)); Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider)); Guard.ArgumentNotNull(calculationsResiliencePolicies?.CacheProviderPolicy, nameof(calculationsResiliencePolicies.CacheProviderPolicy)); Guard.ArgumentNotNull(calculationsResiliencePolicies?.CalculationsRepository, nameof(calculationsResiliencePolicies.CalculationsRepository)); Guard.ArgumentNotNull(calculationsResiliencePolicies?.CalculationsVersionsRepositoryPolicy, nameof(calculationsResiliencePolicies.CalculationsVersionsRepositoryPolicy)); _calculationNameInUseCheck = calculationNameInUseCheck; _calculationsRepository = calculationsRepository; _calculationVersionRepository = calculationVersionRepository; _logger = logger; _instructionAllocationJobCreation = instructionAllocationJobCreation; _searchRepository = searchRepository; _cacheProvider = cacheProvider; _calculationCreateModelValidator = calculationCreateModelValidator; _calculationVersionsRepositoryPolicy = calculationsResiliencePolicies.CalculationsVersionsRepositoryPolicy; _calculationRepositoryPolicy = calculationsResiliencePolicies.CalculationsRepository; _cachePolicy = calculationsResiliencePolicies.CacheProviderPolicy; _typeIdentifierGenerator = new VisualBasicTypeIdentifierGenerator(); }
public void ValidateConstruction_WhenValidatorReturnsFalse_ShouldThrowArgumentNullExceptionWithListOfErrors() { // Arrange EngineSettings nullEngineSettings = Substitute.For <EngineSettings>(); ICalculationsRepository mockCalculationRepository = Substitute.For <ICalculationsRepository>(); ICalculatorResiliencePolicies mockCalculatorResiliencePolicies = Substitute.For <ICalculatorResiliencePolicies>(); var mockMessengerPolicy = Policy.NoOpAsync(); var mockProviderResultsRepositoryPolicy = Policy.NoOpAsync(); mockCalculatorResiliencePolicies.CacheProvider.Returns((AsyncPolicy)null); mockCalculatorResiliencePolicies.Messenger.Returns(mockMessengerPolicy); mockCalculatorResiliencePolicies.ProviderSourceDatasetsRepository.Returns((AsyncPolicy)null); mockCalculatorResiliencePolicies.CalculationResultsRepository.Returns(mockProviderResultsRepositoryPolicy); mockCalculatorResiliencePolicies.CalculationsApiClient.Returns((AsyncPolicy)null); IValidator <ICalculatorResiliencePolicies> validator = new CalculatorResiliencePoliciesValidator(); // Act Action validateAction = () => { ICalculationEngineServiceValidator calculationEngineServiceValidator = new CalculationEngineServiceValidator(validator, nullEngineSettings, mockCalculatorResiliencePolicies, mockCalculationRepository); }; // Assert validateAction .Should() .ThrowExactly <ArgumentNullException>() .And.Message .Should().Contain("CacheProvider") .And.Contain("ProviderSourceDatasetsRepository") .And.Contain("CalculationRepository"); }
public SourceCodeService( ISourceFileRepository sourceFilesRepository, ILogger logger, ICalculationsRepository calculationsRepository, ISourceFileGeneratorProvider sourceFileGeneratorProvider, ICompilerFactory compilerFactory, ICodeMetadataGeneratorService codeMetadataGenerator, ICalcsResiliencePolicies resiliencePolicies) { Guard.ArgumentNotNull(sourceFilesRepository, nameof(sourceFilesRepository)); Guard.ArgumentNotNull(logger, nameof(logger)); Guard.ArgumentNotNull(calculationsRepository, nameof(calculationsRepository)); Guard.ArgumentNotNull(sourceFileGeneratorProvider, nameof(sourceFileGeneratorProvider)); Guard.ArgumentNotNull(compilerFactory, nameof(compilerFactory)); Guard.ArgumentNotNull(codeMetadataGenerator, nameof(codeMetadataGenerator)); Guard.ArgumentNotNull(resiliencePolicies, nameof(resiliencePolicies)); Guard.ArgumentNotNull(resiliencePolicies?.SourceFilesRepository, nameof(resiliencePolicies.SourceFilesRepository)); Guard.ArgumentNotNull(resiliencePolicies?.CalculationsRepository, nameof(resiliencePolicies.CalculationsRepository)); _sourceFilesRepository = sourceFilesRepository; _logger = logger; _calculationsRepository = calculationsRepository; _sourceFileGeneratorProvider = sourceFileGeneratorProvider; _compilerFactory = compilerFactory; _sourceFileGenerator = sourceFileGeneratorProvider.CreateSourceFileGenerator(TargetLanguage.VisualBasic); _codeMetadataGenerator = codeMetadataGenerator; _sourceFilesRepositoryPolicy = resiliencePolicies.SourceFilesRepository; _calculationsRepositoryPolicy = resiliencePolicies.CalculationsRepository; }
public DatasetDefinitionFieldChangesProcessor( IFeatureToggle featureToggle, IDatasetsApiClient datasetsApiClient, ICalcsResiliencePolicies resiliencePolicies, ILogger logger, ICalculationService calculationService, ICalculationsRepository calculationsRepository, IMapper mapper) { Guard.ArgumentNotNull(featureToggle, nameof(featureToggle)); Guard.ArgumentNotNull(datasetsApiClient, nameof(datasetsApiClient)); Guard.ArgumentNotNull(resiliencePolicies, nameof(resiliencePolicies)); Guard.ArgumentNotNull(logger, nameof(logger)); Guard.ArgumentNotNull(calculationService, nameof(calculationService)); Guard.ArgumentNotNull(calculationsRepository, nameof(calculationsRepository)); Guard.ArgumentNotNull(resiliencePolicies?.CalculationsRepository, nameof(resiliencePolicies.CalculationsRepository)); Guard.ArgumentNotNull(resiliencePolicies?.DatasetsApiClient, nameof(resiliencePolicies.DatasetsApiClient)); Guard.ArgumentNotNull(mapper, nameof(mapper)); _featureToggle = featureToggle; _datasetsApiClient = datasetsApiClient; _datasetsApiClientPolicy = resiliencePolicies.DatasetsApiClient; _logger = logger; _calculationService = calculationService; _calculationsRepository = calculationsRepository; _calculationsRepositoryPolicy = resiliencePolicies.CalculationsRepository; _mapper = mapper; _typeIdentifierGenerator = new VisualBasicTypeIdentifierGenerator(); }
public async Task UpdateTemplateCalculationsForSpecification_GivenNoTemplateCalculationsForSpecification_ReturnsNotFoundObjectResults() { // Arrange string datasetRelationshipId = NewRandomString(); Reference user = new Reference(NewRandomString(), NewRandomString()); ILogger logger = CreateLogger(); ICalculationsRepository calculationsRepository = CreateCalculationsRepository(); calculationsRepository.GetTemplateCalculationsBySpecificationId(Arg.Is(SpecificationId)) .Returns(new List <Calculation>()); CalculationService service = CreateCalculationService( calculationsRepository, logger); // Act IActionResult result = await service.UpdateTemplateCalculationsForSpecification(SpecificationId, datasetRelationshipId, user); // Assert result .Should() .BeOfType <NotFoundObjectResult>() .Which .Value .Should() .Be($"No template calculations found for specification id '{SpecificationId}'"); }
public TestEngineService( ICacheProvider cacheProvider, ISpecificationRepository specificationRepository, ILogger logger, ITestEngine testEngine, IScenariosRepository scenariosRepository, IProviderSourceDatasetsRepository providerSourceDatasetsRepository, ITestResultsService testResultsService, ITestResultsRepository testResultsRepository, IBuildProjectRepository buildProjectRepository, ITelemetry telemetry, ITestRunnerResiliencePolicies resiliencePolicies, ICalculationsRepository calculationsRepository) { _cacheProvider = cacheProvider; _specificationRepository = specificationRepository; _logger = logger; _testEngine = testEngine; _scenariosRepository = scenariosRepository; _providerSourceDatasetsRepository = providerSourceDatasetsRepository; _testResultsService = testResultsService; _testResultsRepository = testResultsRepository; _telemetry = telemetry; _cacheProviderPolicy = resiliencePolicies.CacheProviderRepository; _specificationRepositoryPolicy = resiliencePolicies.SpecificationRepository; _scenariosRepositoryPolicy = resiliencePolicies.ScenariosRepository; _providerSourceDatasetsRepositoryPolicy = resiliencePolicies.ProviderSourceDatasetsRepository; _testResultsRepositoryPolicy = resiliencePolicies.TestResultsRepository; _builProjectsRepositoryPolicy = resiliencePolicies.BuildProjectRepository; _buildProjectRepository = buildProjectRepository; _calculationsRepository = calculationsRepository; }
public void Initialize() { _calculationEngine = Substitute.For <ICalculationEngine>(); _providersApiClient = Substitute.For <IProvidersApiClient>(); _specificationsApiClient = Substitute.For <ISpecificationsApiClient>(); _providerSourceDatasetsRepository = Substitute.For <IProviderSourceDatasetsRepository>(); _calculationAggregationService = Substitute.For <ICalculationAggregationService>(); _calculationsRepository = Substitute.For <ICalculationsRepository>(); _logger = Substitute.For <ILogger>(); _mapper = CreateMapper(); _calculatorResiliencePolicies = new CalculatorResiliencePolicies { SpecificationsApiClient = Policy.NoOpAsync(), ProvidersApiClient = Policy.NoOpAsync(), CalculationsApiClient = Policy.NoOpAsync() }; _calculationEnginePreviewService = new CalculationEnginePreviewService( _calculationEngine, _providersApiClient, _mapper, _calculatorResiliencePolicies, _specificationsApiClient, _providerSourceDatasetsRepository, _calculationAggregationService, _calculationsRepository, _logger); }
async public Task GetCalculationById_GivenCalculationIdWasProvidedButCalculationCouldNotBeFound_ReturnsNotFound() { //Arrange IQueryCollection queryStringValues = new QueryCollection(new Dictionary<string, StringValues> { { "calculationId", new StringValues(CalculationId) } }); HttpRequest request = Substitute.For<HttpRequest>(); request .Query .Returns(queryStringValues); ILogger logger = CreateLogger(); ICalculationsRepository calculationsRepository = CreateCalculationsRepository(); calculationsRepository .GetCalculationById(Arg.Is(CalculationId)) .Returns((Calculation)null); CalculationService service = CreateCalculationService(logger: logger, calculationsRepository: calculationsRepository); //Act IActionResult result = await service.GetCalculationById(request); //Assert result .Should() .BeOfType<NotFoundResult>(); logger .Received(1) .Information(Arg.Is($"A calculation was not found for calculation id {CalculationId}")); }
async public Task GetCalculationCurrentVersion_GivencalculationWasFoundWithNoCurrent_ReturnsNotFound() { //Arrange Calculation calculation = new Calculation(); ILogger logger = CreateLogger(); ICalculationsRepository calculationsRepository = CreateCalculationsRepository(); calculationsRepository .GetCalculationById(Arg.Is(CalculationId)) .Returns(calculation); CalculationService service = CreateCalculationService(logger: logger, calculationsRepository: calculationsRepository); //Act IActionResult result = await service.GetCalculationById(CalculationId); //Assert result .Should() .BeOfType <NotFoundResult>(); logger .Received(1) .Information(Arg.Is($"A current calculation was not found for calculation id {CalculationId}")); }
private static CalculationService CreateCalculationService( ICalculationsRepository calculationsRepository = null, ILogger logger = null, ISearchRepository <CalculationIndex> searchRepository = null, IValidator <Calculation> calcValidator = null, IBuildProjectsService buildProjectsService = null, ISpecificationRepository specificationRepository = null, ICacheProvider cacheProvider = null, ICalcsResiliencePolicies resiliencePolicies = null, IVersionRepository <CalculationVersion> calculationVersionRepository = null, IJobsApiClient jobsApiClient = null, ISourceCodeService sourceCodeService = null, IFeatureToggle featureToggle = null, IBuildProjectsRepository buildProjectsRepository = null, ICalculationCodeReferenceUpdate calculationCodeReferenceUpdate = null) { return(new CalculationService (calculationsRepository ?? CreateCalculationsRepository(), logger ?? CreateLogger(), searchRepository ?? CreateSearchRepository(), calcValidator ?? CreateCalculationValidator(), buildProjectsService ?? CreateBuildProjectsService(), specificationRepository ?? CreateSpecificationRepository(), cacheProvider ?? CreateCacheProvider(), resiliencePolicies ?? CalcsResilienceTestHelper.GenerateTestPolicies(), calculationVersionRepository ?? CreateCalculationVersionRepository(), jobsApiClient ?? CreateJobsApiClient(), sourceCodeService ?? CreateSourceCodeService(), featureToggle ?? CreateFeatureToggle(), buildProjectsRepository ?? CreateBuildProjectsRepository(), calculationCodeReferenceUpdate ?? CreateCalculationCodeReferenceUpdate())); }
public async Task ValidateAsync_WhenCalculationNameAlreadyExistsButItsTheSameCalc_EnsuresValidIsTrue() { //Arrange CalculationEditModel model = CreateModel(); Calculation calculationWithSameName = new Calculation { Id = model.CalculationId }; ICalculationsRepository calculationsRepository = CreateCalculationRepository(); calculationsRepository .GetCalculationsBySpecificationIdAndCalculationName(Arg.Is(model.SpecificationId), Arg.Is(model.Name)) .Returns(calculationWithSameName); CalculationEditModelValidator validator = CreateValidator(calculationRepository: calculationsRepository); //Act ValidationResult result = await validator.ValidateAsync(model); //Assert result .IsValid .Should() .BeTrue(); }
public async Task ValidateAsync_WhenCalculationNameAlreadyExists_ValidIsFalse() { //Arrange CalculationCreateModel model = CreateModel(); Calculation calculationWithSameName = new Calculation(); ICalculationsRepository calculationsRepository = CreateCalculationRepository(); calculationsRepository .GetCalculationsBySpecificationIdAndCalculationName(Arg.Is(model.SpecificationId), Arg.Is(model.Name)) .Returns(calculationWithSameName); CalculationCreateModelValidator validator = CreateValidator(calculationRepository: calculationsRepository); //Act ValidationResult result = await validator.ValidateAsync(model); //Assert result .IsValid .Should() .BeFalse(); result.Errors .Should() .Contain(_ => _.ErrorMessage == "A calculation already exists with the name: 'test calc' for this specification"); }
public async Task IsCalculationNameValid_WhenCalculationDoesNotExist_ThenReturnsOkResult() { // Arrange string specificationId = "spec1"; ISpecificationsApiClient specificationsApiClient = CreateSpecificationsApiClient(); specificationsApiClient .GetSpecificationSummaryById(Arg.Is(specificationId)) .Returns(new Common.ApiClient.Models.ApiResponse <SpecModel.SpecificationSummary>(HttpStatusCode.OK, new SpecModel.SpecificationSummary { Id = specificationId })); ICalculationsRepository calculationsRepository = CreateCalculationsRepository(); calculationsRepository .GetCalculationsBySpecificationId(Arg.Is(specificationId)) .Returns(new List <Calculation>()); CalculationService service = CreateCalculationService(specificationsApiClient: specificationsApiClient, calculationsRepository: calculationsRepository); // Act IActionResult result = await service.IsCalculationNameValid(specificationId, "calc1", null); // Assert result .Should() .BeOfType <OkResult>(); }
public SpecificationCalculationAnalysis(ICalcsResiliencePolicies policies, ISpecificationsApiClient specifications, ICalculationsRepository calculations, ICalculationAnalysis calculationAnalysis, IBuildProjectsService buildProjectsService, IDatasetReferenceService datasetReferenceService, IMapper mapper) { Guard.ArgumentNotNull(policies?.CalculationsRepository, nameof(policies.CalculationsRepository)); Guard.ArgumentNotNull(policies?.SpecificationsApiClient, nameof(policies.SpecificationsApiClient)); Guard.ArgumentNotNull(specifications, nameof(specifications)); Guard.ArgumentNotNull(calculations, nameof(calculations)); Guard.ArgumentNotNull(calculationAnalysis, nameof(calculationAnalysis)); Guard.ArgumentNotNull(buildProjectsService, nameof(buildProjectsService)); Guard.ArgumentNotNull(datasetReferenceService, nameof(datasetReferenceService)); Guard.ArgumentNotNull(mapper, nameof(mapper)); _specificationsResilience = policies.SpecificationsApiClient; _calculationsResilience = policies.CalculationsRepository; _specifications = specifications; _calculations = calculations; _calculationAnalysis = calculationAnalysis; _buildProjectsService = buildProjectsService; _datasetReferenceService = datasetReferenceService; _mapper = mapper; }
public ApproveAllCalculationsService( ICalculationsRepository calculationsRepository, ICalcsResiliencePolicies resiliencePolicies, ISpecificationsApiClient specificationsApiClient, IResultsApiClient resultsApiClient, ISearchRepository <CalculationIndex> searchRepository, ICacheProvider cacheProvider, ILogger logger, IJobManagement jobManagement) : base(jobManagement, logger) { Guard.ArgumentNotNull(calculationsRepository, nameof(calculationsRepository)); Guard.ArgumentNotNull(specificationsApiClient, nameof(specificationsApiClient)); Guard.ArgumentNotNull(resultsApiClient, nameof(resultsApiClient)); Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider)); Guard.ArgumentNotNull(searchRepository, nameof(searchRepository)); Guard.ArgumentNotNull(resiliencePolicies?.SpecificationsApiClient, nameof(resiliencePolicies.SpecificationsApiClient)); Guard.ArgumentNotNull(resiliencePolicies?.CacheProviderPolicy, nameof(resiliencePolicies.CacheProviderPolicy)); Guard.ArgumentNotNull(resiliencePolicies?.ResultsApiClient, nameof(resiliencePolicies.ResultsApiClient)); Guard.ArgumentNotNull(resiliencePolicies?.CalculationsRepository, nameof(resiliencePolicies.CalculationsRepository)); Guard.ArgumentNotNull(logger, nameof(logger)); _calculationsRepository = calculationsRepository; _logger = logger; _calculationRepositoryPolicy = resiliencePolicies.CalculationsRepository; _specificationsApiClient = specificationsApiClient; _specificationsApiClientPolicy = resiliencePolicies.SpecificationsApiClient; _resultsApiClient = resultsApiClient; _resultsApiClientPolicy = resiliencePolicies.ResultsApiClient; _searchRepository = searchRepository; _cacheProvider = cacheProvider; _cachePolicy = resiliencePolicies.CacheProviderPolicy; }
public void CreateCalculation_GivenInvalidCalculation_LogsDoesNotSave() { //Arrange dynamic anyObject = new { something = 1 }; string json = JsonConvert.SerializeObject(anyObject); Message message = new Message(Encoding.UTF8.GetBytes(json)); ICalculationsRepository repository = CreateCalculationsRepository(); ILogger logger = CreateLogger(); ValidationResult validationResult = new ValidationResult(new[] { new ValidationFailure("prop1", "any error") }); IValidator <Calculation> validator = CreateCalculationValidator(validationResult); CalculationService service = CreateCalculationService(repository, logger, calcValidator: validator); //Act Func <Task> test = async() => await service.CreateCalculation(message); //Assert test .Should().ThrowExactly <InvalidModelException>(); }
public async Task EditCalculationStatus_GivenCalculationWasNotFound_ReturnsNotFoundResult() { //Arrange EditStatusModel CalculationEditStatusModel = new EditStatusModel { PublishStatus = PublishStatus.Approved }; ILogger logger = CreateLogger(); ICalculationsRepository CalculationsRepository = CreateCalculationsRepository(); CalculationsRepository .GetCalculationById(Arg.Is(CalculationId)) .Returns((Calculation)null); CalculationService service = CreateCalculationService(logger: logger, calculationsRepository: CalculationsRepository); //Act IActionResult result = await service.UpdateCalculationStatus(CalculationId, CalculationEditStatusModel); //Arrange result .Should() .BeOfType <NotFoundObjectResult>() .Which .Value .Should() .Be("Calculation not found"); logger .Received(1) .Warning(Arg.Is($"A calculation was not found for calculation id {CalculationId}")); }
public async Task IsCalculationNameValid_WhenCalculationDoesNotExist_ThenReturnsOkResult() { // Arrange string specificationId = "spec1"; ISpecificationRepository specificationRepository = CreateSpecificationRepository(); specificationRepository .GetSpecificationSummaryById(Arg.Is(specificationId)) .Returns(new SpecificationSummary { Id = specificationId }); ICalculationsRepository calculationsRepository = CreateCalculationsRepository(); calculationsRepository .GetCalculationsBySpecificationId(Arg.Is(specificationId)) .Returns(new List <Models.Calcs.Calculation>()); CalculationService service = CreateCalculationService(specificationRepository: specificationRepository, calculationsRepository: calculationsRepository); // Act IActionResult result = await service.IsCalculationNameValid(specificationId, "calc1", null); // Assert result .Should() .BeOfType <OkResult>(); }
public async Task CreateAdditionalCalculation_GivenCreateJobReturnsNull_ReturnsInternalServerError() { //Arrange CalculationCreateModel model = CreateCalculationCreateModel(); Reference author = CreateAuthor(); ICalculationsRepository calculationsRepository = CreateCalculationsRepository(); calculationsRepository .CreateDraftCalculation(Arg.Any <Calculation>()) .Returns(HttpStatusCode.OK); IVersionRepository <CalculationVersion> versionRepository = CreateCalculationVersionRepository(); ISearchRepository <CalculationIndex> searchRepository = CreateSearchRepository(); IJobManagement jobManagement = CreateJobManagement(); jobManagement .QueueJob(Arg.Any <JobCreateModel>()) .Returns((Job)null); ISpecificationsApiClient specificationsApiClient = CreateSpecificationsApiClient(); specificationsApiClient .GetSpecificationSummaryById(Arg.Is(SpecificationId)) .Returns(new ApiResponse <SpecificationSummary>( HttpStatusCode.OK, new SpecificationSummary { Id = SpecificationId } )); ILogger logger = CreateLogger(); CalculationService calculationService = CreateCalculationService( calculationsRepository: calculationsRepository, calculationVersionRepository: versionRepository, searchRepository: searchRepository, jobManagement: jobManagement, logger: logger, specificationsApiClient: specificationsApiClient); //Act IActionResult result = await calculationService.CreateAdditionalCalculation(SpecificationId, model, author, CorrelationId); //Assert result .Should() .BeOfType <InternalServerErrorResult>() .Which .Value .Should() .Be($"Failed to create job of type '{JobConstants.DefinitionNames.CreateInstructAllocationJob}' on specification '{SpecificationId}'"); logger .Received(1) .Error(Arg.Is($"Failed to create job of type '{JobConstants.DefinitionNames.CreateInstructAllocationJob}' on specification '{SpecificationId}'")); }
public async Task ResetCalculationForFieldDefinitionChanges_GivenNoCalculationsToProcess_LogsAndDoesNotContinue() { //Arrange const string specificationId = "spec-id"; IEnumerable <DatasetSpecificationRelationshipViewModel> relationships = Enumerable.Empty <DatasetSpecificationRelationshipViewModel>(); IEnumerable <string> currentFieldDefinitionNames = Enumerable.Empty <string>(); ILogger logger = CreateLogger(); ICalculationsRepository calculationsRepository = CreateCalculationsRepository(); calculationsRepository .GetCalculationsBySpecificationId(Arg.Is(specificationId)) .Returns(Enumerable.Empty <Calculation>()); CalculationService calculationService = CreateCalculationService(logger: logger, calculationsRepository: calculationsRepository); //Act await calculationService.ResetCalculationForFieldDefinitionChanges(relationships, specificationId, currentFieldDefinitionNames); //Assert logger .Received(1) .Information(Arg.Is($"No calculations found to reset for specification id '{specificationId}'")); }
public void ValidateMessage_WhenMessageContainsAllComponents_ShouldNotThrowException() { // Arrange ILogger mockLogger = Substitute.For <ILogger>(); const string cacheKey = "Cache-key"; const int partitionIndex = 0; const int partitionSize = 100; Message message = new Message(); IDictionary <string, object> messageUserProperties = message.UserProperties; messageUserProperties.Add(PartitionIndexKey, partitionIndex); messageUserProperties.Add(PartitionSizeKey, partitionSize); messageUserProperties.Add(PartitionCacheKeyKey, cacheKey); EngineSettings mockEngineSettings = Substitute.For <EngineSettings>(); ICalculationsRepository mockCalculationRepository = Substitute.For <ICalculationsRepository>(); ICalculatorResiliencePolicies mockCalculatorResiliencePolicies = Substitute.For <ICalculatorResiliencePolicies>(); IValidator <ICalculatorResiliencePolicies> validator = Substitute.For <IValidator <ICalculatorResiliencePolicies> >(); ValidationResult result = new ValidationResult(); validator.Validate(mockCalculatorResiliencePolicies) .Returns(result); ICalculationEngineServiceValidator calculationEngineServiceValidator = new CalculationEngineServiceValidator(validator, mockEngineSettings, mockCalculatorResiliencePolicies, mockCalculationRepository); // Act, Assert calculationEngineServiceValidator.ValidateMessage(mockLogger, message); }
public async Task EditCalculationStatus_GivenCalculationWasNotFound_ReturnsNotFoundResult() { //Arrange EditStatusModel CalculationEditStatusModel = new EditStatusModel { PublishStatus = PublishStatus.Approved }; string json = JsonConvert.SerializeObject(CalculationEditStatusModel); 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> { { "calculationId", new StringValues(CalculationId) }, }); request .Query .Returns(queryStringValues); request .Body .Returns(stream); request .HttpContext .Returns(context); ILogger logger = CreateLogger(); ICalculationsRepository CalculationsRepository = CreateCalculationsRepository(); CalculationsRepository .GetCalculationById(Arg.Is(CalculationId)) .Returns((Calculation)null); CalculationService service = CreateCalculationService(logger: logger, calculationsRepository: CalculationsRepository); //Act IActionResult result = await service.UpdateCalculationStatus(request); //Arrange result .Should() .BeOfType <NotFoundObjectResult>() .Which .Value .Should() .Be("Calculation not found"); logger .Received(1) .Warning(Arg.Is($"A calculation was not found for calculation id {CalculationId}")); }
private static CalculationEditModelValidator CreateValidator( ICalculationsRepository calculationRepository = null, IPreviewService previewService = null) { return(new CalculationEditModelValidator( previewService ?? CreatePreviewService(), calculationRepository ?? CreateCalculationRepository())); }
public async Task ValidateAsync_WhenSourceCodeDoesNotCompile__ValidIsFalse() { //Arrange CalculationCreateModel model = CreateModel(); model.CalculationType = CalculationType.Additional; ICalculationsRepository calculationsRepository = CreateCalculationRepository(); calculationsRepository .GetCalculationsBySpecificationIdAndCalculationName(Arg.Is(model.SpecificationId), Arg.Is(model.Name)) .Returns((Calculation)null); SpecModel.SpecificationSummary specificationSummary = new SpecModel.SpecificationSummary { Name = "spec name", FundingStreams = new[] { new Reference(model.FundingStreamId, "funding stream name") } }; ISpecificationsApiClient specificationsApiClient = CreateSpecificationsApiClient(); specificationsApiClient .GetSpecificationSummaryById(Arg.Is(model.SpecificationId)) .Returns(new Common.ApiClient.Models.ApiResponse <SpecModel.SpecificationSummary>(HttpStatusCode.OK, specificationSummary)); PreviewResponse previewResponse = new PreviewResponse { CompilerOutput = new Build { CompilerMessages = new List <CompilerMessage> { new CompilerMessage { Message = "Failed" } } } }; IPreviewService previewService = CreatePreviewService(previewResponse); CalculationCreateModelValidator validator = CreateValidator( calculationsRepository, previewService: previewService, specificationsApiClient: specificationsApiClient); //Act ValidationResult result = await validator.ValidateAsync(model); //Assert result .IsValid .Should() .BeFalse(); result.Errors .Should() .Contain(_ => _.ErrorMessage == "There are errors in the source code provided"); }
async public Task GetCalculationSummariesForSpecification_WhenCalculationsNotFoundInCacheAndResponseFromRepositoryIsNull_ThenErrorReturned() { // Arrange const string specificationId = "specid"; IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues> { { "specificationId", new StringValues(specificationId) } }); HttpRequest request = Substitute.For <HttpRequest>(); request .Query .Returns(queryStringValues); ILogger logger = CreateLogger(); ICalculationsRepository calculationsRepository = CreateCalculationsRepository(); calculationsRepository .GetCalculationsBySpecificationId(Arg.Is(specificationId)) .Returns((IEnumerable <Calculation>)null); ICacheProvider cacheProvider = CreateCacheProvider(); cacheProvider .GetAsync <List <CalculationSummaryModel> >($"{CacheKeys.CalculationsSummariesForSpecification}{specificationId}") .Returns((List <CalculationSummaryModel>)null); CalculationService service = CreateCalculationService(logger: logger, calculationsRepository: calculationsRepository, cacheProvider: cacheProvider); // Act IActionResult result = await service.GetCalculationSummariesForSpecification(request); // Assert result .Should() .BeOfType <InternalServerErrorResult>() .Which .Value .Should() .Be("Calculations from repository returned null"); await calculationsRepository .Received(1) .GetCalculationsBySpecificationId(Arg.Is(specificationId)); await cacheProvider .Received(1) .GetAsync <List <CalculationSummaryModel> >($"{CacheKeys.CalculationsSummariesForSpecification}{specificationId}"); logger .Received(1) .Warning($"Calculations from repository returned null for specification ID of '{specificationId}'"); }
private static ICalculationsRepository CreateCalculationsRepository(bool isCalculationNameValid = true) { ICalculationsRepository calculationsRepository = Substitute.For <ICalculationsRepository>(); calculationsRepository .IsCalculationNameValid(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <string>()) .Returns(isCalculationNameValid); return(calculationsRepository); }
public GherkinParser(IStepParserFactory stepParserFactory, ICalculationsRepository calculationsRepository, ILogger logger) { Guard.ArgumentNotNull(stepParserFactory, nameof(stepParserFactory)); Guard.ArgumentNotNull(calculationsRepository, nameof(calculationsRepository)); Guard.ArgumentNotNull(logger, nameof(logger)); _stepParserFactory = stepParserFactory; _calculationsRepository = calculationsRepository; _logger = logger; }
public CalculationEngine(IAllocationFactory allocationFactory, ICalculationsRepository calculationsRepository, ILogger logger) { Guard.ArgumentNotNull(allocationFactory, nameof(allocationFactory)); Guard.ArgumentNotNull(calculationsRepository, nameof(calculationsRepository)); Guard.ArgumentNotNull(logger, nameof(logger)); _allocationFactory = allocationFactory; _calculationsRepository = calculationsRepository; _logger = logger; }
public TestEngineService( ICacheProvider cacheProvider, ISpecificationsApiClient specificationsApiClient, ILogger logger, ITestEngine testEngine, IScenariosRepository scenariosRepository, IProviderSourceDatasetsRepository providerSourceDatasetsRepository, ITestResultsService testResultsService, ITestResultsRepository testResultsRepository, ICalculationsApiClient calcsApiClient, ITelemetry telemetry, ITestRunnerResiliencePolicies resiliencePolicies, ICalculationsRepository calculationsRepository, IMapper mapper) { Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider)); Guard.ArgumentNotNull(specificationsApiClient, nameof(specificationsApiClient)); Guard.ArgumentNotNull(logger, nameof(logger)); Guard.ArgumentNotNull(testEngine, nameof(testEngine)); Guard.ArgumentNotNull(scenariosRepository, nameof(scenariosRepository)); Guard.ArgumentNotNull(providerSourceDatasetsRepository, nameof(providerSourceDatasetsRepository)); Guard.ArgumentNotNull(testResultsService, nameof(testResultsService)); Guard.ArgumentNotNull(testResultsRepository, nameof(testResultsRepository)); Guard.ArgumentNotNull(telemetry, nameof(telemetry)); Guard.ArgumentNotNull(resiliencePolicies?.CacheProviderRepository, nameof(resiliencePolicies.CacheProviderRepository)); Guard.ArgumentNotNull(resiliencePolicies?.SpecificationsApiClient, nameof(resiliencePolicies.SpecificationsApiClient)); Guard.ArgumentNotNull(resiliencePolicies?.ScenariosRepository, nameof(resiliencePolicies.ScenariosRepository)); Guard.ArgumentNotNull(resiliencePolicies?.ProviderSourceDatasetsRepository, nameof(resiliencePolicies.ProviderSourceDatasetsRepository)); Guard.ArgumentNotNull(resiliencePolicies?.TestResultsRepository, nameof(resiliencePolicies.TestResultsRepository)); Guard.ArgumentNotNull(resiliencePolicies?.CalculationsApiClient, nameof(resiliencePolicies.CalculationsApiClient));; Guard.ArgumentNotNull(resiliencePolicies?.SpecificationsApiClient, nameof(resiliencePolicies.SpecificationsApiClient)); Guard.ArgumentNotNull(calcsApiClient, nameof(calcsApiClient)); Guard.ArgumentNotNull(calculationsRepository, nameof(calculationsRepository)); Guard.ArgumentNotNull(mapper, nameof(mapper)); _cacheProvider = cacheProvider; _specificationsApiClient = specificationsApiClient; _logger = logger; _testEngine = testEngine; _scenariosRepository = scenariosRepository; _providerSourceDatasetsRepository = providerSourceDatasetsRepository; _testResultsService = testResultsService; _testResultsRepository = testResultsRepository; _telemetry = telemetry; _mapper = mapper; _cacheProviderPolicy = resiliencePolicies.CacheProviderRepository; _scenariosRepositoryPolicy = resiliencePolicies.ScenariosRepository; _providerSourceDatasetsRepositoryPolicy = resiliencePolicies.ProviderSourceDatasetsRepository; _testResultsRepositoryPolicy = resiliencePolicies.TestResultsRepository; _calcsApiClientPolicy = resiliencePolicies.CalculationsApiClient; _calcsApiClient = calcsApiClient; _calculationsRepository = calculationsRepository; _specificationsApiClientPolicy = resiliencePolicies.SpecificationsApiClient; }