public async Task InMemoryDispatchQueueHandlerTest() { string error = "no storage account found"; _accountProviderMock.Setup(m => m.TryGetAccountAsync(ConnectionStringNames.Storage, It.IsAny <CancellationToken>())). ThrowsAsync(new Exception(error)); await _sharedQueue.InitializeAsync(CancellationToken.None); Assert.Empty(_loggerProvider.GetAllLogMessages()); // listenercontext should return inMemoryDispatchQueueHandler when there's no storage account var descriptorMock = new Mock <FunctionDescriptor>(); var triggerExecutorMock = new Mock <ITriggeredFunctionExecutor>(); ListenerFactoryContext context = new ListenerFactoryContext( descriptorMock.Object, triggerExecutorMock.Object, _sharedQueue, CancellationToken.None); var messageHandlerMock = new Mock <IMessageHandler>(); var condition = new AutoResetEvent(false); messageHandlerMock.Setup(m => m.TryExecuteAsync(It.IsAny <JObject>(), It.IsAny <CancellationToken>())) .Returns(async() => { await Task.Yield(); condition.Set(); // will run asynchronously return(new FunctionResult(true)); }); var dispatchQueue = context.GetDispatchQueue(messageHandlerMock.Object); // make sure initialization error is traced Assert.Equal(error, _loggerProvider.GetAllLogMessages().Single().Exception.Message); Assert.Equal(SharedQueueHandler.InitErrorMessage, _loggerProvider.GetAllLogMessages().Single().FormattedMessage); Assert.IsType <InMemoryDispatchQueueHandler>(dispatchQueue); await dispatchQueue.EnqueueAsync(JObject.Parse("{}"), CancellationToken.None); // without storage account, it is still possible to perform local enqueue, dequeue Assert.True(condition.WaitOne(200)); // following two should be NOOP, inner queueListener was never created await _sharedQueue.StartQueueAsync(CancellationToken.None); await _sharedQueue.StopQueueAsync(CancellationToken.None); // no NullPointerException }
private async Task StartAsyncCore(CancellationToken cancellationToken) { // create sharedQueue so that once the listener started, they can enqueue await _sharedQueue.InitializeAsync(cancellationToken); _listener = await _factory.CreateAsync(cancellationToken); _cancellationRegistration = _cancellationSource.Token.Register(_listener.Cancel); await _listener.StartAsync(cancellationToken); // composite listener, startAsync in parallel // start sharedQueue after other listeners await _sharedQueue.StartQueueAsync(cancellationToken); }
public async Task DequeueBehaviorTests() { await _sharedQueue.InitializeAsync(CancellationToken.None); var testCases = new List <TestCase>(); // have three functions // A run X times => expect X times TestCase a = new TestCase { CallCount = 0, TotalEnqueues = 3, Register = true }; testCases.Add(a); // B run Y times => expect Y times TestCase b = new TestCase { CallCount = 0, TotalEnqueues = 5, Register = true }; testCases.Add(b); // C run Z times => expect 0 times TestCase c = new TestCase { CallCount = 0, TotalEnqueues = 7, Register = false //(disabled) }; testCases.Add(c); // start enqueuing await RunDummyEnqueueAsync(testCases); // start dequeuing await _sharedQueue.StartQueueAsync(CancellationToken.None); // wait for dequeue await TestHelpers.Await(() => a.CallCount >= a.TotalEnqueues && b.CallCount >= b.TotalEnqueues, 1000, 200); await _sharedQueue.StopQueueAsync(CancellationToken.None); Assert.Equal(a.TotalEnqueues, a.CallCount); Assert.Equal(b.TotalEnqueues, b.CallCount); Assert.Equal(0, c.CallCount); }