public void ExecuteAsync_IfFunctionIdIsNull_Throws() { // Arrange BlobQueueTriggerExecutor product = CreateProductUnderTest(); var message = CreateMessage("{}"); // Act Task task = product.ExecuteAsync(message, CancellationToken.None); // Assert ExceptionAssert.ThrowsInvalidOperation(() => task.GetAwaiter().GetResult(), "Invalid function ID."); }
public void ExecuteAsync_IfMessageIsNotJson_Throws() { // Arrange BlobQueueTriggerExecutor product = CreateProductUnderTest(); var message = CreateMessage("ThisIsNotValidJson"); // Act Task task = product.ExecuteAsync(message, CancellationToken.None); // Assert Assert.Throws <JsonReaderException>(() => task.GetAwaiter().GetResult()); }
public void GetMonitor_ReturnsSharedMonitor() { var queueListener = new QueueListener(); var watcherMock = new Mock <IBlobWrittenWatcher>(MockBehavior.Strict); var executor = new BlobQueueTriggerExecutor(watcherMock.Object, NullLogger <BlobListener> .Instance); var sharedBlobQueueListener = new SharedBlobQueueListener(queueListener, executor); var sharedListenerMock = new Mock <ISharedListener>(MockBehavior.Strict); var blobListener1 = new BlobListener(sharedBlobQueueListener); var blobListener2 = new BlobListener(sharedBlobQueueListener); var monitor1 = blobListener1.GetMonitor(); var monitor2 = blobListener1.GetMonitor(); Assert.AreSame(monitor1, monitor2); Assert.AreSame(monitor1, queueListener); }
public async Task ExecuteAsync_IfBlobIsUnchanged_CallsInnerExecutor() { // Arrange string functionId = "FunctionId"; Guid expectedParentId = Guid.NewGuid(); string matchingETag = TouchBlob(TestContainerName, TestBlobName); var message = CreateMessage(functionId, 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.AreEqual(expectedParentId, mockInput.ParentId); var resultBlob = (BlobBaseClient)mockInput.TriggerValue; Assert.AreEqual(TestBlobName, resultBlob.Name); }) .ReturnsAsync(expectedResult) .Verifiable(); ITriggeredFunctionExecutor innerExecutor = mock.Object; BlobQueueTriggerExecutor product = CreateProductUnderTest(causalityReader); BlobQueueRegistration registration = new BlobQueueRegistration { BlobServiceClient = _blobServiceClient, Executor = innerExecutor }; product.Register(functionId, registration); // Act FunctionResult result = await product.ExecuteAsync(message, CancellationToken.None); // Assert Assert.AreSame(expectedResult, result); mock.Verify(); }
public SharedBlobQueueListener Create() { BlobQueueTriggerExecutor triggerExecutor = new BlobQueueTriggerExecutor(_blobWrittenWatcher, _loggerFactory.CreateLogger <BlobListener>()); // The poison queue to use for a given poison blob lives in the same // storage account as the triggering blob by default. In multi-storage account scenarios // that means that we'll be writing to different poison queues, determined by // the triggering blob. // However we use a poison queue in the host storage account as a fallback default // in case a particular blob lives in a restricted "blob only" storage account (i.e. no queues). var defaultPoisonQueue = _hostQueueServiceClient.GetQueueClient(HostQueueNames.BlobTriggerPoisonQueue); // This special queue bypasses the QueueProcessorFactory - we don't want people to override this. // So we define our own custom queue processor factory for this listener var queuesOptions = BlobsOptionsToQueuesOptions(_blobsOptions); var queueProcessor = new SharedBlobQueueProcessor(triggerExecutor, _hostBlobTriggerQueue, defaultPoisonQueue, _loggerFactory, queuesOptions); QueueListener.RegisterSharedWatcherWithQueueProcessor(queueProcessor, _sharedQueueWatcher); IListener listener = new QueueListener(_hostBlobTriggerQueue, defaultPoisonQueue, triggerExecutor, _exceptionHandler, _loggerFactory, _sharedQueueWatcher, queuesOptions, queueProcessor, _functionDescriptor, functionId: SharedBlobQueueListenerFunctionId); return(new SharedBlobQueueListener(listener, triggerExecutor)); }
public SharedBlobQueueProcessor(BlobQueueTriggerExecutor triggerExecutor, QueueClient queue, QueueClient poisonQueue, ILoggerFactory loggerFactory, QueuesOptions queuesOptions) : base(new QueueProcessorOptions(queue, loggerFactory, queuesOptions, poisonQueue)) { _executor = triggerExecutor; }
public SharedBlobQueueListener(IListener listener, BlobQueueTriggerExecutor executor) { _listener = listener; _executor = executor; }