public QaSchemaService(IPoliciesApiClient policies,
ISpecificationsApiClient specificationsApiClient,
ITemplateMetadataResolver templateMetadataResolver,
ISqlSchemaGenerator schemaGenerator,
IQaRepository qaRepository,
IProfilingApiClient profilingClient,
ISqlNameGenerator sqlNames,
IPublishingResiliencePolicies resiliencePolicies)
{
Guard.ArgumentNotNull(policies, nameof(policies));
Guard.ArgumentNotNull(specificationsApiClient, nameof(specificationsApiClient));
Guard.ArgumentNotNull(templateMetadataResolver, nameof(templateMetadataResolver));
Guard.ArgumentNotNull(schemaGenerator, nameof(schemaGenerator));
Guard.ArgumentNotNull(qaRepository, nameof(qaRepository));
Guard.ArgumentNotNull(profilingClient, nameof(profilingClient));
Guard.ArgumentNotNull(sqlNames, nameof(sqlNames));
_policies = policies;
_specifications = specificationsApiClient;
_templateMetadataResolver = templateMetadataResolver;
_schemaGenerator = schemaGenerator;
_qaRepository = qaRepository;
_profilingClient = profilingClient;
_sqlNames = sqlNames;
_specificationResilience = resiliencePolicies.SpecificationsApiClient;
_policiesResilience = resiliencePolicies.PoliciesApiClient;
//TODO; extract all of the different table builders so that this can more easily tested
//at the moment it needs a god test with too much setup to make much sense to anyone
}
public void SaveFundingTotals_GivenPublishedProfilingRequestsButProfilingAPIReturnNoResults_LogsAndThrows()
{
//Arrange
IEnumerable <FundingLine> fundingLines = SetUpInput();
ILogger logger = CreateLogger();
SetUpProviderProfilingResponse();
IProfilingApiClient providerProfilingRepository = Substitute.For <IProfilingApiClient>();
providerProfilingRepository
.GetProviderProfilePeriods(Arg.Any <ProviderProfilingRequestModel>())
.Returns(Task.FromResult <ValidatedApiResponse <ProviderProfilingResponseModel> >(null));
ProfilingService serviceapi = CreateProfilingService(
logger: logger,
profilingApiClient: providerProfilingRepository);
//Act
Func <Task> test = async() => await serviceapi.ProfileFundingLines(fundingLines, "PSG", "AY-1819");
//Assert
logger
.Received(0)
.Error(Arg.Is("Failed to Get Profile Periods for updating for Requested FundingPeriodId"));
}
public void SaveFundingTotals_GivenPublishedProfilingRequestsButProfilingAPICausesException_LogsAndThrows()
{
//Arrange
IEnumerable <FundingLine> fundingLines = SetUpInput();
ILogger logger = CreateLogger();
IProfilingApiClient providerProfilingRepository = Substitute.For <IProfilingApiClient>();
ValidatedApiResponse <ProviderProfilingResponseModel> providerProfilingResponseModel =
new ValidatedApiResponse <ProviderProfilingResponseModel>(HttpStatusCode.InternalServerError);
providerProfilingRepository
.GetProviderProfilePeriods(Arg.Any <ProviderProfilingRequestModel>())
.Returns(providerProfilingResponseModel);
ProfilingService service = CreateProfilingService(
logger: logger,
profilingApiClient: providerProfilingRepository);
//Act
Func <Task> test = async() => await service.ProfileFundingLines(fundingLines, "PSG", "AY-1819");
//Assert
test
.Should()
.ThrowExactly <NonRetriableException>()
.Which
.Message
.Should()
.Be("Failed to Get Profile Periods for updating for Requested FundingPeriodId: 'AY-1819' and FundingStreamId: 'PSG'");
logger
.Received(1)
.Error(Arg.Is("Failed to Get Profile Periods for updating for Requested FundingPeriodId: 'AY-1819' and FundingStreamId: 'PSG'"));
}
public ProviderVariationsApplication(IPublishingResiliencePolicies resiliencePolicies,
ISpecificationsApiClient specificationsApiClient,
IPoliciesApiClient policiesApiClient,
ICacheProvider cacheProvider,
IProfilingApiClient profilingApiClient,
IReProfilingRequestBuilder reProfilingRequestBuilder,
IReProfilingResponseMapper reProfilingResponseMapper)
{
Guard.ArgumentNotNull(resiliencePolicies, nameof(resiliencePolicies));
Guard.ArgumentNotNull(resiliencePolicies.SpecificationsApiClient, "resiliencePolicies.SpecificationsApiClient");
Guard.ArgumentNotNull(resiliencePolicies.PoliciesApiClient, "resiliencePolicies.PoliciesApiClient");
Guard.ArgumentNotNull(resiliencePolicies.CacheProvider, "resiliencePolicies.CacheProvider");
Guard.ArgumentNotNull(specificationsApiClient, nameof(specificationsApiClient));
Guard.ArgumentNotNull(policiesApiClient, nameof(policiesApiClient));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(profilingApiClient, nameof(profilingApiClient));
Guard.ArgumentNotNull(reProfilingRequestBuilder, nameof(reProfilingRequestBuilder));
Guard.ArgumentNotNull(reProfilingResponseMapper, nameof(reProfilingResponseMapper));
SpecificationsApiClient = specificationsApiClient;
ResiliencePolicies = resiliencePolicies;
PoliciesApiClient = policiesApiClient;
CacheProvider = cacheProvider;
ProfilingApiClient = profilingApiClient;
ReProfilingRequestBuilder = reProfilingRequestBuilder;
ReProfilingResponseMapper = reProfilingResponseMapper;
}
static ProfilingService CreateProfilingService(ILogger logger = null,
IProfilingApiClient profilingApiClient = null)
{
return(new ProfilingService(
logger ?? CreateLogger(),
profilingApiClient ?? CreateProfilingRepository(),
GenerateTestPolicies()));
}
protected void GivenTheApiResponseDetailsForTheProfileRequest(ProviderProfilingResponseModel providerProfilingResponseModel,
HttpStatusCode statusCode = HttpStatusCode.OK)
{
profilingClient1 = CreateProfilingRepository();
profilingClient1.GetProviderProfilePeriods(Arg.Any <ProviderProfilingRequestModel>())
.Returns(new ValidatedApiResponse <ProviderProfilingResponseModel>(statusCode,
providerProfilingResponseModel));
}
public ProfilingController(IProfilingApiClient profilingApiClient,
IPublishingApiClient publishingApiClient)
{
Guard.ArgumentNotNull(profilingApiClient, nameof(profilingApiClient));
Guard.ArgumentNotNull(publishingApiClient, nameof(publishingApiClient));
_profilingApiClient = profilingApiClient;
_publishingApiClient = publishingApiClient;
}
public PublishServiceAcceptanceStepContext(IFeatureManagerSnapshot featureManagerSnapshot,
ICalculationsApiClient calculationsInMemoryClient,
ICalculationResultsRepository calculationsInMemoryRepository,
IProfilingApiClient profilingApiClient)
{
_featureManagerSnapshot = featureManagerSnapshot;
CalculationsInMemoryRepository = (CalculationInMemoryRepository)calculationsInMemoryRepository;
CalculationsInMemoryClient = (CalculationsInMemoryClient)calculationsInMemoryClient;
ProfilingInMemoryClient = (ProfilingInMemoryClient)profilingApiClient;
}
public ProfilingService(
ILogger logger,
IProfilingApiClient profilingApiClient,
IPublishingResiliencePolicies publishingResiliencePolicies)
{
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(profilingApiClient, nameof(profilingApiClient));
Guard.ArgumentNotNull(publishingResiliencePolicies, nameof(publishingResiliencePolicies));
Guard.ArgumentNotNull(publishingResiliencePolicies.ProfilingApiClient, nameof(publishingResiliencePolicies.ProfilingApiClient));
_logger = logger;
_profilingApiClient = profilingApiClient;
_profilingApiClientPolicy = publishingResiliencePolicies.ProfilingApiClient;
}
public async Task SaveMultipleFundinglines_GivenPublishedProfilingRequests()
{
//Arrange
List <FundingLine> fundingLines = new List <FundingLine>
{
new FundingLine {
Name = "Abc", FundingLineCode = "FL1", Type = FundingLineType.Payment, Value = 500, TemplateLineId = 123, DistributionPeriods = null
},
new FundingLine {
Name = "Xyz", FundingLineCode = "AB1", Type = FundingLineType.Payment, Value = 600, TemplateLineId = 123, DistributionPeriods = null
}
};
ILogger logger = CreateLogger();
ValidatedApiResponse <ProviderProfilingResponseModel> profileResponse = SetUpProviderProfilingResponse();
IProfilingApiClient providerProfilingRepository = Substitute.For <IProfilingApiClient>();
providerProfilingRepository
.GetProviderProfilePeriods(Arg.Any <ProviderProfilingRequestModel>())
.Returns(Task.FromResult(profileResponse));
ProfilingService serviceapi = CreateProfilingService(
logger: logger,
profilingApiClient: providerProfilingRepository);
//Act
await serviceapi.ProfileFundingLines(fundingLines, "PSG", "AY-1819");
//Assert
fundingLines.Where(y => y.Value == 500)
.Select(r => r.DistributionPeriods)
.Should()
.NotBeNullOrEmpty();
fundingLines.Where(y => y.Value == 600)
.Select(r => r.DistributionPeriods)
.Should()
.NotBeNullOrEmpty();
await providerProfilingRepository
.Received(1)
.GetProviderProfilePeriods(Arg.Is <ProviderProfilingRequestModel>(m =>
m.FundingValue == 500));
await providerProfilingRepository
.Received(1)
.GetProviderProfilePeriods(Arg.Is <ProviderProfilingRequestModel>(m =>
m.FundingValue == 600));
}
public ProfilePatternPreview(IReProfilingRequestBuilder reProfilingRequestBuilder,
IProfilingApiClient profiling,
IPoliciesApiClient policies,
IPublishingResiliencePolicies resiliencePolicies)
{
Guard.ArgumentNotNull(reProfilingRequestBuilder, nameof(reProfilingRequestBuilder));
Guard.ArgumentNotNull(profiling, nameof(profiling));
Guard.ArgumentNotNull(resiliencePolicies?.ProfilingApiClient, nameof(resiliencePolicies.ProfilingApiClient));
Guard.ArgumentNotNull(resiliencePolicies.PoliciesApiClient, nameof(resiliencePolicies.PoliciesApiClient));
_reProfilingRequestBuilder = reProfilingRequestBuilder;
_profiling = profiling;
_policies = policies;
_profilingResilience = resiliencePolicies.ProfilingApiClient;
_policiesResilience = resiliencePolicies.PoliciesApiClient;
}
public async Task SaveFundingTotals_GivenPublishedProfilingRequestsReturnProfilePatternKey()
{
//Arrange
IEnumerable <FundingLine> fundingLines = SetUpInput();
IEnumerable <ProfilePatternKey> profilePatternKeys = SetUpProfilePatternKeyt();
ILogger logger = CreateLogger();
ValidatedApiResponse <ProviderProfilingResponseModel> profileResponse = SetUpProviderProfilingResponse();
IProfilingApiClient providerProfilingRepository = Substitute.For <IProfilingApiClient>();
providerProfilingRepository
.GetProviderProfilePeriods(Arg.Any <ProviderProfilingRequestModel>())
.Returns(Task.FromResult(profileResponse));
ProfilingService serviceapi = CreateProfilingService(
logger: logger,
profilingApiClient: providerProfilingRepository);
//Act
IEnumerable <ProfilePatternKey> result = await serviceapi.ProfileFundingLines(fundingLines, "PSG", "AY-1819",
profilePatternKeys, "productType", "productSubType");
//Assert
fundingLines.Where(y => y.Type == FundingLineType.Payment)
.Select(r => r.DistributionPeriods)
.Should()
.NotBeNullOrEmpty();
IEnumerable <FundingLine> expectedFundingLines;
expectedFundingLines = ExpectedOutput();
JsonConvert
.SerializeObject(expectedFundingLines)
.Should()
.BeEquivalentTo(JsonConvert.SerializeObject(fundingLines));
await providerProfilingRepository
.Received(1)
.GetProviderProfilePeriods(Arg.Is <ProviderProfilingRequestModel>(m =>
m.FundingValue == 500));
result.Select(m => m.Key)
.Should()
.BeEquivalentTo("ProfilePatthernKey1");
}
static PublishedResultsService CreateResultsService(ILogger logger = null,
IMapper mapper = null,
ITelemetry telemetry = null,
ICalculationResultsRepository resultsRepository = null,
ISpecificationsRepository specificationsRepository = null,
IResultsResiliencePolicies resiliencePolicies = null,
IPublishedProviderResultsAssemblerService publishedProviderResultsAssemblerService = null,
IPublishedProviderResultsRepository publishedProviderResultsRepository = null,
ICacheProvider cacheProvider = null,
ISearchRepository <AllocationNotificationFeedIndex> allocationNotificationFeedSearchRepository = null,
IProfilingApiClient profilingApiClient = null,
IMessengerService messengerService = null,
IVersionRepository <PublishedAllocationLineResultVersion> publishedProviderResultsVersionRepository = null,
IPublishedAllocationLineLogicalResultVersionService publishedAllocationLineLogicalResultVersionService = null,
IFeatureToggle featureToggle = null,
IJobsApiClient jobsApiClient = null,
IPublishedProviderResultsSettings publishedProviderResultsSettings = null,
IProviderChangesRepository providerChangesRepository = null,
IProviderVariationsService providerVariationsService = null,
IProviderVariationsStorageRepository providerVariationsStorageRepository = null)
{
ISpecificationsRepository specsRepo = specificationsRepository ?? CreateSpecificationsRepository();
return(new PublishedResultsService(
logger ?? CreateLogger(),
mapper ?? CreateMapper(),
telemetry ?? CreateTelemetry(),
resultsRepository ?? CreateResultsRepository(),
specsRepo,
resiliencePolicies ?? ResultsResilienceTestHelper.GenerateTestPolicies(),
publishedProviderResultsAssemblerService ?? CreateResultsAssembler(),
publishedProviderResultsRepository ?? CreatePublishedProviderResultsRepository(),
cacheProvider ?? CreateCacheProvider(),
allocationNotificationFeedSearchRepository ?? CreateAllocationNotificationFeedSearchRepository(),
profilingApiClient ?? CreateProfilingRepository(),
messengerService ?? CreateMessengerService(),
publishedProviderResultsVersionRepository ?? CreatePublishedProviderResultsVersionRepository(),
publishedAllocationLineLogicalResultVersionService ?? CreatePublishedAllocationLineLogicalResultVersionService(),
featureToggle ?? CreateFeatureToggle(),
jobsApiClient ?? CreateJobsApiClient(),
publishedProviderResultsSettings ?? CreatePublishedProviderResultsSettings(),
providerChangesRepository ?? CreateProviderChangesRepository(),
providerVariationsService ?? CreateProviderVariationsService(CreateProviderVariationAssemblerService(), specsRepo),
providerVariationsStorageRepository ?? CreateProviderVariationsStorageRepository()
));
}
public BatchProfilingService(IProfilingApiClient profiling,
IProducerConsumerFactory producerConsumerFactory,
IBatchProfilingOptions options,
IPublishingResiliencePolicies resiliencePolicies,
ILogger logger)
{
Guard.ArgumentNotNull(profiling, nameof(profiling));
Guard.ArgumentNotNull(producerConsumerFactory, nameof(producerConsumerFactory));
Guard.ArgumentNotNull(options, nameof(options));
Guard.ArgumentNotNull(resiliencePolicies?.ProfilingApiClient, nameof(resiliencePolicies.ProfilingApiClient));
Guard.ArgumentNotNull(logger, nameof(logger));
_profiling = profiling;
_producerConsumerFactory = producerConsumerFactory;
_options = options;
_logger = logger;
_profilingResilience = resiliencePolicies.ProfilingApiClient;
}
public PublishedProviderProfilingService(IPublishedFundingRepository publishedFundingRepository,
IPublishedProviderErrorDetection publishedProviderErrorDetection,
IProfilingService profilingService,
IPublishedProviderVersioningService publishedProviderVersioningService,
ISpecificationsApiClient specificationsApiClient,
IReProfilingRequestBuilder profilingRequestBuilder,
IProfilingApiClient profiling,
IPoliciesService policiesService,
IReProfilingResponseMapper reProfilingResponseMapper,
ILogger logger,
IPublishingResiliencePolicies publishingResiliencePolicies)
{
Guard.ArgumentNotNull(publishedFundingRepository, nameof(publishedFundingRepository));
Guard.ArgumentNotNull(publishedProviderErrorDetection, nameof(publishedProviderErrorDetection));
Guard.ArgumentNotNull(profilingService, nameof(profilingService));
Guard.ArgumentNotNull(publishedProviderVersioningService, nameof(publishedProviderVersioningService));
Guard.ArgumentNotNull(specificationsApiClient, nameof(specificationsApiClient));
Guard.ArgumentNotNull(profilingRequestBuilder, nameof(profilingRequestBuilder));
Guard.ArgumentNotNull(profiling, nameof(profiling));
Guard.ArgumentNotNull(publishingResiliencePolicies?.PublishedFundingRepository, nameof(publishingResiliencePolicies.PublishedFundingRepository));
Guard.ArgumentNotNull(publishingResiliencePolicies?.SpecificationsApiClient, nameof(publishingResiliencePolicies.SpecificationsApiClient));
Guard.ArgumentNotNull(publishingResiliencePolicies?.ProfilingApiClient, nameof(publishingResiliencePolicies.ProfilingApiClient));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(policiesService, nameof(policiesService));
Guard.ArgumentNotNull(reProfilingResponseMapper, nameof(reProfilingResponseMapper));
_publishedFundingRepository = publishedFundingRepository;
_publishedProviderErrorDetection = publishedProviderErrorDetection;
_profilingService = profilingService;
_publishedProviderVersioningService = publishedProviderVersioningService;
_specificationsApiClient = specificationsApiClient;
_profilingRequestBuilder = profilingRequestBuilder;
_profiling = profiling;
_publishingResiliencePolicy = publishingResiliencePolicies.PublishedFundingRepository;
_specificationResiliencePolicy = publishingResiliencePolicies.SpecificationsApiClient;
_profilingPolicy = publishingResiliencePolicies.ProfilingApiClient;
_logger = logger;
_policiesService = policiesService;
_reProfilingResponseMapper = reProfilingResponseMapper;
}