public virtual void Duplex_06_OpenCloseConnection() { ClientMock aClient = new ClientMock(MessagingSystemFactory, ChannelId); ServiceMock aService = new ServiceMock(MessagingSystemFactory, ChannelId); try { aService.InputChannel.StartListening(); // Open the connection. aClient.OutputChannel.OpenConnection(); Assert.IsTrue(aClient.OutputChannel.IsConnected); // handling open connection on the client side. EneterTrace.Info("1"); aClient.WaitUntilConnectionOpenIsNotified(1000); Assert.AreEqual(aClient.OutputChannel.ChannelId, aClient.NotifiedOpenConnection.ChannelId); Assert.AreEqual(aClient.OutputChannel.ResponseReceiverId, aClient.NotifiedOpenConnection.ResponseReceiverId); // handling open connection on the service side. EneterTrace.Info("2"); aService.WaitUntilResponseReceiversConnectNotified(1, 1000); Assert.AreEqual(1, aService.ConnectedResponseReceivers.Count()); if (CompareResponseReceiverId) { Assert.AreEqual(aClient.OutputChannel.ResponseReceiverId, aService.ConnectedResponseReceivers[0].ResponseReceiverId); } aClient.OutputChannel.CloseConnection(); Assert.IsFalse(aClient.OutputChannel.IsConnected); EneterTrace.Info("3"); //aClient.WaitUntilConnectionClosedIsNotified(1000); //Assert.AreEqual(aClient.OutputChannel.ChannelId, aClient.NotifiedCloseConnection.ChannelId); //Assert.AreEqual(aClient.OutputChannel.ResponseReceiverId, aClient.NotifiedCloseConnection.ResponseReceiverId); EneterTrace.Info("4"); aService.WaitUntilAllResponseReceiversDisconnectNotified(1000); Assert.AreEqual(1, aService.DisconnectedResponseReceivers.Count()); if (CompareResponseReceiverId) { Assert.AreEqual(aClient.OutputChannel.ResponseReceiverId, aService.DisconnectedResponseReceivers.First().ResponseReceiverId); } } finally { EneterTrace.Debug("CLEANING AFTER TEST"); aClient.OutputChannel.CloseConnection(); aService.InputChannel.StopListening(); // Wait for traces. Thread.Sleep(100); } }
private void SendBroadcastResponseMessage(string channelId, object broadcastMessage, int numberOfClients, int numberOfMessages, int openConnectionTimeout, int allMessagesReceivedTimeout) { ThreadPool.SetMinThreads(50, 2); ClientMockFarm aClientFarm = new ClientMockFarm(MessagingSystemFactory, channelId, numberOfClients); ServiceMock aService = new ServiceMock(MessagingSystemFactory, channelId); try { aService.InputChannel.StartListening(); aClientFarm.OpenConnectionsAsync(); aClientFarm.WaitUntilAllConnectionsAreOpen(openConnectionTimeout); aService.WaitUntilResponseReceiversConnectNotified(numberOfClients, openConnectionTimeout); Assert.AreEqual(aClientFarm.Clients.Count(), aService.ConnectedResponseReceivers.Count()); if (CompareResponseReceiverId) { foreach (ClientMock aClient in aClientFarm.Clients) { Assert.IsTrue(aService.ConnectedResponseReceivers.Any(x => x.ResponseReceiverId == aClient.OutputChannel.ResponseReceiverId)); } } PerformanceTimer aStopWatch = new PerformanceTimer(); aStopWatch.Start(); for (int i = 0; i < numberOfMessages; ++i) { aService.InputChannel.SendResponseMessage("*", broadcastMessage); } aClientFarm.WaitUntilAllResponsesAreReceived(numberOfMessages, allMessagesReceivedTimeout); aStopWatch.Stop(); foreach (DuplexChannelMessageEventArgs aResponseMessage in aClientFarm.ReceivedResponses) { Assert.AreEqual(broadcastMessage, aResponseMessage.Message); } } finally { EneterTrace.Debug("CLEANING AFTER TEST"); aClientFarm.CloseAllConnections(); aService.InputChannel.StopListening(); //EneterTrace.StopProfiler(); Thread.Sleep(500); } }
public virtual void Duplex_12_CloseFromConnectionOpened() { ClientMock aClient = new ClientMock(MessagingSystemFactory, ChannelId); aClient.DoOnConnectionOpen((x, y) => { if (MessagingSystemFactory is NamedPipeMessagingSystemFactory) { Thread.Sleep(500); } aClient.OutputChannel.CloseConnection(); }); ServiceMock aService = new ServiceMock(MessagingSystemFactory, ChannelId); try { aService.InputChannel.StartListening(); aClient.OutputChannel.OpenConnection(); aClient.WaitUntilConnectionOpenIsNotified(1000); if (MessagingSystemFactory is SynchronousMessagingSystemFactory == false) { aService.WaitUntilResponseReceiversConnectNotified(1, 5000); } // Client is disconnected. //aClient.WaitUntilConnectionClosedIsNotified(1000); // Client should be disconnected from the event handler. aService.WaitUntilAllResponseReceiversDisconnectNotified(2000); } finally { EneterTrace.Debug("CLEANING AFTER TEST"); aClient.OutputChannel.CloseConnection(); aService.InputChannel.StopListening(); // Wait for traces. Thread.Sleep(100); } }
public virtual void Duplex_11_CloseConnection() { ClientMockFarm aClients = new ClientMockFarm(MessagingSystemFactory, ChannelId, 2); ServiceMock aService = new ServiceMock(MessagingSystemFactory, ChannelId); try { aService.InputChannel.StartListening(); aClients.OpenConnectionsAsync(); Assert.IsTrue(aClients.Clients[0].OutputChannel.IsConnected); Assert.IsTrue(aClients.Clients[1].OutputChannel.IsConnected); aClients.WaitUntilAllConnectionsAreOpen(1000); aService.WaitUntilResponseReceiversConnectNotified(2, 1000); string aResponseReceiverId1 = aService.ConnectedResponseReceivers[0].ResponseReceiverId; // Cient 1 closes the connection. aClients.Clients[0].OutputChannel.CloseConnection(); Assert.IsFalse(aClients.Clients[0].OutputChannel.IsConnected); //aClients.Clients[0].WaitUntilConnectionClosedIsNotified(1000); aService.WaitUntilResponseRecieverIdDisconnectNotified(aResponseReceiverId1, 2000); if (CompareResponseReceiverId) { Assert.AreEqual(aClients.Clients[0].OutputChannel.ResponseReceiverId, aService.DisconnectedResponseReceivers[0].ResponseReceiverId); } // Client 2 can send message. aClients.Clients[1].OutputChannel.SendMessage(myRequestMessage); aService.WaitUntilMessagesAreReceived(1, 1000); Assert.AreEqual(myRequestMessage, aService.ReceivedMessages[0].Message); } finally { EneterTrace.Debug("CLEANING AFTER TEST"); aClients.CloseAllConnections(); aService.InputChannel.StopListening(); // Wait for traces. Thread.Sleep(100); } }
public virtual void Duplex_09_StopListening_SendMessage() { ClientMock aClient = new ClientMock(MessagingSystemFactory, ChannelId); ServiceMock aService = new ServiceMock(MessagingSystemFactory, ChannelId); try { aService.InputChannel.StartListening(); aClient.OutputChannel.OpenConnection(); aService.WaitUntilResponseReceiversConnectNotified(1, 1000); aService.InputChannel.StopListening(); Assert.IsFalse(aService.InputChannel.IsListening); bool isSomeException = false; try { // Try to send a message via the duplex output channel. aClient.OutputChannel.SendMessage(myRequestMessage); } catch { // Because the duplex input channel is not listening the sending must // fail with an exception. The type of the exception depends from the type of messaging system. isSomeException = true; } Assert.IsTrue(isSomeException); } finally { EneterTrace.Debug("CLEANING AFTER TEST"); aClient.OutputChannel.CloseConnection(); aService.InputChannel.StopListening(); // Wait for traces. Thread.Sleep(100); } }
public virtual void Duplex_13_DisconnectFromResponseReceiverConnected() { ClientMock aClient = new ClientMock(MessagingSystemFactory, ChannelId); ServiceMock aService = new ServiceMock(MessagingSystemFactory, ChannelId); aService.DoOnResponseReceiverConnected((x, y) => { if (MessagingSystemFactory is SynchronousMessagingSystemFactory == false) { aClient.WaitUntilConnectionOpenIsNotified(1000); } aService.InputChannel.DisconnectResponseReceiver(y.ResponseReceiverId); }); try { aService.InputChannel.StartListening(); // The ecent will try to close connection. aClient.OutputChannel.OpenConnection(); aClient.WaitUntilConnectionOpenIsNotified(1000); //aService.WaitUntilAllResponseReceiversDisconnectNotified(1000); aClient.WaitUntilConnectionClosedIsNotified(1000); } finally { EneterTrace.Debug("CLEANING AFTER TEST"); aClient.OutputChannel.CloseConnection(); aService.InputChannel.StopListening(); // Wait for traces. Thread.Sleep(100); } }
private void SendMessageReceiveResponse(string channelId, object message, object responseMessage, int numberOfClients, int numberOfMessages, int openConnectionTimeout, int allMessagesReceivedTimeout) { ThreadPool.SetMinThreads(100, 2); ClientMockFarm aClientFarm = new ClientMockFarm(MessagingSystemFactory, channelId, numberOfClients); ServiceMock aService = new ServiceMock(MessagingSystemFactory, channelId); aService.DoOnMessageReceived_SendResponse(responseMessage); try { //EneterTrace.StartProfiler(); aService.InputChannel.StartListening(); aClientFarm.OpenConnectionsAsync(); aClientFarm.WaitUntilAllConnectionsAreOpen(openConnectionTimeout); aService.WaitUntilResponseReceiversConnectNotified(numberOfClients, openConnectionTimeout); Assert.AreEqual(aClientFarm.Clients.Count(), aService.ConnectedResponseReceivers.Count()); if (CompareResponseReceiverId) { foreach (ClientMock aClient in aClientFarm.Clients) { Assert.IsTrue(aService.ConnectedResponseReceivers.Any(x => x.ResponseReceiverId == aClient.OutputChannel.ResponseReceiverId)); } } PerformanceTimer aStopWatch = new PerformanceTimer(); aStopWatch.Start(); aClientFarm.SendMessageAsync(message, numberOfMessages); aClientFarm.WaitUntilAllResponsesAreReceived(numberOfMessages, allMessagesReceivedTimeout); aStopWatch.Stop(); // Wait little bit more for case there is an error that more messages are sent. Thread.Sleep(500); Assert.AreEqual(numberOfMessages * numberOfClients, aService.ReceivedMessages.Count()); Assert.AreEqual(numberOfMessages * numberOfClients, aClientFarm.ReceivedResponses.Count()); foreach (DuplexChannelMessageEventArgs aMessage in aService.ReceivedMessages) { Assert.AreEqual(message, aMessage.Message); } foreach (DuplexChannelMessageEventArgs aResponseMessage in aClientFarm.ReceivedResponses) { Assert.AreEqual(responseMessage, aResponseMessage.Message); } } finally { EneterTrace.Debug("CLEANING AFTER TEST"); aClientFarm.CloseAllConnections(); aService.InputChannel.StopListening(); //EneterTrace.StopProfiler(); Thread.Sleep(200); } }
public virtual void Duplex_08_OpenFromConnectionClosed() { ClientMock aClient = new ClientMock(MessagingSystemFactory, ChannelId); bool anIsConnected = false; aClient.DoOnConnectionClosed((x, y) => { EneterTrace.Debug("DoOnConnectionClosed"); anIsConnected = aClient.OutputChannel.IsConnected; if (MessagingSystemFactory is SharedMemoryMessagingSystemFactory) { Thread.Sleep(300); } aClient.OutputChannel.OpenConnection(); }); ServiceMock aService = new ServiceMock(MessagingSystemFactory, ChannelId); try { aService.InputChannel.StartListening(); // Client opens the connection. aClient.OutputChannel.OpenConnection(); aClient.WaitUntilConnectionOpenIsNotified(1000); Assert.IsFalse(anIsConnected); aService.WaitUntilResponseReceiversConnectNotified(1, 1000); string aConnectedResponseReceiverId = aService.ConnectedResponseReceivers[0].ResponseReceiverId; aClient.ClearTestResults(); aService.ClearTestResults(); // Service disconnects the client. aService.InputChannel.DisconnectResponseReceiver(aConnectedResponseReceiverId); //aService.WaitUntilResponseRecieverIdDisconnectNotified(aConnectedResponseReceiverId, 1000); aClient.WaitUntilConnectionClosedIsNotified(3000); //Assert.AreEqual(aConnectedResponseReceiverId, aService.DisconnectedResponseReceivers[0].ResponseReceiverId); // Client should open the connection again. aClient.WaitUntilConnectionOpenIsNotified(1000); if (MessagingSystemFactory is SynchronousMessagingSystemFactory == false) { aService.WaitUntilResponseReceiversConnectNotified(1, 1000); } } finally { EneterTrace.Debug("CLEANING AFTER TEST"); aClient.OutputChannel.CloseConnection(); aService.InputChannel.StopListening(); // Wait for traces. Thread.Sleep(500); } }
public virtual void Duplex_06_OpenCloseOpenSend() { ClientMock aClient = new ClientMock(MessagingSystemFactory, ChannelId); ServiceMock aService = new ServiceMock(MessagingSystemFactory, ChannelId); aService.DoOnMessageReceived_SendResponse(myResponseMessage); try { aService.InputChannel.StartListening(); // Client opens the connection. aClient.OutputChannel.OpenConnection(); Assert.IsTrue(aClient.OutputChannel.IsConnected); aClient.WaitUntilConnectionOpenIsNotified(1000); Assert.AreEqual(aClient.OutputChannel.ChannelId, aClient.NotifiedOpenConnection.ChannelId); Assert.AreEqual(aClient.OutputChannel.ResponseReceiverId, aClient.NotifiedOpenConnection.ResponseReceiverId); aService.WaitUntilResponseReceiversConnectNotified(1, 1000); Assert.AreEqual(1, aService.ConnectedResponseReceivers.Count()); if (CompareResponseReceiverId) { Assert.AreEqual(aClient.OutputChannel.ResponseReceiverId, aService.ConnectedResponseReceivers[0].ResponseReceiverId); } // Client closes the connection. aClient.OutputChannel.CloseConnection(); Assert.IsFalse(aClient.OutputChannel.IsConnected); //aClient.WaitUntilConnectionClosedIsNotified(1000); //Assert.AreEqual(aClient.OutputChannel.ChannelId, aClient.NotifiedCloseConnection.ChannelId); //Assert.AreEqual(aClient.OutputChannel.ResponseReceiverId, aClient.NotifiedCloseConnection.ResponseReceiverId); aService.WaitUntilAllResponseReceiversDisconnectNotified(3000); Assert.AreEqual(1, aService.DisconnectedResponseReceivers.Count()); if (CompareResponseReceiverId) { Assert.AreEqual(aClient.OutputChannel.ResponseReceiverId, aService.DisconnectedResponseReceivers[0].ResponseReceiverId); } aClient.ClearTestResults(); aService.ClearTestResults(); // Client opens the connection 2nd time. aClient.OutputChannel.OpenConnection(); Assert.IsTrue(aClient.OutputChannel.IsConnected); aClient.WaitUntilConnectionOpenIsNotified(1000); Assert.AreEqual(aClient.OutputChannel.ChannelId, aClient.NotifiedOpenConnection.ChannelId); Assert.AreEqual(aClient.OutputChannel.ResponseReceiverId, aClient.NotifiedOpenConnection.ResponseReceiverId); aService.WaitUntilResponseReceiversConnectNotified(1, 1000); Assert.AreEqual(1, aService.ConnectedResponseReceivers.Count()); if (CompareResponseReceiverId) { Assert.AreEqual(aClient.OutputChannel.ResponseReceiverId, aService.ConnectedResponseReceivers[0].ResponseReceiverId); } // Client sends the message. aClient.OutputChannel.SendMessage(myRequestMessage); aClient.WaitUntilResponseMessagesAreReceived(1, 1000); Assert.AreEqual(myRequestMessage, aService.ReceivedMessages.First().Message); Assert.AreEqual(myResponseMessage, aClient.ReceivedMessages.First().Message); } finally { EneterTrace.Debug("CLEANING AFTER TEST"); aClient.OutputChannel.CloseConnection(); aService.InputChannel.StopListening(); // Wait for traces. Thread.Sleep(100); } }