public void ExecuteAsync_IfInnerExecutorFails_ReturnsFailureResult() { // Arrange string functionId = "FunctionId"; string matchingETag = "ETag"; IBlobETagReader eTagReader = CreateStubETagReader(matchingETag); IBlobCausalityReader causalityReader = CreateStubCausalityReader(); FunctionResult expectedResult = new FunctionResult(false); Mock <ITriggeredFunctionExecutor> mock = new Mock <ITriggeredFunctionExecutor>(MockBehavior.Strict); mock.Setup(e => e.TryExecuteAsync( It.IsAny <TriggeredFunctionData>(), It.IsAny <CancellationToken>())) .ReturnsAsync(expectedResult) .Verifiable(); BlobQueueTriggerExecutor product = CreateProductUnderTest(eTagReader, causalityReader); ITriggeredFunctionExecutor innerExecutor = mock.Object; product.Register(functionId, innerExecutor); IStorageQueueMessage message = CreateMessage(functionId, matchingETag); // Act Task <FunctionResult> task = product.ExecuteAsync(message, CancellationToken.None); // Assert Assert.False(task.Result.Succeeded); }
public void ExecuteAsync_IfMessageIsFunctionIdIsRegistered_GetsETag(BlobType expectedBlobType) { // Arrange string expectedContainerName = "container"; string expectedBlobName = TestBlobName; string functionId = "FunctionId"; Mock <IBlobETagReader> mock = new Mock <IBlobETagReader>(MockBehavior.Strict); mock.Setup(r => r.GetETagAsync(It.Is <IStorageBlob>(b => b.BlobType == (StorageBlobType)expectedBlobType && b.Name == expectedBlobName && b.Container.Name == expectedContainerName), It.IsAny <CancellationToken>())) .Returns(Task.FromResult("ETag")) .Verifiable(); IBlobETagReader eTagReader = mock.Object; BlobQueueTriggerExecutor product = CreateProductUnderTest(eTagReader); product.Register(functionId, CreateDummyTriggeredFunctionExecutor()); BlobTriggerMessage triggerMessage = new BlobTriggerMessage { FunctionId = functionId, BlobType = (StorageBlobType)expectedBlobType, ContainerName = expectedContainerName, BlobName = expectedBlobName, ETag = "OriginalETag" }; IStorageQueueMessage message = CreateMessage(triggerMessage); // Act Task task = product.ExecuteAsync(message, CancellationToken.None); // Assert task.WaitUntilCompleted(); mock.Verify(); }
public void ExecuteAsync_IfBlobHasChanged_NotifiesWatcherAndReturnsSuccessResult() { // Arrange string functionId = "FunctionId"; IBlobETagReader eTagReader = CreateStubETagReader("NewETag"); Mock <IBlobWrittenWatcher> mock = new Mock <IBlobWrittenWatcher>(MockBehavior.Strict); mock.Setup(w => w.Notify(It.IsAny <IStorageBlob>())) .Verifiable(); IBlobWrittenWatcher blobWrittenWatcher = mock.Object; BlobQueueTriggerExecutor product = CreateProductUnderTest(eTagReader, blobWrittenWatcher); BlobQueueRegistration registration = new BlobQueueRegistration { BlobClient = CreateClient(), Executor = CreateDummyTriggeredFunctionExecutor() }; product.Register(functionId, registration); IStorageQueueMessage message = CreateMessage(functionId, "OriginalETag"); // Act Task <FunctionResult> task = product.ExecuteAsync(message, CancellationToken.None); // Assert task.WaitUntilCompleted(); mock.Verify(); Assert.True(task.Result.Succeeded); }
public void ExecuteAsync_IfLeasedReceiptBecameCompleted_ReleasesLeaseAndReturnsTrue() { // Arrange IStorageBlob blob = CreateBlobReference(); IBlobPathSource input = CreateBlobPath(blob); IBlobETagReader eTagReader = CreateStubETagReader("ETag"); Mock <IBlobReceiptManager> mock = CreateReceiptManagerReferenceMock(); int calls = 0; mock.Setup(m => m.TryReadAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <CancellationToken>())) .Returns(() => { int call = calls++; return(Task.FromResult(call == 0 ? BlobReceipt.Incomplete : BlobReceipt.Complete)); }); mock.Setup(m => m.TryAcquireLeaseAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult("LeaseId")); mock.Setup(m => m.ReleaseLeaseAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <string>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult(0)) .Verifiable(); IBlobReceiptManager receiptManager = mock.Object; ITriggerExecutor <IStorageBlob> product = CreateProductUnderTest(input, eTagReader, receiptManager); // Act Task <bool> task = product.ExecuteAsync(blob, CancellationToken.None); // Assert task.WaitUntilCompleted(); mock.Verify(); Assert.True(task.Result); }
public void ExecuteAsync_IfTryAcquireLeaseSucceeds_ReadsLatestReceipt() { // Arrange IStorageBlob blob = CreateBlobReference(); IBlobPathSource input = CreateBlobPath(blob); IBlobETagReader eTagReader = CreateStubETagReader("ETag"); Mock <IBlobReceiptManager> mock = CreateReceiptManagerReferenceMock(); int calls = 0; mock.Setup(m => m.TryReadAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <CancellationToken>())) .Returns(() => { return(Task.FromResult(calls++ == 0 ? BlobReceipt.Incomplete : BlobReceipt.Complete)); }); mock.Setup(m => m.TryAcquireLeaseAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult("LeaseId")); mock.Setup(m => m.ReleaseLeaseAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <string>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult(0)); IBlobReceiptManager receiptManager = mock.Object; ITriggerExecutor <IStorageBlob> product = CreateProductUnderTest(input, eTagReader, receiptManager); // Act Task <bool> task = product.ExecuteAsync(blob, CancellationToken.None); // Assert task.GetAwaiter().GetResult(); Assert.Equal(2, calls); }
public void ExecuteAsync_IfBlobIsUnchanged_CallsInnerExecutor() { // Arrange string functionId = "FunctionId"; string matchingETag = "ETag"; Guid expectedParentId = Guid.NewGuid(); IBlobETagReader eTagReader = CreateStubETagReader(matchingETag); IBlobCausalityReader causalityReader = CreateStubCausalityReader(expectedParentId); Mock <IFunctionExecutor> mock = new Mock <IFunctionExecutor>(MockBehavior.Strict); mock.Setup(e => e.TryExecuteAsync(It.Is <IFunctionInstance>(f => f.ParentId == expectedParentId), It.IsAny <CancellationToken>())) .Returns(Task.FromResult <IDelayedException>(null)) .Verifiable(); IFunctionExecutor innerExecutor = mock.Object; BlobQueueTriggerExecutor product = CreateProductUnderTest(eTagReader, causalityReader, innerExecutor); product.Register(functionId, CreateFakeInstanceFactory()); IStorageQueueMessage message = CreateMessage(functionId, matchingETag); // Act Task <bool> task = product.ExecuteAsync(message, CancellationToken.None); // Assert task.WaitUntilCompleted(); mock.Verify(); }
public void ExecuteAsync_IfIncompleteBlobReceiptExists_TriesToAcquireLease() { // Arrange IStorageBlob blob = CreateBlobReference(); IBlobPathSource input = CreateBlobPath(blob); IBlobETagReader eTagReader = CreateStubETagReader("ETag"); Mock <IBlobReceiptManager> mock = CreateReceiptManagerReferenceMock(); mock.Setup(m => m.TryReadAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult(BlobReceipt.Incomplete)); mock.Setup(m => m.TryAcquireLeaseAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult <string>(null)) .Verifiable(); IBlobReceiptManager receiptManager = mock.Object; ITriggerExecutor <IStorageBlob> product = CreateProductUnderTest(input, eTagReader, receiptManager); // Act Task <bool> task = product.ExecuteAsync(blob, CancellationToken.None); // Assert task.GetAwaiter().GetResult(); mock.Verify(); }
private static BlobQueueTriggerExecutor CreateProductUnderTest(IBlobETagReader eTagReader, IBlobCausalityReader causalityReader, IBlobWrittenWatcher blobWrittenWatcher) { IStorageBlobClient client = CreateClient(); return(new BlobQueueTriggerExecutor(client, eTagReader, causalityReader, blobWrittenWatcher)); }
public void ExecuteAsync_IfBlobReceiptDoesNotExist_TriesToCreateReceipt() { // Arrange ICloudBlob blob = CreateBlobReference(); IBlobPathSource input = CreateBlobPath(blob); IBlobETagReader eTagReader = CreateStubETagReader("ETag"); Mock <IBlobReceiptManager> mock = CreateReceiptManagerReferenceMock(); mock.Setup(m => m.TryReadAsync(It.IsAny <CloudBlockBlob>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult <BlobReceipt>(null)); mock.Setup(m => m.TryCreateAsync(It.IsAny <CloudBlockBlob>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult(false)) .Verifiable(); IBlobReceiptManager receiptManager = mock.Object; ITriggerExecutor <ICloudBlob> product = CreateProductUnderTest(input, eTagReader, receiptManager); // Act Task <FunctionResult> task = product.ExecuteAsync(blob, CancellationToken.None); // Assert task.GetAwaiter().GetResult(); mock.Verify(); }
public BlobQueueTriggerExecutor(IBlobETagReader eTagReader, IBlobCausalityReader causalityReader, IBlobWrittenWatcher blobWrittenWatcher) { _eTagReader = eTagReader; _causalityReader = causalityReader; _blobWrittenWatcher = blobWrittenWatcher; _registrations = new ConcurrentDictionary <string, BlobQueueRegistration>(); }
private static BlobQueueTriggerExecutor CreateProductUnderTest(IBlobETagReader eTagReader, IBlobWrittenWatcher blobWrittenWatcher) { IBlobCausalityReader causalityReader = CreateDummyCausalityReader(); IFunctionExecutor innerExecutor = CreateDummyInnerExecutor(); return(CreateProductUnderTest(eTagReader, causalityReader, innerExecutor, blobWrittenWatcher)); }
public BlobQueueTriggerExecutor(IStorageBlobClient client, IBlobETagReader eTagReader, IBlobCausalityReader causalityReader, IBlobWrittenWatcher blobWrittenWatcher) { _client = client; _eTagReader = eTagReader; _causalityReader = causalityReader; _blobWrittenWatcher = blobWrittenWatcher; _registrations = new ConcurrentDictionary <string, ITriggeredFunctionExecutor>(); }
public BlobTriggerExecutor(string hostId, string functionId, IBlobPathSource input, IBlobETagReader eTagReader, IBlobReceiptManager receiptManager, IBlobTriggerQueueWriter queueWriter) { _hostId = hostId; _functionId = functionId; _input = input; _queueWriter = queueWriter; _eTagReader = eTagReader; _receiptManager = receiptManager; }
public void ExecuteAsync_IfLeasedIncompleteReceipt_EnqueuesMessageMarksCompletedReleasesLeaseAndReturnsTrue() { // Arrange string expectedFunctionId = "FunctionId"; string expectedETag = "ETag"; IStorageBlob blob = CreateBlobReference("container", "blob"); IBlobPathSource input = CreateBlobPath(blob); IBlobETagReader eTagReader = CreateStubETagReader(expectedETag); Mock <IBlobReceiptManager> managerMock = CreateReceiptManagerReferenceMock(); managerMock .Setup(m => m.TryReadAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult(BlobReceipt.Incomplete)); managerMock .Setup(m => m.TryAcquireLeaseAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult("LeaseId")); managerMock .Setup(m => m.MarkCompletedAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <string>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult(0)) .Verifiable(); managerMock .Setup(m => m.ReleaseLeaseAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <string>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult(0)) .Verifiable(); IBlobReceiptManager receiptManager = managerMock.Object; Mock <IBlobTriggerQueueWriter> queueWriterMock = new Mock <IBlobTriggerQueueWriter>(MockBehavior.Strict); queueWriterMock .Setup(w => w.EnqueueAsync(It.IsAny <BlobTriggerMessage>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult(0)); IBlobTriggerQueueWriter queueWriter = queueWriterMock.Object; ITriggerExecutor <IStorageBlob> product = CreateProductUnderTest(expectedFunctionId, input, eTagReader, receiptManager, queueWriter); // Act Task <bool> task = product.ExecuteAsync(blob, CancellationToken.None); // Assert task.WaitUntilCompleted(); queueWriterMock .Verify( w => w.EnqueueAsync(It.Is <BlobTriggerMessage>(m => m != null && m.FunctionId == expectedFunctionId && m.BlobType == StorageBlobType.BlockBlob && m.BlobName == blob.Name && m.ContainerName == blob.Container.Name && m.ETag == expectedETag), It.IsAny <CancellationToken>()), Times.Once()); managerMock.Verify(); Assert.True(task.Result); }
public void ExecuteAsync_IfBlobDoesNotExist_ReturnsSuccessfulResult() { // Arrange var blob = CreateBlobReference(); IBlobPathSource input = CreateBlobPath(blob); IBlobETagReader eTagReader = CreateStubETagReader(null); ITriggerExecutor <ICloudBlob> product = CreateProductUnderTest(input, eTagReader); // Act Task <FunctionResult> task = product.ExecuteAsync(blob, CancellationToken.None); // Assert Assert.True(task.Result.Succeeded); }
public void ExecuteAsync_IfBlobDoesNotExist_ReturnsTrue() { // Arrange IStorageBlob blob = CreateBlobReference(); IBlobPathSource input = CreateBlobPath(blob); IBlobETagReader eTagReader = CreateStubETagReader(null); ITriggerExecutor <IStorageBlob> product = CreateProductUnderTest(input, eTagReader); // Act Task <bool> task = product.ExecuteAsync(blob, CancellationToken.None); // Assert Assert.True(task.Result); }
public void ExecuteAsync_IfCompletedBlobReceiptExists_ReturnsSuccessfulResult() { // Arrange ICloudBlob blob = CreateBlobReference(); IBlobPathSource input = CreateBlobPath(blob); IBlobETagReader eTagReader = CreateStubETagReader("ETag"); IBlobReceiptManager receiptManager = CreateCompletedReceiptManager(); ITriggerExecutor <ICloudBlob> product = CreateProductUnderTest(input, eTagReader, receiptManager); // Act Task <FunctionResult> task = product.ExecuteAsync(blob, CancellationToken.None); // Assert Assert.True(task.Result.Succeeded); }
public void ExecuteAsync_IfBlobHasBeenDeleted_ReturnsSuccessResult() { // Arrange string functionId = "FunctionId"; IBlobETagReader eTagReader = CreateStubETagReader(null); BlobQueueTriggerExecutor product = CreateProductUnderTest(eTagReader); product.Register(functionId, CreateDummyTriggeredFunctionExecutor()); IStorageQueueMessage message = CreateMessage(functionId, "OriginalETag"); // Act Task <FunctionResult> task = product.ExecuteAsync(message, CancellationToken.None); // Assert Assert.True(task.Result.Succeeded); }
public async Task ExecuteAsync_IfBlobIsUnchanged_CallsInnerExecutor() { // Arrange string functionId = "FunctionId"; string matchingETag = "ETag"; Guid expectedParentId = Guid.NewGuid(); IStorageQueueMessage message = CreateMessage(functionId, matchingETag); IBlobETagReader eTagReader = CreateStubETagReader(matchingETag); IBlobCausalityReader causalityReader = CreateStubCausalityReader(expectedParentId); FunctionResult expectedResult = new FunctionResult(true); Mock <ITriggeredFunctionExecutor> mock = new Mock <ITriggeredFunctionExecutor>(MockBehavior.Strict); mock.Setup(e => e.TryExecuteAsync(It.IsAny <TriggeredFunctionData>(), It.IsAny <CancellationToken>())) .Callback <TriggeredFunctionData, CancellationToken>( (mockInput, mockCancellationToken) => { Assert.Equal(expectedParentId, mockInput.ParentId); StorageBlockBlob resultBlob = (StorageBlockBlob)mockInput.TriggerValue; Assert.Equal(TestBlobName, resultBlob.Name); }) .ReturnsAsync(expectedResult) .Verifiable(); ITriggeredFunctionExecutor innerExecutor = mock.Object; BlobQueueTriggerExecutor product = CreateProductUnderTest(eTagReader, causalityReader); BlobQueueRegistration registration = new BlobQueueRegistration { BlobClient = CreateClient(), Executor = innerExecutor }; product.Register(functionId, registration); // Act FunctionResult result = await product.ExecuteAsync(message, CancellationToken.None); // Assert Assert.Same(expectedResult, result); mock.Verify(); }
public void ExecuteAsync_IfInnerExecutorFails_ReturnsFalse() { // Arrange string functionId = "FunctionId"; string matchingETag = "ETag"; IBlobETagReader eTagReader = CreateStubETagReader(matchingETag); IBlobCausalityReader causalityReader = CreateStubCausalityReader(); IFunctionExecutor innerExecutor = CreateStubInnerExecutor(CreateDummyDelayedException()); BlobQueueTriggerExecutor product = CreateProductUnderTest(eTagReader, causalityReader, innerExecutor); product.Register(functionId, CreateFakeInstanceFactory()); IStorageQueueMessage message = CreateMessage(functionId, matchingETag); // Act Task <bool> task = product.ExecuteAsync(message, CancellationToken.None); // Assert Assert.False(task.Result); }
public void ExecuteAsync_IfEnqueueAsyncThrows_ReleasesLease() { // Arrange IStorageBlob blob = CreateBlobReference(); IBlobPathSource input = CreateBlobPath(blob); IBlobETagReader eTagReader = CreateStubETagReader("ETag"); InvalidOperationException expectedException = new InvalidOperationException(); Mock <IBlobReceiptManager> mock = CreateReceiptManagerReferenceMock(); mock.Setup(m => m.TryReadAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult(BlobReceipt.Incomplete)); mock.Setup(m => m.TryAcquireLeaseAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult("LeaseId")); mock.Setup(m => m.ReleaseLeaseAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <string>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult(0)) .Verifiable(); IBlobReceiptManager receiptManager = mock.Object; Mock <IBlobTriggerQueueWriter> queueWriterMock = new Mock <IBlobTriggerQueueWriter>(MockBehavior.Strict); queueWriterMock .Setup(w => w.EnqueueAsync(It.IsAny <BlobTriggerMessage>(), It.IsAny <CancellationToken>())) .Throws(expectedException); IBlobTriggerQueueWriter queueWriter = queueWriterMock.Object; ITriggerExecutor <IStorageBlob> product = CreateProductUnderTest(input, eTagReader, receiptManager, queueWriter); // Act Task <bool> task = product.ExecuteAsync(blob, CancellationToken.None); // Assert task.WaitUntilCompleted(); mock.Verify(); InvalidOperationException exception = Assert.Throws <InvalidOperationException>( () => task.GetAwaiter().GetResult()); Assert.Same(expectedException, exception); }
public void ExecuteAsync_IfTryAcquireLeaseFails_ReturnsFailureResult() { // Arrange ICloudBlob blob = CreateBlobReference(); IBlobPathSource input = CreateBlobPath(blob); IBlobETagReader eTagReader = CreateStubETagReader("ETag"); Mock <IBlobReceiptManager> mock = CreateReceiptManagerReferenceMock(); mock.Setup(m => m.TryReadAsync(It.IsAny <CloudBlockBlob>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult(BlobReceipt.Incomplete)); mock.Setup(m => m.TryAcquireLeaseAsync(It.IsAny <CloudBlockBlob>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult <string>(null)); IBlobReceiptManager receiptManager = mock.Object; ITriggerExecutor <ICloudBlob> product = CreateProductUnderTest(input, eTagReader, receiptManager); // Act Task <FunctionResult> task = product.ExecuteAsync(blob, CancellationToken.None); // Assert Assert.False(task.Result.Succeeded); }
public void ExecuteAsync_IfTryCreateReceiptFails_ReturnsFalse() { // Arrange IStorageBlob blob = CreateBlobReference(); IBlobPathSource input = CreateBlobPath(blob); IBlobETagReader eTagReader = CreateStubETagReader("ETag"); Mock <IBlobReceiptManager> mock = CreateReceiptManagerReferenceMock(); mock.Setup(m => m.TryReadAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult <BlobReceipt>(null)); mock.Setup(m => m.TryCreateAsync(It.IsAny <IStorageBlockBlob>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult(false)); IBlobReceiptManager receiptManager = mock.Object; ITriggerExecutor <IStorageBlob> product = CreateProductUnderTest(input, eTagReader, receiptManager); // Act Task <bool> task = product.ExecuteAsync(blob, CancellationToken.None); // Assert Assert.False(task.Result); }
private static BlobTriggerExecutor CreateProductUnderTest(IBlobPathSource input, IBlobETagReader eTagReader) { return CreateProductUnderTest(input, eTagReader, CreateDummyReceiptManager()); }
private static BlobQueueTriggerExecutor CreateProductUnderTest(IBlobETagReader eTagReader, IBlobCausalityReader causalityReader, IBlobWrittenWatcher blobWrittenWatcher) { return new BlobQueueTriggerExecutor(eTagReader, causalityReader, blobWrittenWatcher); }
private static BlobQueueTriggerExecutor CreateProductUnderTest(IBlobETagReader eTagReader, IBlobCausalityReader causalityReader, IBlobWrittenWatcher blobWrittenWatcher) { IStorageBlobClient client = CreateClient(); return new BlobQueueTriggerExecutor(client, eTagReader, causalityReader, blobWrittenWatcher); }
private static BlobTriggerExecutor CreateProductUnderTest(string functionId, IBlobPathSource input, IBlobETagReader eTagReader, IBlobReceiptManager receiptManager, IBlobTriggerQueueWriter queueWriter) { return(new BlobTriggerExecutor(String.Empty, functionId, input, eTagReader, receiptManager, queueWriter)); }
private static BlobTriggerExecutor CreateProductUnderTest(IBlobPathSource input, IBlobETagReader eTagReader, IBlobReceiptManager receiptManager, IBlobTriggerQueueWriter queueWriter) { return(CreateProductUnderTest("FunctionId", input, eTagReader, receiptManager, queueWriter)); }
private static BlobTriggerExecutor CreateProductUnderTest(IBlobPathSource input, IBlobETagReader eTagReader) { return(CreateProductUnderTest(input, eTagReader, CreateDummyReceiptManager())); }
private static BlobQueueTriggerExecutor CreateProductUnderTest(IBlobETagReader eTagReader, IBlobCausalityReader causalityReader) { return CreateProductUnderTest(eTagReader, causalityReader, CreateDummyBlobWrittenWatcher()); }
private static BlobTriggerExecutor CreateProductUnderTest(IBlobPathSource input, IBlobETagReader eTagReader, IBlobReceiptManager receiptManager, IBlobTriggerQueueWriter queueWriter) { return CreateProductUnderTest("FunctionId", input, eTagReader, receiptManager, queueWriter); }
private static BlobTriggerExecutor CreateProductUnderTest(string functionId, IBlobPathSource input, IBlobETagReader eTagReader, IBlobReceiptManager receiptManager, IBlobTriggerQueueWriter queueWriter) { return new BlobTriggerExecutor(String.Empty, functionId, input, eTagReader, receiptManager, queueWriter); }
private static BlobQueueTriggerExecutor CreateProductUnderTest(IBlobETagReader eTagReader, IBlobCausalityReader causalityReader) { return(CreateProductUnderTest(eTagReader, causalityReader, CreateDummyBlobWrittenWatcher())); }