public void Subscriber_sends_message_Publisher_receives_message(RedFoxTransport transport)
{
using (var publisher = new Publisher())
using (var subscriber = new TestSubscriber())
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
var eventFired = new ManualResetEventSlim();
IMessage messageReceived = null;
ISocket messageSocket = null;
publisher.MessageReceived += (s, m) =>
{
messageSocket = s;
messageReceived = m;
eventFired.Set();
};
ISocket connectedSocket = null;
publisher.ClientConnected += (s, m) => { connectedSocket = s; };
publisher.Bind(endpoint);
subscriber.Connect(endpoint);
IMessage messageSent = new TestMessage("test");
subscriber.SendMessage(messageSent);
Assert.IsTrue(eventFired.Wait(Timeout));
Assert.AreEqual(messageSent, messageReceived);
Assert.AreEqual(connectedSocket, messageSocket);
}
}
public void RequestAsync_Response_two_messages_simultaneous(RedFoxTransport transport)
{
using (var responder = TestHelpers.CreateTestResponder())
using (var requester = new Requester())
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
responder.Bind(endpoint);
requester.Connect(endpoint);
var messagesReceived = new List <TestMessage>();
Thread.Sleep(100);
var messageSent = new TestMessage {
Text = "Hello"
};
var task1 = requester.RequestAsync(messageSent);
var task2 = requester.RequestAsync(messageSent);
Assert.IsTrue(Task.WhenAll(task1, task2).Wait(TimeSpan.FromSeconds(1)));
messagesReceived.Add((TestMessage)task1.Result);
messagesReceived.Add((TestMessage)task2.Result);
Assert.AreEqual(messageSent.Text, messagesReceived[0].Text);
Assert.AreEqual(messageSent.Text, messagesReceived[1].Text);
}
}
public void TryParse_transport_should_be_parsed(string endpointUri, RedFoxTransport expectedTransport)
{
RedFoxEndpoint endpoint;
Assert.IsTrue(RedFoxEndpoint.TryParse(endpointUri, out endpoint));
Assert.AreEqual(expectedTransport, endpoint.Transport);
}
public RedFoxEndpoint(RedFoxTransport transport, string host, ushort port, string path)
{
Transport = transport;
Host = host;
Port = port;
_path = String.IsNullOrEmpty(path) ? "/" : path;
}
public ISocketAccepter CreateForTransport(RedFoxTransport transport)
{
switch (transport)
{
case RedFoxTransport.Inproc:
return new InProcessSocketAccepter();
case RedFoxTransport.Tcp:
return new TcpSocketAccepter();
default:
throw new NotSupportedException(String.Format("Transport {0} not supported", transport));
}
}
public void Subscriber_Disconnect_doesnt_hang(RedFoxTransport transport)
{
using (var publisher = new Publisher())
using (var subscriber = new TestSubscriber())
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
publisher.Bind(endpoint);
subscriber.Connect(endpoint);
subscriber.Disconnect(true, Timeout);
}
}
public void Subscriber_IsDisconnected_should_be_false_when_connected(RedFoxTransport transport)
{
using (var publisher = new Publisher())
using (var subscriber = new TestSubscriber())
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
publisher.Bind(endpoint);
subscriber.Connect(endpoint);
Assert.IsFalse(subscriber.IsDisconnected);
}
}
public void Requester_IsDisconnected_should_be_false_when_connected(RedFoxTransport transport)
{
using (var responder = TestHelpers.CreateTestResponder())
using (var requester = new Requester())
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
responder.Bind(endpoint);
requester.Connect(endpoint);
Assert.IsFalse(requester.IsDisconnected);
}
}
public ISocketAccepter CreateForTransport(RedFoxTransport transport)
{
switch (transport)
{
case RedFoxTransport.Inproc:
return(new InProcessSocketAccepter());
case RedFoxTransport.Tcp:
return(new TcpSocketAccepter());
default:
throw new NotSupportedException(String.Format("Transport {0} not supported", transport));
}
}
public void Publisher_ClientConnected_event_fires(RedFoxTransport transport)
{
using (var publisher = new Publisher())
using (var subscriber = new TestSubscriber())
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
var eventFired = new ManualResetEventSlim();
publisher.Bind(endpoint);
publisher.ClientConnected += (s, c) => eventFired.Set();
subscriber.Connect(endpoint);
Assert.IsTrue(eventFired.Wait(Timeout));
}
}
public void Request_Response_different_threads_large_message(RedFoxTransport transport)
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
var started = new ManualResetEventSlim();
var stop = new ManualResetEventSlim();
Task.Run(() =>
{
using (var responder = TestHelpers.CreateTestResponder())
{
responder.Bind(endpoint);
started.Set();
stop.Wait();
}
});
var largeMessage = new TestMessage {
Text = new string('x', 1024 * 1024)
};
TestMessage messageReceived = null;
Task.Run(() =>
{
using (var requester = new Requester())
{
started.Wait(Timeout);
requester.Connect(endpoint);
messageReceived = (TestMessage)requester.Request(largeMessage);
stop.Set();
}
});
try
{
Assert.IsTrue(stop.Wait(Timeout));
Assert.AreEqual(largeMessage.Text, messageReceived.Text);
}
finally
{
stop.Set();
}
}
public void Subscribe_to_Publisher_twice_on_same_endpoint(RedFoxTransport transport)
{
for (var i = 0; i < 2; i++)
{
using (var publisher = new Publisher())
using (var subscriber = new TestSubscriber())
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
publisher.Bind(endpoint);
subscriber.Connect(endpoint);
var broadcastedMessage = new TestMessage { Text = "Hello" };
publisher.Broadcast(broadcastedMessage);
}
}
}
public void RequestAsync_Cancel_single_message(RedFoxTransport transport)
{
using (var responder = TestHelpers.CreateTestResponder(1000))
using (var requester = new Requester())
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
responder.Bind(endpoint);
requester.Connect(endpoint);
Thread.Sleep(100);
var messageSent = new TestMessage { Text = "Hello" };
var cancellationToken = new CancellationTokenSource(TimeSpan.FromMilliseconds(100)).Token;
Assert.Throws<AggregateException>(() => requester.RequestAsync(messageSent, cancellationToken).Wait());
}
}
public void RequestAsync_Response_single_message(RedFoxTransport transport)
{
using (var responder = TestHelpers.CreateTestResponder())
using (var requester = new Requester())
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
responder.Bind(endpoint);
requester.Connect(endpoint);
Thread.Sleep(100);
var messageSent = new TestMessage { Text = "Hello" };
var messageReceived = (TestMessage)requester.RequestAsync(messageSent).Result;
Assert.AreEqual(messageSent.Text, messageReceived.Text);
}
}
public void Subscribe_to_Responder_should_cause_protocol_exception(RedFoxTransport transport)
{
using (var responder = TestHelpers.CreateTestResponder())
using (var subscriber = new TestSubscriber())
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
responder.Bind(endpoint);
try
{
subscriber.Connect(endpoint);
}
catch (AggregateException ex)
{
throw ex.InnerExceptions.First();
}
}
}
public void Subscribe_to_Responder_should_cause_protocol_exception(RedFoxTransport transport)
{
using (var responder = TestHelpers.CreateTestResponder())
using (var subscriber = new TestSubscriber())
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
responder.Bind(endpoint);
try
{
subscriber.Connect(endpoint);
}
catch (AggregateException ex)
{
throw ex.InnerExceptions.First();
}
}
}
public void Subscribe_to_Publisher_receive_single_broadcasted_message(RedFoxTransport transport)
{
using (var publisher = new Publisher())
using (var subscriber = new TestSubscriber())
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
publisher.Bind(endpoint);
subscriber.Connect(endpoint);
Thread.Sleep(100);
var broadcastedMessage = new TestMessage { Text = "Hello" };
publisher.Broadcast(broadcastedMessage);
Assert.AreEqual(broadcastedMessage, subscriber.TestMustReceiveMessageWithin(Timeout));
}
}
public void Subscribe_to_Publisher_twice_on_same_endpoint(RedFoxTransport transport)
{
for (var i = 0; i < 2; i++)
{
using (var publisher = new Publisher())
using (var subscriber = new TestSubscriber())
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
publisher.Bind(endpoint);
subscriber.Connect(endpoint);
var broadcastedMessage = new TestMessage {
Text = "Hello"
};
publisher.Broadcast(broadcastedMessage);
}
}
}
public void RequestAsync_Cancel_single_message(RedFoxTransport transport)
{
using (var responder = TestHelpers.CreateTestResponder(1000))
using (var requester = new Requester())
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
responder.Bind(endpoint);
requester.Connect(endpoint);
Thread.Sleep(100);
var messageSent = new TestMessage {
Text = "Hello"
};
var cancellationToken = new CancellationTokenSource(TimeSpan.FromMilliseconds(100)).Token;
Assert.Throws <AggregateException>(() => requester.RequestAsync(messageSent, cancellationToken).Wait());
}
}
public void Requester_Disconnected_event_fired(RedFoxTransport transport)
{
using (var responder = TestHelpers.CreateTestResponder())
using (var requester = new Requester())
{
var eventFired = new ManualResetEventSlim();
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
responder.Bind(endpoint);
requester.Disconnected += eventFired.Set;
requester.Connect(endpoint);
Thread.Sleep(100);
requester.Disconnect();
Assert.IsTrue(eventFired.Wait(Timeout));
}
}
public void RequestAsync_Response_single_message(RedFoxTransport transport)
{
using (var responder = TestHelpers.CreateTestResponder())
using (var requester = new Requester())
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
responder.Bind(endpoint);
requester.Connect(endpoint);
Thread.Sleep(100);
var messageSent = new TestMessage {
Text = "Hello"
};
var messageReceived = (TestMessage)requester.RequestAsync(messageSent).Result;
Assert.AreEqual(messageSent.Text, messageReceived.Text);
}
}
public void Subscribe_to_Publisher_receive_single_broadcasted_message(RedFoxTransport transport)
{
using (var publisher = new Publisher())
using (var subscriber = new TestSubscriber())
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
publisher.Bind(endpoint);
subscriber.Connect(endpoint);
Thread.Sleep(100);
var broadcastedMessage = new TestMessage {
Text = "Hello"
};
publisher.Broadcast(broadcastedMessage);
Assert.AreEqual(broadcastedMessage, subscriber.TestMustReceiveMessageWithin(Timeout));
}
}
public void RequestAsync_Response_two_messages_wait_for_each_message(RedFoxTransport transport)
{
using (var responder = TestHelpers.CreateTestResponder())
using (var requester = new Requester())
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
responder.Bind(endpoint);
requester.Connect(endpoint);
var messagesReceived = new List <TestMessage>();
Thread.Sleep(100);
var messageSent = new TestMessage {
Text = "Hello"
};
messagesReceived.Add((TestMessage)requester.RequestAsync(messageSent).Result);
messagesReceived.Add((TestMessage)requester.RequestAsync(messageSent).Result);
Assert.AreEqual(messageSent.Text, messagesReceived[0].Text);
Assert.AreEqual(messageSent.Text, messagesReceived[1].Text);
}
}
public void one_subscriber_connects_to_one_publisher_receives_message_then_second_subscriber_connects_both_receive_message(RedFoxTransport transport)
{
using (var publisher = new Publisher())
using (var subscriber1 = new TestSubscriber())
using (var subscriber2 = new TestSubscriber())
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
publisher.Bind(endpoint);
subscriber1.Connect(endpoint);
Thread.Sleep(100);
var broadcastMessage = new TestMessage {
Text = "Hello"
};
publisher.Broadcast(broadcastMessage);
Assert.AreEqual(broadcastMessage, subscriber1.TestMustReceiveMessageWithin(Timeout));
subscriber2.Connect(endpoint);
Thread.Sleep(100);
publisher.Broadcast(broadcastMessage);
Assert.AreEqual(broadcastMessage, subscriber1.TestMustReceiveMessageWithin(Timeout));
Assert.AreEqual(broadcastMessage, subscriber2.TestMustReceiveMessageWithin(Timeout));
}
}
public void Request_Response_different_threads_large_message(RedFoxTransport transport)
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
var started = new ManualResetEventSlim();
var stop = new ManualResetEventSlim();
Task.Run(() =>
{
using (var responder = TestHelpers.CreateTestResponder())
{
responder.Bind(endpoint);
started.Set();
stop.Wait();
}
});
var largeMessage = new TestMessage { Text = new string('x', 1024 * 1024) };
TestMessage messageReceived = null;
Task.Run(() =>
{
using (var requester = new Requester())
{
started.Wait(Timeout);
requester.Connect(endpoint);
messageReceived = (TestMessage)requester.Request(largeMessage);
stop.Set();
}
});
try
{
Assert.IsTrue(stop.Wait(Timeout));
Assert.AreEqual(largeMessage.Text, messageReceived.Text);
}
finally
{
stop.Set();
}
}
public void Requester_Disconnected_event_fired(RedFoxTransport transport)
{
using (var responder = TestHelpers.CreateTestResponder())
using (var requester = new Requester())
{
var eventFired = new ManualResetEventSlim();
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
responder.Bind(endpoint);
requester.Disconnected += eventFired.Set;
requester.Connect(endpoint);
Thread.Sleep(100);
requester.Disconnect();
Assert.IsTrue(eventFired.Wait(Timeout));
}
}
public void Requester_IsDisconnected_should_be_true_when_disconnected(RedFoxTransport transport)
{
using (var responder = TestHelpers.CreateTestResponder())
using (var requester = new Requester())
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
responder.Bind(endpoint);
requester.Connect(endpoint);
requester.Disconnect();
Assert.IsTrue(requester.IsDisconnected);
}
}
public void Request_Response_two_messages(RedFoxTransport transport)
{
using (var responder = TestHelpers.CreateTestResponder())
using (var requester = new Requester())
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
responder.Bind(endpoint);
requester.Connect(endpoint);
var messagesReceived = new List<TestMessage>();
Thread.Sleep(100);
var messageSent = new TestMessage { Text = "Hello" };
messagesReceived.Add((TestMessage)requester.Request(messageSent));
messagesReceived.Add((TestMessage)requester.Request(messageSent));
Assert.AreEqual(messageSent.Text, messagesReceived[0].Text);
Assert.AreEqual(messageSent.Text, messagesReceived[1].Text);
}
}
public void TryParse_transport_should_be_parsed(string endpointUri, RedFoxTransport expectedTransport)
{
RedFoxEndpoint endpoint;
Assert.IsTrue(RedFoxEndpoint.TryParse(endpointUri, out endpoint));
Assert.AreEqual(expectedTransport, endpoint.Transport);
}
public static RedFoxEndpoint CreateEndpointForTransport(RedFoxTransport transport, ushort port)
{
return new RedFoxEndpoint(transport, "localhost", port, null);
}
public static RedFoxEndpoint CreateEndpointForTransport(RedFoxTransport transport)
{
return(new RedFoxEndpoint(transport, "localhost", GetFreePort(), null));
}
public void Subscriber_Disconnect_doesnt_hang(RedFoxTransport transport)
{
using (var publisher = new Publisher())
using (var subscriber = new TestSubscriber())
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
publisher.Bind(endpoint);
subscriber.Connect(endpoint);
subscriber.Disconnect(true, Timeout);
}
}
public void Publisher_Unbound_Subscriber_Disconnected_event_fires(RedFoxTransport transport)
{
using (var publisher = new Publisher())
using (var subscriber = new TestSubscriber())
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
var eventFired = new ManualResetEventSlim();
publisher.Bind(endpoint);
subscriber.Disconnected += eventFired.Set;
subscriber.Connect(endpoint);
publisher.Unbind(endpoint);
Assert.IsTrue(eventFired.Wait(Timeout));
Assert.IsTrue(subscriber.IsDisconnected);
}
}
public void Subscriber_sends_message_Publisher_receives_message(RedFoxTransport transport)
{
using (var publisher = new Publisher())
using (var subscriber = new TestSubscriber())
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
var eventFired = new ManualResetEventSlim();
IMessage messageReceived = null;
ISocket messageSocket = null;
publisher.MessageReceived += (s, m) =>
{
messageSocket = s;
messageReceived = m;
eventFired.Set();
};
ISocket connectedSocket = null;
publisher.ClientConnected += (s, m) => { connectedSocket = s; };
publisher.Bind(endpoint);
subscriber.Connect(endpoint);
IMessage messageSent = new TestMessage("test");
subscriber.SendMessage(messageSent);
Assert.IsTrue(eventFired.Wait(Timeout));
Assert.AreEqual(messageSent, messageReceived);
Assert.AreEqual(connectedSocket, messageSocket);
}
}
public void RequestAsync_Response_two_messages_simultaneous(RedFoxTransport transport)
{
using (var responder = TestHelpers.CreateTestResponder())
using (var requester = new Requester())
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
responder.Bind(endpoint);
requester.Connect(endpoint);
var messagesReceived = new List<TestMessage>();
Thread.Sleep(100);
var messageSent = new TestMessage { Text = "Hello" };
var task1 = requester.RequestAsync(messageSent);
var task2 = requester.RequestAsync(messageSent);
Assert.IsTrue(Task.WhenAll(task1, task2).Wait(TimeSpan.FromSeconds(1)));
messagesReceived.Add((TestMessage)task1.Result);
messagesReceived.Add((TestMessage)task2.Result);
Assert.AreEqual(messageSent.Text, messagesReceived[0].Text);
Assert.AreEqual(messageSent.Text, messagesReceived[1].Text);
}
}
public void Subscriber_IsDisconnected_should_be_true_when_disconnected(RedFoxTransport transport)
{
using (var publisher = new Publisher())
using (var subscriber = new TestSubscriber())
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
publisher.Bind(endpoint);
subscriber.Connect(endpoint);
subscriber.Disconnect();
Assert.IsTrue(subscriber.IsDisconnected);
}
}
public static RedFoxEndpoint CreateEndpointForTransport(RedFoxTransport transport)
{
return new RedFoxEndpoint(transport, "localhost", GetFreePort(), null);
}
public static RedFoxEndpoint CreateEndpointForTransport(RedFoxTransport transport, ushort port)
{
return(new RedFoxEndpoint(transport, "localhost", port, null));
}
public void one_subscriber_connects_to_one_publisher_receives_message_then_second_subscriber_connects_both_receive_message(RedFoxTransport transport)
{
using (var publisher = new Publisher())
using (var subscriber1 = new TestSubscriber())
using (var subscriber2 = new TestSubscriber())
{
var endpoint = TestHelpers.CreateEndpointForTransport(transport);
publisher.Bind(endpoint);
subscriber1.Connect(endpoint);
Thread.Sleep(100);
var broadcastMessage = new TestMessage { Text = "Hello" };
publisher.Broadcast(broadcastMessage);
Assert.AreEqual(broadcastMessage, subscriber1.TestMustReceiveMessageWithin(Timeout));
subscriber2.Connect(endpoint);
Thread.Sleep(100);
publisher.Broadcast(broadcastMessage);
Assert.AreEqual(broadcastMessage, subscriber1.TestMustReceiveMessageWithin(Timeout));
Assert.AreEqual(broadcastMessage, subscriber2.TestMustReceiveMessageWithin(Timeout));
}
}
