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 DefinitionSpecificationRelationshipService(IDatasetRepository datasetRepository,
ILogger logger,
ISpecificationsApiClient specificationsApiClient,
IValidator <CreateDefinitionSpecificationRelationshipModel> relationshipModelValidator,
IMessengerService messengerService,
ICalcsRepository calcsRepository,
ICacheProvider cacheProvider,
IDatasetsResiliencePolicies datasetsResiliencePolicies,
IJobManagement jobManagement,
IDateTimeProvider dateTimeProvider)
{
Guard.ArgumentNotNull(dateTimeProvider, nameof(dateTimeProvider));
Guard.ArgumentNotNull(datasetRepository, nameof(datasetRepository));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(specificationsApiClient, nameof(specificationsApiClient));
Guard.ArgumentNotNull(relationshipModelValidator, nameof(relationshipModelValidator));
Guard.ArgumentNotNull(messengerService, nameof(messengerService));
Guard.ArgumentNotNull(calcsRepository, nameof(calcsRepository));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(jobManagement, nameof(jobManagement));
Guard.ArgumentNotNull(datasetsResiliencePolicies?.SpecificationsApiClient, nameof(datasetsResiliencePolicies.SpecificationsApiClient));
_datasetRepository = datasetRepository;
_logger = logger;
_specificationsApiClient = specificationsApiClient;
_relationshipModelValidator = relationshipModelValidator;
_messengerService = messengerService;
_calcsRepository = calcsRepository;
_cacheProvider = cacheProvider;
_jobManagement = jobManagement;
_dateTimeProvider = dateTimeProvider;
_specificationsApiClientPolicy = datasetsResiliencePolicies.SpecificationsApiClient;
_typeIdentifierGenerator = new VisualBasicTypeIdentifierGenerator();
}
async public Task GetDatasetDefinitions_GivenDefinitionsRequestedButContainsResults_ReturnsArray()
{
//Arrange
HttpRequest request = Substitute.For <HttpRequest>();
IEnumerable <DatasetDefinition> definitions = new[]
{
new DatasetDefinition(), new DatasetDefinition()
};
IDatasetRepository repository = CreateDataSetsRepository();
repository
.GetDatasetDefinitions()
.Returns(definitions);
DefinitionsService service = CreateDefinitionsService(datasetsRepository: repository);
//Act
IActionResult result = await service.GetDatasetDefinitions(request);
//Assert
result
.Should()
.BeOfType <OkObjectResult>();
OkObjectResult objResult = (OkObjectResult)result;
IEnumerable <DatasetDefinition> objValue = (IEnumerable <DatasetDefinition>)objResult.Value;
objValue
.Count()
.Should()
.Be(2);
}
public void Validate_GivenNameAlreadyExists_ValidIsFalse()
{
//Arrange
CreateNewDatasetModel model = CreateModel();
IEnumerable <Dataset> datasets = new[]
{
new Dataset()
};
IDatasetRepository repository = CreateDatasetsRepository(true, true);
repository
.GetDatasetsByQuery(Arg.Any <Expression <Func <DocumentEntity <Dataset>, bool> > >())
.Returns(datasets);
CreateNewDatasetModelValidator validator = CreateValidator(repository);
//Act
ValidationResult result = validator.Validate(model);
//Assert
result
.IsValid
.Should()
.BeFalse();
result
.Errors
.Count
.Should()
.Be(1);
}
public ChartControllerTest()
{
Mock <IDatasetRepository> mockDatasetRepository = new Mock <IDatasetRepository>();
mockDatasetRepository
.Setup(repo => repo.GetUsersAsync("datasetId"))
.Returns(Task.FromResult(new List <User>()
{
new User()
{
Id = "1"
},
new User()
{
Id = "2"
}
}));
mockDatasetRepository
.Setup(repo => repo.GetFriendshipsAsync("datasetId"))
.Returns(Task.FromResult(new List <Friendship>()
{
new Friendship()
{
UserOne = "1",
UserTwo = "2"
},
}));
datasetRepository = mockDatasetRepository.Object;
}
public DatasetDefinitionValidator(
IPolicyRepository policyRepository,
IDatasetRepository datasetRepository,
IDatasetsResiliencePolicies datasetsResiliencePolicies)
{
_policyRepository = policyRepository;
_datasetRepository = datasetRepository;
_datasetsRepositoryPolicy = datasetsResiliencePolicies.DatasetRepository;
_typeIdentifierGenerator = new VisualBasicTypeIdentifierGenerator();
RuleFor(model => model.FundingStreamId)
.CustomAsync(async(name, context, ct) =>
{
DatasetDefinition model = context.ParentContext.InstanceToValidate as DatasetDefinition;
if (string.IsNullOrWhiteSpace(model.FundingStreamId))
{
context.AddFailure("You must give a Funding Stream Id for the dataset");
}
else
{
IEnumerable <PoliciesApiModels.FundingStream> fundingStreams = _policyRepository.GetFundingStreams().Result;
if (fundingStreams != null && !fundingStreams.Any(_ => _.Id == model.FundingStreamId))
{
context.AddFailure($"Unable to find given funding stream ID: {model.FundingStreamId}");
}
}
bool datasetWithGivenNameExists =
await _datasetsRepositoryPolicy.ExecuteAsync(() => _datasetRepository.DatasetExistsWithGivenName(model.Name, model.Id));
if (datasetWithGivenNameExists)
{
context.AddFailure($"Given dataset name already exists in repository: {model.Name}");
}
IDictionary <string, string> fieldIdentifierNameMap = new Dictionary <string, string>();
IEnumerable <FieldDefinition> fieldDefinitions = model.TableDefinitions?.SelectMany(_ => _.FieldDefinitions);
if (fieldDefinitions != null)
{
foreach (FieldDefinition fieldDefinition in fieldDefinitions)
{
string fieldDefinitionNameIdentifier = _typeIdentifierGenerator.GenerateIdentifier(fieldDefinition.Name);
if (fieldIdentifierNameMap.ContainsKey(fieldDefinitionNameIdentifier))
{
context.AddFailure($"Given field definition name matches another field definition name. " +
$"{fieldIdentifierNameMap[fieldDefinitionNameIdentifier]} and {fieldDefinition.Name}");
}
else
{
fieldIdentifierNameMap.Add(fieldDefinitionNameIdentifier, fieldDefinition.Name);
}
}
}
});
}
public DatasetService(IUnitOfWork unitOfWork, IUserService userService, IDatasetGuard guard, IDatasetMapper mapper)
: base(unitOfWork, userService)
{
_repository = unitOfWork.DatasetRepository;
_guard = guard;
_mapper = mapper;
}
public StatisticController(
IDatasetRepository datasetRepository,
IStatisticService statisticService
)
{
_datasetRepository = datasetRepository;
_statisticService = statisticService;
}
static CreateNewDatasetModelValidator CreateValidator(
IDatasetRepository datasetsRepository = null,
IPolicyRepository policyRepository = null)
{
return(new CreateNewDatasetModelValidator(
datasetsRepository ?? CreateDatasetsRepository(false, true),
policyRepository ?? CreatePolicyRepository()));
}
public DistributionService(IDistributionRepository distributionRepository, IDatasetRepository datasetRepository, INotificationService notificationService, IUnitOfWork unitOfWork, IMemoryCache cache)
{
_distributionRepository = distributionRepository;
_datasetRepository = datasetRepository;
_notificationService = notificationService;
_unitOfWork = unitOfWork;
_cache = cache;
}
public void ProcessChanges_GivenChangeModelWithFieldNameChangesButNoRelationshipsFound_ThrowsRetriableException()
{
//Arrange
string definitionId = "df-id-1";
string specificationId = "spec-1";
DatasetDefinitionChanges datasetDefinitionChanges = new DatasetDefinitionChanges
{
Id = definitionId,
};
FieldDefinitionChanges fieldDefinitionChanges = new FieldDefinitionChanges
{
FieldDefinition = new FieldDefinition
{
Id = "field1"
}
};
fieldDefinitionChanges.ChangeTypes.Add(FieldDefinitionChangeType.FieldName);
TableDefinitionChanges tableDefinitionChanges = new TableDefinitionChanges();
tableDefinitionChanges.FieldChanges.Add(fieldDefinitionChanges);
datasetDefinitionChanges.TableDefinitionChanges.Add(tableDefinitionChanges);
string json = JsonConvert.SerializeObject(datasetDefinitionChanges);
Message message = new Message(Encoding.UTF8.GetBytes(json));
ILogger logger = CreateLogger();
IEnumerable <string> relationshipSpecificationIds = new[] { specificationId };
IDatasetRepository datasetRepository = CreateDatasetRepository();
datasetRepository
.GetRelationshipSpecificationIdsByDatasetDefinitionId(Arg.Is(definitionId))
.Returns(relationshipSpecificationIds);
datasetRepository
.GetCurrentRelationshipsBySpecificationIdAndDatasetDefinitionId(Arg.Is(specificationId), Arg.Is(definitionId))
.Returns(Enumerable.Empty <DatasetSpecificationRelationshipViewModel>());
DatasetDefinitionFieldChangesProcessor processor = CreateProcessor(logger: logger, datasetRepository: datasetRepository);
//Act
Func <Task> test = async() => await processor.ProcessChanges(message);
//Assert
test
.Should()
.ThrowExactly <RetriableException>()
.Which
.Message
.Should()
.Be($"No relationships found for specificationId '{specificationId}' and dataset definition id '{definitionId}'");
}
public ApplicationService(IApplicationRepository ApplicationRepository, INotificationService notificationService, IPublisherRepository publisherRepository, IDatasetRepository datasetRepository, IUnitOfWork unitOfWork, ICoordinationRepository CoordinationRepository)
{
_applicationRepository = ApplicationRepository;
_coordinationRepository = CoordinationRepository;
_publisherRepository = publisherRepository;
_datasetRepository = datasetRepository;
_notificationService = notificationService;
_unitOfWork = unitOfWork;
}
public CustomDatasetService(IUnitOfWork unit, ICustomDatasetRepository customDatasetRepository,
IDatasetRepository datasetRepository, IFieldTypeRepository typesRepository, IMapperFactory mapperFactory)
{
_uow = unit;
_customDatasetRepository = customDatasetRepository;
_datasetRepository = datasetRepository;
_typesRepository = typesRepository;
_mapper = mapperFactory.GetMapper(typeof(CoreServices).Name);
}
async public Task SaveDefinition_GivenValidYamlButSavingToDatabaseThrowsException_ReturnsInternalServerError()
{
//Arrange
string yaml = CreateRawDefinition();
byte[] byteArray = Encoding.UTF8.GetBytes(yaml);
MemoryStream stream = new MemoryStream(byteArray);
IHeaderDictionary headerDictionary = new HeaderDictionary();
headerDictionary
.Add("yaml-file", new StringValues(yamlFile));
HttpRequest request = Substitute.For <HttpRequest>();
request
.Headers
.Returns(headerDictionary);
request
.Body
.Returns(stream);
ILogger logger = CreateLogger();
IDatasetRepository dataSetsRepository = CreateDataSetsRepository();
dataSetsRepository
.When(x => x.SaveDefinition(Arg.Any <DatasetDefinition>()))
.Do(x => { throw new Exception(); });
DatasetDefinitionChanges datasetDefinitionChanges = new DatasetDefinitionChanges();
IDefinitionChangesDetectionService definitionChangesDetectionService = CreateChangesDetectionService();
definitionChangesDetectionService
.DetectChanges(Arg.Any <DatasetDefinition>(), Arg.Any <DatasetDefinition>())
.Returns(datasetDefinitionChanges);
DefinitionsService service = CreateDefinitionsService(logger, dataSetsRepository, definitionChangesDetectionService: definitionChangesDetectionService);
//Act
IActionResult result = await service.SaveDefinition(request);
//Assert
result
.Should()
.BeOfType <InternalServerErrorResult>()
.Which
.Value
.Should()
.Be("Exception occurred writing to yaml file: 12345.yaml to cosmos db");
logger
.Received(1)
.Error(Arg.Any <Exception>(), Arg.Is($"Exception occurred writing to yaml file: {yamlFile} to cosmos db"));
}
public DefinedDatasetService(IUnitOfWork unit, IDefinedDatasetRepository definedDatasetRepository,
IDatasetRepository datasetRepository, IFieldTypeRepository feFieldTypeRepository, IMapperFactory mapperFactory)
{
_uow = unit;
_definedDatasetRepository = definedDatasetRepository;
_datasetRepository = datasetRepository;
_fieldTypeRepository = feFieldTypeRepository;
_mapper = mapperFactory.GetMapper(typeof(CoreServices).Name);
}
static IDatasetRepository CreateDatasetsRepository(bool hasDataset = false)
{
IDatasetRepository repository = Substitute.For <IDatasetRepository>();
repository
.GetDatasetsByQuery(Arg.Any <Expression <Func <Dataset, bool> > >())
.Returns(hasDataset ? new[] { new Dataset() } : new Dataset[0]);
return(repository);
}
static IDatasetRepository CreateDatasetRepository()
{
IDatasetRepository repository = Substitute.For <IDatasetRepository>();
repository
.DatasetExistsWithGivenName(DatasetDefinitionName, DatasetDefinitionId)
.Returns(true);
return(repository);
}
public UserService(IUserRepository userRepository, IPublisherRepository publisherRepository, IDatasetRepository datasetRepository, ICoordinationRepository coordinationRepository, INotificationService notificationService, IUnitOfWork unitOfWork, IMemoryCache cache)
{
_userRepository = userRepository;
_publisherRepository = publisherRepository;
_datasetRepository = datasetRepository;
_coordinationRepository = coordinationRepository;
_notificationService = notificationService;
_unitOfWork = unitOfWork;
_cache = cache;
}
public GraphService(IDatasetRepository datasetRepository, IDatasetService datasetService, IDistributionRepository distributionRepository, IPublisherRepository publisherRepository, ICategoryRepository categoryRepository, ITagsRepository tagsRepository, IUnitOfWork unitOfWork)
{
_datasetRepository = datasetRepository;
_distributionRepository = distributionRepository;
_publisherRepository = publisherRepository;
_categoryRepository = categoryRepository;
_tagsRepository = tagsRepository;
_unitOfWork = unitOfWork;
_datasetService = datasetService;
}
static IDatasetRepository CreateDatasetRepository(bool isValid = true)
{
IDatasetRepository repository = Substitute.For <IDatasetRepository>();
repository
.GetRelationshipBySpecificationIdAndName(Arg.Is("spec-id"), Arg.Is("test name"))
.Returns(isValid ? (DefinitionSpecificationRelationship)null: new DefinitionSpecificationRelationship());
return(repository);
}
public DatasetService(IDatasetRepository repository,
IArchiveRepository archiveRepository,
IDatasetValidateProcessorFactory datasetValidateProcessorFactory)
{
_repository = repository
?? throw new ArgumentNullException(nameof(repository));
_archiveRepository = archiveRepository
?? throw new ArgumentNullException(nameof(archiveRepository));
_datasetValidateProcessorFactory = datasetValidateProcessorFactory
?? throw new ArgumentNullException(nameof(datasetValidateProcessorFactory));
}
public DatasetService(IDatasetRepository datasetRepository, INotificationService notificationService, IPublisherRepository publisherRepository, ICategoryRepository categoryRepository, ICoordinationRepository coordinationRepository, ITagsRepository tagsRepository, IUnitOfWork unitOfWork, IMemoryCache cache, IGitlabService gitlabService)
{
_datasetRepository = datasetRepository;
_publisherRepository = publisherRepository;
_categoryRepository = categoryRepository;
_coordinationRepository = coordinationRepository;
_tagsRepository = tagsRepository;
_unitOfWork = unitOfWork;
_notificationService = notificationService;
_cache = cache;
_gitlabService = gitlabService;
}
static DatasetDefinitionValidator CreateValidator(
IPolicyRepository policyRepository = null,
IDatasetRepository datasetRepository = null)
{
return(new DatasetDefinitionValidator(
policyRepository ?? CreatePolicyRepository(),
datasetRepository ?? CreateDatasetRepository(),
new DatasetsResiliencePolicies
{
DatasetRepository = Policy.NoOpAsync()
}));
}
private static DatasetDefinitionFieldChangesProcessor CreateProcessor(
IFeatureToggle featureToggle = null,
IDatasetRepository datasetRepository = null,
ILogger logger = null,
IScenariosService scenariosService = null)
{
return(new DatasetDefinitionFieldChangesProcessor(
featureToggle ?? CreateFeatureToggle(),
logger ?? CreateLogger(),
datasetRepository ?? CreateDatasetRepository(),
ScenariosResilienceTestHelper.GenerateTestPolicies(),
scenariosService ?? CreateScenariosService()));
}
public async Task RegenerateProviderSourceDatasets_GivenSpecificationId_ThenCallJobServiceToProcess()
{
// Arrange
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(SpecificationId) },
});
HttpRequest request = Substitute.For <HttpRequest>();
request.Query.Returns(queryStringValues);
IDatasetRepository datasetRepository = CreateDatasetsRepository();
datasetRepository
.GetDefinitionSpecificationRelationshipsByQuery(Arg.Any <Expression <Func <DefinitionSpecificationRelationship, bool> > >())
.Returns(new List <DefinitionSpecificationRelationship>
{
new DefinitionSpecificationRelationship {
DatasetVersion = new DatasetRelationshipVersion {
Id = "DSRV1", Version = 1
},
Specification = new Common.Models.Reference {
Id = SpecificationId, Name = "SpecAbc"
}
}
});
datasetRepository
.GetDatasetsByQuery(Arg.Any <Expression <Func <Dataset, bool> > >())
.Returns(new List <Dataset>
{
new Dataset {
Id = "DS1"
}
});
IJobsApiClient jobsApiClient = CreateJobsApiClient();
DatasetService service = CreateDatasetService(datasetRepository: datasetRepository, jobsApiClient: jobsApiClient);
// Act
await service.RegenerateProviderSourceDatasets(request);
// Assert
await jobsApiClient
.Received(1)
.CreateJob(Arg.Is <JobCreateModel>(j =>
j.JobDefinitionId == "MapDatasetJob" &&
j.Properties.ContainsKey("session-id") &&
j.Properties["session-id"] == SpecificationId));
}
/// <summary>
/// Initializes a new instance of the <see cref="GlobalDatasetLookup"/> class.
/// </summary>
/// <param name="domainTransactions">The domain transactions.</param>
/// <param name="datasetRepository">The dataset repository</param>
/// <param name="associationRepository">The association repository</param>
/// <param name="currentModelContext">The _current model context.</param>
public GlobalDatasetLookup([NotNull] IDomainTransactionManager domainTransactions,
[NotNull] IDatasetRepository datasetRepository,
[NotNull] IAssociationRepository associationRepository,
[CanBeNull] ICurrentModelContext currentModelContext)
{
Assert.ArgumentNotNull(domainTransactions, nameof(domainTransactions));
Assert.ArgumentNotNull(datasetRepository, nameof(datasetRepository));
Assert.ArgumentNotNull(associationRepository, nameof(associationRepository));
_domainTransactions = domainTransactions;
_datasetRepository = datasetRepository;
_associationRepository = associationRepository;
_currentModelContext = currentModelContext;
}
public ProcessDatasetService(
IDatasetRepository datasetRepository,
IExcelDatasetReader excelDatasetReader,
ICacheProvider cacheProvider,
ICalcsRepository calcsRepository,
IBlobClient blobClient,
IMessengerService messengerService,
IProvidersResultsRepository providersResultsRepository,
IResultsRepository resultsRepository,
IProviderService providerService,
IVersionRepository <ProviderSourceDatasetVersion> sourceDatasetsVersionRepository,
ILogger logger,
ITelemetry telemetry,
IDatasetsResiliencePolicies datasetsResiliencePolicies,
IDatasetsAggregationsRepository datasetsAggregationsRepository,
IFeatureToggle featureToggle,
IJobsApiClient jobsApiClient)
{
Guard.ArgumentNotNull(datasetRepository, nameof(datasetRepository));
Guard.ArgumentNotNull(excelDatasetReader, nameof(excelDatasetReader));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(messengerService, nameof(messengerService));
Guard.ArgumentNotNull(calcsRepository, nameof(calcsRepository));
Guard.ArgumentNotNull(providersResultsRepository, nameof(providersResultsRepository));
Guard.ArgumentNotNull(resultsRepository, nameof(resultsRepository));
Guard.ArgumentNotNull(providerService, nameof(providerService));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(telemetry, nameof(telemetry));
Guard.ArgumentNotNull(datasetsAggregationsRepository, nameof(datasetsAggregationsRepository));
Guard.ArgumentNotNull(featureToggle, nameof(featureToggle));
Guard.ArgumentNotNull(jobsApiClient, nameof(jobsApiClient));
_datasetRepository = datasetRepository;
_excelDatasetReader = excelDatasetReader;
_cacheProvider = cacheProvider;
_calcsRepository = calcsRepository;
_blobClient = blobClient;
_providersResultsRepository = providersResultsRepository;
_resultsRepository = resultsRepository;
_providerService = providerService;
_sourceDatasetsVersionRepository = sourceDatasetsVersionRepository;
_logger = logger;
_telemetry = telemetry;
_providerResultsRepositoryPolicy = datasetsResiliencePolicies.ProviderResultsRepository;
_datasetsAggregationsRepository = datasetsAggregationsRepository;
_featureToggle = featureToggle;
_jobsApiClient = jobsApiClient;
_jobsApiClientPolicy = datasetsResiliencePolicies.JobsApiClient;
_messengerService = messengerService;
}
public void SetupTest()
{
_logger = Substitute.For <ILogger>();
_calculationRepository = Substitute.For <ICalculationRepository>();
_specificationRepository = Substitute.For <ISpecificationRepository>();
_datasetRepository = Substitute.For <IDatasetRepository>();
_fundingLineRepository = Substitute.For <IFundingLineRepository>();
_graphService = new GraphService(_logger,
_calculationRepository,
_specificationRepository,
_datasetRepository,
_fundingLineRepository);
}
public DatasetService(
IDatasetRepository datasetRepository,
IUserFriendRepository userFriendRepository,
IUserRepository userRepository,
IUserDatasetRepository userDatasetRepository,
IStringUtilAdapter stringUtilAdapter
)
{
fDatasetRepository = datasetRepository;
fUserDatasetRepository = userDatasetRepository;
fUserFriendRepository = userFriendRepository;
fUserRepository = userRepository;
fStringUtilAdapter = stringUtilAdapter;
}
public async Task GetDatasetSchemaSasUrl_GivenModelAndDatasetNameContainsSlashes_ReplacesSlashesWithUnderscoreAndReturnsUrl()
{
// Arrange
DatasetSchemaSasUrlRequestModel model = new DatasetSchemaSasUrlRequestModel
{
DatasetDefinitionId = "12345"
};
string json = JsonConvert.SerializeObject(model);
byte[] byteArray = Encoding.UTF8.GetBytes(json);
MemoryStream stream = new MemoryStream(byteArray);
HttpRequest request = Substitute.For <HttpRequest>();
request
.Body
.Returns(stream);
IBlobClient blobClient = CreateBlobClient();
DatasetDefinition datasetDefinition = new DatasetDefinition()
{
Id = "12345",
Name = "TEST/SLASH Definition",
};
IDatasetRepository datasetRepository = CreateDataSetsRepository();
datasetRepository
.GetDatasetDefinition(Arg.Is(model.DatasetDefinitionId))
.Returns(datasetDefinition);
DefinitionsService definitionsService = CreateDefinitionsService(
datasetsRepository: datasetRepository,
blobClient: blobClient);
// Act
IActionResult result = await definitionsService.GetDatasetSchemaSasUrl(request);
// Assert
result
.Should()
.BeOfType <OkObjectResult>();
blobClient
.Received(1)
.GetBlobSasUrl(Arg.Is("schemas/TEST_SLASH Definition.xlsx"), Arg.Any <DateTimeOffset>(), Arg.Any <SharedAccessBlobPermissions>());
}
