Example #1
0
        public DataFactoryFunctionUnitTest()
        {
            _loggerMock = new Mock <ILogger>();
            _durableOrchestrationClientMock = new Mock <IDurableOrchestrationClient>();
            _durableOrchestrationContext    = new Mock <IDurableOrchestrationContext>();
            _dataFactoryRepositoryMock      = new Mock <IDataFactoryRepository>();
            _dfAccess = new DataFactoryAccess(AccessToken, DataFactoryName);

            _dataFactoryRepositoryMock
            .Setup(_ => _.CreateAccessToken())
            .ReturnsAsync(AccessToken);

            _durableOrchestrationClientMock
            .Setup(_ => _.StartNewAsync(OrchestratorFunctionName, InstanceId, It.IsAny <object>()))
            .ReturnsAsync(InstanceId);

            _durableOrchestrationClientMock
            .Setup(_ =>
                   _.CreateCheckStatusResponse(It.IsAny <HttpRequestMessage>(), InstanceId, false))
            .Returns(HttpResponseMessage());

            _durableOrchestrationContext
            .Setup(_ => _.CallActivityAsync <string>(CreateDataFactoryFunctionName, _dfAccess))
            .ReturnsAsync(AccessToken);


            _dataFactoryFunction = new DataFactoryFunction(_dataFactoryRepositoryMock.Object);
        }
        public bool IsPipelineRunInProgressOrQueued(DataFactoryAccess dfAccess, string runId)
        {
            var pipelineRun = _client.PipelineRuns.Get(_resourceGroup, dfAccess.Name, runId);

            if (pipelineRun.Status == ErrorPipelineStatus)
            {
                throw new ApplicationException(ErrorPipelineStatus);
            }
            return(pipelineRun.Status == InProgressPipelineStatus || pipelineRun.Status == QueuedPipelineStatus);
        }
 public object GetCopyActivityOutput(DataFactoryAccess dfAccess, string runId) =>
 _client.ActivityRuns.QueryByPipelineRun(_resourceGroup, dfAccess.Name, runId, _parameters.FilterParameters()).Value.First().Output;
 public async Task <string> CreatePipelineRunId(DataFactoryAccess dfAccess) =>
 (await _client.Pipelines.CreateRunWithHttpMessagesAsync(
      _resourceGroup, dfAccess.Name, _pipeline, parameters: _parameters.CreatePipelineParameters()
      )).Body.RunId;
 public void CreatePipeline(DataFactoryAccess dfAccess) =>
 _client.Pipelines.CreateOrUpdate(_resourceGroup, dfAccess.Name, _pipeline, _parameters.CreatePipelineResource());
 public void CreateDataSet(DataFactoryAccess dfAccess) =>
 _client.Datasets.CreateOrUpdate(_resourceGroup, dfAccess.Name, _dataset, _parameters.CreateDatasetResource());
 public async Task <LinkedServiceResource> CreateLinkedService(DataFactoryAccess dfAccess) =>
 await _parameters.CreateDataFactoryManagementClient(dfAccess.Token)
 .LinkedServices.CreateOrUpdateAsync(_resourceGroup, dfAccess.Name, _storage,
                                     _parameters.LinkedServiceResource());
 public async Task <bool> IsPendingCreation(DataFactoryAccess dfAccess) =>
 (await _parameters.CreateDataFactoryManagementClient(dfAccess.Token)
  .Factories.GetAsync(_resourceGroup, dfAccess.Name))
 .ProvisioningState == PendingCreationProvisioningState;
 public async Task <Factory> CreateDataFactory(DataFactoryAccess dfAccess) =>
 await _parameters.CreateDataFactoryManagementClient(dfAccess.Token)
 .Factories.CreateOrUpdateAsync(_resourceGroup, dfAccess.Name, _parameters.DataFactory());