public async void Test_dispatch_dispatches()
{
// Arrange
var subscription = new SubscriptionIdentifier("foo", "B=1");
MessageBusCallbackDelegate emptyDelegate = (topic, filter, message) => { };
MessageBusCallbackDelegate testCallbackDelegate = (topic, filter, message) =>
{
Assert.Pass("Callback successfully called");
};
var mockMessage = new Mock <IMagicHubMessage>();
_mockFilteringService
.Setup(f =>
f.Filter(
It.IsAny <IReadOnlyDictionary <string, object> >(),
It.IsAny <IEnumerable <KeyValuePair <SubscriptionIdentifier, MessageBusCallbackDelegate> > >()))
.Returns(Task.FromResult <IEnumerable <KeyValuePair <SubscriptionIdentifier, MessageBusCallbackDelegate> > >(new[]
{
new KeyValuePair <SubscriptionIdentifier, MessageBusCallbackDelegate>(
subscription,
testCallbackDelegate)
}));
_dispatcher.Subscribe(subscription, emptyDelegate);
// Act
await _dispatcher.DispatchMessage(mockMessage.Object);
}
public void Test_unsubscribe()
{
//Arrange
var waitEvent = new ManualResetEvent(false);
var callback = new MessageBusCallbackDelegate((key, fltr, value) =>
{
waitEvent.Set();
});
var dispatcher = new Mock <IMessageDispatcher>();
dispatcher.Setup(s => s.Subscribe(It.IsAny <SubscriptionIdentifier>(), It.IsAny <MessageBusCallbackDelegate>())).Callback(() => { });
var messageBus = new MessageBus(GlobalHost.DependencyResolver.Resolve <IMessageBus>(),
dispatcher.Object, GlobalHost.DependencyResolver.Resolve <JsonSerializer>());
//Act
messageBus.Subscribe("foo", callback);
messageBus.Publish("foo", "{\"message\":\"blah\"}");
messageBus.Unsubscribe("foo");
waitEvent.WaitOne(100);
//Assert
dispatcher.Verify(g => g.Subscribe(It.Is <SubscriptionIdentifier>(s => s.Topic == "foo" && s.Filter == null), callback), Times.Once());
dispatcher.Verify(g => g.DispatchMessage(It.Is <IMagicHubMessage>(m => (string)m.Context["Topic"] == "foo")), Times.Once());
dispatcher.Verify(g => g.Unsubscribe(It.Is <SubscriptionIdentifier>(s => s.Topic == "foo" && s.Filter == null)), Times.Once());
}
/// <summary>
/// Subscribe to inprocess message bus.
/// </summary>
/// <param name="topic"></param>
/// <param name="filter"></param>
/// <param name="callback"></param>
/// <returns></returns>
/// <remarks>
/// Stores the callback and uses the callback when SignalR calls the main callback.
/// </remarks>
public virtual Task Subscribe(string topic, string filter, MessageBusCallbackDelegate callback)
{
var subscription = new SubscriptionIdentifier(topic, filter);
_messageDispatcher.Subscribe(subscription, callback);
//return emtpy task
return(TaskAsyncHelper.Empty);
}
public void Test_when_concurrent_subscribe_on_same_topic_should_callback_once()
{
//Arrange
var count = 0;
var manualResets = Enumerable.Range(0, 10).Select(_ => new ManualResetEvent(false)).ToArray();
var subscription = new SubscriptionIdentifier("foo", null);
var testCallbackDelegates = new MessageBusCallbackDelegate[10];
for (int i = 0; i < 10; i++)
{
testCallbackDelegates[i] = (topic, filter, message) =>
{
Interlocked.Increment(ref count);
manualResets[i].Set();
}
}
;
var mockMessage = new Mock <IMagicHubMessage>();
_mockFilteringService
.Setup(f =>
f.Filter(
It.IsAny <IReadOnlyDictionary <string, object> >(),
It.IsAny <IEnumerable <KeyValuePair <SubscriptionIdentifier, MessageBusCallbackDelegate> > >()))
.Returns(Task.FromResult <IEnumerable <KeyValuePair <SubscriptionIdentifier, MessageBusCallbackDelegate> > >(new[]
{
new KeyValuePair <SubscriptionIdentifier, MessageBusCallbackDelegate>(
subscription,
(topic, filter, message) => Interlocked.Increment(ref count))
}));
//Act
Enumerable.Range(0, 10).AsParallel().ForAll(i => _dispatcher.Subscribe(subscription, testCallbackDelegates[i]));
_dispatcher.DispatchMessage(mockMessage.Object);
WaitHandle.WaitAny(manualResets, 100);
//Assert
Assert.That(count, Is.EqualTo(1));
}
}
/// <summary>
/// Informs the message dispatcher of a new subscription
/// </summary>
/// <param name="subscription">The subscription.</param>
/// <param name="callback">The callback.</param>
public void Subscribe(SubscriptionIdentifier subscription, MessageBusCallbackDelegate callback)
{
_callbacks[subscription] = callback;
}
/// <summary>
/// Subscribe to inprocess message bus.
/// </summary>
/// <param name="topic">Topic</param>
/// <param name="callback">Callback</param>
/// <returns></returns>
/// <remarks>
/// Stores the callback and uses the callback when SignalR calls the main callback.
/// </remarks>
public virtual Task Subscribe(string topic, MessageBusCallbackDelegate callback)
{
return(Subscribe(topic, null, callback));
}
