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 BuildProjectsService(
ILogger logger,
ITelemetry telemetry,
IProviderResultsRepository providerResultsRepository,
ISpecificationRepository specificationsRepository,
ICacheProvider cacheProvider,
ICalculationsRepository calculationsRepository,
IFeatureToggle featureToggle,
IJobsApiClient jobsApiClient,
ICalcsResiliencePolicies resiliencePolicies,
EngineSettings engineSettings,
ISourceCodeService sourceCodeService,
IDatasetRepository datasetRepository,
IBuildProjectsRepository buildProjectsRepository)
{
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(telemetry, nameof(telemetry));
Guard.ArgumentNotNull(providerResultsRepository, nameof(providerResultsRepository));
Guard.ArgumentNotNull(specificationsRepository, nameof(specificationsRepository));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(calculationsRepository, nameof(calculationsRepository));
Guard.ArgumentNotNull(featureToggle, nameof(featureToggle));
Guard.ArgumentNotNull(jobsApiClient, nameof(jobsApiClient));
Guard.ArgumentNotNull(resiliencePolicies, nameof(resiliencePolicies));
Guard.ArgumentNotNull(engineSettings, nameof(engineSettings));
Guard.ArgumentNotNull(sourceCodeService, nameof(sourceCodeService));
Guard.ArgumentNotNull(datasetRepository, nameof(datasetRepository));
Guard.ArgumentNotNull(buildProjectsRepository, nameof(buildProjectsRepository));
_logger = logger;
_telemetry = telemetry;
_providerResultsRepository = providerResultsRepository;
_specificationsRepository = specificationsRepository;
_cacheProvider = cacheProvider;
_calculationsRepository = calculationsRepository;
_featureToggle = featureToggle;
_jobsApiClient = jobsApiClient;
_jobsApiClientPolicy = resiliencePolicies.JobsApiClient;
_engineSettings = engineSettings;
_sourceCodeService = sourceCodeService;
_datasetRepository = datasetRepository;
_datasetRepositoryPolicy = resiliencePolicies.DatasetsRepository;
_buildProjectsRepository = buildProjectsRepository;
_buildProjectsRepositoryPolicy = resiliencePolicies.BuildProjectRepositoryPolicy;
}
private static CalculationService CreateCalculationService(
ICalculationsRepository calculationsRepository = null,
ILogger logger = null,
ISearchRepository <CalculationIndex> searchRepository = null,
IBuildProjectsService buildProjectsService = null,
IPoliciesApiClient policiesApiClient = null,
ICacheProvider cacheProvider = null,
ICalcsResiliencePolicies resiliencePolicies = null,
IVersionRepository <CalculationVersion> calculationVersionRepository = null,
IJobManagement jobManagement = null,
ISourceCodeService sourceCodeService = null,
IFeatureToggle featureToggle = null,
IBuildProjectsRepository buildProjectsRepository = null,
ICalculationCodeReferenceUpdate calculationCodeReferenceUpdate = null,
IValidator <CalculationCreateModel> calculationCreateModelValidator = null,
IValidator <CalculationEditModel> calculationEditModelValidator = null,
ISpecificationsApiClient specificationsApiClient = null,
IGraphRepository graphRepository = null,
ICalculationsFeatureFlag calculationsFeatureFlag = null,
ICodeContextCache codeContextCache = null,
ISourceFileRepository sourceFileRepository = null,
IResultsApiClient resultsApiClient = null,
IDatasetsApiClient datasetsApiClient = null,
IApproveAllCalculationsJobAction approveAllCalculationsJobAction = null)
{
CalculationNameInUseCheck calculationNameInUseCheck = new CalculationNameInUseCheck(calculationsRepository ?? CreateCalculationsRepository(),
specificationsApiClient ?? CreateSpecificationsApiClient(),
resiliencePolicies ?? CalcsResilienceTestHelper.GenerateTestPolicies());
InstructionAllocationJobCreation instructionAllocationJobCreation =
new InstructionAllocationJobCreation(
calculationsRepository ?? CreateCalculationsRepository(),
resiliencePolicies ?? CalcsResilienceTestHelper.GenerateTestPolicies(),
logger ?? CreateLogger(),
calculationsFeatureFlag ?? CreateCalculationsFeatureFlag(),
jobManagement ?? CreateJobManagement());
return(new CalculationService
(
calculationsRepository ?? CreateCalculationsRepository(),
logger ?? CreateLogger(),
searchRepository ?? CreateSearchRepository(),
buildProjectsService ?? CreateBuildProjectsService(),
policiesApiClient ?? CreatePoliciesApiClient(),
cacheProvider ?? CreateCacheProvider(),
resiliencePolicies ?? CalcsResilienceTestHelper.GenerateTestPolicies(),
calculationVersionRepository ?? CreateCalculationVersionRepository(),
sourceCodeService ?? CreateSourceCodeService(),
featureToggle ?? CreateFeatureToggle(),
buildProjectsRepository ?? CreateBuildProjectsRepository(),
calculationCodeReferenceUpdate ?? CreateCalculationCodeReferenceUpdate(),
calculationCreateModelValidator ?? CreateCalculationCreateModelValidator(),
calculationEditModelValidator ?? CreateCalculationEditModelValidator(),
specificationsApiClient ?? CreateSpecificationsApiClient(),
calculationNameInUseCheck,
instructionAllocationJobCreation,
new CreateCalculationService(calculationNameInUseCheck,
calculationsRepository ?? CreateCalculationsRepository(),
calculationVersionRepository ?? CreateCalculationVersionRepository(),
resiliencePolicies ?? CalcsResilienceTestHelper.GenerateTestPolicies(),
calculationCreateModelValidator ?? CreateCalculationCreateModelValidator(),
cacheProvider ?? CreateCacheProvider(),
searchRepository ?? CreateSearchRepository(),
logger ?? CreateLogger(),
instructionAllocationJobCreation),
graphRepository ?? CreateGraphRepository(),
CreateJobManagement(),
codeContextCache ?? Substitute.For <ICodeContextCache>(),
resultsApiClient ?? Substitute.For <IResultsApiClient>(),
datasetsApiClient ?? Substitute.For <IDatasetsApiClient>(),
approveAllCalculationsJobAction ?? CreateApproveAllCalculationsJobAction()));
}
public async Task EditCalculationStatus_GivenNewStatus_UpdatesSearchReturnsOK()
{
//Arrange
EditStatusModel CalculationEditStatusModel = new EditStatusModel
{
PublishStatus = PublishStatus.Approved
};
ILogger logger = CreateLogger();
Calculation calculation = CreateCalculation();
CalculationVersion calculationVersion = calculation.Current.Clone() as CalculationVersion;
calculationVersion.PublishStatus = PublishStatus.Approved;
ICalculationsRepository CalculationsRepository = CreateCalculationsRepository();
CalculationsRepository
.GetCalculationById(Arg.Is(CalculationId))
.Returns(calculation);
CalculationsRepository
.UpdateCalculation(Arg.Any <Calculation>())
.Returns(HttpStatusCode.OK);
SpecModel.SpecificationSummary specificationSummary = new SpecModel.SpecificationSummary()
{
Id = calculation.SpecificationId,
Name = "spec name",
FundingStreams = new[]
{
new Reference(calculation.FundingStreamId, "funding stream name")
}
};
ISpecificationsApiClient specificationsApiClient = CreateSpecificationsApiClient();
specificationsApiClient
.GetSpecificationSummaryById(Arg.Is(calculation.SpecificationId))
.Returns(new Common.ApiClient.Models.ApiResponse <SpecModel.SpecificationSummary>(HttpStatusCode.OK, specificationSummary));
ISearchRepository <CalculationIndex> searchRepository = CreateSearchRepository();
IVersionRepository <CalculationVersion> versionRepository = CreateCalculationVersionRepository();
versionRepository
.CreateVersion(Arg.Any <CalculationVersion>(), Arg.Any <CalculationVersion>())
.Returns(calculationVersion);
Build build = new Build
{
SourceFiles = new List <SourceFile> {
new SourceFile()
}
};
BuildProject buildProject = new BuildProject();
IBuildProjectsRepository buildProjectsRepository = CreateBuildProjectsRepository();
IBuildProjectsService buildProjectsService = CreateBuildProjectsService();
buildProjectsService
.GetBuildProjectForSpecificationId(Arg.Is(calculation.SpecificationId))
.Returns(buildProject);
ISourceCodeService sourceCodeService = CreateSourceCodeService();
sourceCodeService
.Compile(Arg.Any <BuildProject>(), Arg.Any <IEnumerable <Models.Calcs.Calculation> >(), Arg.Any <CompilerOptions>())
.Returns(build);
IResultsApiClient resultsApiClient = CreateResultsApiClient();
CalculationService service = CreateCalculationService(
logger: logger, calculationsRepository: CalculationsRepository, searchRepository: searchRepository,
specificationsApiClient: specificationsApiClient, calculationVersionRepository: versionRepository,
sourceCodeService: sourceCodeService, buildProjectsService: buildProjectsService, resultsApiClient: resultsApiClient,
buildProjectsRepository: buildProjectsRepository);
//Act
IActionResult result = await service.UpdateCalculationStatus(CalculationId, CalculationEditStatusModel);
//Arrange
result
.Should()
.BeOfType <OkObjectResult>()
.Which
.Value
.Should()
.BeOfType <PublishStatusResultModel>()
.Which
.PublishStatus
.Should()
.Be(PublishStatus.Approved);
calculation
.Current
.PublishStatus
.Should()
.Be(PublishStatus.Approved);
await buildProjectsRepository
.Received(0)
.UpdateBuildProject(Arg.Any <BuildProject>());
}
public BuildProjectsService(
ILogger logger,
ITelemetry telemetry,
IProvidersApiClient providersApiClient,
ICacheProvider cacheProvider,
ICalculationsRepository calculationsRepository,
IFeatureToggle featureToggle,
ICalcsResiliencePolicies resiliencePolicies,
EngineSettings engineSettings,
ISourceCodeService sourceCodeService,
IDatasetsApiClient datasetsApiClient,
IBuildProjectsRepository buildProjectsRepository,
ICalculationEngineRunningChecker calculationEngineRunningChecker,
IJobManagement jobManagement,
IGraphRepository graphRepository,
IMapper mapper,
ISpecificationsApiClient specificationsApiClient,
IPoliciesApiClient policiesApiClient,
ISourceFileRepository sourceFileRepository) : base(jobManagement, logger)
{
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(telemetry, nameof(telemetry));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(calculationsRepository, nameof(calculationsRepository));
Guard.ArgumentNotNull(featureToggle, nameof(featureToggle));
Guard.ArgumentNotNull(resiliencePolicies, nameof(resiliencePolicies));
Guard.ArgumentNotNull(engineSettings, nameof(engineSettings));
Guard.ArgumentNotNull(sourceCodeService, nameof(sourceCodeService));
Guard.ArgumentNotNull(datasetsApiClient, nameof(datasetsApiClient));
Guard.ArgumentNotNull(buildProjectsRepository, nameof(buildProjectsRepository));
Guard.ArgumentNotNull(providersApiClient, nameof(providersApiClient));
Guard.ArgumentNotNull(calculationEngineRunningChecker, nameof(calculationEngineRunningChecker));
Guard.ArgumentNotNull(jobManagement, nameof(jobManagement));
Guard.ArgumentNotNull(graphRepository, nameof(graphRepository));
Guard.ArgumentNotNull(resiliencePolicies?.DatasetsApiClient, nameof(resiliencePolicies.DatasetsApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.ProvidersApiClient, nameof(resiliencePolicies.ProvidersApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.BuildProjectRepositoryPolicy, nameof(resiliencePolicies.BuildProjectRepositoryPolicy));
Guard.ArgumentNotNull(resiliencePolicies?.CalculationsRepository, nameof(resiliencePolicies.CalculationsRepository));
Guard.ArgumentNotNull(mapper, nameof(mapper));
Guard.ArgumentNotNull(specificationsApiClient, nameof(specificationsApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.SpecificationsApiClient, nameof(resiliencePolicies.SpecificationsApiClient));
Guard.ArgumentNotNull(policiesApiClient, nameof(policiesApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.PoliciesApiClient, nameof(resiliencePolicies.PoliciesApiClient));
Guard.ArgumentNotNull(sourceFileRepository, nameof(sourceFileRepository));
_logger = logger;
_telemetry = telemetry;
_providersApiClient = providersApiClient;
_providersApiClientPolicy = resiliencePolicies.ProvidersApiClient;
_cacheProvider = cacheProvider;
_calculationsRepository = calculationsRepository;
_calculationsRepositoryPolicy = resiliencePolicies.CalculationsRepository;
_featureToggle = featureToggle;
_engineSettings = engineSettings;
_sourceCodeService = sourceCodeService;
_datasetsApiClient = datasetsApiClient;
_jobManagement = jobManagement;
_graphRepository = graphRepository;
_datasetsApiClientPolicy = resiliencePolicies.DatasetsApiClient;
_buildProjectsRepository = buildProjectsRepository;
_buildProjectsRepositoryPolicy = resiliencePolicies.BuildProjectRepositoryPolicy;
_calculationEngineRunningChecker = calculationEngineRunningChecker;
_mapper = mapper;
_specificationsApiClient = specificationsApiClient;
_specificationsApiClientPolicy = resiliencePolicies.SpecificationsApiClient;
_policiesApiClient = policiesApiClient;
_policiesApiClientPolicy = resiliencePolicies.PoliciesApiClient;
_sourceFileRepository = sourceFileRepository;
_typeIdentifierGenerator = new VisualBasicTypeIdentifierGenerator();
}
