public IDispatchQueueHandler GetDispatchQueue(IMessageHandler handler)
{
if (_dispatchQueue == null)
{
if (handler == null)
{
throw new InvalidOperationException("Please provide a call back function");
}
if (_sharedQueue.RegisterHandler(Descriptor.Id, handler))
{
_dispatchQueue = new DispatchQueueHandler(_sharedQueue, Descriptor.Id);
}
else
{
// failed to register messageHandler, fall back to in memory implementation
_dispatchQueue = new InMemoryDispatchQueueHandler(handler);
}
}
else if (handler != null)
{
throw new InvalidOperationException("Cannot register more than one handler with a single function");
}
return(_dispatchQueue);
}
public async Task HotPathNotificationTest()
{
await _sharedQueue.InitializeAsync(CancellationToken.None);
var messageHandlerMock = new Mock <IMessageHandler>();
var calls = 0;
messageHandlerMock.Setup(m => m.TryExecuteAsync(It.IsAny <JObject>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(() =>
{
calls++; // executed sequentially, no need interlocked
return(new FunctionResult(true));
});
Assert.True(_sharedQueue.RegisterHandler("mockFunction1", messageHandlerMock.Object));
// register another INotificationHandler to sharedQueueWatcher
// so that we can tell when the sharedQueueListener is notified
var notifies = 0;
var notificationMock = new Mock <INotificationCommand>();
notificationMock.Setup(m => m.Notify()).Callback(() => Interlocked.Increment(ref notifies));
_sharedContextProvider.GetOrCreateInstance <SharedQueueWatcher>(null)
.Register(HostQueueNames.GetHostSharedQueueName(HostId), notificationMock.Object);
await _sharedQueue.StartQueueAsync(CancellationToken.None);
int max = 10;
var enqueue = new List <Task>();
for (int i = 0; i < max; i++)
{
JObject message = JObject.Parse("{count:" + i + "}");
enqueue.Add(_sharedQueue.EnqueueAsync(message, "mockFunction1", CancellationToken.None));
}
await Task.WhenAll(enqueue);
// wait for dequeue
await TestHelpers.Await(() => calls >= max, 1000, 200);
await _sharedQueue.StopQueueAsync(CancellationToken.None);
Assert.Equal(max, notifies);
Assert.Equal(max, calls);
}
private Task RunDummyEnqueueAsync(List <TestCase> testCases)
{
var enqueues = new List <Task>();
int index = 0;
foreach (var testcase in testCases)
{
var functionMock = new Mock <IMessageHandler>();
functionMock.Setup(m => m.TryExecuteAsync(It.IsAny <JObject>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(() => { testcase.CallCount++; return(new FunctionResult(true)); });
if (testcase.Register)
{
Assert.True(_sharedQueue.RegisterHandler(index.ToString(), functionMock.Object));
}
for (int i = 0; i < testcase.TotalEnqueues; i++)
{
// enqueue an empty JObject
enqueues.Add(_sharedQueue.EnqueueAsync(JObject.Parse("{}"), index.ToString(), CancellationToken.None));
}
index++;
}
return(Task.WhenAll(enqueues));
}