public SqlImportContextBuilder(ICosmosRepository cosmos,
IPoliciesApiClient policies,
ITemplateMetadataResolver templateMetadataResolver,
ISpecificationsApiClient specifications,
IPublishingResiliencePolicies resiliencePolicies)
{
Guard.ArgumentNotNull(cosmos, nameof(cosmos));
Guard.ArgumentNotNull(policies, nameof(policies));
Guard.ArgumentNotNull(templateMetadataResolver, nameof(templateMetadataResolver));
Guard.ArgumentNotNull(specifications, nameof(specifications));
Guard.ArgumentNotNull(resiliencePolicies?.SpecificationsApiClient, nameof(resiliencePolicies.SpecificationsApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.PoliciesApiClient, nameof(resiliencePolicies.PoliciesApiClient));
_cosmos = cosmos;
_policies = policies;
_templateMetadataResolver = templateMetadataResolver;
_specifications = specifications;
_specificationResilience = resiliencePolicies.SpecificationsApiClient;
_policiesResilience = resiliencePolicies.PoliciesApiClient;
}
public ApplyTemplateCalculationsService(
ICreateCalculationService createCalculationService,
IPoliciesApiClient policiesApiClient,
ICalcsResiliencePolicies calculationsResiliencePolicies,
ICalculationsRepository calculationsRepository,
IJobManagement jobManagement,
IInstructionAllocationJobCreation instructionAllocationJobCreation,
ILogger logger,
ICalculationService calculationService,
ICacheProvider cacheProvider,
ISpecificationsApiClient specificationsApiClient,
IGraphRepository graphRepository,
ICodeContextCache codeContextCache) : base(jobManagement, logger)
{
Guard.ArgumentNotNull(instructionAllocationJobCreation, nameof(instructionAllocationJobCreation));
Guard.ArgumentNotNull(createCalculationService, nameof(createCalculationService));
Guard.ArgumentNotNull(policiesApiClient, nameof(policiesApiClient));
Guard.ArgumentNotNull(calculationsRepository, nameof(calculationsRepository));
Guard.ArgumentNotNull(calculationsResiliencePolicies?.PoliciesApiClient, nameof(calculationsResiliencePolicies.PoliciesApiClient));
Guard.ArgumentNotNull(calculationsResiliencePolicies?.CalculationsRepository, nameof(calculationsResiliencePolicies.CalculationsRepository));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(calculationService, nameof(calculationService));
Guard.ArgumentNotNull(calculationsResiliencePolicies?.CacheProviderPolicy, nameof(calculationsResiliencePolicies.CacheProviderPolicy));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(graphRepository, nameof(graphRepository));
Guard.ArgumentNotNull(specificationsApiClient, nameof(specificationsApiClient));
_createCalculationService = createCalculationService;
_calculationsRepository = calculationsRepository;
_policiesApiClient = policiesApiClient;
_policiesResiliencePolicy = calculationsResiliencePolicies.PoliciesApiClient;
_calculationsRepositoryPolicy = calculationsResiliencePolicies.CalculationsRepository;
_logger = logger;
_instructionAllocationJobCreation = instructionAllocationJobCreation;
_calculationService = calculationService;
_cachePolicy = calculationsResiliencePolicies.CacheProviderPolicy;
_cacheProvider = cacheProvider;
_specificationsApiClient = specificationsApiClient;
_codeContextCache = codeContextCache;
_specificationsApiClientPolicy = calculationsResiliencePolicies.SpecificationsApiClient;
}
public void Validate_GivenCoreProviderVersionUpdatesUseLatestForFDZProviderSource_ValidIsTrue()
{
//Arrange
SpecificationCreateModel model = CreateModel();
model.CoreProviderVersionUpdates = CoreProviderVersionUpdates.UseLatest;
model.ProviderSnapshotId = 1;
ISpecificationsRepository repository = CreateSpecificationsRepository();
IPoliciesApiClient policiesApiClient = CreatePoliciesApiClient(ProviderSource.FDZ);
SpecificationCreateModelValidator validator = CreateValidator(repository, policiesApiClient: policiesApiClient);
//Act
ValidationResult result = validator.Validate(model);
//Assert
result
.IsValid
.Should()
.BeTrue();
}
public async Task GetFundingPeriods_GivenOneFundingPeriodContainedInConfig_ReturnsCollectionWithOneFundingPeriod()
{
//Arrange
IPoliciesApiClient policiesApiClient = CreatePoliciesApiClient();
policiesApiClient
.GetFundingConfigurationsByFundingStreamId(Arg.Is(fundingStreamId))
.Returns(new ApiResponse <IEnumerable <FundingConfiguration> >(HttpStatusCode.OK,
new[] { new FundingConfiguration {
FundingPeriodId = "fp1"
} }));
policiesApiClient
.GetFundingPeriods()
.Returns(new ApiResponse <IEnumerable <FundingPeriod> >(HttpStatusCode.OK, GetFundingPeriods()));
PolicyController policyController = CreateController(policiesApiClient);
//Act
IActionResult result = await policyController.GetFundingPeriods(fundingStreamId);
//Assert
result
.Should()
.BeAssignableTo <OkObjectResult>();
IEnumerable <Reference> fundingPeriods = (result as OkObjectResult).Value as IEnumerable <Reference>;
fundingPeriods
.Should()
.HaveCount(1);
fundingPeriods
.First()
.Id
.Should()
.Be("fp1");
}
public SpecificationsWithProviderResultsService(ICalculationResultsRepository results,
IPoliciesApiClient policies,
IJobManagement jobs,
IProducerConsumerFactory producerConsumerFactory,
IResultsResiliencePolicies resiliencePolicies,
ILogger logger) : base(jobs, logger)
{
Guard.ArgumentNotNull(results, nameof(results));
Guard.ArgumentNotNull(policies, nameof(policies));
Guard.ArgumentNotNull(resiliencePolicies?.CalculationProviderResultsSearchRepository, nameof(resiliencePolicies.CalculationProviderResultsSearchRepository));
Guard.ArgumentNotNull(resiliencePolicies?.JobsApiClient, nameof(resiliencePolicies.JobsApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.PoliciesApiClient, nameof(resiliencePolicies.PoliciesApiClient));
Guard.ArgumentNotNull(logger, nameof(logger));
_results = results;
_jobs = jobs;
_producerConsumerFactory = producerConsumerFactory;
_resultsPolicy = resiliencePolicies.CalculationProviderResultsSearchRepository;
_jobsPolicy = resiliencePolicies.JobsApiClient;
_policiesPolicy = resiliencePolicies.PoliciesApiClient;
_logger = logger;
_policies = policies;
}
public void GetFundingConfigurations_GivenApiResponseWithInvalidStatusCode_ThrowsException()
{
//Arrange
SpecificationSummary specificationSummary = CreateSpecificationSummary();
IPoliciesApiClient policiesApiClient = CreatePoliciesApiClient();
policiesApiClient
.GetFundingConfiguration(Arg.Any <string>(), Arg.Any <string>())
.Returns(
new ApiResponse <FundingConfiguration>(System.Net.HttpStatusCode.OK, new FundingConfiguration()),
new ApiResponse <FundingConfiguration>(System.Net.HttpStatusCode.BadRequest, null));
FundingConfigurationService fundingConfigurationService = CreateService(policiesApiClient);
//Act
Func <Task> test = () => fundingConfigurationService.GetFundingConfigurations(specificationSummary);
//Assert
test
.Should()
.ThrowExactly <Exception>();
}
public async Task GetFundingPeriods_GivenGetFundingPeriodsFailed_ReturnsFailedResult()
{
//Arrange
IPoliciesApiClient policiesApiClient = CreatePoliciesApiClient();
policiesApiClient
.GetFundingConfigurationsByFundingStreamId(Arg.Is(fundingStreamId))
.Returns(new ApiResponse <IEnumerable <FundingConfiguration> >(HttpStatusCode.OK, new[] { new FundingConfiguration() }));
policiesApiClient
.GetFundingPeriods()
.Returns(new ApiResponse <IEnumerable <FundingPeriod> >(HttpStatusCode.BadRequest, null));
PolicyController policyController = CreateController(policiesApiClient);
//Act
IActionResult result = await policyController.GetFundingPeriods(fundingStreamId);
//Assert
result
.Should()
.BeAssignableTo <BadRequestResult>();
}
public CalculationFundingLineQueryService(IPoliciesApiClient templates,
ICalculationsRepository calculations,
ICacheProvider cache,
ISpecificationsApiClient specifications,
ICalcsResiliencePolicies resiliencePolicies)
{
Guard.ArgumentNotNull(templates, nameof(templates));
Guard.ArgumentNotNull(calculations, nameof(calculations));
Guard.ArgumentNotNull(cache, nameof(cache));
Guard.ArgumentNotNull(specifications, nameof(specifications));
Guard.ArgumentNotNull(resiliencePolicies?.PoliciesApiClient, nameof(resiliencePolicies.PoliciesApiClient));
Guard.ArgumentNotNull(resiliencePolicies.CalculationsRepository, nameof(resiliencePolicies.CalculationsRepository));
Guard.ArgumentNotNull(resiliencePolicies.CacheProviderPolicy, nameof(resiliencePolicies.CacheProviderPolicy));
Guard.ArgumentNotNull(resiliencePolicies.SpecificationsApiClient, nameof(resiliencePolicies.SpecificationsApiClient));
_templates = templates;
_calculations = calculations;
_cache = cache;
_specifications = specifications;
_policyResilience = resiliencePolicies.PoliciesApiClient;
_calculationsResilience = resiliencePolicies.CalculationsRepository;
_cacheResilience = resiliencePolicies.CacheProviderPolicy;
_specificationsResilience = resiliencePolicies.SpecificationsApiClient;
}
public void Validate_GivenEmptyProviderSnapshotId_ValidIsFalse()
{
//Arrange
SpecificationEditModel model = CreateModel();
model.SpecificationId = "specId";
IPoliciesApiClient policiesApiClient = Substitute.For <IPoliciesApiClient>();
policiesApiClient
.GetFundingPeriodById(Arg.Any <string>())
.Returns(new ApiResponse <PolicyModels.FundingPeriod>(HttpStatusCode.OK, new PolicyModels.FundingPeriod()));
policiesApiClient
.GetFundingConfiguration(Arg.Any <string>(), Arg.Any <string>())
.Returns(new ApiResponse <PolicyModels.FundingConfig.FundingConfiguration>(HttpStatusCode.OK, new PolicyModels.FundingConfig.FundingConfiguration {
ProviderSource = ProviderSource.FDZ
}));
SpecificationEditModelValidator validator = CreateValidator(policiesApiClient: policiesApiClient);
//Act
ValidationResult result = validator.Validate(model);
//Assert
result
.IsValid
.Should()
.BeFalse();
result
.Errors
.Count
.Should()
.Be(1);
}
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();
}
public PublishedProviderSearchService(IPublishingApiClient publishingApiClient, IPoliciesApiClient policiesApiClient, ILogger logger, IMapper mapper)
{
_publishingApiClient = publishingApiClient;
_policiesApiClient = policiesApiClient;
_logger = logger;
_mapper = mapper;
}
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 FundingLineDetailsController(IPublishingApiClient publishingApiClient, IProvidersApiClient providersApiClient,
ISpecificationsApiClient specificationsApiClient, IPoliciesApiClient policiesApiClient, IAuthorizationHelper authorizationHelper)
{
_publishingApiClient = publishingApiClient;
_providersApiClient = providersApiClient;
_specificationsApiClient = specificationsApiClient;
_policiesApiClient = policiesApiClient;
_authorizationHelper = authorizationHelper;
}
public async Task GetPublishDates_ValidParametersPassed_ReturnsOK()
{
//Arrange
ILogger logger = CreateLogger();
string specificationId = "testSpecification";
Specification specification = new Specification
{
Current = new SpecificationVersion
{
ExternalPublicationDate = DateTimeOffset.Now.Date,
EarliestPaymentAvailableDate = DateTimeOffset.Now.Date
}
};
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
IPoliciesApiClient policiesApiClient = CreatePoliciesApiClient();
IVersionRepository <SpecificationVersion> specificationVersionRepository = CreateSpecificationVersionRepository();
specificationsRepository
.GetSpecificationById(specificationId)
.Returns(specification);
SpecificationVersion clonedSpecificationVersion = null;
specificationVersionRepository.CreateVersion(Arg.Any <SpecificationVersion>(), Arg.Any <SpecificationVersion>())
.Returns(_ => (SpecificationVersion)_[0])
.AndDoes(_ => clonedSpecificationVersion = _.ArgAt <SpecificationVersion>(0));
SpecificationsService service = CreateService(
logs: logger,
specificationsRepository: specificationsRepository,
specificationVersionRepository: specificationVersionRepository,
policiesApiClient: policiesApiClient);
// Act
IActionResult result = await service.GetPublishDates(specificationId);
//Assert
result
.Should()
.BeOfType <OkObjectResult>();
var objContent = ((OkObjectResult)result);
objContent
.Should()
.NotBeNull();
SpecificationPublishDateModel publishDates = objContent.Value as SpecificationPublishDateModel;
publishDates.EarliestPaymentAvailableDate
.Should()
.Equals(specification.Current.EarliestPaymentAvailableDate);
publishDates.ExternalPublicationDate
.Should()
.Equals(specification.Current.ExternalPublicationDate);
}
public PolicyController CreateController(IPoliciesApiClient policiesApiClient = null, IAuthorizationHelper authorizationHelper = null)
{
return(new PolicyController(policiesApiClient ?? CreatePoliciesApiClient(), authorizationHelper ?? CreateAuthorizationHelper()));
}
public async Task SetProfileVariationPointers_UpdateSpecFails_Returns412WithErrorMessage()
{
//Arrange
ILogger logger = CreateLogger();
string specificationId = "test";
DateTimeOffset externalPublishDate = DateTimeOffset.Now.Date;
DateTimeOffset earliestPaymentAvailableDate = DateTimeOffset.Now.Date;
Specification specification = new Specification
{
Current = new SpecificationVersion
{
ExternalPublicationDate = DateTimeOffset.Now.Date,
EarliestPaymentAvailableDate = DateTimeOffset.Now.Date
}
};
IEnumerable <SpecificationProfileVariationPointerModel> specificationProfileVariationPointerModels = new SpecificationProfileVariationPointerModel[]
{
new SpecificationProfileVariationPointerModel
{
FundingLineId = "FundingLineId",
FundingStreamId = "FundingStreamId",
Occurrence = 1,
PeriodType = "PeriodType",
TypeValue = "TypeValue",
Year = 2019
}
};
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
IPoliciesApiClient policiesApiClient = CreatePoliciesApiClient();
IVersionRepository <SpecificationVersion> specificationVersionRepository = CreateSpecificationVersionRepository();
specificationsRepository
.GetSpecificationById(specificationId)
.Returns(specification);
SpecificationVersion clonedSpecificationVersion = null;
specificationVersionRepository.CreateVersion(Arg.Any <SpecificationVersion>(), Arg.Any <SpecificationVersion>())
.Returns(_ => (SpecificationVersion)_[0])
.AndDoes(_ => clonedSpecificationVersion = _.ArgAt <SpecificationVersion>(0));
specificationsRepository
.UpdateSpecification(Arg.Any <Specification>())
.Returns(HttpStatusCode.BadRequest);
SpecificationsService service = CreateService(
logs: logger,
specificationsRepository: specificationsRepository,
specificationVersionRepository: specificationVersionRepository,
policiesApiClient: policiesApiClient);
// Act
IActionResult result = await service.SetProfileVariationPointers(specificationId, specificationProfileVariationPointerModels);
//Assert
result
.Should()
.BeOfType <InternalServerErrorResult>()
.Which
.Value
.Should()
.Be($"Failed to update specification for id: {specificationId} with ProfileVariationPointers {specificationProfileVariationPointerModels?.AsJson()}");
}
public async Task SetProfileVariationPointer_ValidParametersPassed_ReturnsOKAndSetsSetProfileVariationPointersOnSpec()
{
//Arrange
ILogger logger = CreateLogger();
string specificationId = "test";
Specification specification = new Specification
{
Current = new SpecificationVersion
{
ProfileVariationPointers = new ProfileVariationPointer[] { new ProfileVariationPointer
{
FundingLineId = "FundingLineId",
FundingStreamId = "FundingStreamId",
Occurrence = 1,
PeriodType = "PeriodType",
TypeValue = "TypeValue",
Year = 2019
},
new ProfileVariationPointer {
FundingLineId = "FundingLineId",
FundingStreamId = "FundingStreamId",
Occurrence = 2,
PeriodType = "PeriodType",
TypeValue = "TypeValue",
Year = 2019
} }
}
};
SpecificationProfileVariationPointerModel specificationProfileVariationPointerModel = new SpecificationProfileVariationPointerModel
{
FundingLineId = "FundingLineId",
FundingStreamId = "FundingStreamId",
Occurrence = 1,
PeriodType = "PeriodType",
TypeValue = "TypeValue",
Year = 2019
};
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
IPoliciesApiClient policiesApiClient = CreatePoliciesApiClient();
IVersionRepository <SpecificationVersion> specificationVersionRepository = CreateSpecificationVersionRepository();
specificationsRepository
.GetSpecificationById(specificationId)
.Returns(specification);
SpecificationVersion clonedSpecificationVersion = null;
specificationVersionRepository.CreateVersion(Arg.Any <SpecificationVersion>(), Arg.Any <SpecificationVersion>())
.Returns(_ => (SpecificationVersion)_[0])
.AndDoes(_ => clonedSpecificationVersion = _.ArgAt <SpecificationVersion>(0));
specificationsRepository
.UpdateSpecification(Arg.Any <Specification>())
.Returns(HttpStatusCode.OK);
SpecificationsService service = CreateService(
logs: logger,
specificationsRepository: specificationsRepository,
specificationVersionRepository: specificationVersionRepository,
policiesApiClient: policiesApiClient);
// Act
IActionResult result = await service.SetProfileVariationPointer(specificationId, specificationProfileVariationPointerModel);
//Assert
result
.Should()
.BeOfType <OkObjectResult>()
.Which
.Value
.Should()
.Be(HttpStatusCode.OK);
specificationsRepository
.Received(1);
var profileVariationPointers = clonedSpecificationVersion?
.ProfileVariationPointers;
profileVariationPointers
.Should()
.NotBeNull()
.And.HaveCount(2)
.And.BeEquivalentTo(new ProfileVariationPointer[] { new ProfileVariationPointer
{
FundingLineId = "FundingLineId",
FundingStreamId = "FundingStreamId",
Occurrence = 1,
PeriodType = "PeriodType",
TypeValue = "TypeValue",
Year = 2019
},
new ProfileVariationPointer {
FundingLineId = "FundingLineId",
FundingStreamId = "FundingStreamId",
Occurrence = 2,
PeriodType = "PeriodType",
TypeValue = "TypeValue",
Year = 2019
} });
}
public SpecificationCreateModelValidator(ISpecificationsRepository specificationsRepository,
IProvidersApiClient providersApiClient,
IPoliciesApiClient policiesApiClient,
ISpecificationsResiliencePolicies resiliencePolicies)
{
Guard.ArgumentNotNull(specificationsRepository, nameof(specificationsRepository));
Guard.ArgumentNotNull(providersApiClient, nameof(providersApiClient));
Guard.ArgumentNotNull(policiesApiClient, nameof(policiesApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.PoliciesApiClient, nameof(resiliencePolicies.PoliciesApiClient));
_specificationsRepository = specificationsRepository;
_providersApiClient = providersApiClient;
_policiesApiClient = policiesApiClient;
_policiesApiClientPolicy = resiliencePolicies.PoliciesApiClient;
RuleFor(model => model.FundingPeriodId)
.NotEmpty()
.WithMessage("Null or empty academic year id provided")
.Custom((name, context) =>
{
SpecificationCreateModel specModel = context.ParentContext.InstanceToValidate as SpecificationCreateModel;
if (!string.IsNullOrWhiteSpace(specModel.FundingPeriodId))
{
ApiResponse <PolicyModels.FundingPeriod> fundingPeriodResponse =
_policiesApiClientPolicy.ExecuteAsync(() => _policiesApiClient.GetFundingPeriodById(specModel.FundingPeriodId)).GetAwaiter().GetResult();
if (fundingPeriodResponse?.StatusCode != HttpStatusCode.OK || fundingPeriodResponse?.Content == null)
{
context.AddFailure("Funding period not found");
}
}
});
RuleFor(model => model.ProviderVersionId)
.Custom((name, context) => {
SpecificationCreateModel specModel = context.ParentContext.InstanceToValidate as SpecificationCreateModel;
ApiResponse <PolicyModels.FundingConfig.FundingConfiguration> fundingConfigResponse =
_policiesApiClientPolicy.ExecuteAsync(() => _policiesApiClient.GetFundingConfiguration(specModel.FundingStreamIds.FirstOrDefault(), specModel.FundingPeriodId)).GetAwaiter().GetResult();
if (fundingConfigResponse?.StatusCode != HttpStatusCode.OK || fundingConfigResponse?.Content == null)
{
context.AddFailure("Funding config not found");
return;
}
switch (fundingConfigResponse.Content.ProviderSource)
{
case ProviderSource.CFS:
{
if (string.IsNullOrWhiteSpace(specModel.ProviderVersionId))
{
context.AddFailure($"Null or empty provider version id");
}
if (_providersApiClient.DoesProviderVersionExist(specModel.ProviderVersionId).Result == System.Net.HttpStatusCode.NotFound)
{
context.AddFailure($"Provider version id selected does not exist");
}
if (specModel.CoreProviderVersionUpdates != CoreProviderVersionUpdates.Manual)
{
context.AddFailure($"CoreProviderVersionUpdates - {specModel.CoreProviderVersionUpdates} is not valid for provider source - {fundingConfigResponse.Content.ProviderSource}");
}
break;
}
case ProviderSource.FDZ:
{
if (!specModel.ProviderSnapshotId.HasValue)
{
context.AddFailure($"Null or empty provider snapshot id");
}
break;
}
}
});
RuleFor(model => model.FundingStreamIds)
.NotNull()
.NotEmpty()
.WithMessage("You must select at least one funding stream")
.Custom((name, context) => {
SpecificationCreateModel specModel = context.ParentContext.InstanceToValidate as SpecificationCreateModel;
foreach (string fundingStreamId in specModel.FundingStreamIds)
{
if (string.IsNullOrWhiteSpace(fundingStreamId))
{
context.AddFailure($"A null or empty string funding stream ID was provided");
}
}
});
RuleFor(model => model.Name)
.NotEmpty()
.WithMessage("You must give a unique specification name")
.Custom((name, context) => {
SpecificationCreateModel specModel = context.ParentContext.InstanceToValidate as SpecificationCreateModel;
Specification specification = _specificationsRepository.GetSpecificationByQuery(m => m.Content.Name.ToLower() == specModel.Name.Trim().ToLower()).Result;
if (specification != null)
{
context.AddFailure($"You must give a unique specification name");
}
});
}
public PoliciesStepContext(IPoliciesApiClient policiesApiClient)
{
Client = policiesApiClient;
}
