public void PerformanceTest(int messageSize, bool confirmedSending)
{
var messageBytes = new byte[messageSize];
new Random().NextBytes(messageBytes);
using (var transport = new RabbitMqTransport(_logFactory, HOST, "guest", "guest"))
{
IMessagingSession messagingSession = transport.CreateSession(null, confirmedSending);
Stopwatch sw = Stopwatch.StartNew();
messagingSession.Send(TEST_EXCHANGE, new BinaryMessage {
Bytes = messageBytes, Type = typeof(byte[]).Name
}, 0);
int sendCounter;
for (sendCounter = 0; sw.ElapsedMilliseconds < 4000; sendCounter++)
{
messagingSession.Send(TEST_EXCHANGE, new BinaryMessage {
Bytes = messageBytes, Type = typeof(byte[]).Name
}, 0);
}
int receiveCounter = 0;
var ev = new ManualResetEvent(false);
messagingSession.Subscribe(TEST_QUEUE, (message, acknowledge) => receiveCounter++, typeof(byte[]).Name);
ev.WaitOne(2000);
Console.WriteLine("Send: {0} per second. {1:0.00} Mbit/s", sendCounter / 4, 1.0 * sendCounter * messageSize / 4 / 1024 / 1024 * 8);
Console.WriteLine("Receive: {0} per second. {1:0.00} Mbit/s", receiveCounter / 2, 1.0 * receiveCounter * messageSize / 2 / 1024 / 1024 * 8);
}
}
public void NackTest()
{
using (var transport = new RabbitMqTransport(_logFactory, HOST, "guest", "guest"))
{
var delivered = new ManualResetEvent(false);
IMessagingSession messagingSession = transport.CreateSession(null);
messagingSession.Send(TEST_EXCHANGE, new BinaryMessage {
Bytes = new byte[] { 0x0, 0x1, 0x2 }, Type = typeof(byte[]).Name
}, 0);
messagingSession.Subscribe(TEST_QUEUE, (message, acknowledge) =>
{
Console.WriteLine("message:" + message.Type);
delivered.Set();
acknowledge(false);
}, typeof(byte[]).Name);
Assert.That(delivered.WaitOne(300), Is.True, "Message was not delivered");
}
using (var transport = new RabbitMqTransport(_logFactory, HOST, "guest", "guest"))
{
var delivered = new ManualResetEvent(false);
IMessagingSession messagingSession = transport.CreateSession(null);
messagingSession.Subscribe(TEST_QUEUE, (message, acknowledge) => delivered.Set(), typeof(byte[]).Name);
Assert.That(delivered.WaitOne(1000), Is.True, "Message was not returned to queue");
}
}
public void UnknownMessageTypeHandlerWaitingDoesNotPreventTransportDisposeTest()
{
var received = new ManualResetEvent(false);
Thread connectionThread = null;
using (var transport = new RabbitMqTransport(_logFactory, HOST, "guest", "guest"))
{
IMessagingSession messagingSession = transport.CreateSession(null);
messagingSession.Subscribe(TEST_QUEUE, (message, acknowledge) =>
{
connectionThread = Thread.CurrentThread;
received.Set();
}, "type1");
messagingSession.Send(TEST_EXCHANGE, new BinaryMessage {
Bytes = new byte[] { 0x0, 0x1, 0x2 }, Type = "type1"
}, 0);
Assert.That(received.WaitOne(100), Is.True, "Message was not delivered");
messagingSession.Send(TEST_EXCHANGE, new BinaryMessage {
Bytes = new byte[] { 0x0, 0x1, 0x2 }, Type = "type2"
}, 0);
}
GC.Collect();
Thread.Sleep(30000);
Assert.That(connectionThread.ThreadState, Is.EqualTo(ThreadState.Stopped), "Processing thread is still active in spite of transport dispose");
}
public void SessionIsTreatedAsBrokenAfterSendFailureWithAlreadyClosedExceptionTest()
{
using (var transport = new RabbitMqTransport(_logFactory, HOST, "guest", "guest"))
{
var onFailureCalled = new AutoResetEvent(false);
IMessagingSession messagingSession = transport.CreateSession(() =>
{
onFailureCalled.Set();
Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
});
messagingSession.Send(TEST_EXCHANGE, new BinaryMessage {
Bytes = new byte[] { 0x0, 0x1, 0x2 }, Type = "messageType"
}, 0);
FieldInfo field = typeof(RabbitMqSession).GetField("m_Connection", BindingFlags.NonPublic | BindingFlags.Instance);
var connection = field.GetValue(messagingSession) as IConnection;
connection.Abort(1, "All your base are belong to us");
AlreadyClosedException ex = null;
try
{
messagingSession.Send(TEST_EXCHANGE, new BinaryMessage {
Bytes = new byte[] { 0x0, 0x1, 0x2 }, Type = "messageType"
}, 0);
}
catch (AlreadyClosedException e)
{
ex = e;
}
Assert.That(ex, Is.Not.Null, "Exception was not thrown on send fail");
Assert.That(ex, Is.InstanceOf <AlreadyClosedException>(), "Wrong exception type was thrown on send fail");
Assert.That(transport.SessionsCount, Is.EqualTo(0), "session was not removed after send failed AlreadyClosedException ");
Assert.That(onFailureCalled.WaitOne(500), Is.True, "Subsciptionwas not notefied on failure");
}
}
public void SendFailureTest()
{
using (var transport = new RabbitMqTransport(_logFactory, HOST, "guest", "guest"))
{
var delivered = new ManualResetEvent(false);
IMessagingSession messagingSession = transport.CreateSession(() => Console.WriteLine("onFailure called"));
/*FieldInfo field = typeof(RabbitMqSession).GetField("m_Connection", BindingFlags.NonPublic | BindingFlags.Instance);
* var connection = field.GetValue(messagingSession) as IConnection;
* connection.Abort(1, "All your base are belong to us");*/
while (true)
{
try
{
messagingSession.Send(TEST_EXCHANGE, new BinaryMessage {
Bytes = new byte[] { 0x0, 0x1, 0x2 }, Type = typeof(byte[]).Name
}, 0);
}
catch (Exception e)
{
Console.WriteLine(e.Message + "!!!!!!!!!");
throw;
}
Thread.Sleep(1000);
Console.WriteLine('.');
}
}
}
public void MessageOfUnknownTypeShouldPauseProcessingTillCorrespondingHandlerIsRegisteredTest()
{
using (var transport = new RabbitMqTransport(_logFactory, HOST, "guest", "guest"))
{
IMessagingSession messagingSession = transport.CreateSession(null);
var type1Received = new AutoResetEvent(false);
var type2Received = new AutoResetEvent(false);
messagingSession.Subscribe(TEST_QUEUE, (message, acknowledge) =>
{
type1Received.Set();
acknowledge(true);
}, "type1");
messagingSession.Send(TEST_EXCHANGE, new BinaryMessage {
Bytes = new byte[] { 0x0, 0x1, 0x2 }, Type = "type1"
}, 0);
Assert.That(type1Received.WaitOne(500), Is.True, "Message of subscribed type was not delivered");
messagingSession.Send(TEST_EXCHANGE, new BinaryMessage {
Bytes = new byte[] { 0x0, 0x1, 0x2 }, Type = "type2"
}, 0);
//Give time for type2 message to be pushed back by mq
//Thread.Sleep(500);
messagingSession.Send(TEST_EXCHANGE, new BinaryMessage {
Bytes = new byte[] { 0x0, 0x1, 0x2 }, Type = "type1"
}, 0);
Assert.That(type1Received.WaitOne(500), Is.False, "Message of not subscribed type has not paused processing");
Assert.That(type2Received.WaitOne(500), Is.False, "Message of not subscribed type has not paused processing");
messagingSession.Subscribe(TEST_QUEUE, (message, acknowledge) => { type2Received.Set();
acknowledge(true); }, "type2");
Assert.That(type1Received.WaitOne(500), Is.True, "Processing was not resumed after handler for unknown message type was registered");
Assert.That(type2Received.WaitOne(500), Is.True, "Processing was not resumed after handler for unknown message type was registered");
}
}
public void AttemptToSubscribeSameDestinationAndMessageTypeTwiceFailureTest()
{
using (var transport = new RabbitMqTransport(_logFactory, HOST, "guest", "guest"))
{
IMessagingSession messagingSession = transport.CreateSession(null);
messagingSession.Subscribe(TEST_QUEUE, (message, acknowledge) => { }, "type1");
Assert.That(() => messagingSession.Subscribe(TEST_QUEUE, (message, acknowledge) => { }, "type1"), Throws.TypeOf <InvalidOperationException>());
}
}
public void UnsubscribeTest(string messageType)
{
using (var transport = new RabbitMqTransport(_logFactory, HOST, "guest", "guest"))
{
var ev = new AutoResetEvent(false);
IMessagingSession messagingSession = transport.CreateSession(null);
messagingSession.Send(TEST_EXCHANGE, new BinaryMessage {
Bytes = new byte[] { 0x0, 0x1, 0x2 }, Type = messageType
}, 0);
IDisposable subscription = messagingSession.Subscribe(TEST_QUEUE, (message, acknowledge) => ev.Set(), messageType);
Assert.That(ev.WaitOne(500), Is.True, "Message was not delivered");
subscription.Dispose();
Assert.That(ev.WaitOne(500), Is.False, "Message was delivered for canceled subscription");
}
}
public void HandlerWaitStopsAndMessageOfUnknownTypeReturnsToQueueOnUnsubscribeTest()
{
using (var transport = new RabbitMqTransport(_logFactory, HOST, "guest", "guest"))
{
IMessagingSession messagingSession = transport.CreateSession(null);
var received = new AutoResetEvent(false);
IDisposable subscription = messagingSession.Subscribe(TEST_QUEUE, (message, acknowledge) =>
{
received.Set();
Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
}, "type2");
messagingSession.Send(TEST_EXCHANGE, new BinaryMessage {
Bytes = new byte[] { 0x0, 0x1, 0x2 }, Type = "type1"
}, 0);
Assert.That(received.WaitOne(500), Is.False, "Message of not subscribed type has not paused processing");
subscription.Dispose();
messagingSession.Subscribe(TEST_QUEUE, (message, acknowledge) => received.Set(), "type1");
Assert.That(received.WaitOne(500), Is.True, "Message was not returned to queue");
}
}
public void ConnectionFailureTest()
{
using (var transport = new RabbitMqTransport(_logFactory, HOST, "guest", "guest"))
{
var onFailureCalled = new AutoResetEvent(false);
IMessagingSession messagingSession = transport.CreateSession(() =>
{
onFailureCalled.Set();
Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
});
messagingSession.Send(TEST_EXCHANGE, new BinaryMessage {
Bytes = new byte[] { 0x0, 0x1, 0x2 }, Type = "messageType"
}, 0);
messagingSession.Subscribe(TEST_QUEUE, (message, acknowledge) => { }, "messageType");
FieldInfo field = typeof(RabbitMqSession).GetField("m_Connection", BindingFlags.NonPublic | BindingFlags.Instance);
var connection = field.GetValue(messagingSession) as IConnection;
connection.Abort(1, "All your base are belong to us");
Assert.That(onFailureCalled.WaitOne(500), Is.True, "Subsciptionwas not notefied on failure");
}
}
public void RpcTest()
{
using (var transport = new RabbitMqTransport(_logFactory, HOST, "guest", "guest"))
{
var request = new byte[] { 0x0, 0x1, 0x2 };
var response = new byte[] { 0x2, 0x1, 0x0 };
byte[] actualResponse = null;
var received = new ManualResetEvent(false);
var session = transport.CreateSession(null);
session.RegisterHandler(TEST_QUEUE, message => new BinaryMessage {
Bytes = response, Type = typeof(byte[]).Name
}, null);
session.SendRequest(TEST_EXCHANGE, new BinaryMessage {
Bytes = request, Type = typeof(byte[]).Name
}, message =>
{
actualResponse = message.Bytes;
received.Set();
});
Assert.That(received.WaitOne(500), Is.True, "Response was not received");
Assert.That(actualResponse, Is.EqualTo(response), "Received response does not match sent one");
}
}
