public PublishedProviderStatusService(
ISpecificationIdServiceRequestValidator validator,
ISpecificationService specificationService,
IPublishedFundingRepository publishedFundingRepository,
IPublishingResiliencePolicies publishingResiliencePolicies,
IPublishedProviderFundingCountProcessor fundingCountProcessor,
IPublishedProviderFundingCsvDataProcessor fundingCsvDataProcessor,
ICsvUtils csvUtils,
IBlobClient blobClient)
{
Guard.ArgumentNotNull(validator, nameof(validator));
Guard.ArgumentNotNull(specificationService, nameof(specificationService));
Guard.ArgumentNotNull(publishedFundingRepository, nameof(publishedFundingRepository));
Guard.ArgumentNotNull(publishingResiliencePolicies, nameof(publishingResiliencePolicies));
Guard.ArgumentNotNull(publishingResiliencePolicies.PublishedFundingRepository, nameof(publishingResiliencePolicies.PublishedFundingRepository));
Guard.ArgumentNotNull(publishingResiliencePolicies.SpecificationsRepositoryPolicy, nameof(publishingResiliencePolicies.SpecificationsRepositoryPolicy));
Guard.ArgumentNotNull(publishingResiliencePolicies.BlobClient, nameof(publishingResiliencePolicies.BlobClient));
Guard.ArgumentNotNull(fundingCountProcessor, nameof(fundingCountProcessor));
Guard.ArgumentNotNull(fundingCsvDataProcessor, nameof(fundingCsvDataProcessor));
Guard.ArgumentNotNull(csvUtils, nameof(csvUtils));
Guard.ArgumentNotNull(blobClient, nameof(blobClient));
_validator = validator;
_specificationService = specificationService;
_publishedFundingRepository = publishedFundingRepository;
_fundingCountProcessor = fundingCountProcessor;
_publishedFundingRepositoryResilience = publishingResiliencePolicies.PublishedFundingRepository;
_specificationsRepositoryPolicy = publishingResiliencePolicies.SpecificationsRepositoryPolicy;
_blobClientPolicy = publishingResiliencePolicies.BlobClient;
_fundingCsvDataProcessor = fundingCsvDataProcessor;
_csvUtils = csvUtils;
_blobClient = blobClient;
}
public async Task GetProviderFundingVersionsBody_GivenGetBlobReferenceCausesException_LogsAndReturnsInternalServerError()
{
//Arrange
ILogger logger = CreateLogger();
IBlobClient blobClient = CreateBlobClient();
blobClient
.BlobExistsAsync(blobName)
.Returns(true);
blobClient
.GetBlobReferenceFromServerAsync(blobName)
.Throws(new Exception());
string errorMessage = $"Failed to fetch blob '{blobName}' from azure storage";
ProviderFundingVersionService service = CreateProviderFundingVersionService(logger, blobClient);
//Act
IActionResult result = await service.GetProviderFundingVersion(providerFundingVersion);
//Assert
result
.Should()
.BeAssignableTo <InternalServerErrorResult>()
.Which
.Value
.Should()
.Be(errorMessage);
logger
.Received(1)
.Error(Arg.Any <Exception>(), Arg.Is(errorMessage));
}
protected CustomFieldManager(IRepositoryContainer repositories, IBlobClient blobClient, IDataTableBinder dataTableBinder, IUserAuditor auditor)
{
if (repositories == null)
{
throw new ArgumentNullException("repositories");
}
if (blobClient == null)
{
throw new ArgumentNullException("blobClient");
}
if (dataTableBinder == null)
{
throw new ArgumentNullException("dataTableBinder");
}
if (auditor == null)
{
throw new ArgumentNullException("auditor");
}
RepositoryContainer = repositories;
CustomDataOriginRepository = repositories.Obtain <ICustomDataOriginRepository>();
CustomFieldCategoryRepository = repositories.Obtain <ICustomFieldCategoryRepository>();
CustomFieldRepository = repositories.Obtain <ICustomFieldRepository>();
CustomFieldTypeRepository = repositories.Obtain <ICustomFieldTypeRepository>();
CustomFieldValueRepository = repositories.Obtain <ICustomFieldValueRepository>();
StudentRepository = repositories.Obtain <IStudentRepository>();
ServiceTypeRepository = repositories.Obtain <IServiceTypeRepository>();
DataFileBlobContainer = blobClient.CreateContainer(DataFileBlobContainerName);
DataTableBinder = dataTableBinder;
Auditor = auditor;
}
public async Task IsHealthOk_ReturnsAsExpected(bool blobOk, string blobMessage)
{
//Arrange
IBlobClient blobClient = Substitute.For <IBlobClient>();
blobClient
.IsHealthOk()
.Returns((blobOk, blobMessage));
ProviderFundingVersionService providerFundingVersionService = CreateProviderFundingVersionService(blobClient: blobClient);
ServiceHealth health = await providerFundingVersionService.IsHealthOk();
health.Name
.Should()
.Be(nameof(ProviderFundingVersionService));
health.Dependencies.Count.Should().Be(1);
health
.Dependencies
.Count(x => x.HealthOk == blobOk && x.Message == blobMessage)
.Should()
.Be(1);
}
public void SetUp()
{
IPublishedFundingContentsGeneratorResolver publishedFundingContentsGeneratorResolver = Substitute.For <IPublishedFundingContentsGeneratorResolver>();
IConfiguration configuration = Substitute.For <IConfiguration>();
_blobClient = Substitute.For <IBlobClient>();
_publishedFundingContentsGenerator = Substitute.For <IPublishedFundingContentsGenerator>();
_templateMetadataContents = new Common.TemplateMetadata.Models.TemplateMetadataContents {
SchemaVersion = _schema
};
publishedFundingContentsGeneratorResolver.GetService(Arg.Is(_schema))
.Returns(_publishedFundingContentsGenerator);
_publishedFundingContentsPersistanceService = new PublishedFundingContentsPersistanceService(
publishedFundingContentsGeneratorResolver,
_blobClient, PublishingResilienceTestHelper.GenerateTestPolicies(),
new PublishingEngineOptions(configuration));
_cloudBlob = Substitute.For <ICloudBlob>();
_publishedFundingPeriod = new PublishedFundingPeriod {
Type = PublishedFundingPeriodType.AY, Period = "123"
};
}
public void SetUp()
{
_specificationId = NewRandomString();
_validationResult = new ValidationResult();
_validator = Substitute.For <ISpecificationIdServiceRequestValidator>();
_validator.Validate(_specificationId)
.Returns(_validationResult);
_specificationService = Substitute.For <ISpecificationService>();
_publishedFundingRepository = Substitute.For <IPublishedFundingRepository>();
_fundingCountProcessor = Substitute.For <IPublishedProviderFundingCountProcessor>();
_fundingCsvDataProcessor = Substitute.For <IPublishedProviderFundingCsvDataProcessor>();
_csvUtils = Substitute.For <ICsvUtils>();
_blobClient = Substitute.For <IBlobClient>();
_service = new PublishedProviderStatusService(_validator, _specificationService, _publishedFundingRepository, new ResiliencePolicies
{
PublishedFundingRepository = Polly.Policy.NoOpAsync(),
SpecificationsRepositoryPolicy = Polly.Policy.NoOpAsync(),
BlobClient = Polly.Policy.NoOpAsync()
},
_fundingCountProcessor,
_fundingCsvDataProcessor,
_csvUtils,
_blobClient);
}
protected BasePublishingCsvGenerator(
IJobManagement jobManagement,
IFileSystemAccess fileSystemAccess,
IBlobClient blobClient,
IPublishingResiliencePolicies policies,
ICsvUtils csvUtils,
ILogger logger,
IFileSystemCacheSettings fileSystemCacheSettings,
IPublishedProviderCsvTransformServiceLocator publishedProviderCsvTransformServiceLocator) : base(jobManagement, logger)
{
Guard.ArgumentNotNull(fileSystemAccess, nameof(fileSystemAccess));
Guard.ArgumentNotNull(blobClient, nameof(blobClient));
Guard.ArgumentNotNull(policies?.BlobClient, nameof(policies.BlobClient));
Guard.ArgumentNotNull(csvUtils, nameof(csvUtils));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(fileSystemCacheSettings, nameof(fileSystemCacheSettings));
Guard.ArgumentNotNull(publishedProviderCsvTransformServiceLocator, nameof(publishedProviderCsvTransformServiceLocator));
_fileSystemAccess = fileSystemAccess;
_blobClient = blobClient;
_blobClientPolicy = policies.BlobClient;
_csvUtils = csvUtils;
_fileSystemCacheSettings = fileSystemCacheSettings;
_publishedProviderCsvTransformServiceLocator = publishedProviderCsvTransformServiceLocator;
_logger = logger;
}
public DefinitionsService(
ILogger logger,
IDatasetRepository dataSetsRepository,
ISearchRepository <DatasetDefinitionIndex> datasetDefinitionSearchRepository,
IDatasetsResiliencePolicies datasetsResiliencePolicies,
IExcelWriter <DatasetDefinition> excelWriter,
IBlobClient blobClient,
IDefinitionChangesDetectionService definitionChangesDetectionService,
IMessengerService messengerService)
{
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(dataSetsRepository, nameof(dataSetsRepository));
Guard.ArgumentNotNull(datasetDefinitionSearchRepository, nameof(datasetDefinitionSearchRepository));
Guard.ArgumentNotNull(datasetsResiliencePolicies, nameof(datasetsResiliencePolicies));
Guard.ArgumentNotNull(excelWriter, nameof(excelWriter));
Guard.ArgumentNotNull(definitionChangesDetectionService, nameof(definitionChangesDetectionService));
Guard.ArgumentNotNull(messengerService, nameof(messengerService));
_logger = logger;
_datasetsRepository = dataSetsRepository;
_datasetDefinitionSearchRepository = datasetDefinitionSearchRepository;
_datasetDefinitionSearchRepositoryPolicy = datasetsResiliencePolicies.DatasetDefinitionSearchRepository;
_datasetsRepositoryPolicy = datasetsResiliencePolicies.DatasetRepository;
_excelWriter = excelWriter;
_blobClient = blobClient;
_blobClientPolicy = datasetsResiliencePolicies.BlobClient;
_definitionChangesDetectionService = definitionChangesDetectionService;
_messengerService = messengerService;
}
public BlobRepository(IServiceProvider serviceProvider, ILoggerFactory loggerFactory)
{
logger = loggerFactory.CreateLogger <BlobRepository <T> >();
var configuration = serviceProvider.GetRequiredService <IConfiguration>();
var storageSettings = configuration.GetConfiguredSettings <StorageDataSettings>();
var prop = storageSettings.GetType().GetProperties()
.FirstOrDefault(p =>
{
var customAttr = p.GetCustomAttribute <MappedModelAttribute>();
if (customAttr != null && customAttr.ModelType == typeof(T))
{
return(true);
}
return(false);
});
if (prop == null)
{
throw new Exception($"Missing backend mapping for model: {typeof(T).Name}");
}
var blobStorageSettings = prop.GetValue(storageSettings) as BlobStorageSettings;
if (blobStorageSettings == null)
{
throw new Exception($"Missing backend mapping for model: {typeof(T).Name}");
}
client = new BlobClient(serviceProvider, loggerFactory, new OptionsWrapper <BlobStorageSettings>(blobStorageSettings));
}
public FundingLineCsvGenerator(IFundingLineCsvTransformServiceLocator transformServiceLocator,
IPublishedFundingPredicateBuilder predicateBuilder,
IBlobClient blobClient,
IFileSystemAccess fileSystemAccess,
IFileSystemCacheSettings fileSystemCacheSettings,
IFundingLineCsvBatchProcessorServiceLocator batchProcessorServiceLocator,
IPublishingResiliencePolicies policies,
IJobManagement jobManagement,
ILogger logger) : base(jobManagement, logger)
{
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(blobClient, nameof(blobClient));
Guard.ArgumentNotNull(transformServiceLocator, nameof(transformServiceLocator));
Guard.ArgumentNotNull(predicateBuilder, nameof(predicateBuilder));
Guard.ArgumentNotNull(fileSystemAccess, nameof(fileSystemAccess));
Guard.ArgumentNotNull(fileSystemCacheSettings, nameof(fileSystemCacheSettings));
Guard.ArgumentNotNull(policies?.BlobClient, nameof(policies.BlobClient));
Guard.ArgumentNotNull(batchProcessorServiceLocator, nameof(batchProcessorServiceLocator));
_logger = logger;
_batchProcessorServiceLocator = batchProcessorServiceLocator;
_blobClient = blobClient;
_transformServiceLocator = transformServiceLocator;
_fileSystemAccess = fileSystemAccess;
_fileSystemCacheSettings = fileSystemCacheSettings;
_blobClientPolicy = policies.BlobClient;
}
public static async Task ProvisionResources(this IBlobClient client, IHost host, CancellationToken token = default)
{
var configuration = host.Services.GetRequiredService <IConfiguration>();
switch (client)
{
case S3BlobClient _:
if (Environment.GetEnvironmentVariable("MINIO_SERVER") != null)
{
var s3Client = host.Services.GetRequiredService <AmazonS3Client>();
var s3Options = new S3BlobClientOptions();
configuration.GetSection(nameof(S3BlobClientOptions)).Bind(s3Options);
var buckets = await s3Client.ListBucketsAsync(token);
if (!buckets.Buckets.Exists(bucket => bucket.BucketName == s3Options.Buckets[WellknownBuckets.ImportLegacyBucket]))
{
await s3Client.PutBucketAsync(s3Options.Buckets[WellknownBuckets.ImportLegacyBucket], token);
}
}
break;
case FileBlobClient _:
var fileOptions = new FileBlobClientOptions();
configuration.GetSection(nameof(FileBlobClientOptions)).Bind(fileOptions);
if (!Directory.Exists(fileOptions.Directory))
{
Directory.CreateDirectory(fileOptions.Directory);
}
break;
}
}
protected CustomFieldManager(IRepositoryContainer repositories, IBlobClient blobClient, IDataTableBinder dataTableBinder, IUserAuditor auditor)
{
if (repositories == null)
{
throw new ArgumentNullException("repositories");
}
if (blobClient == null)
{
throw new ArgumentNullException("blobClient");
}
if (dataTableBinder == null)
{
throw new ArgumentNullException("dataTableBinder");
}
if (auditor == null)
{
throw new ArgumentNullException("auditor");
}
RepositoryContainer = repositories;
CustomDataOriginRepository = repositories.Obtain<ICustomDataOriginRepository>();
CustomFieldCategoryRepository = repositories.Obtain<ICustomFieldCategoryRepository>();
CustomFieldRepository = repositories.Obtain<ICustomFieldRepository>();
CustomFieldTypeRepository = repositories.Obtain<ICustomFieldTypeRepository>();
CustomFieldValueRepository = repositories.Obtain<ICustomFieldValueRepository>();
StudentRepository = repositories.Obtain<IStudentRepository>();
ServiceTypeRepository = repositories.Obtain<IServiceTypeRepository>();
DataFileBlobContainer = blobClient.CreateContainer(DataFileBlobContainerName);
DataTableBinder = dataTableBinder;
Auditor = auditor;
}
public ProvidersStepContext(IProviderService service,
IProvidersApiClient client,
IBlobClient blobClient)
{
_blobClient = blobClient;
Service = service;
Client = client;
}
public PublishedFundingRepositoryStepContext(ICosmosRepository cosmosRepo,
IBlobClient blobRepo,
IPublishedFundingRepository publishedFundingRepository)
{
CosmosRepo = cosmosRepo;
_blobRepo = blobRepo;
_publishedFundingRepository = publishedFundingRepository;
}
public HomeController(IBlobClient blobClient, IModelCreator modelCreator, IEloCalulator eloCalulator, ITeamGenerator teamGenerator, ITrendCalculator trendCalculator)
{
this.blobClient = blobClient;
this.modelCreator = modelCreator;
this.eloCalulator = eloCalulator;
this.teamGenerator = teamGenerator;
this.trendCalculator = trendCalculator;
}
protected ErrorRecorder(IPublishingResiliencePolicies resiliencePolicies, IBlobClient blobClient)
{
Guard.ArgumentNotNull(blobClient, nameof(blobClient));
Guard.ArgumentNotNull(resiliencePolicies?.BlobClient, nameof(resiliencePolicies.BlobClient));
_resiliencePolicy = resiliencePolicies.BlobClient;
_blobClient = blobClient;
}
public Blob(string blobName, IBlobClient blobClient, IBlobContainer container, IBlobDirectory blobDirectory)
{
_blobName = blobName;
_exists = false;
_blobContainer = container;
_blobClient = blobClient;
_blobDirectory = blobDirectory;
}
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 BlobCache(IServiceProvider serviceProvider, ILoggerFactory loggerFactory)
{
logger = loggerFactory.CreateLogger<BlobCache>();
appTelemetry = serviceProvider.GetRequiredService<IAppTelemetry>();
var configuration = serviceProvider.GetRequiredService<IConfiguration>();
cacheSettings = configuration.GetConfiguredSettings<CacheSettings>();
blobClient = new BlobClient(serviceProvider, loggerFactory,
new OptionsWrapper<BlobStorageSettings>(cacheSettings.BlobCache));
}
public async Task Run(IDictionary <string, object> parameters)
{
IBlobClient client = _blobClientFactory.CreateBlobClient();
IBlobContainer container = client.GetContainerReference(_containerName);
await container.CreateIfNotExistsAsync((BlobRequestOptions)parameters["options"]);
IBlockBlob blob = container.GetBlockBlobReference((string)parameters["blobPath"]);
await blob.UploadFromFileAsync((string)parameters["filePath"], (string)parameters["contentType"]);
}
private static async Task <ApiResourceCollection> GetApiCollectionAsync(IBlobClient blobClient)
{
_ = blobClient ?? throw new ArgumentNullException(nameof(blobClient));
var container = blobClient.GetContainer(ApiContainer);
var file = await container.GetItemAsync <ApiResourceCollection>(ApiFile);
return(file.Item);
}
public BatchUploadReader(IBlobClient blobClient,
IPublishingResiliencePolicies resiliencePolicies)
{
Guard.ArgumentNotNull(blobClient, nameof(blobClient));
Guard.ArgumentNotNull(resiliencePolicies?.BlobClient, "resiliencePolicies.BlobClient");
_blobClient = blobClient;
_blobResilience = resiliencePolicies.BlobClient;
}
public BatchUploadReaderFactory(IBlobClient blobClient,
IPublishingResiliencePolicies resiliencePolicies)
{
Guard.ArgumentNotNull(blobClient, nameof(blobClient));
Guard.ArgumentNotNull(resiliencePolicies, nameof(resiliencePolicies));
_blobClient = blobClient;
_resiliencePolicies = resiliencePolicies;
}
public BatchCreator(IConfiguration configuration, ILoggerFactory loggerFactory, IAppTelemetry appTelemetry,
IBlobClient blobClient, IRangeHelper <TField> rangeHelper)
{
_batchSetting = configuration.GetConfiguredSettings <BatchSetting <TField> >();
_logger = loggerFactory.CreateLogger <BatchCreator <TField> >();
_appTelemetry = appTelemetry;
_blobClient = blobClient;
_rangeHelper = rangeHelper;
_getBlobName = t => $"{_batchSetting.Name}-{t.Sequence}";
}
private void Cleanup()
{
IBlobClient cleanupClient = AzureBlobClientFactory.Create();
foreach (string containerName in ContainersToClean)
{
IBlobContainer container = cleanupClient.CreateContainer(containerName);
CleanupContainer(container);
}
}
public PublishedProviderStepContext(IProviderService service,
IProvidersApiClient client,
ISearchRepository <PublishedProviderIndex> searchRepository,
IBlobClient blobClient)
{
_searchRepository = searchRepository;
_blobClient = blobClient;
Service = service;
Client = client;
}
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 BatchUploadQueryService(IBlobClient blobClient,
IPublishingResiliencePolicies resiliencePolicies,
ILogger logger)
{
Guard.ArgumentNotNull(blobClient, nameof(blobClient));
Guard.ArgumentNotNull(resiliencePolicies?.BlobClient, "resiliencePolicies.BlobClient");
Guard.ArgumentNotNull(logger, nameof(logger));
_blobClient = blobClient;
_blobResilience = resiliencePolicies.BlobClient;
_logger = logger;
}
public PublishedFundingUndoBlobStoreRepository(IBlobClient blobClient,
IPublishingResiliencePolicies resiliencePolicies,
ILogger logger)
{
Guard.ArgumentNotNull(resiliencePolicies?.BlobClient, "resiliencePolicies.BlobClient");
Guard.ArgumentNotNull(blobClient, nameof(blobClient));
Guard.ArgumentNotNull(logger, nameof(logger));
_resilience = resiliencePolicies.BlobClient;
_blobClient = blobClient;
_logger = logger;
}
public DeletePublishedFundingBlobDocumentsService(IPublishingResiliencePolicies resiliencePolicies,
IBlobClient blobClient,
ILogger logger)
{
Guard.ArgumentNotNull(resiliencePolicies?.BlobClient, "resiliencePolicies.BlobClient");
Guard.ArgumentNotNull(blobClient, nameof(blobClient));
Guard.ArgumentNotNull(logger, nameof(logger));
_blobClientPolicy = resiliencePolicies.BlobClient;
_blobClient = blobClient;
_logger = logger;
}
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'");
}
protected BaseFileProcessor(IBlobClient blobClient, IRepositoryContainer repositories)
{
if (blobClient == null)
{
throw new ArgumentNullException("blobClient");
}
if (repositories == null)
{
throw new ArgumentNullException("repositories");
}
BlobClient = blobClient;
RepositoryContainer = repositories;
ServiceOfferingRepository = repositories.Obtain<IServiceOfferingRepository>();
StudentRepository = repositories.Obtain<IStudentRepository>();
StudentAssignedOfferingRepository = repositories.Obtain<IStudentAssignedOfferingRepository>();
SubjectRepository = repositories.Obtain<ISubjectRepository>();
ServiceAttendanceRepository = repositories.Obtain<IServiceAttendanceRepository>();
}
public ServiceAttendanceFileProcessor(IBlobClient blobClient, IRepositoryContainer repositories)
: base(blobClient, repositories)
{
}
public StorageManager(ITableClient tables, IBlobClient blobs)
{
_tables = tables;
}
public void SetBlobClient(IBlobClient blobClient)
{
_blobClient = blobClient;
}
public PublicFieldManager(IRepositoryContainer repositories, IBlobClient blobClient, IDataTableBinder dataTableBinder, IUserAuditor auditor)
: base(repositories, blobClient, dataTableBinder, auditor)
{
}
public ServiceOfferingFileProcessor(IBlobClient blobClient, IRepositoryContainer repositories)
: base(blobClient, repositories)
{
}
public PrivateHealthFieldManager(IRepositoryContainer repositories, IBlobClient blobClient, IDataTableBinder dataTableBinder, IUserAuditor auditor)
: base(repositories, blobClient, dataTableBinder, auditor)
{
ProviderRepository = repositories.Obtain<IProviderRepository>();
}
private void DeleteDataDisks(IBlobClient client)
{
// delete the data disks in the reverse order
if (_vmRole.HardDisks.HardDiskCollection == null) return;
for (int i = _vmRole.HardDisks.HardDiskCollection.Count - 1; i >= 0; i--)
{
var dataDiskCommand = new DeleteVirtualMachineDiskCommand(_vmRole.HardDisks.HardDiskCollection[i].DiskName)
{
SubscriptionId = Properties.SubscriptionId,
Certificate = Properties.Certificate
};
dataDiskCommand.Execute();
int pos = _vmRole.HardDisks.HardDiskCollection[i].MediaLink.LastIndexOf('/');
string diskFile = _vmRole.HardDisks.HardDiskCollection[i].MediaLink.Substring(pos + 1);
if(client != null)
client.DeleteBlob(diskFile);
}
}
