public void TCPServerWith2Clients_Disconnect1Client_1ClientDisconnected()
{
//Arrange
Client disconnectedClient = null;
tcpserver = new TCPServerChannel("127.0.0.1", 0);
ObjectTransport serverObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(tcpserver);
serverObjectTransport.OnClientDisconnect(c => disconnectedClient = c);
tcpclient = new TCPClientChannel("127.0.0.1", tcpserver.LocalPort);
ObjectTransport clientObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(tcpclient);
tcpclient2 = new TCPClientChannel("127.0.0.1", tcpserver.LocalPort);
ObjectTransport clientObjectTransport2 = TestObjectTransportFactory.CreateNewObjectTransport(tcpclient2);
Utilities.WaitFor(() => serverObjectTransport.GetConnectedClients().Count() == 2);
//Act
var FirstClient = serverObjectTransport.GetConnectedClients().First();
serverObjectTransport.DisconnectClient(FirstClient);
Utilities.WaitFor(ref disconnectedClient);
//Assert
Client LastClient = serverObjectTransport.GetConnectedClients().First();
Assert.AreEqual(1, serverObjectTransport.GetConnectedClients().Count());
Assert.AreNotEqual(FirstClient.Port, LastClient.Port);
}
public void TCPServerWith2Clients_Disconnect2Client_AllClientsDisconnected()
{
//Arrange
List <Client> disconnectedClients = new List <Client>();
tcpserver = new TCPServerChannel("127.0.0.1", 0);
ObjectTransport serverObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(tcpserver);
serverObjectTransport.OnClientDisconnect(c => disconnectedClients.Add(c));
tcpclient = new TCPClientChannel("127.0.0.1", tcpserver.LocalPort);
ObjectTransport clientObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(tcpclient);
tcpclient2 = new TCPClientChannel("127.0.0.1", tcpserver.LocalPort);
ObjectTransport clientObjectTransport2 = TestObjectTransportFactory.CreateNewObjectTransport(tcpclient2);
Utilities.WaitFor(() => serverObjectTransport.GetConnectedClients().Count() == 2);
//Act
var allClients = serverObjectTransport.GetConnectedClients().ToArray();
serverObjectTransport.DisconnectClient(allClients);
Utilities.WaitFor(() => disconnectedClients.Count == 2);
//Assert
Assert.AreEqual(0, serverObjectTransport.GetConnectedClients().Count());
Assert.AreEqual(2, disconnectedClients.Count());
}
public void TCPClient_ClientDisconnectsServer_ServerOnClientDisconnectCalled()
{
//Arrange
Client disconnectedClient = null;
Client connectedServer = null;
tcpserver = new TCPServerChannel("127.0.0.1", 0);
ObjectTransport serverObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(tcpserver);
serverObjectTransport.OnClientDisconnect(c => disconnectedClient = c);
tcpclient = new TCPClientChannel("127.0.0.1", tcpserver.LocalPort);
ObjectTransport clientObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(tcpclient);
clientObjectTransport.OnClientConnect(c => connectedServer = c);
tcpclient2 = new TCPClientChannel("127.0.0.1", tcpserver.LocalPort);
ObjectTransport clientObjectTransport2 = TestObjectTransportFactory.CreateNewObjectTransport(tcpclient2);
Utilities.WaitFor(() => serverObjectTransport.GetConnectedClients().Count() == 2);
//Act
//disconnect the server from the client
clientObjectTransport.DisconnectClient();
Utilities.WaitFor(ref disconnectedClient);
//Assert
//Ensure that the client record was disconnect from the server
Assert.AreEqual(1, serverObjectTransport.GetConnectedClients().Count());
//Esnure that the client who disconnected from the server was the one that we called disconect
Assert.AreEqual(disconnectedClient.Port, tcpclient.LocalPort);
}
public void TCPServer_ClientDisconnects_CallbackCalled()
{
//Arrange
Client clientConnect = null;
Client clientDisconnect = null;
tcpserver = new TCPServerChannel("127.0.0.1", 0);
ObjectTransport serverObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(tcpserver);
serverObjectTransport.OnClientConnect(c => clientConnect = c);
serverObjectTransport.OnClientDisconnect(c => clientDisconnect = c);
tcpclient = new TCPClientChannel("127.0.0.1", tcpserver.LocalPort);
ObjectTransport clientObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(tcpclient);
Utilities.WaitFor(ref clientConnect);
Utilities.WaitFor(() => clientObjectTransport.GetConnectedClients().Count() == 1);
//Act
clientObjectTransport.Stop();
Utilities.WaitFor(ref clientDisconnect);
Utilities.Wait();
//Assert
Assert.AreEqual(clientConnect.IPAddress, "127.0.0.1");
Assert.AreEqual(clientDisconnect.IPAddress, "127.0.0.1");
Assert.AreEqual(clientDisconnect, clientConnect);
Assert.AreEqual(0, clientObjectTransport.GetConnectedClients().Count());
Assert.AreEqual(0, serverObjectTransport.GetConnectedClients().Count());
}
public void TCPClient_SendUnreliably_ExceptionThrown()
{
//Arrange
Client client = null;
Client clientDisconnect = null;
server = new TCPServerChannel("127.0.0.1", 0);
ObjectTransport serverObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(server);
tcpclient = new TCPClientChannel("127.0.0.1", server.LocalPort);
ObjectTransport clientObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(tcpclient);
clientObjectTransport.OnClientDisconnect(c => clientDisconnect = c);
client = clientObjectTransport.GetConnectedClients().First();
Utilities.WaitFor(ref client);
Utilities.WaitFor(() => serverObjectTransport.GetConnectedClients().Count() == 1);
var message = new MockObjectMessage();
//Act
clientObjectTransport.Send(message)
.Unreliable()
.Execute();
}
public void TCPServer_WhenClientConnects_CallbackFunctionCalled()
{
bool connected = false;
tcpserver = new TCPServerChannel("127.0.0.1", 0);
tcpserver.OnClientConnect(c => connected = true);
tcpclient = new TCPClientChannel("127.0.0.1", tcpserver.LocalPort);
Utilities.WaitFor(ref connected);
Assert.IsTrue(connected);
}
/// <summary>
/// Image service constructor.
/// </summary>
/// <param name="args"></param>
public ImageService(string[] args)
{
try
{
InitializeComponent();
//Get settings from app.config.
ServiceSettings serviceSettings = ServiceSettings.GetServiceSettings();
//Set service settings.
string eventSourceName = serviceSettings.SourceName;
//Set log name.
string logName = serviceSettings.LogName;
if (args.Count() > 0)
{
eventSourceName = args[0];
}
if (args.Count() > 1)
{
logName = args[1];
}
//Create event logger.
eventLog1 = new System.Diagnostics.EventLog();
if (!System.Diagnostics.EventLog.SourceExists(eventSourceName))
{
System.Diagnostics.EventLog.CreateEventSource(eventSourceName, logName);
}
eventLog1.Source = eventSourceName;
eventLog1.Log = logName;
//Create image service modal.
m_imageServiceModal = new ImageServiceModal(serviceSettings.OutputDir, serviceSettings.ThumbnailSize);
//Create logging service.
m_loggingService = new LoggingService();
m_loggingService.MessageRecieved += WriteToLog;
//Create controller.
m_controller = new ImageController(m_imageServiceModal);
//Create image server.
m_imageServer = new ImageServer(m_controller, m_loggingService, serviceSettings.Handlers);
m_loggingService.Log("Image service created", MessageTypeEnum.INFO);
HandleAndroidClient handleAndroidRequest = new HandleAndroidClient(m_loggingService, m_imageServiceModal, serviceSettings.Handlers[0]);
m_tcpServer = new TCPServerChannel(1102, m_loggingService, handleAndroidRequest);
//handleGuiRequest.NotifyClients += m_tcpServer.NotifyClientsOnChange;
m_loggingService.NotifyClients += m_tcpServer.NotifyClientsOnChange;
m_tcpServer.Start();
}
catch (Exception e)
{
m_loggingService.Log("Failed creating image service, exception: " + e.Message, MessageTypeEnum.FAIL);
}
}
public static Tuple <ObjectTransport, ObjectTransport> GetConnectObjectTransports()
{
server = new TCPServerChannel("127.0.0.1", 0);
ObjectTransport serverObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(server);
tcpclient = new TCPClientChannel("127.0.0.1", server.LocalPort);
ObjectTransport client = TestObjectTransportFactory.CreateNewObjectTransport(tcpclient);
Tuple <ObjectTransport, ObjectTransport> result = new Tuple <ObjectTransport, ObjectTransport>(serverObjectTransport, client);
return(result);
}
public void Start()
{
_server = NetworkConnectivity.CreateTCPServerChannel("server");
_server.ChannelClientConnected += new ServerConnectionEventHandler(_server_ChannelClientConnected);
_server.ChannelClientDisconnected += new ServerConnectionEventHandler(_server_ChannelClientDisconnected);
//_server.ChannelConnected +=
//_server.ChannelDisconnected +=
_server.DataReceived += new ServerDataEventHandler(_server_DataReceived);
//_server.DataSent +=
//_server.ExceptionOccurred +=
_server.ExceptionOccurred += new System.IO.ErrorEventHandler(_server_ExceptionOccurred);
_server.Connect(_serviceport);
}
public void Start()
{
server = NetworkConnectivity.CreateTCPServerChannel("server");
server.ChannelClientConnected += server_ChannelClientConnected;
server.ChannelClientDisconnected += server_ChannelClientDisconnected;
//_server.ChannelConnected +=
//_server.ChannelDisconnected +=
server.DataReceived += server_DataReceived;
//_server.DataSent +=
//_server.ExceptionOccurred +=
server.ExceptionOccurred += server_ExceptionOccurred;
server.Connect(servicePort);
}
public void Start()
{
server = NetworkConnectivity.CreateTCPServerChannel("server");
server.ChannelClientConnected += server_ChannelClientConnected;
server.ChannelClientDisconnected += server_ChannelClientDisconnected;
//_server.ChannelConnected +=
//_server.ChannelDisconnected +=
server.DataReceived += server_DataReceived;
//_server.DataSent +=
//_server.ExceptionOccurred +=
server.ExceptionOccurred += server_ExceptionOccurred;
server.Connect(servicePort);
}
public void Start()
{
server = NetworkConnectivity.CreateTCPServerChannel("server");
server.ChannelClientConnected += new ServerConnectionEventHandler(server_ChannelClientConnected);
server.ChannelClientDisconnected += new ServerConnectionEventHandler(server_ChannelClientDisconnected);
//_server.ChannelConnected +=
//_server.ChannelDisconnected +=
server.DataReceived += new ServerDataEventHandler(server_DataReceived);
//_server.DataSent +=
//_server.ExceptionOccurred +=
server.ExceptionOccurred += new System.IO.ErrorEventHandler(server_ExceptionOccurred);
server.Connect(servicePort);
}
public void TCPNetwork_SendAndReplyMessage_ResponseIsCalled()
{
//Arrange
Client client = null;
Client clientDisconnect = null;
server = new TCPServerChannel("127.0.0.1", 0);
ObjectTransport serverObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(server);
tcpclient = new TCPClientChannel("127.0.0.1", server.Port);
ObjectTransport clientObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(tcpclient);
clientObjectTransport.OnClientDisconnect(c => clientDisconnect = c);
client = clientObjectTransport.GetConnectedClients().First();
Utilities.WaitFor(ref client);
Utilities.WaitFor(() => serverObjectTransport.GetConnectedClients().Count() == 1);
//Act
serverObjectTransport.Receive <MockObjectMessage>()
.Reply((o) => { return(o); })
.Execute();
var mockObject = new MockObjectMessage()
{
Property1_string = "Mock Object"
};
MockObjectMessage responseObject = null;
clientObjectTransport.Send(mockObject)
.Response <MockObjectMessage>((r) => { responseObject = r; })
.Execute();
Utilities.WaitFor(ref responseObject);
//Assert
Assert.AreEqual(responseObject.Property1_string, "Mock Object");
}
public void TCPServer_SendObject_CorrectObjectSent()
{
//Arrange
MockObjectMessage receivedObject = null;
tcpserver = new TCPServerChannel("127.0.0.1", 0);
Client client = null;
ObjectTransport serverObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(tcpserver);
serverObjectTransport.OnClientConnect(c => client = c);
tcpclient = new TCPClientChannel("127.0.0.1", tcpserver.LocalPort);
ObjectTransport clientObjectTransport = TestObjectTransportFactory.CreateNewObjectTransport(tcpclient);
Utilities.WaitFor(ref client);
//Act
clientObjectTransport.Receive <MockObjectMessage>(o =>
receivedObject = o
).Execute();
serverObjectTransport.Send(new MockObjectMessage()
{
Property1_string = "hello world!",
Property2_int = 123,
Property3_decimal = 12.3M
})
.To(client)
.Execute();
Utilities.WaitFor(ref receivedObject);
//Assert
Assert.AreEqual("hello world!", receivedObject.Property1_string);
Assert.AreEqual(123, receivedObject.Property2_int);
Assert.AreEqual(12.3M, receivedObject.Property3_decimal);
}
