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