public ProviderCalculationResultsReIndexerService(
ILogger logger,
ISearchRepository <ProviderCalculationResultsIndex> providerCalculationResultsSearchRepository,
ISpecificationsApiClient specificationsApiClient,
ICalculationResultsRepository resultsRepository,
IResultsResiliencePolicies resiliencePolicies,
IFeatureToggle featureToggle,
IMessengerService messengerService)
{
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(providerCalculationResultsSearchRepository, nameof(providerCalculationResultsSearchRepository));
Guard.ArgumentNotNull(specificationsApiClient, nameof(specificationsApiClient));
Guard.ArgumentNotNull(resultsRepository, nameof(resultsRepository));
Guard.ArgumentNotNull(resiliencePolicies?.ResultsRepository, nameof(resiliencePolicies.ResultsRepository));
Guard.ArgumentNotNull(resiliencePolicies?.SpecificationsApiClient, nameof(resiliencePolicies.SpecificationsApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.ResultsSearchRepository, nameof(resiliencePolicies.ResultsSearchRepository));
Guard.ArgumentNotNull(featureToggle, nameof(featureToggle));
Guard.ArgumentNotNull(messengerService, nameof(messengerService));
_logger = logger;
_providerCalculationResultsSearchRepository = providerCalculationResultsSearchRepository;
_specificationsApiClient = specificationsApiClient;
_resultsRepository = resultsRepository;
_resultsRepositoryPolicy = resiliencePolicies.ResultsRepository;
_specificationsApiClientPolicy = resiliencePolicies.SpecificationsApiClient;
_resultsSearchRepositoryPolicy = resiliencePolicies.ResultsSearchRepository;
_featureToggle = featureToggle;
_messengerService = messengerService;
}
public async Task QueueCsvGenerationMessages_GivenSpecificationSummariesFoundAndHasNewResults_CreatesNewMessage()
{
//Arrange
IEnumerable <SpecModel.SpecificationSummary> specificationSummaries = new[]
{
new SpecModel.SpecificationSummary {
Id = specificationId
}
};
ISpecificationsApiClient specificationsApiClient = CreateSpecificationsApiClient();
specificationsApiClient
.GetSpecificationSummaries()
.Returns(new ApiResponse <IEnumerable <SpecModel.SpecificationSummary> >(HttpStatusCode.OK, specificationSummaries));
ICalculationResultsRepository calculationResultsRepository = CreateResultsRepository();
calculationResultsRepository
.CheckHasNewResultsForSpecificationIdAndTime(
Arg.Is(specificationId),
Arg.Any <DateTimeOffset>())
.Returns(true);
ILogger logger = CreateLogger();
IJobManagement jobManagement = CreateJobManagement();
IBlobClient blobClient = CreateBlobClient();
blobClient
.DoesBlobExistAsync($"{CalculationResultsReportFilePrefix}-{specificationId}", CalcsResultsContainerName)
.Returns(true);
ResultsService resultsService = CreateResultsService(
logger,
specificationsApiClient: specificationsApiClient,
resultsRepository: calculationResultsRepository,
jobManagement: jobManagement,
blobClient: blobClient);
//Act
await resultsService.QueueCsvGenerationMessages();
//Assert
await
jobManagement
.Received(1)
.QueueJob(
Arg.Is <JobCreateModel>(_ =>
_.JobDefinitionId == JobConstants.DefinitionNames.GenerateCalcCsvResultsJob &&
_.Properties["specification-id"] == specificationId));
logger
.Received()
.Information($"Found new calculation results for specification id '{specificationId}'");
}
public PublishServiceAcceptanceStepContext(IFeatureManagerSnapshot featureManagerSnapshot,
ICalculationsApiClient calculationsInMemoryClient,
ICalculationResultsRepository calculationsInMemoryRepository,
IProfilingApiClient profilingApiClient)
{
_featureManagerSnapshot = featureManagerSnapshot;
CalculationsInMemoryRepository = (CalculationInMemoryRepository)calculationsInMemoryRepository;
CalculationsInMemoryClient = (CalculationsInMemoryClient)calculationsInMemoryClient;
ProfilingInMemoryClient = (ProfilingInMemoryClient)profilingApiClient;
}
public CalculationResultsService(
IPublishingResiliencePolicies resiliencePolicies,
ICalculationResultsRepository calculationResultsRepository)
{
Guard.ArgumentNotNull(calculationResultsRepository, nameof(calculationResultsRepository));
Guard.ArgumentNotNull(resiliencePolicies, nameof(resiliencePolicies));
Guard.ArgumentNotNull(resiliencePolicies.CalculationResultsRepository, nameof(resiliencePolicies.CalculationResultsRepository));
_calculationResultsRepository = calculationResultsRepository;
_resultsRepositoryPolicy = resiliencePolicies.CalculationResultsRepository;
}
public ResultsService(ILogger logger,
IFeatureToggle featureToggle,
ICalculationResultsRepository resultsRepository,
IMapper mapper,
ISearchRepository <ProviderIndex> searchRepository,
ITelemetry telemetry,
IProviderSourceDatasetRepository providerSourceDatasetRepository,
ISearchRepository <ProviderCalculationResultsIndex> calculationProviderResultsSearchRepository,
ISpecificationsRepository specificationsRepository,
IResultsResiliencePolicies resiliencePolicies,
IProviderImportMappingService providerImportMappingService,
ICacheProvider cacheProvider,
IMessengerService messengerService,
ICalculationsRepository calculationRepository,
IValidator <MasterProviderModel> masterProviderModelValidator,
IBlobClient blobClient)
{
Guard.ArgumentNotNull(resultsRepository, nameof(resultsRepository));
Guard.ArgumentNotNull(mapper, nameof(mapper));
Guard.ArgumentNotNull(searchRepository, nameof(searchRepository));
Guard.ArgumentNotNull(telemetry, nameof(telemetry));
Guard.ArgumentNotNull(providerSourceDatasetRepository, nameof(providerSourceDatasetRepository));
Guard.ArgumentNotNull(calculationProviderResultsSearchRepository, nameof(calculationProviderResultsSearchRepository));
Guard.ArgumentNotNull(specificationsRepository, nameof(specificationsRepository));
Guard.ArgumentNotNull(resiliencePolicies, nameof(resiliencePolicies));
Guard.ArgumentNotNull(providerImportMappingService, nameof(providerImportMappingService));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(messengerService, nameof(messengerService));
Guard.ArgumentNotNull(calculationRepository, nameof(calculationRepository));
Guard.ArgumentNotNull(masterProviderModelValidator, nameof(masterProviderModelValidator));
Guard.ArgumentNotNull(featureToggle, nameof(featureToggle));
Guard.ArgumentNotNull(blobClient, nameof(blobClient));
_logger = logger;
_resultsRepository = resultsRepository;
_mapper = mapper;
_searchRepository = searchRepository;
_telemetry = telemetry;
_providerSourceDatasetRepository = providerSourceDatasetRepository;
_calculationProviderResultsSearchRepository = calculationProviderResultsSearchRepository;
_resultsRepositoryPolicy = resiliencePolicies.ResultsRepository;
_specificationsRepository = specificationsRepository;
_resultsSearchRepositoryPolicy = resiliencePolicies.ResultsSearchRepository;
_specificationsRepositoryPolicy = resiliencePolicies.SpecificationsRepository;
_providerImportMappingService = providerImportMappingService;
_cacheProvider = cacheProvider;
_messengerService = messengerService;
_calculationRepository = calculationRepository;
_masterProviderModelValidator = masterProviderModelValidator;
_calculationsRepositoryPolicy = resiliencePolicies.CalculationsRepository;
_featureToggle = featureToggle;
_blobClient = blobClient;
_blobClientPolicy = resiliencePolicies.CsvBlobPolicy;
}
public async Task QueueCsvGenerationMessages_GivenSpecificationSummariesFoundButNoResults_DoesNotCreateNewMessages()
{
//Arrange
IEnumerable <SpecModel.SpecificationSummary> specificationSummaries = new[]
{
new SpecModel.SpecificationSummary {
Id = "spec-1"
}
};
ISpecificationsApiClient specificationsApiClient = CreateSpecificationsApiClient();
specificationsApiClient
.GetSpecificationSummaries()
.Returns(new ApiResponse <IEnumerable <SpecModel.SpecificationSummary> >(HttpStatusCode.OK, specificationSummaries));
ICalculationResultsRepository calculationResultsRepository = CreateResultsRepository();
calculationResultsRepository
.ProviderHasResultsBySpecificationId(
Arg.Is("spec-1"))
.Returns(false);
IBlobClient blobClient = CreateBlobClient();
blobClient
.DoesBlobExistAsync($"{CalculationResultsReportFilePrefix}-spec-1", CalcsResultsContainerName)
.Returns(false);
ILogger logger = CreateLogger();
IJobManagement jobManagement = CreateJobManagement();
ResultsService resultsService = CreateResultsService(
logger,
specificationsApiClient: specificationsApiClient,
resultsRepository: calculationResultsRepository,
jobManagement: jobManagement,
blobClient: blobClient);
//Act
await resultsService.QueueCsvGenerationMessages();
//Assert
await
jobManagement
.DidNotReceive()
.QueueJob(Arg.Any <JobCreateModel>());
logger
.DidNotReceive()
.Information($"Found new calculation results for specification id 'spec-1'");
}
public async Task QueueCsvGenerationMessages_GivenSpecificationSummariesFoundAndHasNewResults_CreatesNewMessage()
{
//Arrange
IEnumerable <SpecificationSummary> specificationSummaries = new[]
{
new SpecificationSummary {
Id = "spec-1"
}
};
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationSummaries()
.Returns(specificationSummaries);
ICalculationResultsRepository calculationResultsRepository = CreateResultsRepository();
calculationResultsRepository
.CheckHasNewResultsForSpecificationIdAndTimePeriod(
Arg.Is("spec-1"),
Arg.Any <DateTimeOffset>(),
Arg.Any <DateTimeOffset>())
.Returns(true);
ILogger logger = CreateLogger();
IMessengerService messengerService = CreateMessengerService();
ResultsService resultsService = CreateResultsService(
logger,
specificationsRepository: specificationsRepository,
resultsRepository: calculationResultsRepository,
messengerService: messengerService);
//Act
await resultsService.QueueCsvGenerationMessages();
//Assert
await
messengerService
.Received(1)
.SendToQueue(
Arg.Is(ServiceBusConstants.QueueNames.CalculationResultsCsvGeneration),
Arg.Is(string.Empty),
Arg.Is <Dictionary <string, string> >(m => m["specification-id"] == "spec-1"), Arg.Is(false));
logger
.Received()
.Information($"Found new calculation results for specification id 'spec-1'");
}
public MergeSpecificationsWithProviderResultsDocuments(ICosmosRepository cosmosRepository,
ILogger logger,
ISpecificationsApiClient specifications,
IProducerConsumerFactory producerConsumerFactory,
IResultsResiliencePolicies resultsResiliencePolicies,
IPoliciesApiClient policies,
ICalculationResultsRepository results)
{
_cosmosRepository = cosmosRepository;
_logger = logger;
_specifications = specifications;
_producerConsumerFactory = producerConsumerFactory;
_policies = policies;
_results = results;
_policiesPolicy = resultsResiliencePolicies.PoliciesApiClient;
}
public void SetUp()
{
_calculationResultsRepository = Substitute.For <ICalculationResultsRepository>();
_blobClient = Substitute.For <IBlobClient>();
_csvUtils = Substitute.For <ICsvUtils>();
_transformation = Substitute.For <IProviderResultsToCsvRowsTransformation>();
_cloudBlob = Substitute.For <ICloudBlob>();
_fileSystemAccess = Substitute.For <IFileSystemAccess>();
_fileSystemCacheSettings = Substitute.For <IFileSystemCacheSettings>();
_jobManagement = Substitute.For <IJobManagement>();
_calcsApiClient = Substitute.For <ICalculationsApiClient>();
_specsApiClient = Substitute.For <ISpecificationsApiClient>();
_service = new ProviderResultsCsvGeneratorService(Substitute.For <ILogger>(),
_blobClient,
_calcsApiClient,
_specsApiClient,
_calculationResultsRepository,
new ResiliencePolicies
{
BlobClient = Policy.NoOpAsync(),
CalculationsApiClient = Policy.NoOpAsync(),
SpecificationsApiClient = Policy.NoOpAsync(),
ResultsRepository = Policy.NoOpAsync()
},
_csvUtils,
_transformation,
_fileSystemAccess,
_fileSystemCacheSettings,
_jobManagement);
_message = new Message();
_rootPath = NewRandomString();
_fileSystemCacheSettings.Path
.Returns(_rootPath);
_fileSystemAccess
.Append(Arg.Any <string>(), Arg.Any <Stream>())
.Returns(Task.CompletedTask);
_blobProperties = new BlobProperties();
_cloudBlob
.Properties
.Returns(_blobProperties);
}
public ResultsService(ILogger logger,
IFeatureToggle featureToggle,
ICalculationResultsRepository resultsRepository,
IProviderSourceDatasetRepository providerSourceDatasetRepository,
ISearchRepository <ProviderCalculationResultsIndex> calculationProviderResultsSearchRepository,
ISpecificationsApiClient specificationsApiClient,
ICalculationsApiClient calculationsApiClient,
IResultsResiliencePolicies resiliencePolicies,
ICalculationsRepository calculationRepository,
IMapper mapper,
IJobManagement jobManagement,
IBlobClient blobClient) : base(jobManagement, logger)
{
Guard.ArgumentNotNull(resultsRepository, nameof(resultsRepository));
Guard.ArgumentNotNull(providerSourceDatasetRepository, nameof(providerSourceDatasetRepository));
Guard.ArgumentNotNull(calculationProviderResultsSearchRepository, nameof(calculationProviderResultsSearchRepository));
Guard.ArgumentNotNull(specificationsApiClient, nameof(specificationsApiClient));
Guard.ArgumentNotNull(calculationsApiClient, nameof(calculationsApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.ResultsRepository, nameof(resiliencePolicies.ResultsRepository));
Guard.ArgumentNotNull(resiliencePolicies?.ResultsSearchRepository, nameof(resiliencePolicies.ResultsSearchRepository));
Guard.ArgumentNotNull(resiliencePolicies?.SpecificationsApiClient, nameof(resiliencePolicies.SpecificationsApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.CalculationsApiClient, nameof(resiliencePolicies.CalculationsApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.CalculationsRepository, nameof(resiliencePolicies.CalculationsRepository));
Guard.ArgumentNotNull(resiliencePolicies?.BlobClient, nameof(resiliencePolicies.BlobClient));
Guard.ArgumentNotNull(calculationRepository, nameof(calculationRepository));
Guard.ArgumentNotNull(featureToggle, nameof(featureToggle));
Guard.ArgumentNotNull(mapper, nameof(mapper));
Guard.ArgumentNotNull(blobClient, nameof(blobClient));
_logger = logger;
_mapper = mapper;
_resultsRepository = resultsRepository;
_providerSourceDatasetRepository = providerSourceDatasetRepository;
_calculationProviderResultsSearchRepository = calculationProviderResultsSearchRepository;
_resultsRepositoryPolicy = resiliencePolicies.ResultsRepository;
_specificationsApiClient = specificationsApiClient;
_calculationsApiClient = calculationsApiClient;
_resultsSearchRepositoryPolicy = resiliencePolicies.ResultsSearchRepository;
_specificationsApiClientPolicy = resiliencePolicies.SpecificationsApiClient;
_calculationsApiClientPolicy = resiliencePolicies.CalculationsApiClient;
_blobClientPolicy = resiliencePolicies.BlobClient;
_calculationRepository = calculationRepository;
_calculationsRepositoryPolicy = resiliencePolicies.CalculationsRepository;
_featureToggle = featureToggle;
_blobClient = blobClient;
}
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 ProviderResultsCsvGeneratorService(ILogger logger,
IBlobClient blobClient,
ICalculationsApiClient calculationsApiClient,
ISpecificationsApiClient specificationsApiClient,
ICalculationResultsRepository resultsRepository,
IResultsResiliencePolicies policies,
ICsvUtils csvUtils,
IProviderResultsToCsvRowsTransformation resultsToCsvRowsTransformation,
IFileSystemAccess fileSystemAccess,
IFileSystemCacheSettings fileSystemCacheSettings,
IJobManagement jobManagement) : base(jobManagement, logger)
{
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(blobClient, nameof(blobClient));
Guard.ArgumentNotNull(specificationsApiClient, nameof(specificationsApiClient));
Guard.ArgumentNotNull(calculationsApiClient, nameof(calculationsApiClient));
Guard.ArgumentNotNull(resultsRepository, nameof(resultsRepository));
Guard.ArgumentNotNull(resultsToCsvRowsTransformation, nameof(resultsToCsvRowsTransformation));
Guard.ArgumentNotNull(fileSystemAccess, nameof(fileSystemAccess));
Guard.ArgumentNotNull(policies?.BlobClient, nameof(policies.BlobClient));
Guard.ArgumentNotNull(policies?.CalculationsApiClient, nameof(policies.CalculationsApiClient));
Guard.ArgumentNotNull(policies?.SpecificationsApiClient, nameof(policies.SpecificationsApiClient));
Guard.ArgumentNotNull(policies?.ResultsRepository, nameof(policies.ResultsRepository));
Guard.ArgumentNotNull(fileSystemCacheSettings, nameof(fileSystemCacheSettings));
Guard.ArgumentNotNull(jobManagement, nameof(jobManagement));
_logger = logger;
_blobClient = blobClient;
_calculationsApiClient = calculationsApiClient;
_specificationsApiClient = specificationsApiClient;
_resultsRepository = resultsRepository;
_blobClientPolicy = policies.BlobClient;
_calculationsApiClientPolicy = policies.CalculationsApiClient;
_specificationsApiClientPolicy = policies.SpecificationsApiClient;
_resultsRepositoryPolicy = policies.ResultsRepository;
_csvUtils = csvUtils;
_resultsToCsvRowsTransformation = resultsToCsvRowsTransformation;
_fileSystemAccess = fileSystemAccess;
_fileSystemCacheSettings = fileSystemCacheSettings;
_jobManagement = jobManagement;
}
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 ReIndexCalculationResults_GivenResultReturnedFromDatabaseWithTwoCalcResultsButSearchReturnsErrors_ThrowsRetriableException()
{
//Arrange
const string expectedErrorMessage = "Failed to index calculation provider result documents with errors: an error";
Message message = new Message();
message.UserProperties["user-id"] = "123";
message.UserProperties["user-name"] = "Joe Bloggs";
ProviderResult providerResult = CreateProviderResult();
ISearchRepository <ProviderCalculationResultsIndex> searchRepository = CreateSearchRepository();
searchRepository
.Index(Arg.Any <IEnumerable <ProviderCalculationResultsIndex> >())
.Returns(new[] { new IndexError {
ErrorMessage = "an error"
} });
ICalculationResultsRepository calculationResultsRepository = CreateCalculationResultsRepository();
calculationResultsRepository
.WhenForAnyArgs(x => x.ProviderResultsBatchProcessing(default, default)).Do(x =>
public ProviderCalculationResultsIndexDataReader(ICalculationResultsRepository calculationResultsRepository)
{
Guard.ArgumentNotNull(calculationResultsRepository, nameof(calculationResultsRepository));
_calculationResultsRepository = calculationResultsRepository;
}
public void Setup()
{
_repository = Substitute.For <ICalculationResultsRepository>();
_reader = new ProviderCalculationResultsIndexDataReader(_repository);
}
