public void Bus_ErrorSubscriber_MessageDeserializedException()
{
const string busId = "MyBus";
using (IBus bus = new MessageBus.Core.RabbitMQBus(c => c.SetBusId(busId)))
{
using (ISubscriber subscriber = bus.CreateSubscriber(c => c.UseErrorSubscriber(this).SetReceiveSelfPublish()))
{
subscriber.Subscribe(delegate(ContractToReceive ok) { });
subscriber.Open();
using (IPublisher publisher = bus.CreatePublisher())
{
publisher.Send(new ContractToSend { Data = 4 });
}
bool wait = _ev.WaitOne(TimeSpan.FromSeconds(5));
wait.Should().BeTrue();
_busMessage.Name.Should().Be("Data");
_busMessage.Namespace.Should().Be("bus.error.test.org");
_busMessage.Data.GetType().Should().Be(typeof(byte[]));
_busMessage.BusId.Should().Be(busId);
_exception.Should().BeOfType<JsonSerializationException>();
}
}
}
public void Bus_AsyncSubscriberException_ErrorHandlerCalled()
{
ImportiantData data = new ImportiantData { Info = "Valuable information" };
// Second bus subscribes to message after it was dispatched and should receive it
using (var bus = new MessageBus.Core.RabbitMQBus())
{
using (IAsyncSubscriber subscriber = bus.CreateAsyncSubscriber(c => c.SetReceiveSelfPublish().UseErrorSubscriber(this)))
{
subscriber.Subscribe<ImportiantData>(Subscribe);
subscriber.Open();
using (IPublisher publisher = bus.CreatePublisher())
{
publisher.Send(data);
}
bool wait = _ev.WaitOne(TimeSpan.FromSeconds(5));
wait.Should().BeTrue();
}
}
}
public void Bus_PublishedMessage_FilterByHeader()
{
Person actualT1 = new Person
{
Id = 5
};
Person actualT2 = new Person
{
Id = 15
};
Person b1 = null, b2 = null, c1 = null;
const string header = "type";
ManualResetEvent ev1 = new ManualResetEvent(false), ev2 = new ManualResetEvent(false), ev3 = new ManualResetEvent(false);
using (MessageBus.Core.RabbitMQBus busA = new MessageBus.Core.RabbitMQBus(), busB = new MessageBus.Core.RabbitMQBus(), busC = new MessageBus.Core.RabbitMQBus())
{
using (ISubscriber subscriberB1 = busB.CreateSubscriber(), subscriberB2 = busB.CreateSubscriber(), subscriberC1 = busC.CreateSubscriber())
{
subscriberB1.Subscribe<Person>(p => { b1 = p; ev1.Set(); }, filter: new[] { new BusHeader { Name = header, Value = "T1"} });
subscriberB2.Subscribe<Person>(p => { b2 = p; ev2.Set(); }, filter: new[] { new BusHeader { Name = header, Value = "T2"} });
subscriberC1.Subscribe<Person>(p => { c1 = p; ev3.Set(); }, filter: new[] { new BusHeader { Name = header, Value = "T1" } });
subscriberB1.Open();
subscriberB2.Open();
subscriberC1.Open();
using (IPublisher publisher = busA.CreatePublisher())
{
BusMessage<Person> m1 = new BusMessage<Person> {Data = actualT1};
m1.Headers.Add(new BusHeader { Name = header, Value = "T1"});
publisher.Send(m1);
BusMessage<Person> m2 = new BusMessage<Person> { Data = actualT2 };
m2.Headers.Add(new BusHeader { Name = header, Value = "T2" });
publisher.Send(m2);
}
bool wait = ev1.WaitOne(TimeSpan.FromSeconds(5)) &&
ev2.WaitOne(TimeSpan.FromSeconds(5)) &&
ev3.WaitOne(TimeSpan.FromSeconds(5));
wait.Should().BeTrue("Message should arrive to all subscribers");
b1.Should().NotBeNull();
b2.Should().NotBeNull();
c1.Should().NotBeNull();
b1.ShouldBeEquivalentTo(actualT1);
b2.ShouldBeEquivalentTo(actualT2);
c1.ShouldBeEquivalentTo(actualT1);
}
}
}
public void Bus_ErrorSubscriber_MessageDispatchException()
{
const string busId = "MyBus";
Exception ex = new Exception("My process error");
using (IBus bus = new MessageBus.Core.RabbitMQBus(c => c.SetBusId(busId)))
{
using (ISubscriber subscriber = bus.CreateSubscriber(c => c.UseErrorSubscriber(this).SetReceiveSelfPublish()))
{
subscriber.Subscribe(delegate(ContractToSend ok) { throw ex; });
subscriber.Open();
using (IPublisher publisher = bus.CreatePublisher())
{
publisher.Send(new ContractToSend { Data = 4 });
}
bool wait = _ev.WaitOne(TimeSpan.FromSeconds(5));
wait.Should().BeTrue();
_busMessage.Name.Should().Be("Data");
_busMessage.Namespace.Should().Be("bus.error.test.org");
_busMessage.Data.Should().BeOfType<ContractToSend>();
_busMessage.BusId.Should().Be(busId);
_exception.Should().BeSameAs(ex);
}
}
}
public void Clean()
{
using (var bus = new MessageBus.Core.RabbitMQBus())
{
using (IRouteManager routeManager = bus.CreateRouteManager())
{
routeManager.DeleteQueue(QueueName);
}
}
}
public void Initialize()
{
using (var bus = new MessageBus.Core.RabbitMQBus())
{
using (IRouteManager routeManager = bus.CreateRouteManager())
{
routeManager.CreateQueue(QueueName, true, false, CreateQueueSettings.Default);
routeManager.QueueBindMessage<ImportiantData>(QueueName);
}
}
}
public void Bus_PublishedMessage_FilterByHeader()
{
Person actualT1 = new Person
{
Id = 5
};
Person actualT2 = new Person
{
Id = 15
};
const string header = "type";
using (MessageBus.Core.RabbitMQBus busA = new MessageBus.Core.RabbitMQBus(), busB = new MessageBus.Core.RabbitMQBus(), busC = new MessageBus.Core.RabbitMQBus())
{
using (IReceiver receiverB1 = busB.CreateReceiver(), receiverB2 = busB.CreateReceiver(), receiverC1 = busC.CreateReceiver())
{
receiverB1.Subscribe<Person>(filter: new[] { new BusHeader { Name = header, Value = "T1" } });
receiverB2.Subscribe<Person>(filter: new[] { new BusHeader { Name = header, Value = "T2" } });
receiverC1.Subscribe<Person>(filter: new[] { new BusHeader { Name = header, Value = "T1" } });
receiverB1.Open();
receiverB2.Open();
receiverC1.Open();
using (IPublisher publisher = busA.CreatePublisher())
{
BusMessage<Person> m1 = new BusMessage<Person> { Data = actualT1 };
m1.Headers.Add(new BusHeader { Name = header, Value = "T1" });
publisher.Send(m1);
BusMessage<Person> m2 = new BusMessage<Person> { Data = actualT2 };
m2.Headers.Add(new BusHeader { Name = header, Value = "T2" });
publisher.Send(m2);
}
Person b1 = receiverB1.Receive<Person>();
Person b2 = receiverB2.Receive<Person>();
Person c1 = receiverC1.Receive<Person>();
b1.Should().NotBeNull();
b2.Should().NotBeNull();
c1.Should().NotBeNull();
b1.ShouldBeEquivalentTo(actualT1);
b2.ShouldBeEquivalentTo(actualT2);
c1.ShouldBeEquivalentTo(actualT1);
}
}
}
public void RabbitMQBus_Dialog_WithOrderedDelivery_AllSubscriptionTypes()
{
using (MessageBus.Core.RabbitMQBus entityA = new MessageBus.Core.RabbitMQBus(), entityB = new MessageBus.Core.RabbitMQBus())
{
Data messageA = new Person
{
Id = 5
};
Data messageB = new Car
{
Number = "39847239847"
};
List<Data> received = new List<Data>();
ManualResetEvent ev1 = new ManualResetEvent(false), ev2 = new ManualResetEvent(false);
using (ISubscriber subscriberA = entityA.CreateSubscriber(), subscriberB = entityB.CreateSubscriber())
{
subscriberA.Subscribe<Data>(received.Add, true);
subscriberA.Subscribe(typeof(OK), (Action<object>) (data => ev1.Set()));
subscriberB.Subscribe((Action<OK>) (data => ev2.Set()));
subscriberA.Open();
subscriberB.Open();
using (IPublisher publisher = entityB.CreatePublisher())
{
publisher.Send(messageA);
publisher.Send(messageB);
publisher.Send(new OK());
}
using (IPublisher publisher = entityA.CreatePublisher())
{
publisher.Send(new OK());
}
bool waitOne = ev1.WaitOne(TimeSpan.FromSeconds(20)) && ev2.WaitOne(TimeSpan.FromSeconds(20));
waitOne.Should().BeTrue("Message not received");
received.Should().ContainInOrder(messageA, messageB);
}
}
}
public void Bus_PublishedMessage_EachSubscriberGetsMessageCopy()
{
Person actual = new Person
{
Id = 5
};
Person b1 = null, b2 = null, c1 = null;
ManualResetEvent ev1 = new ManualResetEvent(false), ev2 = new ManualResetEvent(false), ev3 = new ManualResetEvent(false);
using (MessageBus.Core.RabbitMQBus busA = new MessageBus.Core.RabbitMQBus(), busB = new MessageBus.Core.RabbitMQBus(), busC = new MessageBus.Core.RabbitMQBus())
{
using (ISubscriber subscriberB1 = busB.CreateSubscriber(), subscriberB2 = busB.CreateSubscriber(), subscriberC1 = busC.CreateSubscriber())
{
subscriberB1.Subscribe<Person>(p => { b1 = p; ev1.Set(); });
subscriberB2.Subscribe<Person>(p => { p.Id *= 2; b2 = p; ev2.Set(); });
subscriberC1.Subscribe<Person>(p => { c1 = p; ev3.Set(); });
subscriberB1.Open();
subscriberB2.Open();
subscriberC1.Open();
using (IPublisher publisher = busA.CreatePublisher())
{
publisher.Send(actual);
}
bool wait = ev1.WaitOne(TimeSpan.FromSeconds(5)) &&
ev2.WaitOne(TimeSpan.FromSeconds(5)) &&
ev3.WaitOne(TimeSpan.FromSeconds(5));
wait.Should().BeTrue("Message should arrive to all subscribers");
b1.Should().NotBeNull();
b2.Should().NotBeNull();
c1.Should().NotBeNull();
b1.ShouldBeEquivalentTo(actual);
b2.ShouldBeEquivalentTo(new Person
{
Id = actual.Id * 2
});
c1.ShouldBeEquivalentTo(actual);
}
}
}
public void Bus_BusMessage_HeadersAndPropertiesUsage()
{
const string busId = "Bus";
using (MessageBus.Core.RabbitMQBus bus = new MessageBus.Core.RabbitMQBus(c => c.SetBusId(busId)))
{
BusMessage<Person> message = new BusMessage<Person>
{
Data = new Person { Id = 5 }
};
message.Headers.Add(new BusHeader
{
Name = "Version", Value = "Ver1"
});
BusMessage<Person> received = null;
ManualResetEvent ev = new ManualResetEvent(false);
DateTime sent;
using (ISubscriber subscriber = bus.CreateSubscriber(c => c.SetReceiveSelfPublish()))
{
subscriber.Subscribe((Action<BusMessage<Person>>) (m =>
{
received = m;
ev.Set();
}));
subscriber.Open();
using (IPublisher publisher = bus.CreatePublisher())
{
sent = DateTime.Now;
publisher.Send(message);
}
bool wait = ev.WaitOne(TimeSpan.FromSeconds(5));
wait.Should().BeTrue();
}
received.ShouldBeEquivalentTo(message, options => options.Excluding(m => m.BusId).Excluding(m => m.Sent));
received.BusId.Should().Be(busId);
received.Sent.Should().BeCloseTo(sent, 1000);
}
}
public void Bus_TransferBlob()
{
byte[] blob = new byte[10*1024*1024];
byte[] received = null;
int counter = 0;
ManualResetEvent ev = new ManualResetEvent(false);
using (IBus bus = new MessageBus.Core.RabbitMQBus())
{
using (ISubscriber subscriber = bus.CreateSubscriber(c => c.SetReceiveSelfPublish()))
{
subscriber.Subscribe((byte[] bytes) =>
{
received = bytes;
counter++;
});
subscriber.Subscribe(new Action<OK>(ok => ev.Set()));
subscriber.Open();
const int expected = 5;
using (IPublisher publisher = bus.CreatePublisher())
{
for (int i = 0; i < expected; i++)
{
publisher.Send(blob);
}
publisher.Send(new OK());
}
bool waitOne = ev.WaitOne(TimeSpan.FromSeconds(60));
waitOne.Should().BeTrue();
counter.Should().Be(expected);
}
}
}
public void Bus_MessageBaseSubscription_CallReceived()
{
ManualResetEvent ev = new ManualResetEvent(false);
MessageBasedImplementation implementation = new MessageBasedImplementation(ev);
using (IBus bus = new MessageBus.Core.RabbitMQBus())
{
using (ISubscription subscription = bus.RegisterSubscription(implementation, c => c.SetReceiveSelfPublish()))
{
subscription.Open();
using (IPublisher publisher = bus.CreatePublisher())
{
Person person = new Person {Id = 5};
BusMessage<Person> busMessage = new BusMessage<Person>
{
Data = person
};
busMessage.Headers.Add(new BusHeader
{
Name = "Header",
Value = "RightValue"
});
publisher.Send(busMessage);
bool waitOne = ev.WaitOne(TimeSpan.FromSeconds(5000));
waitOne.Should().BeTrue();
busMessage.ShouldBeEquivalentTo(implementation.Message,
options =>
options.Excluding(message => message.BusId)
.Excluding(message => message.Sent));
}
}
}
}
public void Bus_DurableBus_SubscribesAfterPublishing_MessagesShouldBeReceived()
{
ImportiantData data = new ImportiantData { Info = "Valuable information" };
// Dispatch message
using (var bus = new MessageBus.Core.RabbitMQBus())
{
using (IPublisher publisher = bus.CreatePublisher())
{
publisher.Send(data);
}
}
ImportiantData expected = null;
ManualResetEvent ev = new ManualResetEvent(false);
// Second bus subscribes to message after it was dispatched and should receive it
using (var bus = new MessageBus.Core.RabbitMQBus())
{
using (ISubscriber subscriber = bus.CreateSubscriber(c => c.UseDurableQueue(QueueName)))
{
subscriber.Subscribe<ImportiantData>(p =>
{
expected = p;
ev.Set();
});
subscriber.Open();
bool wait = ev.WaitOne(TimeSpan.FromSeconds(5));
wait.Should().BeTrue();
}
}
expected.Should().NotBeNull();
expected.ShouldBeEquivalentTo(data);
}
public void Bus_UndeliverableMessages_ReturnedToSubscriber()
{
using (IBus bus = new MessageBus.Core.RabbitMQBus())
{
using (IPublisher publisher = bus.CreatePublisher(c => c.SetMandatoryDelivery().UseErrorHandler(this)))
{
Person person = new Person {Id = 5};
BusMessage<Person> busMessage = new BusMessage<Person>
{
Data = person
};
busMessage.Headers.Add(new BusHeader
{
Name = "Header",
Value = "Value"
});
publisher.Send(busMessage);
bool waitOne = _ev.WaitOne(TimeSpan.FromSeconds(5));
waitOne.Should().BeTrue();
_errorCode.Should().Be(312);
_text.Should().Be("NO_ROUTE");
_message.BusId.Should().Be(bus.BusId);
_message.Name.Should().Be("Person");
_message.Sent.Should().BeCloseTo(DateTime.Now, 2000);
_message.Data.Should().BeOfType<Person>();
_message.Headers.OfType<BusHeader>().Should().OnlyContain(header => header.Name == "Header" && header.Value == "Value");
person.ShouldBeEquivalentTo(_message.Data);
}
}
}
public void Bus_PublishedMessage_EachReceiverGetsMessageCopy()
{
Person actual = new Person
{
Id = 5
};
using (MessageBus.Core.RabbitMQBus busA = new MessageBus.Core.RabbitMQBus(), busB = new MessageBus.Core.RabbitMQBus(), busC = new MessageBus.Core.RabbitMQBus())
{
using (IReceiver receiverB1 = busB.CreateReceiver(), receiverB2 = busB.CreateReceiver(), receiverC1 = busC.CreateReceiver())
{
receiverB1.Subscribe<Person>();
receiverB2.Subscribe<Person>();
receiverC1.Subscribe<Person>();
receiverB1.Open();
receiverB2.Open();
receiverC1.Open();
using (IPublisher publisher = busA.CreatePublisher())
{
publisher.Send(actual);
}
Person b1 = receiverB1.Receive<Person>();
Person b2 = receiverB2.Receive<Person>();
Person c1 = receiverC1.Receive<Person>();
b1.Should().NotBeNull();
b2.Should().NotBeNull();
c1.Should().NotBeNull();
b1.ShouldBeEquivalentTo(actual);
b2.ShouldBeEquivalentTo(actual);
c1.ShouldBeEquivalentTo(actual);
}
}
}
public void Bus_PublishedMessage_EachReceiverGetsMessageCopy()
{
Person actual = new Person
{
Id = 5
};
using (MessageBus.Core.RabbitMQBus busA = new MessageBus.Core.RabbitMQBus(), busB = new MessageBus.Core.RabbitMQBus(), busC = new MessageBus.Core.RabbitMQBus())
{
using (IReceiver receiverB1 = busB.CreateReceiver(), receiverB2 = busB.CreateReceiver(), receiverC1 = busC.CreateReceiver())
{
receiverB1.Subscribe <Person>();
receiverB2.Subscribe <Person>();
receiverC1.Subscribe <Person>();
receiverB1.Open();
receiverB2.Open();
receiverC1.Open();
using (IPublisher publisher = busA.CreatePublisher())
{
publisher.Send(actual);
}
Person b1 = receiverB1.Receive <Person>();
Person b2 = receiverB2.Receive <Person>();
Person c1 = receiverC1.Receive <Person>();
b1.Should().NotBeNull();
b2.Should().NotBeNull();
c1.Should().NotBeNull();
b1.ShouldBeEquivalentTo(actual);
b2.ShouldBeEquivalentTo(actual);
c1.ShouldBeEquivalentTo(actual);
}
}
}
public void Bus_CustomConsumerTag_ShouldArriveToSubscriber()
{
ManualResetEvent ev = new ManualResetEvent(false);
using (var bus = new MessageBus.Core.RabbitMQBus())
{
using (ISubscriber subscriber = bus.CreateSubscriber(c => c.SetReceiveSelfPublish().SetConsumerTag("MyConsumer")))
{
subscriber.Subscribe((Action <OK>)(ok => ev.Set()));
subscriber.Open();
using (IPublisher publisher = bus.CreatePublisher())
{
publisher.Send(new OK());
}
bool wait = ev.WaitOne(TimeSpan.FromSeconds(10));
wait.Should().BeTrue();
}
}
}
public void Bus_CustomConsumerTag_ShouldArriveToSubscriber()
{
ManualResetEvent ev = new ManualResetEvent(false);
using (var bus = new MessageBus.Core.RabbitMQBus())
{
using (ISubscriber subscriber = bus.CreateSubscriber(c => c.SetReceiveSelfPublish().SetConsumerTag("MyConsumer")))
{
subscriber.Subscribe((Action<OK>) (ok => ev.Set()));
subscriber.Open();
using (IPublisher publisher = bus.CreatePublisher())
{
publisher.Send(new OK());
}
bool wait = ev.WaitOne(TimeSpan.FromSeconds(10));
wait.Should().BeTrue();
}
}
}
public void Bus_PublishedMessage_ReceiveSelfPublishIsTrue_ShouldArriveToSubscriber()
{
ManualResetEvent ev = new ManualResetEvent(false);
using (var bus = new MessageBus.Core.RabbitMQBus())
{
using (ISubscriber subscriber = bus.CreateSubscriber(c => c.SetReceiveSelfPublish()))
{
subscriber.Subscribe((Action <OK>)(ok => ev.Set()));
subscriber.Open();
using (IPublisher publisher = bus.CreatePublisher())
{
publisher.Send(new OK());
}
bool wait = ev.WaitOne(TimeSpan.FromSeconds(10));
wait.Should().BeTrue("Message should not arrive from publisher to subscriber within same bus instance");
}
}
}
public void Bus_ErrorSubscriber_UnregisteredMessageShouldNotArrive()
{
const string busId = "MyBus";
using (IBus bus = new MessageBus.Core.RabbitMQBus(c => c.SetBusId(busId)))
{
using (ISubscriber subscriber = bus.CreateSubscriber(c => c.UseErrorSubscriber(this)))
{
subscriber.Open();
using (IPublisher publisher = bus.CreatePublisher())
{
publisher.Send(new ContractToSend {
Data = 4
});
}
bool wait = _ev.WaitOne(TimeSpan.FromSeconds(5));
wait.Should().BeFalse();
_busMessage.Should().BeNull();
}
}
}
public void Bus_ErrorSubscriber_MessageFilteredOut()
{
const string busId = "MyBus";
using (IBus bus = new MessageBus.Core.RabbitMQBus(c => c.SetBusId(busId)))
{
using (ISubscriber subscriber = bus.CreateSubscriber(c => c.UseErrorSubscriber(this)))
{
subscriber.Subscribe((OK ok) => Trace.WriteLine("Received"));
subscriber.Open();
OK expectation = new OK();
using (IPublisher publisher = bus.CreatePublisher())
{
publisher.Send(expectation);
}
bool wait = _ev.WaitOne(TimeSpan.FromSeconds(5));
wait.Should().BeTrue();
_busMessage.Name.Should().Be("OK");
_busMessage.Namespace.Should().Be("bus.test.org");
_busMessage.Data.Should().BeOfType<OK>();
_busMessage.BusId.Should().Be(busId);
}
}
}
public void Bus_ErrorSubscriber_MessageGeneralException()
{
const string busId = "MyBus";
using (IBus bus = new MessageBus.Core.RabbitMQBus(c => c.SetBusId(busId)))
{
using (ISubscriber subscriber = bus.CreateSubscriber(c => c.UseErrorSubscriber(this).SetReceiveSelfPublish()))
{
subscriber.Subscribe(delegate(ContractToSend ok) { });
subscriber.Open();
ConnectionFactory factory = new ConnectionFactory();
using (IConnection connection = factory.CreateConnection())
{
using (var model = connection.CreateModel())
{
IBasicProperties prop = model.CreateBasicProperties();
prop.Headers = new Dictionary<string, object>
{
{"Name", "Data"},
{"Namespace", "bus.error.test.org"}
};
model.BasicPublish("amq.headers", "", prop, Encoding.ASCII.GetBytes("sdjashdkjashd"));
}
}
bool wait = _ev.WaitOne(TimeSpan.FromSeconds(5));
wait.Should().BeTrue();
_busMessage.Should().BeNull();
_exception.Should().NotBeNull();
}
}
}
public void Bus_PublishedMessage_ReceiveSelfPublishIsTrue_ShouldArriveToReceiver()
{
using (MessageBus.Core.RabbitMQBus bus = new MessageBus.Core.RabbitMQBus())
{
using (IReceiver receiver = bus.CreateReceiver(c => c.SetReceiveSelfPublish()))
{
receiver.Subscribe<OK>();
receiver.Open();
using (IPublisher publisher = bus.CreatePublisher())
{
publisher.Send(new OK());
}
OK receive = receiver.Receive<OK>();
receive.Should()
.NotBeNull("Message should not arrive from publisher to subscriber within same bus instance");
}
}
}
public void Bus_ErrorSubscriber_UnregisteredMessageShouldNotArrive()
{
const string busId = "MyBus";
using (IBus bus = new MessageBus.Core.RabbitMQBus(c => c.SetBusId(busId)))
{
string queue;
using (var manager = bus.CreateRouteManager())
{
queue = manager.CreateQueue("test32424", true, true, CreateQueueSettings.Default);
using (ISubscriber subscriber = bus.CreateSubscriber(c => c.UseDurableQueue(queue).UseErrorSubscriber(this)))
{
subscriber.Open();
ConnectionFactory factory = new ConnectionFactory();
using (IConnection connection = factory.CreateConnection())
{
using (var model = connection.CreateModel())
{
IBasicProperties prop = model.CreateBasicProperties();
prop.Headers = new Dictionary<string, object>
{
{"Name", "Data"},
{"Namespace", "bus.error.test.org"}
};
model.BasicPublish("", queue, prop, Encoding.ASCII.GetBytes("sdjashdkjashd"));
}
}
bool wait = _ev.WaitOne(TimeSpan.FromSeconds(5));
wait.Should().BeTrue();
_busMessage.Should().NotBeNull();
}
}
}
}
public void RabbitMQBus_Dialog_WithOrderedDelivery_AllSubscriptionTypes()
{
using (MessageBus.Core.RabbitMQBus entityA = new MessageBus.Core.RabbitMQBus(), entityB = new MessageBus.Core.RabbitMQBus())
{
Data messageA = new Person
{
Id = 5
};
Data messageB = new Car
{
Number = "39847239847"
};
List <Data> received = new List <Data>();
ManualResetEvent ev1 = new ManualResetEvent(false), ev2 = new ManualResetEvent(false);
using (ISubscriber subscriberA = entityA.CreateSubscriber(), subscriberB = entityB.CreateSubscriber())
{
subscriberA.Subscribe <Data>(received.Add, true);
subscriberA.Subscribe(typeof(OK), (Action <object>)(data => ev1.Set()));
subscriberB.Subscribe((Action <OK>)(data => ev2.Set()));
subscriberA.Open();
subscriberB.Open();
using (IPublisher publisher = entityB.CreatePublisher())
{
publisher.Send(messageA);
publisher.Send(messageB);
publisher.Send(new OK());
}
using (IPublisher publisher = entityA.CreatePublisher())
{
publisher.Send(new OK());
}
bool waitOne = ev1.WaitOne(TimeSpan.FromSeconds(20)) && ev2.WaitOne(TimeSpan.FromSeconds(20));
waitOne.Should().BeTrue("Message not received");
received.Should().ContainInOrder(messageA, messageB);
}
}
}
public void Bus_ErrorSubscriber_UnregisteredMessageShouldNotArrive()
{
const string busId = "MyBus";
using (IBus bus = new MessageBus.Core.RabbitMQBus(c => c.SetBusId(busId)))
{
using (ISubscriber subscriber = bus.CreateSubscriber(c => c.UseErrorSubscriber(this)))
{
subscriber.Open();
using (IPublisher publisher = bus.CreatePublisher())
{
publisher.Send(new ContractToSend { Data = 4 });
}
bool wait = _ev.WaitOne(TimeSpan.FromSeconds(5));
wait.Should().BeFalse();
_busMessage.Should().BeNull();
}
}
}
public void Queue_NonDurableQueue_TwoExclusiveSubscribers_BothShouldGetMessage()
{
var receivedMessages = new int[2];
for (int subscriberNum = 0; subscriberNum < receivedMessages.GetLength(0); subscriberNum++)
{
receivedMessages[subscriberNum] = 0;
}
ManualResetEvent ev1 = new ManualResetEvent(false);
ManualResetEvent ev2 = new ManualResetEvent(false);
bool wait1;
bool wait2;
IBus subscriberBus = null;
ISubscriber subscriber1 = null, subscriber2 = null;
try
{
subscriberBus = new MessageBus.Core.RabbitMQBus();
subscriber1 = subscriberBus.CreateSubscriber(c => { });
subscriber1.Subscribe((GenericMessage <Specific1> p) =>
{
Interlocked.Increment(ref receivedMessages[0]);
ev1.Set();
});
subscriber1.Open();
subscriber2 = subscriberBus.CreateSubscriber(c => { });
subscriber2.Subscribe((GenericMessage <Specific2> p) =>
{
Interlocked.Increment(ref receivedMessages[1]);
ev2.Set();
});
subscriber2.Open();
// Dispatch message
using (var bus = new MessageBus.Core.RabbitMQBus())
{
using (IPublisher publisher = bus.CreatePublisher())
{
publisher.Send(new GenericMessage <Specific2> {
RequestReference = Guid.NewGuid()
});
publisher.Send(new GenericMessage <Specific1> {
RequestReference = Guid.NewGuid()
});
publisher.Send(new GenericMessage <Specific2> {
RequestReference = Guid.NewGuid()
});
publisher.Send(new GenericMessage <Specific2> {
RequestReference = Guid.NewGuid()
});
publisher.Send(new GenericMessage <Specific1> {
RequestReference = Guid.NewGuid()
});
publisher.Send(new GenericMessage <Specific2> {
RequestReference = Guid.NewGuid()
});
publisher.Send(new GenericMessage <Specific2> {
RequestReference = Guid.NewGuid()
});
}
}
wait1 = ev1.WaitOne(TimeSpan.FromMilliseconds(100));
wait2 = ev2.WaitOne(TimeSpan.FromMilliseconds(100));
}
finally
{
subscriber2?.Dispose();
subscriber1?.Dispose();
subscriberBus?.Dispose();
}
wait1.Should().BeTrue();
wait2.Should().BeTrue();
receivedMessages[0].ShouldBeEquivalentTo(2);
receivedMessages[1].ShouldBeEquivalentTo(5);
}
public void Bus_PublishedMessage_FilterByHeader()
{
Person actualT1 = new Person
{
Id = 5
};
Person actualT2 = new Person
{
Id = 15
};
Person b1 = null, b2 = null, c1 = null;
const string header = "type";
ManualResetEvent ev1 = new ManualResetEvent(false), ev2 = new ManualResetEvent(false), ev3 = new ManualResetEvent(false);
using (MessageBus.Core.RabbitMQBus busA = new MessageBus.Core.RabbitMQBus(), busB = new MessageBus.Core.RabbitMQBus(), busC = new MessageBus.Core.RabbitMQBus())
{
using (ISubscriber subscriberB1 = busB.CreateSubscriber(), subscriberB2 = busB.CreateSubscriber(), subscriberC1 = busC.CreateSubscriber())
{
subscriberB1.Subscribe <Person>(p => { b1 = p; ev1.Set(); }, filter: new[] { new BusHeader {
Name = header, Value = "T1"
} });
subscriberB2.Subscribe <Person>(p => { b2 = p; ev2.Set(); }, filter: new[] { new BusHeader {
Name = header, Value = "T2"
} });
subscriberC1.Subscribe <Person>(p => { c1 = p; ev3.Set(); }, filter: new[] { new BusHeader {
Name = header, Value = "T1"
} });
subscriberB1.Open();
subscriberB2.Open();
subscriberC1.Open();
using (IPublisher publisher = busA.CreatePublisher())
{
BusMessage <Person> m1 = new BusMessage <Person> {
Data = actualT1
};
m1.Headers.Add(new BusHeader {
Name = header, Value = "T1"
});
publisher.Send(m1);
BusMessage <Person> m2 = new BusMessage <Person> {
Data = actualT2
};
m2.Headers.Add(new BusHeader {
Name = header, Value = "T2"
});
publisher.Send(m2);
}
bool wait = ev1.WaitOne(TimeSpan.FromSeconds(5)) &&
ev2.WaitOne(TimeSpan.FromSeconds(5)) &&
ev3.WaitOne(TimeSpan.FromSeconds(5));
wait.Should().BeTrue("Message should arrive to all subscribers");
b1.Should().NotBeNull();
b2.Should().NotBeNull();
c1.Should().NotBeNull();
b1.ShouldBeEquivalentTo(actualT1);
b2.ShouldBeEquivalentTo(actualT2);
c1.ShouldBeEquivalentTo(actualT1);
}
}
}
public void Bus_PublishedMessage_ReceiveSelfPublishIsTrue_ShouldArriveToSubscriber()
{
ManualResetEvent ev = new ManualResetEvent(false);
using (var bus = new MessageBus.Core.RabbitMQBus())
{
using (ISubscriber subscriber = bus.CreateSubscriber(c => c.SetReceiveSelfPublish()))
{
subscriber.Subscribe((Action<OK>) (ok => ev.Set()));
subscriber.Open();
using (IPublisher publisher = bus.CreatePublisher())
{
publisher.Send(new OK());
}
bool wait = ev.WaitOne(TimeSpan.FromSeconds(10));
wait.Should().BeTrue("Message should arrive from publisher to subscriber within same bus instance");
}
}
}
public void Bus_SubscriptionWithFilter_CallFiltered()
{
ManualResetEvent ev = new ManualResetEvent(false);
FilterImplementation implementation = new FilterImplementation(ev);
using (IBus bus = new MessageBus.Core.RabbitMQBus())
{
using (ISubscription subscription = bus.RegisterSubscription(implementation, c => c.SetReceiveSelfPublish()))
{
subscription.Open();
using (IPublisher publisher = bus.CreatePublisher())
{
Person person = new Person {Id = 5};
BusMessage<Person> busMessage = new BusMessage<Person>
{
Data = person
};
busMessage.Headers.Add(new BusHeader
{
Name = "Header",
Value = "WrongValue"
});
publisher.Send(busMessage);
bool waitOne = ev.WaitOne(TimeSpan.FromSeconds(5));
waitOne.Should().BeFalse();
}
}
}
}
public void Queue_NonDurableQueue_TwoExclusiveSubscribers_BothShouldGetMessage()
{
NonImportantData data = new NonImportantData {
Info = "Non-Valuable information"
};
NonImportantData expected1 = null;
NonImportantData expected2 = null;
ManualResetEvent ev1 = new ManualResetEvent(false);
ManualResetEvent ev2 = new ManualResetEvent(false);
bool wait1;
bool wait2;
IBus subscriberBus = null;
ISubscriber subscriber1 = null, subscriber2 = null;
try
{
subscriberBus = new MessageBus.Core.RabbitMQBus();
subscriber1 = subscriberBus.CreateSubscriber(c => { });
subscriber1.Subscribe <NonImportantData>(p =>
{
expected1 = p;
ev1.Set();
});
subscriber1.Open();
subscriber2 = subscriberBus.CreateSubscriber(c => { });
subscriber2.Subscribe <NonImportantData>(p =>
{
expected2 = p;
ev2.Set();
});
subscriber2.Open();
// Dispatch message
using (var bus = new MessageBus.Core.RabbitMQBus())
{
using (IPublisher publisher = bus.CreatePublisher())
{
publisher.Send(data);
}
}
wait1 = ev1.WaitOne(TimeSpan.FromMilliseconds(100));
wait2 = ev2.WaitOne(TimeSpan.FromMilliseconds(100));
}
finally
{
subscriber2?.Dispose();
subscriber1?.Dispose();
subscriberBus?.Dispose();
}
wait1.Should().BeTrue();
wait2.Should().BeTrue();
expected1.Should().NotBeNull();
expected1.ShouldBeEquivalentTo(data);
expected2.Should().NotBeNull();
expected2.ShouldBeEquivalentTo(data);
}
public void Queue_NonDurableQueue_TwoSharedQueueSubscribers_OneShouldGetMessage()
{
NonImportantData data = new NonImportantData {
Info = "Non-Valuable information"
};
NonImportantData expected1 = null;
NonImportantData expected2 = null;
ManualResetEvent ev1 = new ManualResetEvent(false);
ManualResetEvent ev2 = new ManualResetEvent(false);
bool wait1;
bool wait2;
IBus subscriberBus = null;
ISubscriber subscriber1 = null, subscriber2 = null;
try
{
subscriberBus = new MessageBus.Core.RabbitMQBus();
subscriber1 = subscriberBus.CreateSubscriber(c => c.UseNonDurableNamedQueue(NonDurableTestQueueSuffix));
subscriber1.Subscribe <NonImportantData>(p =>
{
expected1 = p;
ev1.Set();
});
subscriber1.Open();
subscriber2 = subscriberBus.CreateSubscriber(c => c.UseNonDurableNamedQueue(NonDurableTestQueueSuffix));
subscriber2.Subscribe <NonImportantData>(p =>
{
expected2 = p;
ev2.Set();
});
subscriber2.Open();
// Dispatch message
using (var bus = new MessageBus.Core.RabbitMQBus())
{
using (IPublisher publisher = bus.CreatePublisher())
{
publisher.Send(data);
}
}
wait1 = ev1.WaitOne(TimeSpan.FromMilliseconds(100));
wait2 = ev2.WaitOne(TimeSpan.FromMilliseconds(100));
}
finally
{
subscriber2?.Dispose();
subscriber1?.Dispose();
subscriberBus?.Dispose();
}
// Wait for reset events to timeout
Thread.Sleep(500);
wait1.ShouldBeEquivalentTo(!wait2);
if (wait1)
{
expected2.Should().BeNull();
expected1.Should().NotBeNull();
expected1.ShouldBeEquivalentTo(data);
}
else
{
expected1.Should().BeNull();
expected2.Should().NotBeNull();
expected2.ShouldBeEquivalentTo(data);
}
}
public void Bus_PublishedMessage_FilterByHeader()
{
Person actualT1 = new Person
{
Id = 5
};
Person actualT2 = new Person
{
Id = 15
};
const string header = "type";
using (MessageBus.Core.RabbitMQBus busA = new MessageBus.Core.RabbitMQBus(), busB = new MessageBus.Core.RabbitMQBus(), busC = new MessageBus.Core.RabbitMQBus())
{
using (IReceiver receiverB1 = busB.CreateReceiver(), receiverB2 = busB.CreateReceiver(), receiverC1 = busC.CreateReceiver())
{
receiverB1.Subscribe <Person>(filter: new[] { new BusHeader {
Name = header, Value = "T1"
} });
receiverB2.Subscribe <Person>(filter: new[] { new BusHeader {
Name = header, Value = "T2"
} });
receiverC1.Subscribe <Person>(filter: new[] { new BusHeader {
Name = header, Value = "T1"
} });
receiverB1.Open();
receiverB2.Open();
receiverC1.Open();
using (IPublisher publisher = busA.CreatePublisher())
{
BusMessage <Person> m1 = new BusMessage <Person> {
Data = actualT1
};
m1.Headers.Add(new BusHeader {
Name = header, Value = "T1"
});
publisher.Send(m1);
BusMessage <Person> m2 = new BusMessage <Person> {
Data = actualT2
};
m2.Headers.Add(new BusHeader {
Name = header, Value = "T2"
});
publisher.Send(m2);
}
Person b1 = receiverB1.Receive <Person>();
Person b2 = receiverB2.Receive <Person>();
Person c1 = receiverC1.Receive <Person>();
b1.Should().NotBeNull();
b2.Should().NotBeNull();
c1.Should().NotBeNull();
b1.ShouldBeEquivalentTo(actualT1);
b2.ShouldBeEquivalentTo(actualT2);
c1.ShouldBeEquivalentTo(actualT1);
}
}
}
public void Bus_PublishedMessage_EachSubscriberGetsMessageCopy()
{
Person actual = new Person
{
Id = 5
};
Person b1 = null, b2 = null, c1 = null;
ManualResetEvent ev1 = new ManualResetEvent(false), ev2 = new ManualResetEvent(false), ev3 = new ManualResetEvent(false);
using (MessageBus.Core.RabbitMQBus busA = new MessageBus.Core.RabbitMQBus(), busB = new MessageBus.Core.RabbitMQBus(), busC = new MessageBus.Core.RabbitMQBus())
{
using (ISubscriber subscriberB1 = busB.CreateSubscriber(), subscriberB2 = busB.CreateSubscriber(), subscriberC1 = busC.CreateSubscriber())
{
subscriberB1.Subscribe <Person>(p => { b1 = p; ev1.Set(); });
subscriberB2.Subscribe <Person>(p => { p.Id *= 2; b2 = p; ev2.Set(); });
subscriberC1.Subscribe <Person>(p => { c1 = p; ev3.Set(); });
subscriberB1.Open();
subscriberB2.Open();
subscriberC1.Open();
using (IPublisher publisher = busA.CreatePublisher())
{
publisher.Send(actual);
}
bool wait = ev1.WaitOne(TimeSpan.FromSeconds(5)) &&
ev2.WaitOne(TimeSpan.FromSeconds(5)) &&
ev3.WaitOne(TimeSpan.FromSeconds(5));
wait.Should().BeTrue("Message should arrive to all subscribers");
b1.Should().NotBeNull();
b2.Should().NotBeNull();
c1.Should().NotBeNull();
b1.ShouldBeEquivalentTo(actual);
b2.ShouldBeEquivalentTo(new Person
{
Id = actual.Id * 2
});
c1.ShouldBeEquivalentTo(actual);
}
}
}
public void Bus_Receive_NoMassagesAvailableToReceiver()
{
using (MessageBus.Core.RabbitMQBus bus = new MessageBus.Core.RabbitMQBus())
{
using (IReceiver receiver = bus.CreateReceiver())
{
receiver.Subscribe<OK>();
receiver.Open();
OK receive = receiver.Receive<OK>();
receive.Should().BeNull("No messages are in queue, so NULL should be returned");
}
}
}
