public void CanSendMessageToMultipleSubscribers()
{
var latch = new CountDownLatch(3);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe <SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.Subscribe <SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.Subscribe <SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.PublishAsync(new SimpleMessageA {
Data = "Hello"
});
bool success = latch.Wait(100);
Assert.True(success, "Failed to receive all messages.");
}
private static async void MessageBusTest()
{
IMessageBus messageBus = new InMemoryMessageBus();
messageBus.SubscribeAsync <SimpleMessageA>(msg =>
{
Console.WriteLine(msg.Data);
});
await messageBus.PublishAsync(new SimpleMessageA { Data = "hello" });
}
public async Task CanCheckMessageCounts()
{
var messageBus = new InMemoryMessageBus(o => o.LoggerFactory(Log));
await messageBus.PublishAsync(new SimpleMessageA {
Data = "Hello"
});
Assert.Equal(1, messageBus.MessagesSent);
Assert.Equal(1, messageBus.GetMessagesSent <SimpleMessageA>());
Assert.Equal(0, messageBus.GetMessagesSent <SimpleMessageB>());
}
public void CanSubscribeToAllMessageTypes()
{
var latch = new CountDownLatch(3);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe <object>(msg => {
latch.Signal();
});
messageBus.PublishAsync(new SimpleMessageA {
Data = "Hello"
});
messageBus.PublishAsync(new SimpleMessageB {
Data = "Hello"
});
messageBus.PublishAsync(new SimpleMessageC {
Data = "Hello"
});
bool success = latch.Wait(100);
Assert.True(success, "Failed to receive all messages.");
}
public void CanSendMessage() {
var resetEvent = new AutoResetEvent(false);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe<SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
resetEvent.Set();
});
messageBus.PublishAsync(new SimpleMessageA {
Data = "Hello"
});
bool success = resetEvent.WaitOne(100);
Assert.True(success, "Failed to receive message.");
}
public void WillReceiveDerivedMessageTypes()
{
var latch = new CountDownLatch(2);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe <ISimpleMessage>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.PublishAsync(new SimpleMessageA {
Data = "Hello"
});
messageBus.PublishAsync(new SimpleMessageB {
Data = "Hello"
});
messageBus.PublishAsync(new SimpleMessageC {
Data = "Hello"
});
bool success = latch.Wait(100);
Assert.True(success, "Failed to receive all messages.");
}
public void CanSendMessage()
{
var resetEvent = new AutoResetEvent(false);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe <SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
resetEvent.Set();
});
messageBus.PublishAsync(new SimpleMessageA {
Data = "Hello"
});
bool success = resetEvent.WaitOne(100);
Assert.True(success, "Failed to receive message.");
}
public void CanTolerateSubscriberFailure() {
var latch = new CountDownLatch(2);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe<SimpleMessageA>(msg => {
throw new ApplicationException();
});
messageBus.Subscribe<SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.Subscribe<SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.PublishAsync(new SimpleMessageA {
Data = "Hello"
});
bool success = latch.Wait(900);
Assert.True(success, "Failed to receive all messages.");
}
public void CanSendMessageToMultipleSubscribers() {
var latch = new CountDownLatch(3);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe<SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.Subscribe<SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.Subscribe<SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.PublishAsync(new SimpleMessageA {
Data = "Hello"
});
bool success = latch.Wait(100);
Assert.True(success, "Failed to receive all messages.");
}
public void CanTolerateSubscriberFailure()
{
var latch = new CountDownLatch(2);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe <SimpleMessageA>(msg => {
throw new ApplicationException();
});
messageBus.Subscribe <SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.Subscribe <SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.PublishAsync(new SimpleMessageA {
Data = "Hello"
});
bool success = latch.Wait(900);
Assert.True(success, "Failed to receive all messages.");
}
public void WillReceiveDerivedMessageTypes() {
var latch = new CountDownLatch(2);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe<ISimpleMessage>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.PublishAsync(new SimpleMessageA {
Data = "Hello"
});
messageBus.PublishAsync(new SimpleMessageB {
Data = "Hello"
});
messageBus.PublishAsync(new SimpleMessageC {
Data = "Hello"
});
bool success = latch.Wait(100);
Assert.True(success, "Failed to receive all messages.");
}
public void CanSubscribeToAllMessageTypes() {
var latch = new CountDownLatch(3);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe<object>(msg => {
latch.Signal();
});
messageBus.PublishAsync(new SimpleMessageA {
Data = "Hello"
});
messageBus.PublishAsync(new SimpleMessageB {
Data = "Hello"
});
messageBus.PublishAsync(new SimpleMessageC {
Data = "Hello"
});
bool success = latch.Wait(100);
Assert.True(success, "Failed to receive all messages.");
}
public void PublishEvent(IntegrationRequestEvent @event)
{
inMemoryBus.PublishAsync(@event);
}