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()));
}
